investment_problem.class.cpp

Go to the documentation of this file.

class investment_problem : public investor, public portfolio
{
public:
//inherited:  int investor_id;
  investment_problem(int investor);       
  void solve();                           
  int  get_nbr_goals();
  std::map<int, aGOAL> goalZ;             
  int  get_max_month_for_lower_goals(int g);
  void javaGraph(int g,string xtra_var = "", string xtra_label = "", int followup_mnth = 0);
  void prepare_javaVars_colors(int g, int followup_mnth);
  void parse_javaGraph(int g, string xtra_var = "", string xtra_label = ""); 

protected:
  std::map<int, portfolio> portfolios;    
  void set_followup_color_prae(float Vlow, float Vmed, float Vhigh, int g);
  void set_followup_color_post(float V, int g);

private:

  std::map<int, float> means;             
  std::map<int, float> means_left;        
  std::map<int, float> means_used;        
  std::map<int, float> means_block;       
  std::map<int, float> means_tmp;         

  int nbr_portfolios;                     
  //inherited:   age;                       // the age of the investor TODAY
  int    nbr_goals;                       
  int    nbr_assets = 0;                  
  int    nbr_cfs;                         

  void  set_assets();                     
  void  set_cfs();
  void  set_goals();
  void  set_means_goal(int g);            
  void  expand_cf(float amount, string freq = "M", string fromStr="", string tillStr="",  int goal_nbr = 0);
  void  set_portfolios();                 
  float get_optimal_portfolio(int g);     
  float calc_alpha(int priority, int monthNbr);    
  void  set_priorityLimits();             
  float goal_seek_means(int g, int p);    
  void  goal_seek_tmp_means(float *perc, int g, int p); 
  float calc_risk(int g,int p) ;          
  float calc_V_high(int g, int p = 0);    
  void  set_goal_color(int g, float opt_perc);  
  void  set_goal_remarks(int g);                
  void  allocate_to_unallocated_goal(int unallocated_goal_nbr); 
  int   get_portfolio_safest();              
  int   get_portfolio_riskiest();            
  bool  set_unallocated_goal();
  //bool* portfolio_suitable = NULL;
  std::map<int, bool> portfolio_suitable;
  

//  float get_risk(const char* riskFunction, int theGoal, int thePortfolio);
//  float ExpectedShortfall_normDist(int theGoal, int thePortfolio);
  int priorityMax;
  int priorityMin;
  /*
  std::map<int, asset> assets;       // set of asset_objects
  std::map<int, cf> cfs;             // set of CF-objects
  std::map<int, goal> goals;         // set of goal-objects
*/

};

investment_problem::investment_problem(int investor)
 // : market(investor)  ///< note: parent class constructur in the initializer list in order to pass the parameter
{
  if (load_from_db(to_string(investor)) <= 0 )  {    /*TODO : errorhandling*/  }
  investor_id = investor;
  for (int i=0; i <= months2simulate(); i++) 
  {
    means.insert      (std::pair<int,float>(i, 0.0) );
    means_left.insert (std::pair<int,float>(i, 0.0) );
    means_used.insert (std::pair<int,float>(i, 0.0) );
    means_block.insert(std::pair<int,float>(i, 0.0) );
    means_tmp.insert  (std::pair<int,float>(i, 0.0) );
  } // initialize means ...
  set_assets();     // adds assets to means[]  
  set_cfs();        // adds cash flows to means[]
  
  set_goals();      // adds goals to goalZ[] in the right order(!)
  
  //market(investor_id);  ///< re-execute the constructor with the right user-id now ... DOES NOT WORK (changes investor_id into a pointer to market)
  load_ER(investor_id);
  load_covar(investor_id);
  set_portfolios(); // sets nbr_portfolios, the map portfolios and the portfolio_suitable map (executes set_mu() and set_sigma, using the ER van covar)

  if (nbr_goals == 0) {error_message = error_message + t_errMsg["no_goals"];}
  if (nbr_assets + nbr_cfs == 0) {error_message = error_message + t_errMsg["no_assets"];}

}

void investment_problem::set_assets() 
{
  string s, the_curr   = "";
  float  theSum = 0;
  cls_currency oCurr;
  s = "SELECT amount, currency FROM " + oConfig.tbl_prefix + "_assets WHERE investor = " + std::to_string(investor_id) + ";";
  
  db.res = db.stmt->executeQuery(s);
  while (db.res->next())  
  {
    the_curr = db.res->getString("currency");
    if (oCurr.set_curr(the_curr))
    {
      theSum += oCurr.to_curr(db.getFloat("amount"), this->currency);
      //theSum += db.getFloat("amount");
      nbr_assets++;
    }
    else
    {
      error_message = error_message + "<li> ERRN3400: invalid currency</li>";
      theSum += db.getFloat("amount");
    }
//    cout << " || the " << nbr_assets << " first assets are " << theSum << this->currency << " worth. XDB<BR>";
  }
//  cout << "<BR>the number of assets=" << nbr_assets;
  this->means.at(0) = theSum;
 }

 void investment_problem::expand_cf(float amount, string freq, string fromStr, string tillStr, int goal_nbr)
 {
   int m, step;
   int startMnth;
   int endMnth = this->months2simulate();
   struct tm tm1; struct tm tm2;
   if (freq == "M")      step = 1;
   else if (freq == "A") step = 12;
   else if (freq == "Q") step = 3;
   else if (freq == "S") step = 6;
   else if (freq == "W") 
   {
      amount *= 30.4375/7;  // note: 30.4375 = 365.25/
      step = 1;
   }
   else if (freq == "D") 
   {
     amount *= 30.4375;  // note: 30.4375 = 365.25/
     step = 1;
   }
   else step = 1;
   tm1 = get_tm();
   dateStr2tm(fromStr, &tm2);
   if (is_valid_dateStr(fromStr) && (difftime(mktime(&tm1), mktime(&tm2)) < 0)) {startMnth = dateStr2Mnbr(fromStr);} else {startMnth = 0;}
   if (is_valid_dateStr(tillStr)) {endMnth = dateStr2Mnbr(tillStr);} else {endMnth = this->months2simulate();}
   m = startMnth;
   while (m <= endMnth && m <= this->months2simulate()) //just in case endMnth > months2simulate
    {
    if (goal_nbr == 0)
      {
        means.at(m) += amount;
      }
      else
      {
        goalZ[goal_nbr].means_goal.at(m) += amount;
      }
        m += step;
        }
//        cout << "<BR>expand_cf: from=" << startMnth << " | to_m=" << m << " | add_to_means=" << add_to_means<< " | step=" << step;
 }

void investment_problem::set_cfs()
 {
  string s = "", d1, d2, the_curr;
  float amnt;
  cls_currency oCurr;
  s = "SELECT * FROM " + oConfig.tbl_prefix + "_cash_flows WHERE investor = " + std::to_string(this->investor_id) + ";";
  db.res = db.stmt->executeQuery(s);
  while (db.res->next())
  {
    d1 = db.res->getString("from_date");
    d2 = db.res->getString("till_date");
    the_curr = db.res->getString("currency");
    oCurr.set_curr(the_curr);
    amnt = oCurr.to_curr(atof(db.res->getString("amount").c_str()), this->currency);

    expand_cf(amnt, db.res->getString("frequency").c_str(), d1, d2);
    nbr_cfs++; // increment the number of cash flows so that at the end this reflects the number of cash flows
  }
}

void investment_problem::set_goals()
{
  string s = "";
  int nbr  = 0;
  s = "SELECT * FROM " + oConfig.tbl_prefix + "_goals WHERE investor = " + to_string(this->investor_id) + " ORDER BY priority ASC;";
  this->set_priorityLimits();
  db.res = db.stmt->executeQuery(s);
#ifdef DEBUG
  debug_info = debug_info + "<BR>goal_type_s2i[\"amount@date\"] = " + to_string(goal_type_s2i["amount@date"]);
  debug_info = debug_info + "<BR>goal_type_s2i[\"income from/to\"] = " + to_string(goal_type_s2i["income from/to"]);
#endif
  while (db.res->next())
  {
    nbr++;
//    this->goalZ[nbr] = aGOAL(investor_id); //create new and run constructor
    this->goalZ.insert(pair<int, aGOAL>(nbr, aGOAL(investor_id)));
    this->goalZ[nbr].set_from_db();
#ifdef DEBUG
   debug_info = debug_info + "<BR>---goal: " + to_string(nbr);
   debug_info = debug_info + "<BR>goal_type = " + to_string(goalZ[nbr].goal_type);
#endif
 
//cout << "<br>g=" << to_string(nbr) << "   amount=" << goalZ[nbr].amount;
    //GOAL_TYPES:  (4, "amount asap"),     
    if (goalZ[nbr].goal_type == goal_type_s2i["unallocated"]) //(0, "unallocated"),        
      {
        goalZ[nbr].realization_monthNbr = months2simulate();
        goalZ[nbr].target_amount        = 0;
     }
      else if (goalZ[nbr].goal_type == goal_type_s2i["amount@date"]) //(1, "amount@date")
      {
    goalZ[nbr].realization_monthNbr = age2monthNbr(goalZ[nbr].realization_age);
    goalZ[nbr].target_amount        = goalZ[nbr].amount;
      }
      else if (goalZ[nbr].goal_type == goal_type_s2i["income from/to"]) // (2, "income from/to")
      {
    goalZ[nbr].realization_monthNbr = dateStr2Mnbr(goalZ[nbr].till_date);
    goalZ[nbr].target_amount        = 0;
//  debug_info = debug_info + "<BR>goalZ[nbr].realization_monthNbr" + to_string(goalZ[nbr].realization_monthNbr);
//  debug_info = debug_info + "<BR>goalZ[nbr].target_amount" + to_string(goalZ[nbr].target_amount);
      }
      else if (goalZ[nbr].goal_type == goal_type_s2i["rainy day savings"]) // (3, "rainy day savings")
      {
    goalZ[nbr].realization_monthNbr = RAINY_DAY_MONTH_NBR;
    goalZ[nbr].target_amount        = goalZ[nbr].amount;
      }
      else if (goalZ[nbr].goal_type == goal_type_s2i["amount asap"]) // (4, "amount asap")
      {
    goalZ[nbr].realization_monthNbr = months2simulate();
    goalZ[nbr].target_amount        = goalZ[nbr].amount;
      }
      else                                // assume that it is an amount@date type of goal
      {
    goalZ[nbr].realization_monthNbr = age2monthNbr(goalZ[nbr].realization_age);
    goalZ[nbr].target_amount        = goalZ[nbr].amount;
      }
    this->goalZ[nbr].alpha             = calc_alpha(this->goalZ[nbr].priority, this->goalZ[nbr].realization_monthNbr);
 //   cout << "<br>goalZ[" << nbr<<"].alpha = " << goalZ[nbr].alpha;
      
  set_means_goal(nbr);
  
    if ( goalZ[nbr].realization_monthNbr > months2simulate())  goalZ[nbr].realization_monthNbr = months2simulate();
  }
  this->nbr_goals = nbr;
}


void investment_problem::set_priorityLimits()
{
  string s = "";
  s = "SELECT MIN(priority) as theMin, MAX(priority) as theMax FROM " + oConfig.tbl_prefix + "_goals WHERE investor = " + to_string(this->investor_id) + " AND goal_type != " + to_string(goal_type_s2i["unallocated"]) + ";";
  db.res = db.stmt->executeQuery(s);
  while (db.res->next())
  {
    this->priorityMax = atoi(db.res->getString("theMax").c_str());
    this->priorityMin = atoi(db.res->getString("theMin").c_str());
  }
}


inline float investment_problem::calc_alpha(int priority, int monthNbr)
{
  float x;
  if (priorityMin != priorityMax)
  {
    x =  MIN_ALPHA + (MAX_ALPHA - MIN_ALPHA)*(priority - priorityMin)/(priorityMax-priorityMin);
  }
  else
  {
    x =  0.01;
  }
//xx  cout << "[" << x;
  if (x < ALPHA_UPPER_LIMIT) x += (ALPHA_UPPER_LIMIT - x) * (1 - exp(- monthNbr / 12 / 35));
//xx  cout << " --> " << x  ;
  if (x > ALPHA_LOWER_LIMIT) x -= (x - ALPHA_LOWER_LIMIT) * exp(- monthNbr / 12 / 5);
//xx  cout << " --> " << x << "]"   ;
  return x;
}


void investment_problem::set_portfolios()
{
  int nbr  = 0, count = 0, p, ac;
  bool is_suitable;
  string s = "SELECT portfolio_id FROM " + oConfig.tbl_prefix + "_portfolios ORDER BY portfolio_id;";
  db.res = db.stmt->executeQuery(s);
  while (db.res->next())
  {
    nbr = db.res->getInt("portfolio_id");
    if (this->portfolios[nbr].get_portf_from_db(nbr)) //success retrieving info
    {
      this->portfolios[nbr].set_mu(this->assetClass_mu);        //sets pMu
      this->portfolios[nbr].set_sigma(this->assetClass_covar); // sets pSigma
 //xxx     cout << "<br>portf[" << nbr << "] ER=" << exp(12 * portfolios[nbr].pMu) - 1 << "    S=" << sqrt(12) * portfolios[nbr].pSigma;
      count++;
    }
  }
/* not needed any more because portfolio_suitable is a C++ map  now and not a C array any longer
  bool* new_block = NULL;
  new_block = (bool*) realloc(portfolio_suitable, nbr_portfolios * sizeof(bool));
  if (new_block != NULL)
    {
        portfolio_suitable = new_block;
    }
    else
    {
      free(portfolio_suitable);
#ifdef DEBUG
      debug_info = debug_info + "<br/>realloc() failed in portfolio_suitable()";
#endif
    }
    */

  // set the number of portfolios (note: already used in the next lines!)
  this->nbr_portfolios = count;

  // now set the portfolio_suitable map
  load_preferences();  // to set the map set_max_exposure (inherited from the investor class)
  for (p =1; p <= nbr_portfolios; p++) 
  {
    is_suitable = true;
    for (ac = 1; ac <= NBR_ASSET_CLASSES; ac++)
    {
    //(portfolios[p].weights[ac-1] <= max_exposure[ac])?portfolio_suitable[p-1] = true : portfolio_suitable[p-1] = false;
      if (portfolios[p].weights[ac-1] > max_exposure[ac]) is_suitable = false;
    }
    portfolio_suitable[p] = is_suitable;    
  }

}

void investment_problem::solve()
{
  int g = 1,m, k, freeFrom, unallocated_goal_nbr = 0;
  float opt_perc, amnt_used, currency_conversion;
  cls_currency g_currency; 
  
  //cout << " ### months2simulate=" << to_string(months2simulate());  
  //cout << " ### goalZ[g].realization_monthNbr=" << to_string(goalZ[g].realization_monthNbr);
  
  
  for(m=0;m<=goalZ[g].realization_monthNbr;m++) 
  {
    means_left.at(m) = means.at(m);  
    //cout << "  | means.at(" << m << ")=" << means.at(m);
  }

  for (g = 1; g <= this->nbr_goals; g++)
    {
      
      /*
      //TODO: prepare covar, E_R and eventually portfolios for the relevant goal-currency
      set_mu(goalZ[g].currency);
      set_covar(goalZ[g].currency);
      set_portfolios(goalZ[g].currency);
      */
      
      // convert all relevant means_left to the goal-currency
      g_currency.set_curr(this->currency);
      currency_conversion = g_currency.to_curr(1.0, goalZ[g].currency);
      if (currency_conversion != 0) 
      {
    for(m=0;m<=goalZ[g].realization_monthNbr;m++) 
    {
      means_left.at(m) = means_left.at(m) * currency_conversion;  
    }
      }
      else
      { // if the currency_conversion equals zero, then we convert it to one (to avoid dividing by 0 later)
    currency_conversion = 1;
      }
      
      if (goalZ[g].goal_type == goal_type_s2i["unallocated"]) 
      {
    unallocated_goal_nbr = g;
    continue;  
      }
      freeFrom = get_max_month_for_lower_goals(g);

      
/* TODO: refine the allocation for from/to goals
       if (goalZ[g].goal_type == goal_type_s2i["income from/to"]
      {
    
      }
  */    
      for(m=0; m<=goalZ[g].realization_monthNbr; m++) 
      {
    means_used[m] = 0;     
      }


//xx      set_means_goal(g);/// calculate the means that are implied by the goal (eg as income "from/till"
      if ((goalZ[g].goal_type == goal_type_s2i["amount asap"]) || (goalZ[g].goal_type == goal_type_s2i["rainy day savings"]))
      { 
    //for (k = 0; k < months2simulate(); k++) means_block[k] = 0;
    k = 0;
    
    do
    {
      means_block[k] = means_left[k];
      goalZ[g].realization_monthNbr = k;
      if (k > 0) 
      {
        means_used[k-1]  = means_block[k-1];
        means_block[k-1] = 0;
      }
      opt_perc = get_optimal_portfolio(g);
    } while ((opt_perc > 1 - PRECISSION) && (k < months2simulate()) );

/*  
    means_block[0] = means_left[0];
    goalZ[g].realization_monthNbr = 0;
    opt_perc = get_optimal_portfolio(g);
    for (k = 1; (k < months2simulate()) && (opt_perc > 1 - PRECISSION); k++) //realization_monthNbr = months2simulate()-1
    {
      goalZ[g].realization_monthNbr = k;
          means_used[k-1]  = means_block[k-1];
      means_block[k-1] = 0;
      means_block[k]   = means_left[k];
      opt_perc         = get_optimal_portfolio(g);
    }
*/  
      }
      else 
      {
        for (k = freeFrom; k <= goalZ[g].realization_monthNbr; k++) means_block[k] = means_left[k];
    opt_perc = get_optimal_portfolio(g);
    
    if (opt_perc > 1 - PRECISSION)
    {
      //means_used = means_block since we're only here if opt_perc == 1
      for (k = freeFrom; k <= goalZ[g].realization_monthNbr; k++)
      {
        means_used[k]  = means_block[k];
        means_block[k] = 0;
      }
      for (k = 0; k < freeFrom;k++) means_block[k] = means_left[k];
  //xx  cout << "<br>===[GOAL " << g << "]====<br>";
      opt_perc = get_optimal_portfolio(g);
  //xx  cout << "<br>===[end]===<br>";
    }
      }
      

    for (k = 0; k <= goalZ[g].realization_monthNbr; k++)
    {
      amnt_used = means_used[k] + (means_block[k] * opt_perc);
     // if(amnt_used > 0)
     // {
    means_left[k] = (means_left[k] - amnt_used) / currency_conversion;
    goalZ[g].saving_plan[k] = amnt_used;

     // }
    }
    for (k = 1; k <= NBR_ASSET_CLASSES; k++)
    {
       goalZ[g].benchmark[k] = portfolios[goalZ[g].optimal_portf].weights[k-1];
    }
    set_goal_color(g, opt_perc);    
    set_goal_remarks(g);            

  //goalZ.save_results();   //TODO
  } //(g = 1; g <= this->nbr_goals; g++)

  allocate_to_unallocated_goal(unallocated_goal_nbr);
}


void investment_problem::set_goal_color(int g, float opt_perc)
{
if (opt_perc < 1 - PRECISSION)
    {
      goalZ[g].success = true;
      if (flSum(&means_left, goalZ[g].realization_monthNbr) > 0.1 * flSum(&goalZ[g].saving_plan, goalZ[g].realization_monthNbr))
       {
         goalZ[g].remarks = t_feedback["brightgreen"];
         goalZ[g].color   = "brightgreen";
       }
      else
      {
        goalZ[g].remarks = t_feedback["green"];
    goalZ[g].color   = "green";
      }
    }
    else  // opt_perc = 1
    {
      goalZ[g].success = false;
      //cout << "<br>flSum(&goalZ["<<g<<"].saving_plan, goalZ[g].realization_monthNbr)="<<flSum(&goalZ[g].saving_plan, goalZ[g].realization_monthNbr);
      if (flSum(&goalZ[g].saving_plan, goalZ[g].realization_monthNbr) > 0)
      {
    goalZ[g].remarks = t_feedback["red"];
    goalZ[g].color   = "red";
      }
      else
      {
    goalZ[g].remarks = t_feedback["darkred"];
    goalZ[g].color   = "darkred";
      }
      if (calc_V_high(g) >= goalZ[g].amount - goalZ[g].max_shortfall)
      {
        goalZ[g].remarks = t_feedback["amber"];
    goalZ[g].color   = "amber";
      }
    }  
}

void investment_problem::set_goal_remarks(int g)
{
 goalZ[g].remarks = "<u>" + goalZ[g].remarks + "</u>"
           + "<br>The portoflio corresponding to this benchmark is called " + portfolios[goalZ[g].optimal_portf].description + "."
           + "<br>The shortfall of this portfolio with the given savings plan is estimated to be "
           + curr_format(goalZ[g].realized_shortfall, currency) + " with a probability of "
       + to_string((int)((1-goalZ[g].alpha)*10000)/100) + "%."
       + "<br>The sum of all savings (not discounted) is " +
       curr_format(flSum(&goalZ[g].saving_plan, goalZ[g].realization_monthNbr), currency) + ".";
}

void investment_problem::allocate_to_unallocated_goal(int unallocated_goal_nbr)
{
  int k, optimal_portf;
  if (unallocated_goal_nbr == 0)  // if it was not encountered above, then create it
  {
    unallocated_goal_nbr = ++nbr_goals;
    this->goalZ.insert(pair<int, aGOAL>(nbr_goals, aGOAL(investor_id)));
    goalZ[nbr_goals].description = "Unallocated Resources";    
  }

  if (set_unallocated_goal())
  {
    // set the saving_plan:
    for (k = 0; k <= months2simulate(); k++)
//x.x.x    for (k = 1; k <= 10; k++)
    {
    goalZ[unallocated_goal_nbr].saving_plan[k] = means_left[k];
    }
    // set the optimal portfolio
    optimal_portf = get_portfolio_riskiest();
   
   // set optimal_portf and alpha
   goalZ[unallocated_goal_nbr].optimal_portf = optimal_portf;
   goalZ[unallocated_goal_nbr].alpha = (MAX_ALPHA + MIN_ALPHA) / 2;

   // set the benchmark
   for (k = 1; k <= NBR_ASSET_CLASSES; k++)
    {
       goalZ[unallocated_goal_nbr].benchmark[k] = portfolios[optimal_portf].weights[k-1];
    }
    //set color and comments
    goalZ[unallocated_goal_nbr].remarks = goalZ[unallocated_goal_nbr].remarks  + "This is not really a &quot;goal&quot."
          + "This is simply all the assets that are not or cannot be used by other goals.<br>"
      + "The non-discounted sum of this savings is: " 
          + curr_format(flSum(&goalZ[unallocated_goal_nbr].saving_plan, months2simulate()), currency) ;
    goalZ[unallocated_goal_nbr].color   = "brightgreen";  
  }
  else
  {
    error_message = error_message + "<li>Failed to create the unallocated goal, so after all the goals mentioned here, some means might be left</li>";
  }
}

void investment_problem::set_means_goal(int g)
{
  int m;
 // for ...:     goalZ[g].means_goal.insert (std::pair<int,float>(i, 0.0) );
  for (m = 0; m <= goalZ[g].realization_monthNbr; m++) goalZ[g].means_goal[m] = 0; 
  if (goalZ[g].goal_type == goal_type_s2i["income from/to"]) // only for "income from/till"
  {
     expand_cf(goalZ[g].amount, goalZ[g].frequency, goalZ[g].from_date, goalZ[g].till_date, g);
  }
}


float investment_problem::get_optimal_portfolio(int g)
{
  int p, optimal_portf = 0;
  float opt_perc = 1; // initalize to one to make sure it is replaced
  float* perc_bloc_used = NULL;
  float* new_block = NULL;
  new_block = (float*) realloc(perc_bloc_used, nbr_portfolios * sizeof(float));
  if (new_block != NULL)
    {
        perc_bloc_used = new_block;
    }
    else
    {
      free(perc_bloc_used);
#ifdef DEBUG
      debug_info = debug_info + "<br/>realloc() failed in get_optimal_portfolio()";
#endif
       return false;
    }
  
  for (p =1; p <= nbr_portfolios; p++) 
  {
    // do this only for suitable portfolios
    if (portfolio_suitable[p]) 
    {
      perc_bloc_used[p-1] = goal_seek_means(g, p);
    }
    else
    {
      perc_bloc_used[p-1] = opt_perc + 1; // in order to exclude this portfolio automatically in the next lines
    }
  }

  for (p =1; p <= nbr_portfolios; p++)
  {
//xx    cout << "<br>portf="<<p<<"  , opt_perc: " << opt_perc << " | perc_bloc_used[" << p-1 << "] :" << perc_bloc_used[p-1];
    if (perc_bloc_used[p-1] <= opt_perc)  
    {
    opt_perc = perc_bloc_used[p-1];
    optimal_portf = p;
    }
  }
if (goalZ[g].realization_monthNbr <= MAX_MONTHS_TO_SAFEST) 
{
  goalZ[g].optimal_portf = get_portfolio_safest();
}
else
{
  goalZ[g].optimal_portf = optimal_portf;
}

//cout << "<br>g="<<to_string(g)<< "  optimal_portf="<<to_string(goalZ[g].optimal_portf);

goalZ[g].realized_shortfall = calc_risk(g, optimal_portf);
return opt_perc;
}

float investment_problem::goal_seek_means(
      int g, 
      int p  
  )
{
  int m;
  float perc = 0.5;  // the perecentage used of this block

  for(m = 0; m <= goalZ[g].realization_monthNbr; m++) means_tmp[m] = 0;
  if ((calc_risk(g, p) <= goalZ[g].max_shortfall) || (goalZ[g].realization_monthNbr < 0)) 
  {
    return 0.0;
  }

  for(m= 0; m<=goalZ[g].realization_monthNbr; m++) means_tmp[m] = means_block[m];
  if (calc_risk(g, p) >= goalZ[g].max_shortfall) 
  {
    return 1.0;
  }
  
  
  
//xx  for(m=0;m<=goalZ[g].realization_monthNbr;m++) means_tmp[m] = perc * means_block[m];
  goal_seek_tmp_means(&perc, g, p);  
  return perc;
}

inline void investment_problem::goal_seek_tmp_means(float *perc, int g, int p)
{
  int k, m;
  for (k = 2; k <= NBR_ITERATIONS; k++)
  {
    if ((goalZ[g].goal_type == goal_type_s2i["amount asap"]) || (goalZ[g].goal_type == goal_type_s2i["rainy day savings"]))      
    {
      means_tmp[goalZ[g].realization_monthNbr] = (*perc) * means_block[goalZ[g].realization_monthNbr];
    }
    else
    {
      for(m = 0; m <= goalZ[g].realization_monthNbr; m++) means_tmp[m] = (*perc) * means_block[m];
    }
//    for(m=1;m<=goalZ[g].realization_monthNbr;m++) cout << "  ["<< m << "]" << means_tmp[m];
//    cout << "<BR>perc=" << to_string(*perc) << "  | calc_risk(g, p)=" << to_string(calc_risk(g, p)) << "  | goalZ[g].max_shortfall" << to_string(goalZ[g].max_shortfall);
    if (calc_risk(g, p) > goalZ[g].max_shortfall)
      {*perc += pow(2,-k);}
      else
      {*perc -= pow(2,-k);}
  }
}


float investment_problem::calc_risk(
                  int g,             
                  int p              
  )
{
  float V_min,       
        V,           
        delta,       
        s = 0,       
        mnt_avg = 0; 
  float const my_errf = erfinv(2 * goalZ[g].alpha - 1);
  int m;
  
  V_min = V = delta = means_used[0] + means_tmp[0] - goalZ[g].means_goal[0];
  s = portfolios[p].pSigma;
  for (m = 1; m <= goalZ[g].realization_monthNbr; m++)
  {
    delta = means_used[m] + means_tmp[m] - goalZ[g].means_goal[m];
    mnt_avg++;
    if (abs(V) + abs(delta) != 0) 
    {
      mnt_avg = (abs(V) * (mnt_avg) + abs(delta) * 1) / (abs(V) + abs(delta));
    }
      V = V * exp(portfolios[p].pLogR + pow(s, 2) / 2) + delta;
      V_min = V_min * exp(portfolios[p].pLogR +sqrt(2) * s * (sqrt(mnt_avg) - sqrt(mnt_avg-1)) * my_errf) + delta;
  }

if (oConfig.riskFunction == "VaR") {return (goalZ[g].target_amount - V_min);}  
else {return (goalZ[g].target_amount - V_min);}
}


/* =====not used any more ========
 * turns the relevant risk measure for given goal and portfolio for means_block
 *
 * riskFunction = the risk function to use : ES_normdist
 */
/*
inline float investment_problem::get_risk(const char* riskFunction, int theGoal, int thePortfolio)
{
  if (strcmp(riskFunction,"ES_normdist") == 0) return  ExpectedShortfall_normDist(theGoal, thePortfolio);
  //else if (
  else return 0;
}
*/
/*float portfolio::get_risk(
      float alpha,                //!< the confidence level (small)
      float (*riskFunction)(float alpha, float (*AssetClass_mu), float (*AssetClass_varCov)),      //!< pointer to the risk function to use
      float (*AssetClass_mu),     ///< pointer to the array of E[R] of the asset classes
      float (*AssetClass_varCov)) ///< pointer to the two dimensional array of sigma[n][m]
{
 return (*riskFunction) (alpha, AssetClass_mu, AssetClass_varCov);
}
*/

/* TODO: improve the previous as follows:
 * td::function<bool()> my_fun;

if (condition1)
    my_fun = std::bind(&MyClass::function_one, my_class);
else if (condition2)
    my_fun = std::bind(&MyClass::function_two, my_class, a, b);
else if (condition3)
    my_fun = std::bind(&MyClass::function_three, my_class, a, b, c);
else if (condition4)
    my_fun = std::bind(&MyClass::function_four, my_class, a, b, c, d);

while (my_fun())
{ ... }
*/

/* OR:
 * or the sake of interest, there's also a simple lo-tech solution from the C world that as far as it goes, works in C++. Instead of allowing arbitrary parameters, define the function as void (*func)(void*), and make "params" void*. It's then the caller's job to define some struct that will contain the parameters, and manage its lifecycle. Usually the caller would also write a simple wrapper to the function that's really needed to be called:

void myfunc(int, float); // defined elsewhere

typedef struct {
    int foo;
    float bar;
} myfunc_params;

void myfunc_wrapper(void *userdata) {
    myfunc_params *params = (myfunc_params *)p;
    myfunc(p->foo, p->bar);
}

int main() {
    myfunc_params x = {1, 2};
    AddTimer(23, 5, myfunc_wrapper, &x);
    sleep(23*5 + 1);
}*/

/* ==============[not used any more]===========
 * returns the expected shortfall for the GAUSSIAN distribution for given alpha using
 *
 * ES = mu + a sigma
 *
 * with
 *
 * a = (1/alpha sqrt(2 Pi) exp {-[errfinv(2 alpha -1)]^2})
 */
/*
float investment_problem::ExpectedShortfall_normDist(int theGoal, int thePortfolio)
{
  int k = 1;
  float EV, Sigma, a;
  EV = means_block[k] + means_used[k];
  Sigma = portfolios[thePortfolio].pSigma * EV;
  while (k <= this->goalZ[theGoal].realization_monthNbr)
  {
    EV = EV * (1 + portfolios[thePortfolio].pMu) + means_block[k] + means_used[k];
    Sigma = sqrt( 2 * Sigma * Sigma + pow((means_block[k] + means_used[k]) * portfolios[thePortfolio].pSigma, 2));
    k++;
  }

  // calculate a:
  a = fast_erfinv(2 * goalZ[theGoal].alpha - 1);
  a = exp(- pow(a,2));
  a = (1 / (2 * goalZ[theGoal].alpha * pow(Pi,0.5))) * a;

  return (- EV + a * Sigma);
}
*/

int investment_problem::get_nbr_goals()
{
  return nbr_goals;
}

int investment_problem::get_max_month_for_lower_goals(int g)
{
  int k, max_month = 0;
  if (g < nbr_goals)
  {
    for (k = g + 1; k <= this->nbr_goals; k++) 
    { 
      if (goalZ[k].goal_type != 0 && goalZ[k].realization_monthNbr > max_month) {max_month = goalZ[k].realization_monthNbr;}
    }
  }
  return max_month;
}

void investment_problem::prepare_javaVars_colors(int g, int followup_mnth)
{
  int k;
  string s1, s2, s3, s4, comma;
  float Vlow, Vhigh, Vmed, Vexp, Vexp_evol,
        sigma, the_diff, age_now = age(0), age_at_cutoff, diff_cum, erf_low, erf_high, erf_med, age_at_k, 
        mnt_avg  = 0,  
        mnth_max = (goal_type_i2s[goalZ[g].goal_type] == "rainy day savings") ? months2simulate() : goalZ[g].realization_monthNbr;
  int p = goalZ[g].optimal_portf;
  s1 = s2 = s3 = s4 = "";
  sigma = portfolios[p].pSigma ;
  erf_low  = erfinv(2 * goalZ[g].alpha - 1);
  erf_high = erfinv(2 * (1-goalZ[g].alpha) - 1);
  erf_med  = erfinv(0);
  set_means_goal(g);

  if (followup_mnth == 0)
  { // in this case we are making a feedback or a Simulation, thus the tricolor graph starts from month 0, independent from the simulation
    Vlow = Vhigh = Vmed = diff_cum = Vexp  = goalZ[g].saving_plan[0] - goalZ[g].means_goal[0];
  }
  else // in this case we are producing the Feedback screen and hence we start the tricolor plot at the end of the simulation
  {
    Vlow = Vhigh = Vmed = diff_cum = Vexp  = goalZ[g].saving_plan[followup_mnth] - goalZ[g].means_goal[followup_mnth] + goalZ[g].simulation_endvalue;
  }
  age_at_cutoff = age_now +  (float)followup_mnth / 12;
//  cout << "<br> goalZ[" << to_string(g) << "].saving_plan[0] " << to_string(goalZ[g].saving_plan[0]) << " -- goalZ[g].means_goal[0] = " << to_string(goalZ[g].means_goal[0]);
  if ( followup_mnth < mnth_max)
  {
    s1 = "[" + to_string(age_at_cutoff) + ", " + to_string(Vexp) + "]";
    s2 = "[" + to_string(age_at_cutoff) + ", " + to_string(Vexp) + "]";
    s3 = "[" + to_string(age_at_cutoff) + ", " + to_string(Vexp) + "]";
  }
  else
  {
    s1 = s2 = s3 = "[]";
  }

  for (k=followup_mnth + 1; k <= mnth_max; k++)
  {
//    Vexp_sign = (Vexp >= 0) ? 1.0 : -1.0;
//    Vexp      = Vexp * Vexp_sign; // ==> is now always positive
    Vexp_evol = Vexp * exp(portfolios[p].pLogR + pow(portfolios[p].pSigma, 2) / 2);
//    sigma    = sqrt(pow(sigma, 2) + pow(portfolios[p].pSigma * Vexp,2));
    the_diff = goalZ[g].saving_plan[k] - goalZ[g].means_goal[k];
    diff_cum += the_diff;
//    Vexp      = Vexp_sign * Vexp_evol + the_diff;  //set back to positive or negative
    Vexp      = Vexp_evol + the_diff;  //set back to positive or negative
    mnt_avg++;
    if (abs(Vexp) + abs(the_diff) != 0) 
    {
      mnt_avg = (abs(Vexp) * (mnt_avg) + abs(the_diff) * 1) / (abs(Vexp) + abs(the_diff));
    }
//    cout << "<br>VLow=" << to_string(Vlow) <<   " -- sigma=" << to_string(sigma) <<"-- exp(portfolios[" << to_string(p) << "].pLogR)= " << to_string(exp(portfolios[p].pLogR)) << " -- exp...=" << exp(portfolios[p].pLogR +sqrt(2) * (sqrt(mnt_avg) - sqrt(mnt_avg-1)) * sigma * erf_low);
    
    Vlow  = Vlow  * exp(portfolios[p].pLogR +sqrt(2) * (sqrt(mnt_avg) - sqrt(mnt_avg-1)) * sigma * erf_low)  + the_diff;
    Vmed  = Vmed  * exp(portfolios[p].pLogR +sqrt(2) * (sqrt(mnt_avg) - sqrt(mnt_avg-1)) * sigma * erf_med)  + the_diff;
    Vhigh = Vhigh * exp(portfolios[p].pLogR +sqrt(2) * (sqrt(mnt_avg) - sqrt(mnt_avg-1)) * sigma * erf_high) + the_diff;
    Vexp      = Vexp_evol + the_diff;  //set back to positive or negative
    age_at_k = age_now + (float)k / 12;
    s1 = s1 + ", [" + to_string(age_at_k) + ", " + to_string(Vlow) + "]";
#ifdef SHOW_Vexp_not_Vmed
    s2 = s2 + ", [" + to_string(age_at_k) + ", " + to_string(Vexp) + "]";
#else
    s2 = s2 + ", [" + to_string(age_at_k) + ", " + to_string(Vmed) + "]";
#endif
    s3 = s3 + ", [" + to_string(age_at_k) + ", " + to_string(Vhigh) + "]";
  }
  //s4: for the rainy day savings a line, for all other goals a big dot
  if (goalZ[g].goal_type == goal_type_s2i["rainy day savings"])
  {
    s4 = s4 + "[" + to_string(age_now) + ", " + to_string(goalZ[g].target_amount) + "]";
    for (k=1; k <= mnth_max; k++)    
    {
      age_at_k = age_now + (float)k / 12;
      s4 = s4 + ", [" + to_string(age_at_k) + ", " + to_string(goalZ[g].target_amount) + "]";
    }
  }
  else
  {
    s4 = "[" + to_string(age_now + ((float)goalZ[g].realization_monthNbr)/12) + "," + to_string(goalZ[g].target_amount) + "]";
  }
 // cout << "<div class=\"jqplot-target\" id=\"xchart" << g << "\" style=\"height: 300px; width: 500px; position: relative;\">";
 // cout << "<script class=\"code\" type=\"text/javascript\">$(document).ready(function(){var plot1 = $.jqplot ('xchart" << g << "', [[3,7,9,1,5,3,8,2,5]]);});</script>";
  
  goalZ[g].s_low  = s1;
  goalZ[g].s_exp  = s2;
  goalZ[g].s_high = s3;
  goalZ[g].s_goal = s4;
  
  if (followup_mnth > 0)
  { // in this case we are in the "Follow-Up screen"
      if (followup_mnth + 1 > goalZ[g].realization_monthNbr)
      {
    // if the previous for-loop was not executed, so we are before 
    set_followup_color_post(Vexp, g);
      }
      else
      {
    set_followup_color_prae(Vlow, Vexp, Vhigh, g);
      }

  }
}



void investment_problem::javaGraph(int g, string xtra_var, string xtra_label, int followup_mnth)
{
  prepare_javaVars_colors(g, followup_mnth);
  
  parse_javaGraph( g, xtra_var, xtra_label);
}

void investment_problem::parse_javaGraph(int g, string xtra_var, string xtra_label)
{
  string xtra_var_name;
  cout << "<div id=\"chartOverview"<<g<<"\" style=\"height:400px; width:700px;\"></div>";
  cout << "<script class=\"code\" type=\"text/javascript\">$(document).ready(function(){ \n";
  cout << "var l1 = [" + this->goalZ[g].s_low + "]; \n";
  cout << "var l2 = [" + this->goalZ[g].s_exp + "]; \n";
  cout << "var l3 = [" + this->goalZ[g].s_high + "]; \n";
  cout << "var l4 = [" + this->goalZ[g].s_goal + "]; \n";
  if (xtra_var != "")
  {
    cout << "var l5 = [" + xtra_var + "]; ";
    xtra_var_name = ", l5";
  }
  
 /* cout << "var l1 = [[1,3],[2.5,4],[3,5],[5,7]]; \n";
  cout << "var l2 = [[1,3],[2.5,6],[3,6],[5,6]]; \n";
  cout << "var l3 = [[1,3],[2.5,3],[3,4],[5,6]]; \n";
  cout << "var l4 = [[1,3]]; \n";*/
  cout <<  "var overviewPlot" << g << " = var" << g << " =  $.jqplot ('chartOverview" << g << "', [l1, l2, l3, l4" << xtra_var_name << "] ";
  cout << ", {";
  cout <<    "seriesDefaults: {";
  cout <<                       "showMarker: false ,";
  cout <<                       "rendererOptions: { smooth: false },";
  cout <<                       "markerOptions: { style:\"o\", size:5 }, ";
  cout <<                       "lineWidth:7 ";
  cout <<                    "},";
  cout <<    "legend: {show: true, location: 'e', fontSize: '2em', placement: 'outside', marginRight: \"600px\",";
  cout <<             "labels:['"<<t_plotlabels_evol[1]<<"', '"<<t_plotlabels_evol[2]<<"', '"<<t_plotlabels_evol[3]<<"', '"<<t_plotlabels_evol[4]<<g<<"'";
  if (xtra_var != "") cout << ", '" << xtra_label << "'";
  cout <<             "]},";
//  cout <<    "markerOptions: { style:\"o\", size:5 }, lineWidth:1}";
  
 /*/ ///////////////////
  if (goalZ[g].goal_type != goal_type_s2i["rainy day savings"])
  { // for the goals the special big dot
    cout << "{markerOptions: {   show: true, style: 'circle', size: 12, shadow: false, shadowDepth: 6,  shadowAlpha: 0.07, shapeRenderer: new $.jqplot.customMarkerRenderer() }}"; // old markerOptions:  style:\"circle\", size:17
  }
  else
  { // except for the rainy day savings: the simple black line
    cout << "{showMarker: false}";
  }
  if (xtra_var != "") cout << ", {markerOptions: { style:\"o\", size:5 }, lineWidth:1}";
       cout << "],";
  
  cout <<    "series: [{}, {}, {}, "; //  for the goal: something special=
  if (goalZ[g].goal_type != goal_type_s2i["rainy day savings"])
  { // the typical presentation of the goal:
    cout <<            "{showMarker: true, markerOptions: { style:\"filledCircle\", size:17}, shadowDepth: 6,  shadowAlpha: 0.07, shapeRenderer: new $.jqplot.customMarkerRenderer() }";
  }
  else
  {
    cout <<            "{showMarker: false}";
  }
  if (xtra_var != "") 
  {// if there is a simulation to be added, provide here the customization of the plot
    cout <<            ", {showMarker: true, markerOptions: {style:\"filledCircle\",  size:15 }, lineWidth:3}"; 
  }
  cout <<             "], ";
 
  cout <<     "seriesColors: " << hh.seriesColorsGoalPlot << ", ";
  cout <<     "axesDefaults: {labelRenderer: $.jqplot.CanvasAxisLabelRenderer},";
  //cout << "axes: {xaxis: {label: \"age\" }, yaxis: {label: \"" << currency << "\"}, {tickOptions: {formatter:tickFormatter}}}";  // , pad: 0
  cout <<     "axes: {xaxis: {label: \"age\" }, yaxis: {label: \"" << goalZ[g].currency << "\"}}";  // , pad: 0

  cout << "}";
  cout << "); });";
  cout << "</script>"; 
  return;

//150215  cout <<  "var plot" << g << " = $.jqplot('chartOverview" << g << "', [l1, l2, l3, l4" << xtra_var_name << "], {";

  
  //        axesDefaults: {
//            pad: 1.05
  //     },
/*        //////
        // Use the fillBetween option to control fill between two
        // lines on a plot.
        fillBetween: {
            // series1: Required, if missing won't fill.
            series1: 1,
            // series2: Required, if  missing won't fill.
            series2: 2,
            // color: Optional, defaults to fillColor of series1.
            color: "rgba(227, 167, 111, 0.7)",
            // baseSeries:  Optional.  Put fill on a layer below this series
            // index.  Defaults to 0 (first series).  If an index higher than 0 is
            // used, fill will hide series below it.
            baseSeries: 0,
            // fill:  Optional, defaults to true.  False to turn off fill.
            fill: true
        },*/
  cout << "seriesDefaults: {rendererOptions: { smooth: false }},";
  cout << "legend: {show: true, location: 'e', placement: 'outside', marginRight: \"600px\",";
  cout << "labels:['negative scenario', 'expected evolution', 'good scenario', 'YOUR GOAL #"<<g<<"'";
      if (xtra_var != "") cout << ", '" << xtra_label << "'";
      cout    << "]},";
//  cout << "seriesDefaults: {showMarker: false}, ";
      
      
  cout << "series:[{showMarker: false},{showMarker:false,lineWidth:5},{showMarker: false},";
  
  
  
  if (goalZ[g].goal_type != goal_type_s2i["rainy day savings"])
  { // for the goals the special big dot
    cout << "{markerOptions: {   show: true, style: 'circle', size: 12, shadow: false, shadowDepth: 6,  shadowAlpha: 0.07, shapeRenderer: new $.jqplot.customMarkerRenderer() }}"; // old markerOptions:  style:\"circle\", size:17
  }
  else
  { // except for the rainy day savings: the simple black line
    cout << "{showMarker: false}";
  }
  if (xtra_var != "") cout << ", {markerOptions: { style:\"o\", size:5 }, lineWidth:1}";
       cout << "],";
       
  cout << "seriesColors: " << hh.seriesColorsGoalPlot << ", ";
  cout << "axesDefaults: {labelRenderer: $.jqplot.CanvasAxisLabelRenderer},";
  //cout << "axes: {xaxis: {label: \"age\" }, yaxis: {label: \"" << currency << "\"}, {tickOptions: {formatter:tickFormatter}}}";  // , pad: 0
  cout << "axes: {xaxis: {label: \"age\" }, yaxis: {label: \"" << goalZ[g].currency << "\"}}";  // , pad: 0
  cout << "  } ); }); </script>";
}

inline void investment_problem::set_followup_color_prae(float Vlow, float Vmed, float Vhigh, int g)
{ 
 //NOTE Vhigh is not used now ...
 if      (Vlow > this->goalZ[g].target_amount) this->goalZ[g].color_followup = "green";
 else if (Vmed > this->goalZ[g].target_amount) this->goalZ[g].color_followup = "amber";
 else                                   this->goalZ[g].color_followup = "red";
}

inline void investment_problem::set_followup_color_post(float V, int g)
{
  if      (V > this->goalZ[g].target_amount)                   this->goalZ[g].color_followup = "green";
  else if (V > this->goalZ[g].target_amount * (1 - MIN_ALPHA)) this->goalZ[g].color_followup = "amber";
  else                                                  this->goalZ[g].color_followup = "red";
}


float investment_problem::calc_V_high(int g, int p)
{
  int k;
  float V0, Vhigh,sigma, logR, Vexp;
  if (p == 0) p = goalZ[g].optimal_portf;
  Vhigh = Vexp = V0 = goalZ[g].saving_plan[0] - goalZ[g].means_goal[0];//rm 1;
  sigma = portfolios[p].pSigma * V0;

  for (k=1; k <= goalZ[g].realization_monthNbr; k++)
  {
    sigma = sqrt(pow(sigma, 2) + pow(portfolios[p].pSigma * Vexp,2));
    Vexp    = Vexp * exp(portfolios[p].pLogR + pow(portfolios[p].pSigma, 2) / 2) + goalZ[g].saving_plan[k] - goalZ[g].means_goal[k];
    logR = log(Vexp / V0);
    Vhigh  = V0 * exp(logR + sigma / Vexp * norminv(ALPHA_PLOT_HIGH));
  }
  return Vhigh;
}



bool investment_problem::set_unallocated_goal()
{
  bool success = true;
  aGOAL unalloc_goal(investor_id);
  // check if an unallocated goal already exists
  string s = "SELECT * FROM " + oConfig.tbl_prefix + "_goals WHERE investor = " + to_string(investor_id) 
             + " AND goal_type = " + to_string(goal_type_s2i["unallocated"]) + ";";
  try
  {
    db.res = db.stmt->executeQuery(s);
    if (db.res->next())
    {
//      db.res->previous();
//      while (res->next())
//  {
      unalloc_goal.set_from_db();
//  }
    }
    else
    {
//      this->goal_id         = res->getInt("goal_id");
//done in the constructor:      this->investor        = investor_id;
      unalloc_goal.amount          = 0;
      unalloc_goal.goal_type       = goal_type_s2i["unallocated"];
      unalloc_goal.description     = "unallocated means";
      unalloc_goal.realization_age = simulate_till_age;
      unalloc_goal.currency        = currency;
      unalloc_goal.priority        = 99;
      unalloc_goal.from_date       = "";
      unalloc_goal.till_date       = "";
      unalloc_goal.frequency       = "O";
      unalloc_goal.max_shortfall   = 0;
      if (!unalloc_goal.add_to_db()) 
      {
    error_message = error_message + "<li>Failed to save the new unallocated goal.</li>";
    success = false;
      }
    }
   }
  catch (sql::SQLException &e)
  {
   #ifdef DEBUG
    debug_info = "<br>" + s + "<br>";
    debug_info =  debug_info + "# ERR: SQLException in " + __FILE__ + "(" + __FUNCTION__
                  + ") on line " + to_string(__LINE__) + "<br># ERR: " + e.what() 
          + " (MySQL error code: " + to_string(e.getErrorCode())
                  + ", SQLState: " + e.getSQLState() + " )<br>";
   #endif
    error_message = error_message +  "<li>Sorry, I failed to load a goal.</li>";
    success = false;
  }
  return success;
}



int investment_problem::get_portfolio_safest()
{
  int p, the_portfolio = 1;
  float sigma = portfolios[1].pSigma;
   for (p =1; p <= nbr_portfolios; p++)
   {
     if (portfolio_suitable[p] &&  portfolios[p].pSigma <= sigma)
    {
    sigma = portfolios[p].pSigma;
    the_portfolio = p;
    }
   }
  return the_portfolio;
}

int investment_problem::get_portfolio_riskiest()
{
  int p, the_portfolio = 1;
  float sigma = portfolios[1].pSigma;
  for (p =1; p <= nbr_portfolios; p++)
   {
     if (portfolio_suitable[p] &&  portfolios[p].pSigma >= sigma)
    {
    sigma = portfolios[p].pSigma;
    the_portfolio = p;
    }
   }
  return the_portfolio;
}