---

LowDimensionalCostFunctionMapper.cpp

Go to the documentation of this file.

// LowDimensionalCostFunctionMapper.cpp: implementation of the CLowDimensionalCostFunctionMapper class.
//

#include "LowDimensionalCostFunctionMapper.h"

// Construction/Destruction

CLowDimensionalCostFunctionMapper::CLowDimensionalCostFunctionMapper()
{
        m_pMO = new CMatrixOperations();
}

CLowDimensionalCostFunctionMapper::~CLowDimensionalCostFunctionMapper()
{
        delete m_pMO;
}

void CLowDimensionalCostFunctionMapper::Map(Minimizable *pMin, CParameterFilter *pFilter, double *p1, double *p2, double a, double b, int nPts)
{
        // open a file to write the answer
        fstream *pfLine = new fstream("line.par",ios::out);
        *pfLine << "##################################################################" << endl;
        *pfLine << "# LINE EVALUATION OF COST FUNCTION" << endl;
        *pfLine << "# LAMBDA    COST" << endl;
        *pfLine << "##################################################################" << endl;
        // set the number of parameters
        int nParameters = pMin->GetNParameters();
        // create a vector to hold the LC
        double *v = new double[nParameters];
        // transform the p's
        pFilter->ForwardTransformation(p1,nParameters);
        pFilter->ForwardTransformation(p2,nParameters);
        // traverse the line joining p1 and p2, evaluating the cost as we go
        double lambda = a;
        for(int i = 0; i < nPts; i++)
        {
                // set lambda to the appropriate increment
                lambda = a + (b - a)*(i/(nPts - 1.0));
                // form the LC
                m_pMO->TwoVectorLC(1.0-lambda,p1,lambda,p2,v,nParameters);
                // back transform and evaluate the cost
                pFilter->BackwardTransformation(v,nParameters);
                double cost = pMin->ObjectiveFunction(v);
                pFilter->ForwardTransformation(v,nParameters);
                // write the answer to the file
                *pfLine << lambda << "\t" << cost << endl;
        }

        pfLine->close();
        delete pfLine;
        delete [] v;
}

void CLowDimensionalCostFunctionMapper::Map(Minimizable *pMin,CParameterFilter *pFilter, double *p1, double *p2, double *p3, double a, double b, double c, double d, int nPts)
{
        // open a file to write the answer
        fstream *pfPlane = new fstream("plane.par",ios::out);
        *pfPlane << "##################################################################" << endl;
        *pfPlane << "# PLANE EVALUATION OF COST FUNCTION" << endl;
        *pfPlane << "# BETA1    BETA2   COST" << endl;
        *pfPlane << "##################################################################" << endl;
        // set the number of parameters
        int nParameters = pMin->GetNParameters();
        // create a vector to hold the LC and an intermediate
        double *v = new double[nParameters];
        double *vint = new double[nParameters];
        // create two vectors to hold differences
        double *b1diff = new double[nParameters];
        double *b2diff = new double[nParameters];
        // transform the p's
        pFilter->ForwardTransformation(p1,nParameters);
        pFilter->ForwardTransformation(p2,nParameters);
        pFilter->ForwardTransformation(p3,nParameters);
        // traverse the parallelogram with p1,p2,and p3 as vertices.  Use a rectangular
        // grid that is sqrt(Np) X sqrt(Np).  beta1 is the p1-p3 axis and beta2 is the
        // p1-p2 axis
        double beta1 = 0.0;
        double beta2 = 0.0;
        int Nx = (int) sqrt((double)nPts);
        int Ny = (int) sqrt((double)nPts);
        for(int x = 0; x < Nx; x++)
        {
                beta1 = a + (b - a)*(x/(Nx - 1.0));
                // compute the things that don't change as we loop over beta2
                m_pMO->TwoVectorLC(beta1,p3,-beta1,p1,b1diff,nParameters);
                m_pMO->TwoVectorLC(1.0,p1,1.0,b1diff,vint,nParameters);
                
                for(int y = 0; y < Ny; y++)
                {
                        beta2 = c + (d - c)*(y/(Ny - 1.0));
                        // form the second difference
                        m_pMO->TwoVectorLC(beta2,p2,-beta2,p1,b2diff,nParameters);
                        // form the LC using the intermediate vector
                        m_pMO->TwoVectorLC(1.0,vint,1.0,b2diff,v,nParameters);
                        // back transform and evaluate the cost
                        pFilter->BackwardTransformation(v,nParameters);
                        double cost = pMin->ObjectiveFunction(v);
                        pFilter->ForwardTransformation(v,nParameters);
                        // write the answer to the file
                        *pfPlane << beta1 << "\t" << beta2 << "\t" << cost << endl;
                }
        }

        pfPlane->close();
        delete pfPlane;
        delete [] v;
        delete [] vint;
        delete [] b1diff;
        delete [] b2diff;
}

---