void SobolGenerator::GetUniforms(MJArray& variates) {//this is the function to use to Sobel vectors void i4_sobol ( int dim_num, int *seed, float quasi[ ] ) float* quasi=(float *)malloc(sizeof(float)*GetDimensionality()); i4_sobol ( GetDimensionality(), (int*)SobolGenerator::seed,quasi ); for (unsigned long j=0; j < (unsigned long)GetDimensionality(); j++) variates[j] = quasi[j]; free(quasi); }
void SobolGenerator::GetUniforms(MJArray& variates) {// here is the Sobol sequence generated. Note that I have a static value to remember the seed. float *quasi= (float*)malloc( GetDimensionality()); static int seed_1=(int)SobolGenerator::seed; i4_sobol ( GetDimensionality(),&seed_1, quasi ); for (int j=0; j < GetDimensionality(); j++){ variates[j] =(double) quasi[j]; } free(quasi); }
void RandomParkMiller::Skip(unsigned long numberOfPaths){ MJArray tmp(GetDimensionality()); for(unsigned long j=0;j<numberOfPaths;j++){ GetUniforms(tmp); } }
void TransformUnrolledArraysPass::CollectArrays(int dimensionality) { ClearReferences() ; assert(innermost != NULL) ; list<ArrayReferenceExpression*>* allRefs = collect_objects<ArrayReferenceExpression>(innermost) ; list<ArrayReferenceExpression*>::iterator refIter = allRefs->begin() ; while(refIter != allRefs->end()) { if (GetDimensionality(*refIter) == dimensionality) { // Create a new Equivalent reference EquivalentReferences* nextReference = new EquivalentReferences() ; nextReference->original = (*refIter) ; currentReferences.push_back(nextReference) ; } ++refIter ; } delete allRefs ; Uniquify() ; }
AntiThetic::AntiThetic(const Wrapper<RandomBase>& finnerGenerator): RandomBase(*finnerGenerator), InnerGenerator(finnerGenerator) { InnerGenerator->Reset(); OddEven = true; NextVariates.resize(GetDimensionality()); }
// *innerGenerator: get underlying RandomBase pbject ("*" is overloading in Wrapper class) // specify the inherited random number generator AntiThetic::AntiThetic(const Wrapper<RandomBase>& innerGenerator):RandomBase(*innerGenerator),InnerGenerator(innerGenerator) { // perform intialization InnerGenerator->Reset(); OddEven = true; NextVariates.resize(GetDimensionality()); }
void AntiThetic::GetGaussians(MJArray& variates) { if (OddEven){ InnerGenerator->GetGaussians(variates); for (unsigned long i =0; i < GetDimensionality(); i++) NextVariates[i] = - variates[i]; OddEven = false; }else{ variates = NextVariates; OddEven = true; } }
void AntiThetic::GetGaussians(vector<double>& variates, double m, double s) { if (OddEven){ InnerGenerator->GetGaussians(variates,m,s); for (unsigned long i = 0; i < GetDimensionality(); i++) NextVariates[i] = - variates[i]; OddEven = false; } else{ variates = _NextVariates; OddEven = true; } }
void AntiThetic::GetUniforms(vector<double>& variates, double a, double b) { if (OddEven){ InnerGenerator->GetUniforms(variates,a,b); for (unsigned long i = 0; i < GetDimensionality(); i++) NextVariates[i] = b - variates[i]; OddEven = false; } else{ variates = _NextVariates; OddEven = true; } }
void AntiThetic::GetUniforms(std::vector<double>& variates) { if (OddEven) { InnerGenerator->GetUniforms(variates); for (unsigned long i = 0; i < GetDimensionality(); ++i) { NextVariates[i] = 1.0 - variates[i]; } OddEven = false; } else { variates = NextVariates; OddEven = true; } }
void AntiThetic::Skip(unsigned long numberOfPaths) { if (numberOfPaths ==0) return; if (OddEven){ OddEven = false; numberOfPaths--; } InnerGenerator->Skip(numberOfPaths / 2); if (numberOfPaths % 2){ MJArray tmp(GetDimensionality()); GetUniforms(tmp); } }
void AntiThetic::GetUniforms(MJArray &variates) { if (OddEven)// if true, use anti-thetic { InnerGenerator->GetUniforms(variates); // generate one path using undering random generator // make anti-thetic for (unsigned long i=0; i<GetDimensionality(); i++) { NextVariates[i] = 1.0 - variates[i]; } OddEven = false; } else { variates = NextVariates; OddEven= true; } }
void AntiThetic::Skip(unsigned long numberOfPaths) { if (numberOfPaths == 0) return; if (!OddEven) { OddEven = true; // ensure the skip is considered from an odd position --numberOfPaths; } InnerGenerator->Skip(numberOfPaths / 2); if (numberOfPaths % 2) { std::vector<double> tmp(GetDimensionality()); GetUniforms(tmp); } }
int TransformUnrolledArraysPass::MaxDimension() { assert(innermost != NULL) ; int maxSize = 0 ; list<ArrayReferenceExpression*>* allRefs = collect_objects<ArrayReferenceExpression>(innermost) ; list<ArrayReferenceExpression*>::iterator refIter = allRefs->begin() ; refIter = allRefs->begin() ; while (refIter != allRefs->end()) { int currentSize = GetDimensionality(*refIter) ; if (currentSize > maxSize) { maxSize = currentSize ; } ++refIter ; } delete allRefs ; return maxSize ; }
void AntiThetic::Skip(unsigned long numberOfPaths) { //not skip if (numberOfPaths==0) return; // if next step have to do anti-thetic, reverse the flag and reduce one path if (OddEven) { OddEven = false; numberOfPaths--; } InnerGenerator -> Skip(numberOfPaths/2); if (numberOfPaths %2) { MJArray tmp(GetDimensionality()); GetUniforms(tmp); } }
// All of the array references expressions in the passed in the struct are // equivalent, so we can determine types of the original and use that // to create a new expression with which to replace everything. bool TransformUnrolledArraysPass::ReplaceNDReference(EquivalentReferences* a) { assert(a != NULL) ; assert(a->original != NULL) ; // Check to see if the reference at this stage is a constant or not IntConstant* constantIndex = dynamic_cast<IntConstant*>(a->original->get_index()) ; if (constantIndex == NULL) { // There was no replacement made return false ; } Expression* baseAddress = a->original->get_base_array_address() ; assert(baseAddress != NULL) ; assert(constantIndex != NULL) ; // Create a replacement expression for this value. This will either // be another array reference expression or a single variable. Expression* replacementExp = NULL ; // QualifiedType* elementType = GetQualifiedTypeOfElement(a->original) ; VariableSymbol* originalSymbol = GetArrayVariable(a->original) ; assert(originalSymbol != NULL) ; LString replacementName = GetReplacementName(originalSymbol->get_name(), constantIndex->get_value().c_int()) ; int dimensionality = GetDimensionality(a->original) ; QualifiedType* elementType = originalSymbol->get_type() ; while (dynamic_cast<ArrayType*>(elementType->get_base_type()) != NULL) { elementType = dynamic_cast<ArrayType*>(elementType->get_base_type())->get_element_type() ; } // There is a special case for one dimensional arrays as opposed to all // other dimensional arrays. It only should happen if we are truly // replacing an array with a one dimensional array. if (dimensionality == 1 && dynamic_cast<ArrayReferenceExpression*>(a->original->get_parent())==NULL) { VariableSymbol* replacementVar = create_variable_symbol(theEnv, GetQualifiedTypeOfElement(a->original), TempName(replacementName)) ; procDef->get_symbol_table()->append_symbol_table_object(replacementVar) ; replacementExp = create_load_variable_expression(theEnv, elementType->get_base_type(), replacementVar) ; } else { // Create a new array with one less dimension. This requires a new // array type. ArrayType* varType = dynamic_cast<ArrayType*>(originalSymbol->get_type()->get_base_type()) ; assert(varType != NULL) ; ArrayType* replacementArrayType = create_array_type(theEnv, varType->get_element_type()->get_base_type()->get_bit_size(), 0, // bit alignment OneLessDimension(originalSymbol->get_type(), dimensionality), dynamic_cast<Expression*>(varType->get_lower_bound()->deep_clone()), dynamic_cast<Expression*>(varType->get_upper_bound()->deep_clone()), TempName(varType->get_name())) ; procDef->get_symbol_table()->append_symbol_table_object(replacementArrayType) ; VariableSymbol* replacementArraySymbol = create_variable_symbol(theEnv, create_qualified_type(theEnv, replacementArrayType, TempName(LString("qualType"))), TempName(replacementName)) ; procDef->get_symbol_table()->append_symbol_table_object(replacementArraySymbol) ; // Create a new symbol address expression for this variable symbol SymbolAddressExpression* replacementAddrExp = create_symbol_address_expression(theEnv, replacementArrayType, replacementArraySymbol) ; // Now, replace the symbol address expression in the base // array address with this symbol. ReplaceSymbol(a->original, replacementAddrExp) ; // And replace this reference with the base array address. replacementExp = a->original->get_base_array_address() ; a->original->set_base_array_address(NULL) ; replacementExp->set_parent(NULL) ; } // Replace all of the equivalent expressions with the newly generated // replacement expression. assert(replacementExp != NULL) ; a->original->get_parent()->replace(a->original, replacementExp) ; // ReplaceChildExpression(a->original->get_parent(), // a->original, // replacementExp) ; list<ArrayReferenceExpression*>::iterator equivIter = a->allEquivalent.begin() ; while (equivIter != a->allEquivalent.end()) { (*equivIter)->get_parent()->replace((*equivIter), dynamic_cast<Expression*>(replacementExp->deep_clone())) ; // ReplaceChildExpression((*equivIter)->get_parent(), // (*equivIter), // dynamic_cast<Expression*>(replacementExp->deep_clone())) ; ++equivIter ; } return true ; }
//below are just some functions override the RandomBase class methods. void SobolGenerator::Skip(unsigned long numberOfPaths){ MJArray tmp(GetDimensionality()); for (unsigned long j=0; j < numberOfPaths; j++) SobolGenerator::GetUniforms(tmp); }
void RandomParkMiller::Skip(unsigned long NumberOfPaths) { std::vector<double> tmp(GetDimensionality()); for(unsigned long j=0; j<NumberOfPaths; j++) GetUniforms(tmp); }
void RandomParkMiller::GetUniforms(std::vector<double>& variates) { for(unsigned long j=0; j<GetDimensionality(); j++) variates[j] = InnerGenerator.GetOneRandomInteger() * Reciprocal; }
void RandomParkMiller::GetUniforms(MJArray& variates){ for (unsigned long j=0;j<GetDimensionality();j++){ variates[j]=InnerGenerator.GetOneRandomInteger()*Reciprocal; } }