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="******" -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 build_kernel(Binary<expr::op::Mult, Binary<O, L, R>, S> e, Kernel<T>& k) { Kernel<T> k1(k); Kernel_builder<Binary<O, L, R>, T>::apply(e.arg1(), k1); k1 *= T(e.arg2()); k += k1; }
void build_kernel(Binary<expr::op::Div, Call<B, I, J>, S> e, Kernel<T>& k) { Kernel<T> k1(k); Kernel_builder<Call<B, I, J>, T>::apply(e.arg1(), k1); k1 /= T(e.arg2()); k += k1; }
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; }
static Kernel* get_scan_dim_kernels(int kerIdx) { try { static std::once_flag compileFlags[DeviceManager::MAX_DEVICES]; static std::map<int, Program*> scanProgs; static std::map<int, Kernel*> scanKerns; static std::map<int, Kernel*> bcastKerns; int device= getActiveDeviceId(); std::call_once(compileFlags[device], [device] () { Binary<To, op> scan; ToNum<To> toNum; 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=" << toNum(scan.init()) << " -D " << binOpName<op>() << " -D CPLX=" << af::iscplx<Ti>() << " -D isFinalPass="******" -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()); scanProgs[device] = new Program(prog); scanKerns[device] = new Kernel(*scanProgs[device], "scan_dim_kernel"); bcastKerns[device] = new Kernel(*scanProgs[device], "bcast_dim_kernel"); }); return (kerIdx == 0) ? scanKerns[device] : bcastKerns[device]; } catch (cl::Error err) { CL_TO_AF_ERROR(err); throw; } }
Binary Binary::toBinary(Binary::value_type i) { Binary b; if(i == 0) return b; b.i = i; b.bString = ""; while(i > 0) { int modI = i % 2; b.bString = (modI) ? "1"+b.str() :"0"+b.str(); i >>= 1; } b.setBitSize(b.bString.size()); return b; }
LLVMSymbolizer::BinaryPair LLVMSymbolizer::getOrCreateBinary(const std::string &Path) { BinaryMapTy::iterator I = BinaryForPath.find(Path); if (I != BinaryForPath.end()) return I->second; Binary *Bin = nullptr; Binary *DbgBin = nullptr; ErrorOr<Binary *> BinaryOrErr = createBinary(Path); if (!error(BinaryOrErr.getError())) { std::unique_ptr<Binary> ParsedBinary(BinaryOrErr.get()); // Check if it's a universal binary. Bin = ParsedBinary.get(); ParsedBinariesAndObjects.push_back(std::move(ParsedBinary)); if (Bin->isMachO() || Bin->isMachOUniversalBinary()) { // On Darwin we may find DWARF in separate object file in // resource directory. const std::string &ResourcePath = getDarwinDWARFResourceForPath(Path); BinaryOrErr = createBinary(ResourcePath); error_code EC = BinaryOrErr.getError(); if (EC != std::errc::no_such_file_or_directory && !error(EC)) { DbgBin = BinaryOrErr.get(); ParsedBinariesAndObjects.push_back(std::unique_ptr<Binary>(DbgBin)); } } // Try to locate the debug binary using .gnu_debuglink section. if (!DbgBin) { std::string DebuglinkName; uint32_t CRCHash; std::string DebugBinaryPath; if (getGNUDebuglinkContents(Bin, DebuglinkName, CRCHash) && findDebugBinary(Path, DebuglinkName, CRCHash, DebugBinaryPath)) { BinaryOrErr = createBinary(DebugBinaryPath); if (!error(BinaryOrErr.getError())) { DbgBin = BinaryOrErr.get(); ParsedBinariesAndObjects.push_back(std::unique_ptr<Binary>(DbgBin)); } } } } if (!DbgBin) DbgBin = Bin; BinaryPair Res = std::make_pair(Bin, DbgBin); BinaryForPath[Path] = Res; return Res; }
ErrorOr<ObjectFile *> LLVMSymbolizer::getOrCreateObject(const std::string &Path, const std::string &ArchName) { const auto &I = BinaryForPath.find(Path); Binary *Bin = nullptr; if (I == BinaryForPath.end()) { Expected<OwningBinary<Binary>> BinOrErr = createBinary(Path); if (!BinOrErr) { auto EC = errorToErrorCode(BinOrErr.takeError()); BinaryForPath.insert(std::make_pair(Path, EC)); return EC; } Bin = BinOrErr->getBinary(); BinaryForPath.insert(std::make_pair(Path, std::move(BinOrErr.get()))); } else if (auto EC = I->second.getError()) { return EC; } else { Bin = I->second->getBinary(); } assert(Bin != nullptr); if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(Bin)) { const auto &I = ObjectForUBPathAndArch.find(std::make_pair(Path, ArchName)); if (I != ObjectForUBPathAndArch.end()) { if (auto EC = I->second.getError()) return EC; return I->second->get(); } ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = UB->getObjectForArch(ArchName); if (auto EC = ObjOrErr.getError()) { ObjectForUBPathAndArch.insert( std::make_pair(std::make_pair(Path, ArchName), EC)); return EC; } ObjectFile *Res = ObjOrErr->get(); ObjectForUBPathAndArch.insert(std::make_pair(std::make_pair(Path, ArchName), std::move(ObjOrErr.get()))); return Res; } if (Bin->isObject()) { return cast<ObjectFile>(Bin); } return object_error::arch_not_found; }
Binary Binary::operator ^(const Binary& B) { Binary::value_type tempInt = i & B.i; Binary _xor(tempInt); if(B.bitSize > _xor.bitSize) _xor.bitSize = B.getBitSize(); return _xor; }
/** * Evaluates a solution * @param solution The solution to evaluate */ void ZDT5::evaluate(Solution *solution) { Binary * variable ; int counter ; variable = (Binary *)(solution->getDecisionVariables()[0]) ; fx_[0] = 1 + variable->cardinality(); double g = evalG(solution) ; double h = evalH(fx_[0],g) ; fx_[1] = h * g ; solution->setObjective(0,fx_[0]); solution->setObjective(1,fx_[1]); } // evaluate
void Database::_Update(const Binary& arPoint, size_t aIndex) { if(UpdateValue<Binary>(mBinaryVec, arPoint, aIndex)) { LOG_BLOCK(LEV_DEBUG, "Binary Change: " << arPoint.ToString() << " Index: " << aIndex); BinaryInfo& v = mBinaryVec[aIndex]; if(mpEventBuffer) mpEventBuffer->Update(v.mValue, v.mClass, aIndex); } }
void GroundTruth::on_pushButton_clicked() { QString filename = QFileDialog::getOpenFileName( this, tr("Open File"), "/home/soumyadeep/work/stampVarOwnData/soumya/non_overlapped/", "All Files (*.*)" ); string imagepath; imagepath = filename.toUtf8().constData(); src = imread(imagepath,1); cvtColor(src, src_gray, CV_BGR2GRAY); //IITkgp_functions::statistical_analysis stat; //stat.DrawHistogram(src_gray); IITkgp_functions::folder folderobj; imagename = imagepath.c_str(); substring = folderobj.input_image_name_cut(imagepath.c_str()); folderobj.makedir(substring); /* char *name; name = (char *) malloc ( 2001 * sizeof(char)); if(name == NULL) { printf("Memory can not be allocated\n"); exit(0); } name = folderobj.CreateNameIntoFolder(substring,"gray.png"); imwrite(name,src_gray); */ namedWindow( "Src Image", CV_WINDOW_KEEPRATIO ); imshow("Src Image",src); Binary BSelecWin; BSelecWin.setModal(true); BSelecWin.exec(); //waitKey(0); }
Binary operator-(const Binary& other) { int maxSize = 0; if(strlen(this->binaryNum) > strlen(other.binaryNum)) maxSize = strlen(this->binaryNum); else maxSize = strlen(other.binaryNum); Binary result = new char[maxSize + 2]; assert(result!=NULL); if(this->getBinaryNum().fromBinary() > other.getBinaryNum().fromBinary()) { int tmp = this->getBinaryNum().fromBinary() - other.getBinaryNum().fromBinary(); strcpy(result.binaryNum, toBinary(tmp)); return result.binaryNum; } else return 0; }
void operator()(To *out, const dim4 ostrides, const dim4 odims, const Ti *in , const dim4 istrides, const dim4 idims, const int dim) { dim_type istride = istrides[dim]; dim_type ostride = ostrides[dim]; Transform<Ti, To, op> transform; // FIXME: Change the name to something better Binary<To, op> scan; To out_val = scan.init(); for (dim_type i = 0; i < idims[dim]; i++) { To in_val = transform(in[i * istride]); out_val = scan(in_val, out_val); out[i * ostride] = out_val; } }
/* * Checking if the input Binary is particular Array2D. * Particular Array2D is a Binary data that starts with 512 byte data of * all value that is 0xff. * Notice: Particular Array2D's size is not 512 byte. I misunderstood it. * http://twitter.com/rgssws4m told me about this case. */ bool Array2D::isInvalidArray2D(Binary const& b) { static unsigned const PARTICULAR_DATA_SIZE = 512; // check the data size if( b.size() < PARTICULAR_DATA_SIZE ) return false; // check the data inside Binary for(unsigned i = 0; i < PARTICULAR_DATA_SIZE; i++) if(b[i] != 0xff) return false; debug::Tracer::printBinary(b, clog); // return true if it is particular Array2D return true; }
Nullable<Binary> Statement::GetBinaryDataInRow(unsigned int column) { Nullable<Binary> result; if (column >= _resultParams.size()) { throw DatabaseException("Error in Statement::GetDataInRow", 0, "----", "column out of range"); } if (_resultBind[column].buffer_type != MYSQL_TYPE_BLOB) { throw DatabaseException("Error in Statement::GetDataInRow", 0, "----", "column not of correct type"); } if (! (*(_resultParams[column]->IsNull()))) { if (mysql_stmt_fetch_column(_stmt, &(_resultBind[column]), column, 0) != 0) { throw DatabaseException(_stmt, "Error in GetDataInRow(Binary)"); } Binary fromdb; fromdb.AssignDataToBuffer((unsigned char *)_resultParams[column]->Buffer(), *(_resultParams[column]->BufferLength())); result = fromdb; } return result; }
Binary *crossBinary(double probability, Binary *bins1, Binary *bins2) { if (PseudoRandom::randDouble() < probability) { //1. Compute the total number of bits int totalNumberOfBits = bins1->getNumberOfBits(); //2. Calculate the point to make the crossover int crossoverPoint = PseudoRandom::randInt(0, totalNumberOfBits - 1); //3. Compute the variable containing the crossoverPoint bit Binary *offspring = new Binary(totalNumberOfBits); for (int i = 0; i < crossoverPoint; ++i) { offspring->setIth(i, bins1->getIth(i)); } for (int i = crossoverPoint; i < bins1->getNumberOfBits(); ++i) { offspring->setIth(i, bins2->getIth(i)); } return offspring; } return bins1; }