void TestReCode5()
{
cout << " TestReCode5()" << endl;
GaloisElemVV vv;
GaloisElemV _x1 = generateRandomNC(8);
GaloisElemV _x2 = generateRandomNC(8);
GaloisElemV _x3 = _x1;
MTRand CodingCoefficient;
int x = CodingCoefficient.randInt(CodingSpace)+1;//int(tompo);
GaloisElem a(&gf, x);
int y = CodingCoefficient.randInt(CodingSpace)+1;//int(tompo);
GaloisElem b(&gf, y);
GaloisElemV::iterator it_2 = _x2.begin();
GaloisElemV::iterator it_3 = _x3.begin();
for(; it_2 != _x2.end(); )
{
(*it_3) *= a;
*it_2 *= b;
(*it_3) += *it_2;
it_2++;
it_3++;
}
vv.push_back(_x1);
vv.push_back(_x2);
vv.push_back(_x3);
cout << gaussElimination(vv) << endl;
}
void HPRC4LikeCipher::Init(const uint8 *key, uint32 size)
{
// align key to 32 bits
std::vector<uint32> keycopy((size + sizeof(uint32) - 1) / sizeof(uint32));
DEBUG(ASSERT(keycopy.size() * sizeof(uint32) >= size));
// the last 3 bytes may be incomplete, null those before copying
keycopy[keycopy.size() - 1] = 0;
memcpy(&keycopy[0], key, size);
#if IS_BIG_ENDIAN
for(uint32 i = 0; i < keycopy.size(); ++i)
ToLittleEndian(keycopy[i]);
#endif
MTRand mt;
mt.seed((uint32*)&keycopy[0], keycopy.size());
for(uint32 i = 0; i < 256; ++i)
_sbox[i] = i | (mt.randInt() << 8); // lowest bit is always the exchange index, like in original RC4
uint32 a = 0, b = 0;
for(uint32 i = 0; i < std::max<uint32>(256, size); ++i)
{
b += key[a] + _sbox[i & 0xFF];
iswap(_sbox[i & 0xFF], _sbox[b & 0xFF]);
++a;
a %= size;
}
}
bool cChunkGenerator::Start(cWorld * a_World, cIniFile & a_IniFile)
{
MTRand rnd;
m_World = a_World;
m_Seed = a_IniFile.GetValueSetI("Seed", "Seed", rnd.randInt());
AString GeneratorName = a_IniFile.GetValueSet("Generator", "Generator", "Composable");
if (NoCaseCompare(GeneratorName, "Noise3D") == 0)
{
m_Generator = new cNoise3DGenerator(*this);
}
else
{
if (NoCaseCompare(GeneratorName, "composable") != 0)
{
LOGWARN("[Generator]::Generator value \"%s\" not recognized, using \"Composable\".", GeneratorName.c_str());
}
m_Generator = new cComposableGenerator(*this);
}
if (m_Generator == NULL)
{
LOGERROR("Generator could not start, aborting the server");
return false;
}
m_Generator->Initialize(a_World, a_IniFile);
return super::Start();
}
void world::recordGeneration()
{
// choose a random clock from within the population
MTRand randGen;
int randNum = randGen.randInt((int)mWorldSettings.mPopulationSize - 1);
// for each row in the genome
for (int x = 0; x < mWorldSettings.mGenomeSize; x++)
{
// for each column in the genome
for (int y = 0; y < mWorldSettings.mGenomeSize; y++)
{
// get the piece genome data
clockPiece outputPiece = mPopulation[randNum].getClockPiece(x, y);
outputPiece.getPieceType();
// output genome layout to screen, replacing numeric values with letters which represent the part type
if (outputPiece.getPieceType() != PTYPE_NULL)
{
if (outputPiece.getPieceType() == PTYPE_ESCAPEMENT)
{
cout << "E";
gout << "E";
}
else if (outputPiece.getPieceType() == PTYPE_GEAR)
{
cout << "G";
gout << "G";
}
else if (outputPiece.getPieceType() == PTYPE_PENDULUM)
{
cout << "P";
gout << "P";
}
else if (outputPiece.getPieceType() == PTYPE_MAINSPRING)
{
cout << "M";
gout << "M";
}
else if (outputPiece.getPieceType() == PTYPE_HAND)
{
cout << "H";
gout << "H";
}
}
else
{
cout << " ";
gout << " ";
}
}
cout << endl;
gout << endl;
}
// output clock data
mPopulation[randNum].calcSurvivalScore(true);
gout << endl;
}
void Graph::pass_messages(MTRand &mtrand){
//std::cout<<"WOW I am HERE";
for (std::vector<Person*>::const_iterator p = m_people.begin(); p != m_people.end(); ++p){
std::list<Person*> friends=((*p)->get_friends());
std::list<Message*> messages_lst=((*p)->get_messages());
std::list<Message*>::const_iterator it4=messages_lst.back();
Message* c=messages_lst.back();
const std::string z=((*c)->get_message());
int random_num=mtrand.randInt(friends.size());
// find the random number from the friends list and send the message to that number
std::list<Person*>::const_iterator it3=friends.begin();
for(int i=0;i<random_num-1;i++){
it3++;
}
//Person* p1=it3;
std::string pers=(*it3)->get_name();
// we need to add the message into the graph also and that will call message of person.
// We need to change the owner of the function also
bool a=add_message(pers,z);
bool b=((*it3)->remove_message(it4));
}
}
static cell_t GetURandomInt(IPluginContext *ctx, const cell_t *params)
{
MTRand *randobj = s_RandHelpers.RandObjForPlugin(ctx);
/* Note the sign bit must be stripped off because cell_t is signed,
* and this guarantees a range of [0,max_int]
*/
return randobj->randInt() & 0x7FFFFFFF;
}
int RandomBin :: randInt(Stream_type Stream)
{
MTRand *streamPtr = GetStream(Stream);
if (streamPtr != NULL) {
return streamPtr->randInt();
}
return 0;
}
// ==========================================================================
// To get you started, this function places tiles on the board and
// randomly and outputs the results (in all likelihood *not* a
// solution!) in the required format
void RandomlyPlaceTiles(Board &board, const std::vector<Tile*> &tiles, std::vector<Location> &locations) {
// MersenneTwister is an excellent library for psuedo-random numbers!
MTRand mtrand;
for (int t = 0; t < tiles.size(); t++) {
// loop generates random locations until we (eventually) find one
// that is not occupied
int i,j;
do {
// generate a random coordinate within the range 0,0 -> rows-1,cols-1
i = mtrand.randInt(board.numRows()-1);
j = mtrand.randInt(board.numColumns()-1);
} while (board.getTile(i,j) != NULL);
// rotation is always 0 (for now)
locations.push_back(Location(i,j,0));
board.setTile(i,j,tiles[t]);
}
}
void Graph::pass_messages(MTRand &mtrand){
for (std::vector<Person*>::const_iterator p2 = m_people.begin(); p2 != m_people.end(); ++p2){
std::list<Person*> friends=((*p2)->get_friends());
std::list<Message*> messages_lst=((*p2)->get_messages());
//std::cout<<"size"<<friends.size()<<std::endl;
if(messages_lst.size()==0)
{
continue;
}
//std::cout<<"Person"<<(*p2)->get_name()<<std::endl;
//for (std::list<Message *>::const_iterator it1 = messages_lst.begin(); it1 != messages_lst.end(); ++it1){
int random_num=mtrand.randInt(friends.size());
//std::cout<<"random number generated"<<random_num<<std::endl;
if(random_num==0)
{
continue;
}
else{
std::list<Person*>::const_iterator it3=friends.begin();
std::list<Message *>::const_iterator it1 = messages_lst.begin();
for(int i=0;i<random_num-1;i++){
it3++;
}
//Person* p1=*it3;
std::string pers=(*it3)->get_name();
// std::cout<<"person"<<pers<<std::endl;
const std::string z=((*it1)->get_message());
//std::cout<<z;
bool a=add_message(pers,z);
bool b=((*p2)->remove_message(*it1));
}
// find the random number from the friends list and send the message to that number
// we need to add the message into the graph also and that will call message of person.
// We need to change the owner of the function also
//continue;
//}
}
}
void Recode(GaloisElemV& des, GaloisElemV src)
{
//cout << "Recode(GaloisElemV& in_cache, const GaloisElemV new_come)" << endl;
MTRand CodingCoefficient;
int x = CodingCoefficient.randInt(CodingSpace)+1;//int(tompo);
GaloisElem a(&gf, x);
int y = CodingCoefficient.randInt(CodingSpace)+1;//int(tompo);
GaloisElem b(&gf, y);
GaloisElemV::iterator it_des = des.begin();
GaloisElemV::iterator it_src = src.begin();
for(;it_des != des.end(); )
{
(*it_des) = a * (*it_des) + b * (*it_src);
it_des++;
it_src++;
}
}
// constructs a random clockpiece
clockPiece::clockPiece()
{
// creates an MTRand that can make random numbers
MTRand randGen;
// initialize data
mPieceType = randGen.randInt(PTYPE_AMT);
mPieceInterval = 0;
mPendulumLength = 0;
mNumTeeth = 0;
mIsConnected = false;
mIsPowered = false;
mIsAttToHand = false;
// determine other member variables based on the part type
if (mPieceType == PTYPE_PENDULUM)
// random length of pendulum between 0 and 1 meter
mPendulumLength = randGen.rand();
else if (mPieceType == PTYPE_GEAR)
// random number of gear teeth (physical minimum is 3)
mNumTeeth = randGen.randInt(MAX_TEETH - 3) + 3;
}
void Recode(GaloisElemVV& _factors, GaloisElemV factor)
{
cout << "Recode(GaloisElemVV& in_cache, const GaloisElemV new_come)" << endl;
MTRand CodingCoefficient;
int x = CodingCoefficient.randInt(CodingSpace)+1;//int(tompo);
//int x = 1;
GaloisElem a(&gf, x);
int y = CodingCoefficient.randInt(CodingSpace)+1;//int(tompo);
//int y = 1;
GaloisElem b(&gf, y);
for(GaloisElemVV::iterator it_vv = _factors.begin();it_vv != _factors.end(); it_vv++)
{
GaloisElemV::iterator it_f = factor.begin();
GaloisElemV::iterator it_v = it_vv->begin();
for(; it_v != it_vv->end(); )
{
(*it_v) = a * (*it_v) + b * (*it_f);
it_v++;
it_f++;
}
}
}
void SwarmFitterInterface::randomizeTopology(vector< SwarmFly > & swarm, int maxInformed, MTRand & randGen) {
for (int i = 0; i < (int)swarm.size(); i++) {
swarm[i].resetInformants();
showMessage(str(i) + " informs: { ",4,fixedParams);
for (int j = 0; j < maxInformed; j++) {
int randI = randGen.randInt(swarm.size()-1);
swarm[randI].addInformant(&(swarm[j]));
showMessage(str(randI) + " ",4,fixedParams);
}
showMessage("}\n",4,fixedParams);
}
}
// generate the next word in the sentence
std::pair<std::string, float> WordFrequency::NextWord( const std::vector<std::string> & sentence, bool random) {
static MTRand mtrand;
int start_index = std::max(0,int(sentence.size()) - (depth-1));
WordFrequency* tmp = this;
// navigate to the right portion of the overall map hierarchy
for ( unsigned int i = start_index; i < sentence.size(); i++ ) {
tmp = tmp->GetWord(sentence[i]);
if ( tmp == NULL) {
return std::make_pair(std::string(""),0.0);
}
}
assert(tmp!=NULL);
// calculate statistis about the options
int max = -1;
int total = 0;
std::string answer;
std::map<std::string,WordFrequency*>::const_iterator j;
for ( j= tmp->frequency.begin(); j!=tmp->frequency.end(); j++ ) {
total += j->second->samples;
if ( max < j->second->samples) {
max = j->second->samples;
answer = j->first;
}
}
if (total == 0 )
return std::make_pair(std::string(""),0.0);
if (random == false )
return std::make_pair(answer,max/double(total));
assert(total > 0);
int rand = mtrand.randInt(total-1);
assert(rand >=0 && rand < total);
int sum =0;
int prob = 0;
for ( j=tmp->frequency.begin(); j != tmp->frequency.end(); j++ ) {
sum+= j->second->samples;
if ( sum > rand ) {
answer = j->first;
prob = j->second->samples;
break;
}
}
assert(sum>rand);
assert(sum <= total);
assert(answer !="");
return std::make_pair(answer,prob/float(total));
}
bool cChunkGenerator::Start(cPluginInterface & a_PluginInterface, cChunkSink & a_ChunkSink, cIniFile & a_IniFile)
{
m_PluginInterface = &a_PluginInterface;
m_ChunkSink = &a_ChunkSink;
// Get the seed; create a new one and log it if not found in the INI file:
if (a_IniFile.HasValue("Seed", "Seed"))
{
m_Seed = a_IniFile.GetValueI("Seed", "Seed");
}
else
{
MTRand rnd;
m_Seed = rnd.randInt();
LOGINFO("Chosen a new random seed for world: %d", m_Seed);
a_IniFile.SetValueI("Seed", "Seed", m_Seed);
}
// Get the generator engine based on the INI file settings:
AString GeneratorName = a_IniFile.GetValueSet("Generator", "Generator", "Composable");
if (NoCaseCompare(GeneratorName, "Noise3D") == 0)
{
m_Generator = new cNoise3DGenerator(*this);
}
else
{
if (NoCaseCompare(GeneratorName, "composable") != 0)
{
LOGWARN("[Generator]::Generator value \"%s\" not recognized, using \"Composable\".", GeneratorName.c_str());
}
m_Generator = new cComposableGenerator(*this);
}
if (m_Generator == nullptr)
{
LOGERROR("Generator could not start, aborting the server");
return false;
}
m_Generator->Initialize(a_IniFile);
return super::Start();
}
// integer from 0 to n-1
int randInt(int max) {
//return (int)((float) max*rand()/(RAND_MAX+1.0));
return twist.randInt(max-1);
}
int32 rand32()
{
return mtRand.randInt();
}
uint32 urand(uint32 min, uint32 max)
{
return mtRand.randInt(max - min) + min;
}
int32 irand(int32 min, int32 max)
{
return int32(mtRand.randInt(max - min)) + min;
}
// integer in [0,2^32-1]
uint32_t SoarRandInt()
{
return gSoarRand.randInt();
}
list<ListGraph::Node> GreedyHeuristic::execute() {
typedef ListGraph::EdgeMap<double> LengthMap;
typedef Dijkstra<SubGraph<ListGraph>, LengthMap> ShortestPath;
list<ListGraph::Node> solution;
// First we instantiate an vector with all the terminal nodes
list<ListGraph::Node> tnode;
for (ListGraph::NodeIt v(*graph); v!= INVALID; ++v) {
if ((*terminal)[v]) {
tnode.push_back(v);
}
}
// Random get an terminal node
MTRand rand;
list<ListGraph::Node>::iterator iter;
int i = rand.randInt() % tnode.size();
int currentNode = 0;
ListGraph::Node node;
for (iter = tnode.begin(); iter != tnode.end(); iter++) {
if (currentNode == i) {
node = *iter;
tnode.erase(iter);
break;
}
currentNode++;
}
solution.push_back(node);
while (tnode.size() > 0) {
double min = DBL_MAX;
list<ListGraph::Node>::iterator term;
list<ListGraph::Node>::iterator bestNode;
Path<ListGraph> p;
// First we instantiate an vector with all the terminal nodes
list<ListGraph::Node> fulltnode;
for (ListGraph::NodeIt v(*graph); v!= INVALID; ++v) {
if ((*terminal)[v]) {
fulltnode.push_back(v);
}
}
//cout << "Saindo de: " << (*graph).id(node);
for (term = tnode.begin(); term != tnode.end(); term++) {
ListGraph::NodeMap<bool> node_filter(*graph);
ListGraph::EdgeMap<bool> edge_filter(*graph);
//cout << " Chegando em: " << (*graph).id(*term) << endl;
list<ListGraph::Node> nodesToRemove;
// Create the node_filter
for (ListGraph::NodeIt v(*graph); v != INVALID; ++v) {
//cout << "No atual: " << (*graph).id(v) << endl;
bool belongSubGraph = true;
if(( (*graph).id(v) != (*graph).id(node)) &&
((*graph).id(v) != (*graph).id(*term))) {
list<ListGraph::Node>::iterator iter;
// Remove all the nodes that belongs to the solution
for (iter = solution.begin(); iter != solution.end(); iter++) {
if((*graph).id(v) == (*graph).id(*iter)) {
nodesToRemove.push_back(v);
belongSubGraph = false;
//cout << "\t no " << (*graph).id(*iter) << "removido pertence a solucao" << endl;
break;
}
}
// Remove all the other terminal nodes
for (iter = fulltnode.begin(); iter != fulltnode.end(); iter++) {
if((*graph).id(v) == (*graph).id(*iter)) {
nodesToRemove.push_back(v);
belongSubGraph = false;
//cout << "\t no " << (*graph).id(*iter) << "removido pertence aos terminais" << endl;
break;
}
}
}
node_filter[v] = belongSubGraph;
}
// Create the edge_filter
for (ListGraph::EdgeIt ed((*graph)); ed != INVALID; ++ed) {
list<ListGraph::Node>::iterator iter;
bool value = true;
for (iter = nodesToRemove.begin(); iter != nodesToRemove.end(); iter++) {
if ( (*graph).u(ed) == *iter || (*graph).v(ed) == *iter) {
value = false;
}
}
edge_filter[ed] = value;
}
// Generate a subgraph with the nodes that arent on the solution
SubGraph<ListGraph> sg(*graph, node_filter, edge_filter);
ShortestPath d(sg, *length);
d.run(node);
double current = calculatePathValue(d.path(*term));
if (current < min) {
min = current;
bestNode = term;
p = d.path(*term);
}
//cout << "VALUE: " << current << " PATH: " << (*graph).id(node)<< " ";
for (Path<ListGraph>::ArcIt it(p); it != INVALID; ++it) {
ListGraph::Arc a = it;
ListGraph::Edge x = a;
if ((*graph).u(x) == node) {
//cout << (*graph).id((*graph).v(x)) << " ";
} else if ((*graph).v(x) == node) {
//cout << (*graph).id((*graph).u(x)) << " ";
}
}
//cout << endl;
}
tnode.erase(bestNode);
// Add the shortest path to the solution
bool first = true;
//cout << "PATH: " << endl;
for (Path<ListGraph>::ArcIt it(p); it != INVALID; ++it) {
ListGraph::Arc a = it;
ListGraph::Edge x = a;
//cout << "edge: " << (*graph).id((*graph).u(x)) << "->" << (*graph).id((*graph).v(x)) << endl;
if ((*graph).u(x) == node) {
solution.push_back((*graph).v(x));
} else if ((*graph).v(x) == node) {
solution.push_back((*graph).u(x));
} else {
solution.push_back((*graph).v(x));
}
//cout << "\t add 1 nodes:" << endl;;
//cout << "\t\t add " << (*graph).id((*graph).v(x)) << endl;
}
//cout << "SOLUCAO ATUAL: ";
list<ListGraph::Node>::iterator s;
for (s = solution.begin(); s != solution.end(); s++) {
//cout << (*graph).id(*s) << " ";
}
//cout << endl;
// Get the last element from solution
term = solution.end();
term--; node = *term;
}
return solution;
}
/*!
Uniform sampling of an integer in the range [a, b].
Precondition: a <= b
*/
int p3d_random_integer(int a, int b)
{
assert(a <= b);
return(mersenne_twister_rng.randInt(b - a) + a);
}
void world::mateClocks()
{
// create a random number generator
MTRand randGen;
const int CLOCKS_TO_COMPETE = 3;
const int SRC_1 = 0;
const int SRC_2 = 1;
const int LEAST_ACC = 2;
// store indexes and accuracies of relevant clocks
int clockIndexes[CLOCKS_TO_COMPETE];
double clockScores[CLOCKS_TO_COMPETE];
// temp variables for swapping while sorting
int tempIndex;
double tempScore;
// stores selected clocks, initialized to a value out of array
int selectedClocks[CLOCKS_TO_COMPETE - 1] = {-1,-1};
int randClock = 0;
// run through each generation
for (int x = 0; x < mWorldSettings.mNumGenerations; x++)
{
// a generation is defined by x matings in a population of x clocks
for (int y = 0; y < mWorldSettings.mPopulationSize; y++)
{
for (int i = 0; i < CLOCKS_TO_COMPETE; i++)
{
do
{
randClock = randGen.randInt(mPopulation.size() - 1);
}
while (selectedClocks[0] == randClock || selectedClocks[1] == randClock);
if (i != CLOCKS_TO_COMPETE)
selectedClocks[i] = randClock;
// randomly choose a clock index from the population
clockIndexes[i] = randClock;
// retrieve the score of the clock
clockScores[i] = mPopulation[clockIndexes[i]].calcSurvivalScore();
}
// sort clocks by survival score
for (int j = 0; j < CLOCKS_TO_COMPETE; j++)
{
for (int k = j; k < CLOCKS_TO_COMPETE; k++)
{
// ensure that the index goes from greatest to least accurate
if (clockScores[j] < clockScores[k])
{
// if it doesn't, swap the accuracy and index reference
tempScore = clockScores[k];
clockScores[k] = clockScores[j];
clockScores[j] = tempScore;
tempIndex = clockIndexes[k];
clockIndexes[k] = clockIndexes[j];
clockIndexes[j] = tempIndex;
}
}
}
// rewrite third (least accurate) clock using source data from two other ones (the parents)
bioClock childClock (mPopulation[clockIndexes[SRC_1]], mPopulation[clockIndexes[SRC_2]]);
mPopulation[clockIndexes[LEAST_ACC]] = childClock;
}
recordGeneration();
cout << endl << "This is generation " << x + 1 << endl;
outputGenAverages();
}
}
extern "C" int rand()
{
return library_randomness.randInt();
}
int cProbabDistrib::Random(MTRand & a_Rand) const
{
int v = a_Rand.randInt(m_Sum);
return MapValue(v);
}
// integer in [0,n] for n < 2^32
uint32_t SoarRandInt(const uint32_t& max)
{
return gSoarRand.randInt(max);
}