C++ Binary类代码示例

    static Kernel get_scan_dim_kernels(int kerIdx, int dim, bool isFinalPass, uint threads_y)
    {
        std::string ref_name =
            std::string("scan_") +
            std::to_string(dim) +
            std::string("_") +
            std::to_string(isFinalPass) +
            std::string("_") +
            std::string(dtype_traits<Ti>::getName()) +
            std::string("_") +
            std::string(dtype_traits<To>::getName()) +
            std::string("_") +
            std::to_string(op) +
            std::string("_") +
            std::to_string(threads_y) +
            std::string("_") +
            std::to_string(int(inclusive_scan));

        int device = getActiveDeviceId();

        kc_entry_t entry = kernelCache(device, ref_name);

        if (entry.prog==0 && entry.ker==0) {
            Binary<To, op> scan;
            ToNumStr<To> toNumStr;

            std::ostringstream options;
            options << " -D To=" << dtype_traits<To>::getName()
                    << " -D Ti=" << dtype_traits<Ti>::getName()
                    << " -D T=To"
                    << " -D dim=" << dim
                    << " -D DIMY=" << threads_y
                    << " -D THREADS_X=" << THREADS_X
                    << " -D init=" << toNumStr(scan.init())
                    << " -D " << binOpName<op>()
                    << " -D CPLX=" << af::iscplx<Ti>()
                    << " -D isFinalPass=" << (int)(isFinalPass)
                    << " -D inclusive_scan=" << inclusive_scan;
            if (std::is_same<Ti, double>::value ||
                std::is_same<Ti, cdouble>::value) {
                options << " -D USE_DOUBLE";
            }

            const char *ker_strs[] = {ops_cl, scan_dim_cl};
            const int   ker_lens[] = {ops_cl_len, scan_dim_cl_len};
            cl::Program prog;
            buildProgram(prog, 2, ker_strs, ker_lens, options.str());

            entry.prog = new Program(prog);
            entry.ker = new Kernel[2];

            entry.ker[0] = Kernel(*entry.prog, "scan_dim_kernel");
            entry.ker[1] = Kernel(*entry.prog, "bcast_dim_kernel");


            addKernelToCache(device, ref_name, entry);
        }

        return entry.ker[kerIdx];
    }

 Binary Binary::operator +(const Binary& B)
 {
   Binary sum(i+B.getInt());
   if(B.getBitSize() > sum.bitSize)
     sum.setBitSize(B.getBitSize());
   return sum;
 }

LLVMSymbolizer::BinaryPair
LLVMSymbolizer::getOrCreateBinary(const std::string &Path) {
  BinaryMapTy::iterator I = BinaryForPath.find(Path);
  if (I != BinaryForPath.end())
    return I->second;
  Binary *Bin = 0;
  Binary *DbgBin = 0;
  OwningPtr<Binary> ParsedBinary;
  OwningPtr<Binary> ParsedDbgBinary;
  if (!error(createBinary(Path, ParsedBinary))) {
    // Check if it's a universal binary.
    Bin = ParsedBinary.take();
    ParsedBinariesAndObjects.push_back(Bin);
    if (Bin->isMachO() || Bin->isMachOUniversalBinary()) {
      // On Darwin we may find DWARF in separate object file in
      // resource directory.
      const std::string &ResourcePath =
          getDarwinDWARFResourceForPath(Path);
      bool ResourceFileExists = false;
      if (!sys::fs::exists(ResourcePath, ResourceFileExists) &&
          ResourceFileExists &&
          !error(createBinary(ResourcePath, ParsedDbgBinary))) {
        DbgBin = ParsedDbgBinary.take();
        ParsedBinariesAndObjects.push_back(DbgBin);
      }
    }
  }
  if (DbgBin == 0)
    DbgBin = Bin;
  BinaryPair Res = std::make_pair(Bin, DbgBin);
  BinaryForPath[Path] = Res;
  return Res;
}

/*
Step 1: Let zi := xi for i =1,2, ...,n (i.e., z is a copy of the
		primary parent x).
Step 2: Let zi := (1 - zi) with a probability PBF when xi = yi
		where PBF is a prespecified bit-flip probability.
Note:	Random primary parent selection
*/
bool BinaryCrsNonGeometric::mate(GenotypeP gen1, GenotypeP gen2, GenotypeP child)
{
	Binary* p1 = (Binary*) (gen1.get());
	Binary* p2 = (Binary*) (gen2.get());
	Binary* ch = (Binary*) (child.get());
	
	double PBF = 0.5; //prespecified bit-flip probability

	//Step 1
	for (uint dimension = 0; dimension < p1->variables.size(); dimension++) {
		switch (state_->getRandomizer()->getRandomInteger(0, 1)) {
			case 0: for (uint i = 0; i < p1->getNumBits(); i++) {
						ch->variables[dimension][i] = p1->variables[dimension][i];
					}
					break;
			case 1: for (uint i = 0; i < p2->getNumBits(); i++) {
						ch->variables[dimension][i] = p2->variables[dimension][i];
					}
		}
		//Step 2
		for(uint i = 0; i < p1->getNumBits(); i++) {
			if (p1->variables[dimension][i] == p2->variables[dimension][i]) {
				double changeProbability = state_->getRandomizer()->getRandomDouble();
				if (changeProbability > PBF)
					ch->variables[dimension][i] =  ch->variables[dimension][i]  ? false:true;				
			}
		}
	}

	// update integer and real domain representation
	ch->update();

	return true;
}

 Binary Binary::operator -(const Binary& B)
 {
   Binary diff(i-B.i);
   if(B.getBitSize() > diff.bitSize)
     diff.setBitSize(B.getBitSize());
   return diff;
 }

void build_kernel(Binary<expr::op::Sub, L, R> e, Kernel<T>& k)
{
  Kernel_builder<L, T>::apply(e.arg1(), k);
  Kernel<T> k2(k);
  Kernel_builder<R, T>::apply(e.arg2(), k2);
  k -= k2;
}

    To reduce_all(const Array<Ti> &in)
    {
        Transform<Ti, To, op> transform;
        Binary<To, op> reduce;

        To out = reduce.init();

        // Decrement dimension of select dimension
        af::dim4 dims = in.dims();
        af::dim4 strides = in.strides();
        const Ti *inPtr = in.get();

        for(dim_t l = 0; l < dims[3]; l++) {
            dim_t off3 = l * strides[3];

            for(dim_t k = 0; k < dims[2]; k++) {
                dim_t off2 = k * strides[2];

                for(dim_t j = 0; j < dims[1]; j++) {
                    dim_t off1 = j * strides[1];

                    for(dim_t i = 0; i < dims[0]; i++) {
                        dim_t idx = i + off1 + off2 + off3;

                        To val = transform(inPtr[idx]);
                        out = reduce(val, out);
                    }
                }
            }
        }

        return out;
    }

void main()
{
	randomize();

	Binary b;
	b.execute();
}

void SpongeConstruction(string inputString, int outputLen)
{
	// Transform the input string into binary bits
	BinaryTransfer( inputString ) ;

	// Padding using Multirate
	vector< Binary > Message = Padding( inputString ) ;

	//Initialize the state variable
	Binary stateVar ;


	// Absorbing phase
	for(auto & block: Message){
		block<<=CAPACITY;
		//XOR with statevar
		stateVar^=block;
		stateVar=internalFun(stateVar);
	}
	// Squeezing phase
	string hashVal ; // The final output value
	if(outputLen <BITRATE){
		hashVal=stateVar.to_string().substr(0,outputLen);
	}else{
		hashVal+=stateVar.to_string().substr(0,BITRATE);
		while(hashVal.length() < outputLen){
			stateVar=internalFun(stateVar);
			hashVal+=stateVar.to_string().substr(0,BITRATE);
		}
	}


	// Print the hash value to the stdout
	PrintHex( hashVal.substr(0, outputLen) ) ;
}

 Binary Binary::operator |(const Binary& B)
 {
   Binary _or(i | B.getInt());
   if(B.getBitSize() > _or.bitSize)
     _or.setBitSize(B.getBitSize());
   return _or;
 }

 Binary Binary::operator &(const Binary& B)
 {
   Binary _and(i & B.getInt());
   if(B.getBitSize() > _and.bitSize)
     _and.setBitSize(B.getBitSize());
   return _and;
 }

void DataObserverAdapter::_Update(const Binary& arMeas, size_t aIndex)
{
	JNIEnv* pEnv = GetEnv();

	jboolean value = arMeas.GetValue();
	jbyte quality = arMeas.GetQuality();
	jlong timestamp = arMeas.GetTime();
	jlong index = aIndex;

	pEnv->CallVoidMethod(mProxy, mUpdateBinaryInput, value, quality, timestamp, index);
}

double ZDT5::evalG(Solution * solution) {
  double res = 0.0;
  Binary * variable ;

  for (int i = 1; i < numberOfVariables_; i++) {
  	variable = (Binary *)(solution->getDecisionVariables()[i]) ;
    res += evalV(variable->cardinality());
  }

  return res;
}

Status BinCommon::rd_value(CommandInitiator* thread, Binary& value)
{
  uint size;
  Status status = rd_value(thread, size);
  if (status == OK) {
    if (size > 0) { // protect from unrealistic size?
      value.reserve(size);
      status = rd_bytes(thread, size, (char*) value.data());
    }
  }
  return status;
}

bool operator==(const Binary &left, const Binary &right) {
	unsigned char* leftBuffer = left.Buffer();
	unsigned char* rightBuffer = right.Buffer();
	size_t leftLen = left.BufferLength();
	size_t rightLen = right.BufferLength();

	if (leftLen != rightLen) return false;

	for (size_t i = 0; i < leftLen; i++) {
		if (leftBuffer[i] != rightBuffer[i]) return false;
	}
	return true;
}