My program deals with the Genetic Algorithm and Hill Climber Algorithm. I have a program that compiles without any errs, its just the data is gives is incorrect. I explain my error on the bottom part of my post

Header File

#include <iostream>
using namespace std;
//------------------------------------------------------------------------------
    template<class T>
    class redefinedVector
   {
   public:
      redefinedVector();
      int get_size() const; 
      int get_capacity() const; 
      void push_back(T);
      void pop(); 
      void resize(); 
      void print(); 
      T& operator[](int index); 
      ~redefinedVector(); 
  
   private:
      T *basket; 
      int capacity, size;
   };
//------------------------------------------------------------------------------   
    class Individual
   {
   public:
      friend class GeneticAlgorithm;
      friend class HillClimberAlgorithm;
      friend class UserInterface;
      
      Individual(); 
      Individual(int problem); 
      
      double randomization(double, double); 
      double GetData(int index) const;
      double GetFitness() const
       { 
         return fitness;
       }
       
      void SetProblem(int problem);
      void MathProblemsFitness();      
      void setData(int index,double numbers); 
      
      int getProblem()const
       { 
         return problem;
       }
   private:
      double data[30]; 
      double fitness; 
      double max; 
      double min; 
      int problem; 
   };
 
//------------------------------------------------------------------------------

class UserInterface
   {
   public:
      UserInterface();
      UserInterface(bool parameters, bool Problem, bool Optimization); 
      
      void setTimeResult(int,int);
      void setDataResult(int,Individual);
      
      Individual GetDataResult(int)const;     
      int getTimeResult(int) const;
   private:
      int highestTimes [3];
      Individual best [3];
   }; 
//------------------------------------------------------------------------------ 
 class GeneticAlgorithm
   {
       friend class UserInterface;
   public:
          
      GeneticAlgorithm(); 
      GeneticAlgorithm(int,int,double,double); 
          
      redefinedVector<Individual> individualResults;
      redefinedVector<int> iterationVector;
      redefinedVector<Individual> mainVector;
      
      
      int selection(int); 
      int randomization(int,int); 
      int checkAnswer(); 
      int rando(double);
      
      double randomizationDouble(double min, double max);
      
      void Breed(int,int,int,double,double); 
      void replace(Individual);      
      void Optimize(int, int,double,double);
      
   private:
      int parent1, parent2;
      int iterationNumber; 
   };
//------------------------------------------------------------------------------
class HillClimberAlgorithm
{
      public:

             HillClimberAlgorithm ();
             HillClimberAlgorithm(int problem, double mutation_chance, double mutation_amount);
             
             redefinedVector<Individual> finalHillClimber;
             redefinedVector<int>runTime;
             redefinedVector<Individual> hillVector;
             
             int randomization(int,int); 
             int checkAnswer();
             int rando(double mutation_rate);
  
             double randomizationDouble(double min, double max);
             void replace(Individual individual);
             
               
      private:          
             int inidividualA, individualB;
             int counter;
             double fitness;
};

Implementation

#include <cmath>
#include <cstdlib>
#include <ctime>
#include <string.h>
#include <fstream>
#include <sstream>
#include <stdexcept>
#include <stdio.h>
#include <ctype.h>
#include <vector>
#include <cctype>
#include <algorithm>
#include <iterator>
#include <iomanip>
#include <cstdlib>
#include <iostream>
#include <math.h>
#include "bpt0004_3.h"

using namespace std;
using std :: ifstream;
using std :: ofstream;
using std :: endl;

template<class T>
    redefinedVector<T>::redefinedVector() :capacity(2), size(0)
   {
      basket = new T [capacity];
   }

    template<class T>
    void redefinedVector<T>::push_back(T element)
   {
      if(size < capacity)
      {
         basket[size] = element; 
         size++;
      }
      else 
      {
         resize();
         basket[size] = element;
         size++; 
      }
   }
 
    template<class T>
    T& redefinedVector<T>::operator[](int index)
   {
      if(index >= size) 
      {
         cout << "Illegal index." << endl; 
         exit(0);
      }
      return basket[index]; 
   }
  
    template<class T>
    void redefinedVector<T>::pop()
   {
      if(size != 0)
      {
         size--; 
         capacity = size + 1; 
         T *newBasket = new T[capacity]; 
         for(int i = 0; i < size; i++)
         {
            newBasket[i] = basket[i];
         }
         delete [] basket; 
         basket = newBasket; 
      }
      else
      {
         cout << "Vector is Empty." << endl;
      } 
   }

    template<class T>
    redefinedVector<T>::~redefinedVector()
   {
      delete [] basket;
   }

    template<class T>
    void redefinedVector<T>::resize()
   { 
      T *newBasket = new T[capacity + 2]; 
      for(int i = 0; i < size; i++) 
      {
         newBasket[i] = basket[i];
      }
      delete [] basket; 
      basket = newBasket; 
      capacity += 2; 
   }
 
    template<class T>
    void redefinedVector<T>::print()
   {
      for(int i = 0; i < size; i++)
      {
         cout << basket[i] << " ";
      }
   }
 
    template<class T>
    int redefinedVector<T>::get_size() const
   {
      return size;
   }

    template<class T>
    int redefinedVector<T>::get_capacity() const
   {
      return capacity;
   } 
//-----------------------------------------------------------------------------

UserInterface::UserInterface()
   {
   }
 
int UserInterface::getTimeResult(int index)const
   {
      return highestTimes[index];
   }
void UserInterface::setTimeResult(int index, int numbers)  
   {
      highestTimes[index] = numbers;
   } 
Individual UserInterface::GetDataResult(int index)const
   {
      return best[index];
   }
void UserInterface::setDataResult(int index, Individual indiv)  
   {
      best[index] = indiv;
   }
UserInterface::UserInterface(bool parameters, bool Problem, bool Optimization)
   {                                  
   /*
   UserInterface Method that is the main menu for the user. Each bool parameter
   ensures that values are entered into various parts within the menu.
   */
   srand (time(0));
      
     
      bool sc = false;
      bool ro = false;
      bool gr = false;
      int userChoice = 0;
      int populationSize= 0; 
      int problem =0;
      int algoChoice=0;
      double mutation_amount=0; 
      double mutation_rate=0;
      bool menuBool=true;
          
      while(userChoice != 6)
      {
         do{ 
            cout << "Function Optimizer:\n" 
                 << "\n"
                 << "1. Choose Algorithm \n"
                 << "2. Choose Algorithm Parameters\n" 
                 << "3. Choose Problem (Schwefel, Rosenbrock, Griewangk).\n" 
                 << "4. Perform Optimization\n"  
                 << "5. Show All Optimization Results\n" 
                 << "6. Exit the System\n"
                 << "\n"
                 << "";
                       
            if(!(cin >> userChoice))
            {
               cout << endl;
               cout << "Unknown Value!" << endl;
               exit(0);
            } 
                   
            cout << endl;
         }
         
         while(userChoice > 6 || userChoice < 1); 
         
         if(userChoice ==1)
         {
          do
          {
            cout << "Enter Algorithm Choice\n"
                 << "1. HillClimber\n"
                 << "2. GeneticAlgorithm\n"
                 << endl;
            if (!(cin >>algoChoice))
            {
                      cout << endl;
                      cout << "Unknown Value!" <<endl;
                      exit(0);
            }
            if (algoChoice==1)
               cout <<"Hill Climber Chosen \n"
                    <<"";
            if (algoChoice==2)
               cout <<"GeneticAlgorithm Chosen\n"
                    <<"";
            }
            while((algoChoice < 0)&&(algoChoice >2));
            }             
                    
         if(userChoice == 2)
         {
            cout <<"Enter parameters for each algorithm. Only the mutation amount and mutation\n"
                 <<"chance will be used for the Hillclimber, the Genetic will take in the muation \n"
                 <<"chance, mutation amount, and population size.\n"
                 <<"\n";
            do{
               cout << "Enter Mutation Amount(.03-1.0): ";
               if(!(cin >> mutation_amount))
               {
                  cout << endl;
                  cout << "Unknown Value!" << endl;
                  exit(0);
               }
               cout << endl;
            }
            while(mutation_amount < -1);
        
            do{
               cout << "Enter Mutation Rate (.03-.25): ";
               if(!(cin >> mutation_rate))
               {
                  cout << endl;
                  cout << "Unknown Value!" << endl;
                  exit(0);
               }
               cout << endl;
            }while(mutation_rate < -1);
        
            do{
               cout << "Enter Population Size (2-50): ";
               if(!(cin >> populationSize))
               {
                  cout << endl;
                  cout << "Unknown Value!" << endl;
                  exit(0);
               }
               cout << endl;
               }
            
            while(populationSize < 2);
            parameters = true;
         }
        
         else if(userChoice == 3)
         {
            do{
               cout << "Choose a problem (Schwefel, Rosenbrock, Griewangk)." << endl;
               cout << "1 Schwefel" << endl;
               cout << "2 Rosenbrock" << endl;
               cout << "3 Griewangk" << endl;
            
               if(!(cin >> problem))
               {
                  cout << endl;
                  cout << "Unknown Value!" << endl;
                  exit(0);
               }
               cout << endl;
               if(problem == 1)
               {
                  sc = true;
               }
               else if(problem == 2)
               {
                  ro = true;
               }
               else if(problem == 3)
               {
                  gr = true;
               }
            }while(problem > 3 || problem < 1);
            Problem = true;
         }
        
         else if(userChoice == 4)
         {
            if(!parameters || !Problem)
            {
               cout << "Error" << endl << endl;
            }
            
            if (algoChoice==1)
            {
               HillClimberAlgorithm(problem, mutation_rate, mutation_amount);
               Optimization = true;
            }
            else if (algoChoice==2)
            {
               GeneticAlgorithm(problem,populationSize,mutation_rate,mutation_amount);             
               Optimization = true;
               
            }
         }
        
         else if(userChoice == 5)
         {
            if(!Optimization)
            {
               cout << "Optimization not run" << endl << endl;
            }
            else
            {
               if(sc == true)
               {
               
                  cout <<"Iterations: " << highestTimes[0] <<"\n";
               }
               else
               {
                  cout << "Schwefel information empty\n"
                       <<" " ;
                       
               }
               if(ro == true)
               {
              
                  
                  cout <<"Iterations: " << highestTimes[1] <<"\n";
               }
               else
               {
                  cout << "Rosenbrock information empty\n" 
                       << " " ;
               }
               if(gr == true)
               {
                 
                  cout <<"Iterations: " << highestTimes[2] <<"\n";
                 
               }
               else
               {
                  cout << "Griewangk information empty" << endl << endl;
               }
               }
              
         }
        
         else if(userChoice == 6)
         {
            cout << "Exiting" << endl;
            exit(0);
         }
         }   
   }
//------------------------------------------------------------------------------
HillClimberAlgorithm::HillClimberAlgorithm() 

{
}
void HillClimberAlgorithm::replace(Individual newIndividual)
/*Replace takes the least fit individual and replaces it the the newIndividual
Pre-condition: takes in a newIndividual of type Individual, which sets a vector of random integers between a range
determined by the problem.
Post-condition replaces the current individual at hillvector[i] with the newIndividual
*/
   {
      double temp = hillVector[0].GetFitness(); 
      int index = 0; 
      for(int i = 1; i < hillVector.get_size(); i++)
      {
         if(temp < hillVector[i].GetFitness())
         {
            temp = hillVector[i].GetFitness();
            index = i; 
         }
      }
     
      for(int i = 0; i < 30; i++)
      {
         hillVector[index].setData(i,newIndividual.GetData(i));
         hillVector[index].MathProblemsFitness();
      }
     
      counter++;
     }
int HillClimberAlgorithm::rando(double mutation_rate)
/*
Pre-condition: user entered mutation_rate
Post-condition: generates a random double based on the mutation_rate
*/
   {
      double number = rand() / (double)RAND_MAX;
      return number < mutation_rate;
   }
int HillClimberAlgorithm::randomization(int min, int max)
/*
Pre-condition: 2 integers
Post-condition: random generated integer between the range of min and max
*/
   {
      return static_cast<int>(( static_cast<double>(rand()))/ static_cast<double>( RAND_MAX) *(max-min + 1) + min);
   }
double HillClimberAlgorithm::randomizationDouble(double min, double max)
/*
Pre-condition: 2 double
Post-condition: random generated double between the range of min and max
*/
   {
      return static_cast<double>(rand())/ static_cast<double>( RAND_MAX) *(max-min + 1) + min;
   }
HillClimberAlgorithm::HillClimberAlgorithm(int problem, double mutation_rate, double mutation_amount)
/*
Main constructor used in the HillClimber Algorithm
Pre-condition: takes in three parameters: problem, mutation_rate, mutation_amount
Post-condition: Passes the Individual through the MathProblemsFitness and generates a fitness,
if the fitness is less than the current fitness, than the newIndividual replaces individual
*/
{
       Individual newIndividualA(problem);
       fitness= newIndividualA.GetFitness();
       
       double range=0;
       if(problem == 1) 
      {
         range = 131.072;
      }
      else if(problem == 2)
      {
         range = 4.096;
      }
      else
      {
         range = 1200;
      }
       
       while( fitness < .1)
       {
         int chance = 0;
         int choice = rando(mutation_rate);
         int selection = 0;
         selection = randomization(1,2);
         Individual newIndividualB;
         for(int i = 0; i < 30; i++)
         {
         if(choice == 1)
         {
         
          
            double newData = hillVector[selection].GetData(i); //get the data from the chosen parent
            newData = newData + range*(randomizationDouble(0,2)-1)*mutation_amount; //mutate it occording to the formula
            newIndividualB.setData(i,newData); //set the new data into the corresponding index of the child object
            if(newData > range/2) //if the number goes out of the upper bounds
            {
               newIndividualB.setData(i,range/2);
            }
            else if(newData < ((range/2)*-1)) //if the number gooes out of the lower bounds
            {
               newIndividualB.setData(i,((range/2)*-1));
            }
         }
         else 
         {
            newIndividualB.setData(i,hillVector[selection].GetData(i));
         }
      }
         
              int iterations=0;
              for (int i=0; i < 30; i++)
              {
           
               Individual newIndividualB (problem);           
               newIndividualB.setData(i,newIndividualB.GetData(i)+newIndividualB.GetData(i)*((static_cast<double>(rand())/ static_cast<double>( RAND_MAX) *(2-0 + 1) + 0))*mutation_amount); 
               double newFitness=newIndividualB.GetFitness();
               
               iterations++;
             
             if (newFitness < fitness)
             { newIndividualB.MathProblemsFitness();
               replace(newIndividualB);
             }
               
             
              cout << iterations << endl;            
               }  
               
       }  
        
       }
//------------------------------------------------------------------------------
Individual::Individual() 
   {
   }
  
double Individual::GetData(int index) const
   {
      return data[index]; 
   }
  
void Individual::setData(int index, double numbers) 
   {
      data[index] = numbers;
   }
  
void Individual::SetProblem(int Problem) 
   {
      problem = Problem; 
   }

Individual::Individual(int problem)
/*
Creates a new individual, and based on the problem, enters random values into 
a vector and passes that vector through MathProblemsFitness to create a fitness

Pre-condition:user entered problem
Post-condition: New individual created based on the problem choice and a fitness calculated
*/
   {
      SetProblem(problem); 
      if(problem == 1)
      {  
      for(int i = 0; i < 30; i++)
      {
         data[i] = randomization(-65.536,65.536);
      }         
      }
      else if(problem == 2)
      { 
      for(int i = 0; i < 30; i++)
      {
         data[i] = randomization(-2.048,2.048);
      }
      }
      else if(problem == 3)
      {
      
      for(int i = 0; i < 30; i++)
      {
         data[i] = randomization(-600,600);
      }
      }
      
      MathProblemsFitness();
   }
 
 double Individual::randomization(double min, double max) 
   {
      return static_cast<double>(rand())/ static_cast<double>( RAND_MAX) *(max-min + 1) + min;
   }
 
    void Individual::MathProblemsFitness()
    /*
    MathProblemsFitness defines the three math probelems (Schwefel, Rosenbrock, Griewangk)
    each vector from individual passes through these problems to calculate a fitness
    */
   {
      double holder = 0;
      double temp2 = 1;
      fitness = 0; 
      int next = 1; 
      if(problem == 1) 
      {
         for(int i = 0; i < 30; i++)
         {
            holder = 0;
            for(int j = 0; j < next; j++)
            {
               holder = holder + data[j];
            }
            next++;
            fitness = fitness + (holder*holder);
         }
      }
      else if(problem == 2)
      {
         for(int i = 0; i < 29; i++)
         {
            holder = 0;
            holder = 100*(data[i+1]-(data[i]*data[i]))*(data[i+1]-(data[i]*data[i])) + (data[i] - 1)*(data[i] - 1);
            fitness = fitness + holder;
         }
      }
      else if(problem == 3)
      {
         for(int i = 0; i < 30; i++)
         {
            holder = 0;
            holder = (data[i]*data[i])/4000;
            fitness = fitness+ holder;
         }
         fitness = fitness + 1;
       
         for(int i = 0; i < 30; i++)
         {
            holder = 0;
            holder = cos(data[i]/sqrt(i+1));
            temp2 = temp2 * holder;
         }
         fitness = fitness - temp2;
      }
   }
//------------------------------------------------------------------------------    
GeneticAlgorithm::GeneticAlgorithm() 
   {
  
   }
  
  GeneticAlgorithm::GeneticAlgorithm(int problem, int populationSize, double mutation_rate, double mutation_amount)
  /*
  Builds the population of individuals and pushes it into the mainVector, then loop through 5 times
  until the desired value is reached.
  */
   {
      UserInterface m;
      int iterations;
      for(int i = 0; i < 5;  i++)
      {
         iterationNumber = 0; 
         for(int i = 0; i < populationSize; i++)
         {
            Individual I(problem); 
            mainVector.push_back(I); 
         }
         int foundIt = 0; 
         checkAnswer(); 
         while(foundIt == 0 && iterationNumber < 5000000) 
         {
            foundIt = checkAnswer();
            Optimize(problem, populationSize,mutation_rate, mutation_amount); 
            foundIt++;
         }  
            
     
         int index = 0;
         double temp = mainVector[0].GetFitness(); 
         
         for(int i = 1; i < mainVector.get_size(); i++)
         {
                 
            if(temp > mainVector[i].GetFitness())
            {
               temp = mainVector[i].GetFitness();
               index = i; 
            }
         }
         individualResults.push_back(mainVector[index]);
         iterationVector.push_back(iterationNumber);
         
         if(problem == 1)
         {
            if(iterationNumber < m.getTimeResult(0))
            {
               m.setTimeResult(0,iterationNumber);
               m.setDataResult(0,mainVector[index]);
            }
         }
         
         else if(problem == 2)
         {
            if(iterationNumber < m.getTimeResult(1))
            {
               m.setTimeResult(1,iterationNumber);
               m.setDataResult(1,mainVector[index]);
            }
         }
         else
         {
            if(iterationNumber < m.getTimeResult(2))
            {
                       
               m.setTimeResult(2,iterationNumber);
               m.setDataResult(2,mainVector[index]);
            }
         }
         for(int i = 0; i < populationSize; i++) 
         {
            mainVector.pop();
         }
      }
  
      cout << endl;
      
      cout << "Results: \n"
           << "\n"
           << "";
        
      for(int i = 0; i < individualResults.get_size(); i++)
      {
         cout << endl;
         cout << "Individual Best: ";
         for(int j = 0; j < 30; j++)
         {
            cout << individualResults[i].data[j] << "\n"
                 <<"";
         }
         cout << "\n"
              << "Fitness Level: " << individualResults[i].GetFitness() << "\n"
              << "Iterations: " << iterationVector[i] << endl;
      }
     
      for(int i = 0; i < individualResults.get_size(); i++)
      {
         individualResults.pop();
         iterationVector.pop();
      }
      cout << endl;
   }


    
void  GeneticAlgorithm::Optimize(int problem, int populationSize, double mutRate, double mutAmount)
   {
      parent1 = selection(populationSize);
      parent2= selection(populationSize);
      Breed(parent1,parent2,problem,mutRate,mutAmount); 
   }

    void GeneticAlgorithm::Breed(int parent1, int parent2, int problem, double mutation_rate,double mutation_amount)
   {
      Individual child(problem); 
      double range = 0;
      if(problem == 1) 
      {
         range = 131.072;
      }
      else if(problem == 2)
      {
         range = 4.096;
      }
      else
      {
         range = 1200;
      }
      for(int i = 0; i < 30; i++)
      {
         int selection = 0;
         selection = randomization(1,2); 
         if(selection == 1)
         {
            selection = parent1; 
         }
         else
         {
            selection = parent2; 
         }
         int chance = 0;
         int choice = rando(mutation_rate); 
         if(choice == 1) 
         {
          
            double newData = mainVector[selection].GetData(i);
            newData = newData + range*(randomizationDouble(0,2)-1)*mutation_amount; 
            child.setData(i,newData); 
            if(newData > range/2) 
            {
               child.setData(i,range/2);
            }
            else if(newData < ((range/2)*-1)) 
            {
               child.setData(i,((range/2)*-1));
            }
         }
         else 
         {
            child.setData(i,mainVector[selection].GetData(i));
         }
      }
      child.SetProblem(mainVector[parent1].getProblem()); 
      child.MathProblemsFitness(); 
      replace(child); 
   }
  
int GeneticAlgorithm::rando(double mutRate)
   {
      double number = rand() / (double)RAND_MAX;
      return number < mutRate;
   }

void GeneticAlgorithm::replace(Individual child)
   {
      double temp = mainVector[0].GetFitness(); 
      int index = 0; 
      for(int i = 1; i < mainVector.get_size(); i++)
      {
         if(temp < mainVector[i].GetFitness())
         {
            temp = mainVector[i].GetFitness();
            index = i; 
         }
      }
     
      for(int i = 0; i < 30; i++)
      {
         mainVector[index].setData(i,child.GetData(i));
         mainVector[index].MathProblemsFitness();
      }
     
      iterationNumber++; 
 while (iterationNumber ==0)
      //if(iterationNumber %100 == 0) 
      {
                         
         temp = mainVector[0].GetFitness(); 
         for(int i = 1; i < mainVector.get_size(); i++)
         {
            if(temp > mainVector[i].GetFitness())
            {
               temp = mainVector[i].GetFitness();
            }
         }
         cout << "Best Fitness: " << iterationNumber <<" " << temp <<endl; 
      }  

    
   
   }
  
int GeneticAlgorithm::checkAnswer()
   {
      for(int i = 0; i < mainVector.get_size(); i++)
      {
         if(mainVector[i].GetFitness() < .1)
         {
            return 1;
         }
         else
         {
            return 0;
         }
      }
   }

int GeneticAlgorithm::selection(int populationSize)
   {
      int choice = rand() % populationSize;
      int choice2 = rand() % populationSize;
      if(mainVector[choice].GetFitness() < mainVector[choice2].GetFitness())
      {
         return choice;
      }
      else
         return choice2;
   }
 
 int GeneticAlgorithm::randomization(int min, int max)
   {
      return static_cast<int>(( static_cast<double>(rand()))/ static_cast<double>( RAND_MAX) *(max-min + 1) + min);
   }
  
    double GeneticAlgorithm::randomizationDouble(double min, double max)
   {
      return static_cast<double>(rand())/ static_cast<double>( RAND_MAX) *(max-min + 1) + min;
   }

and Main

#include <iostream>
#include "bpt0004_3.h"

using namespace std;

int main() 
   {
      
      bool parameters = false, Problem = false, Optimization = false; 
      UserInterface(parameters, Problem, Optimization);
      
      return 0;
   }

My error:
1. first choose 1, then choose 2 for genetic algorithm
2. choose 2, then input parameters within the ranges given
3. choose 3, and choose 1(schwefel)
4. choose 4 to optimize
5. choose 5 <-----this displays the correct number of iterations
6. choose 3, and choose 2 or 1(Rosenbrock or Griewangk)
7. choose 4 to optimize
8. choose 5 <-----This displays the error

Error
Genetic Iterations Schwefel: -1209686560
Genetic Iterations Rosenbrock: 1
Genetic Iterations Griewangk: -1079226444


Why am i getting negative numbers and why is the iterations for rosenbrock just 1?? Please help me, this program is due tonight.

Edited 7 Years Ago by bpt0004: n/a

You miscopied the implementation, it's just a duplicate of the header, so I can't make any comments on your error except speculation.

>Why am i getting negative numbers and why is the iterations for rosenbrock just 1??
I can't say why rosenbrock is 1, though with a name like rosenbrock, I'm not sure I'd want more than one anyway. However, unexpected negative numbers usually result from uninitialized variables, or arithmetic overflow. Make sure that you're initializing your variables, and then step through the code in a debugger to make sure that you aren't exceeding the range of the data type. Technically it's undefined, but in practice you'll usually get wraparound into negatives.

Narue, i posted the implentation file. I rechecked everything with a bunch of couts and g++ and i still cant find it. I have everything initialized everywhere, or at least since i checked last time.

>I have everything initialized everywhere, or at least since i checked last time.
Then your problem is with the math, or you're overflowing an array somewhere and ultimately using uninitialized/garbage data. In all honesty, I'd rather have a root canal done on my eyeballs than troubleshoot that mess, so you'll just have to step through the algorithm yourself and see where it starts to go bad.

My advice is to keep a close watch on your numeric variables. Arithmetic overflow can easily bork up results. Also, watch your indices and verify that you aren't accessing an array outside of its boundaries.

check your functions. Instead of passing your variables by value; pass them by reference.

double randomization(double &, double &); //function header

Make sure that all the function headers have the ampersand(&) and when in your function you need the ampersand as well.

double randomization(double & x, double & y)// example
{

return whatever// going to need to return a value unless if its a void
}

This article has been dead for over six months. Start a new discussion instead.