MatlabEngine::DoubleMatrix
MatlabEngine::GetMatrix( const string& inExp )
{
DoubleMatrix result;
mxArray* ans = GetMxArray( inExp );
if( ans )
{
int numDims = mxGetNumberOfDimensions( ans );
const int* dims = mxGetDimensions( ans );
if( numDims != 2 )
bcierr << "Can only handle two dimensions" << endl;
result.resize( dims[ 0 ], vector<double>( dims[ 1 ] ) );
double* value = mxGetPr( ans );
if( value )
{
int indices[] = { 0, 0 };
for( size_t i = 0; i < result.size(); ++i )
{
indices[ 0 ] = i;
for( size_t j = 0; j < result[ i ].size(); ++j )
{
indices[ 1 ] = j;
result[ i ][ j ] = value[ mxCalcSingleSubscript( ans, 2, indices ) ];
}
}
}
mxDestroyArray( ans );
}
return result;
}
void StopRule::multiple (DoubleVector &vec1, DoubleVector &vec2, DoubleMatrix &proMat) {
int row_, col_;
proMat.resize(vec1.size());
for (row_ = 0; row_ < vec1.size(); row_++)
proMat[row_].resize(vec2.size());
for (row_ = 0; row_ < vec1.size(); row_ ++)
for (col_ = 0; col_ < vec2.size(); col_ ++)
proMat[row_][col_] = vec1[row_] * vec2[col_];
}
double
MatlabEngine::GetScalar( const string& inExp )
{
DoubleMatrix result = GetMatrix( inExp );
if( result.empty() || result[ 0 ].empty() )
{
bcierr << "Could not get scalar value \"" << inExp << "\"" << endl;
result.resize( 1, vector<double>( 1 ) );
}
return result[ 0 ][ 0 ];
}
void StopRule::readMat (char *fileName, DoubleMatrix &oriMat, int &size) {
std::ifstream inFile_;
inFile_.open(fileName);
inFile_ >> size;
oriMat.resize(size);
for (int i = 0; i < size; i++) oriMat[i].resize(size);
for (int row_ = 0; row_ < size; row_ ++)
for (int col_ = 0; col_ < size; col_ ++)
inFile_ >> oriMat[row_][col_];
inFile_.close ();
}
void multiply(const DoubleMatrix &X, const DoubleMatrix &Y, DoubleMatrix& Z)
{
assert(&X!=&Z);
assert(&Y!=&Z);
if( X.isEmpty() || Y.isEmpty() )
return;
//
// Row Major Matrices
//
// C = alpha * A * B + beta * C --- (1)
//
// A : m by k lda (stride) = k
// B : k by n ldb (stride) = n
// C : m by n ldc (stride) = n
//
// Column Major Matrices
//
// Z = alpha * X * Y + beta * C --- (2)
// Z = C^t
// = alpha * B^t * A^t + beta * C^t --- (3)
//
// X = B^t : n by k ldx (stride) = n
// Y = A^t : k by m ldy (stride) = k
// Z = C^t : n by m ldz (stride) = n
//
int m = Y.nc();
int k = X.nc();
int n = X.nr();
Z.resize( n, m );
assert( X.nr() == n );
assert( X.nc() == k );
assert( Y.nr() == k );
assert( Y.nc() == m );
assert( Z.nr() == n );
assert( Z.nc() == m );
const double * pX = X.data();
const double * pY = Y.data();
double * pZ = Z.data();
int lda = n;
int ldb = k;
int ldc = n;
cblas_dgemm( CblasColMajor, CblasNoTrans, CblasNoTrans, n, m, k, ALPHA, pX, lda, pY, ldb , BETA, pZ, ldc );
}
void StopRule::multiple (DoubleMatrix &mat1, DoubleMatrix &mat2, DoubleMatrix &proMat) {
int row_, col_;
//proMat.setLimit (mat1.getNRow (), mat2.getNCol ());
proMat.resize(mat1.size());
int nrow_ = proMat.size();
int ncol_ = mat2[0].size();
for (row_ = 0; row_ < proMat.size(); row_++) proMat[row_].resize(ncol_);
for (row_ = 0; row_ < nrow_; row_ ++)
for (col_ = 0; col_ < ncol_; col_ ++) {
proMat[row_][col_] = 0.0;
for (int count_ = 0; count_ < mat1[0].size(); count_ ++) {
proMat[row_][col_] += mat1[row_][count_] * mat2[count_][col_];
// std::cout << mat1[row_][count_] << " --> " << mat2[count_][col_] << endl;
}
}
}
long _stdcall getChartData(int bond_id, bool cluster, double* arr, unsigned char bonds[], int numbonds, long* maturities, int microWidth, int dateTolerance, int clusterLower, int clusterUpper, int history){
SimpleRefData bbg(1);
DoubleMatrix yieldData;
std::vector <std::string> bond_vec;
for (int b = 0; b < numbonds; b++){
std::string prefix = "/isin/";
std::string suffix;
suffix.clear();
for (int j = 0; j < ISIN_LENGTH; j++){
char a = bonds[b + j*(numbonds + 1)];
suffix += a;
}
bond_vec.push_back((prefix + suffix).c_str());
}
double** yieldArray;
yieldArray = new double*[numbonds+1];
for (int i = 0; i <= numbonds; i++){
yieldArray[i] = new double[history];
}
int days_data = bbg.runHistData(yieldArray, bond_vec, history);
yieldData.resize(numbonds);
for (int i = 0; i <= numbonds; i++){
yieldData[i].resize(days_data);
}
for (int i = 0; i <= numbonds; i++){
for (int j = 0; j < days_data; j++){
yieldData.at(i).at(j) = yieldArray[i][j];
}
}
std::vector<double> dataLocal;
if (cluster){
chartData(dataLocal, cluster, bond_id, yieldData, maturities, 0, clusterLower, clusterUpper, days_data);
}
else{
chartData(dataLocal, cluster, bond_id, yieldData, maturities, dateTolerance, microWidth, microWidth, days_data);
}
for (int i = 0; i < days_data; i++){
arr[i] = dataLocal.at(i);
}
return days_data;
}
DoubleMatrix ParseMatrixFromText(const string& textMatrix)
{
DoubleMatrix mat;
//Parse the matrix
vector<string> rows = splitString(textMatrix, "\n");
for(int row = 0; row < rows.size(); row++)
{
vector<string> values = splitString(rows[row], " \t");
for(int col = 0; col < values.size(); col++)
{
if(!mat.size())
{
mat.resize(rows.size(), values.size());
}
mat(row, col) = toDouble(values[col]);
}
}
return mat;
}
void StopRule::cmpLamdaMat (int k, DoubleMatrix &lamdaMat) {
int i, j;
lamdaMat.resize(k);
for (i = 0; i < k; i ++)
lamdaMat[i].resize(k);
double muy_ = cmpMuy (k);
for (i = 0; i < k; i ++)
for (j = 0; j <= i; j ++) {
/*
lamdaMat[i][j] = (cmpGamma (2*muy_ + i + 1) * cmpGamma (muy_ + j + 1) ) /
( cmpGamma (muy_ + i + 1) * cmpGamma (j + 1) );*/
// to fix divide by zero PROBLEM!
lamdaMat[i][j] = cmpLnGamma (2*muy_ + i + 1) + cmpLnGamma (muy_ + j + 1) -
cmpLnGamma (muy_ + i + 1) - cmpLnGamma (j + 1);
//if (i == 98 && j == 97)
// std::cout << i << "," << j << " -> " << lamdaMat[i][j] << endl;
lamdaMat[i][j] = exp(lamdaMat[i][j]);
lamdaMat[j][i] = lamdaMat[i][j];
}
}
/*
* b = [1]
* [1]
*/
void lambdaTest::setB(DoubleMatrix &b)
{
b.resize(2,1);
b.fill(rand()/(pow(2.0,32.0)) * 100.0);
}
extern void spk_non_par(
size_t level ,
SpkModel< CppAD::AD<double> > &admodel ,
SpkModel<double> &model ,
const DoubleMatrix &N ,
const DoubleMatrix &y ,
const DoubleMatrix &max_itr ,
const DoubleMatrix &epsilon ,
const DoubleMatrix &blow ,
const DoubleMatrix &bup ,
const DoubleMatrix &Bin ,
DoubleMatrix &Bout ,
DoubleMatrix &lamout ,
DoubleMatrix &Pout )
{
// temporary indices
size_t i, j, k;
// temporary double pointer
double *ptr;
const double *ptr_c;
// number of discrete measure points
size_t J = Bin.nc();
// number of random effects
size_t n = blow.nr();
// ------------ Arguments to non_par::opt_measure --------------------
assert( max_itr.nr() == 2 );
mat2cpp::matrix<size_t> maxitr(2, 1);
maxitr(0, 0) = size_t( *(max_itr.data() + 0) );
maxitr(1, 0) = size_t( *(max_itr.data() + 1) );
assert( epsilon.nr() == 5 );
mat2cpp::matrix<double> eps(5, 1);
eps(0, 0) = *(epsilon.data() + 0);
eps(1, 0) = *(epsilon.data() + 1);
eps(2, 0) = *(epsilon.data() + 2);
eps(3, 0) = *(epsilon.data() + 3);
eps(4, 0) = *(epsilon.data() + 4);
// input likelihood function
Like like(admodel, model, N, y, n);
// input number of individuals in the population
size_t M = N.nr();
// input lower limit for the random effects
mat2cpp::matrix<double> xLow(1, n);
ptr_c = blow.data();
for(k = 0; k < n; k++)
xLow(0, k) = ptr_c[k];
// input upper limit for the random effects
mat2cpp::matrix<double> xUp(1, n);
ptr_c = bup.data();
for(k = 0; k < n; k++)
xUp(0, k) = ptr_c[k];
// input and return discrete measure points
mat2cpp::matrix<double> X(J, n);
ptr_c = Bin.data();
for(j = 0; j < J; j++)
{ for(k = 0; k < n; k++)
X(j, k) = ptr_c[k + j * n];
}
// return weight corresponding to each measure oint
mat2cpp::matrix<double> lambda(J, 1);
// return convergence information
mat2cpp::matrix<double> info;
// return status message
const char *msg;
// -----------------------------------------------------------------
msg = non_par::opt_measure( level, maxitr, eps,
&like, M, xLow, xUp, X, lambda, info
);
// -----------------------------------------------------------------
if( strcmp(msg, "ok") != 0 )
{ throw SpkException(
SpkError::SPK_NON_PAR_ERR,
msg,
__LINE__,
__FILE__
);
}
// determine number of discrete measure points
assert( n == X.size2() );
J = X.size1();
// dimension the return matrices
Bout.resize(n, J);
lamout.resize(J, 1);
Pout.resize(M, J);
// retrun elements of Bout
ptr = Bout.data();
for(j = 0; j < J; j++)
{ for(k = 0; k < n; k++)
ptr[k + j * n] = X(j, k);
}
// return elements of lamout
ptr = lamout.data();
for(j = 0; j < J; j++)
ptr[j] = lambda(j, 0);
// return elements of Pout
mat2cpp::matrix<double> beta(1, n);
mat2cpp::matrix<double> psi(M, 1);
ptr = Pout.data();
for(j = 0; j < J; j++)
{ for(k = 0; k < n; k++)
beta(0, k) = X(j, k);
psi = like(beta);
for(i = 0; i < M; i++)
ptr[ i + j * M ] = psi(i, 0);
}
// Check for measure points that are constrained
checkMeasurePoints( eps(0, 0), xLow, xUp, X );
return;
}
/*Inputs: Destinaion Excel grid, array of ISINS, number of bonds, array of maturities, date tolerance for flies, */
long _stdcall getFlyData(double* arr, unsigned char bonds[], int numbonds, long* maturities, int microWidth, int dateTolerance, int clusterLower, int clusterUpper, int history){
SimpleRefData bbg(1);
DoubleMatrix yieldData;
DoubleMatrix micro;
DoubleMatrix cluster;
std::vector <std::string> bond_vec;
std::wstring stemp2 = std::to_wstring(numbonds);
LPCWSTR sw2 = stemp2.c_str();
OutputDebugString(L"numbonds ");
OutputDebugString(sw2);
for (int b = 0; b <= numbonds; b++){
std::string prefix = "/isin/";
std::string suffix;
suffix.clear();
for (int j = 0; j < ISIN_LENGTH; j++){
char a = bonds[b + j*(numbonds + 1)];
suffix += a;
}
std::wstring stemp = std::wstring(suffix.begin(), suffix.end());
LPCWSTR sw = stemp.c_str();
OutputDebugString(sw);
OutputDebugString(L"\n");
bond_vec.push_back((prefix + suffix).c_str());
}
double** yieldArray;
yieldArray = new double*[numbonds+1];
for (int i = 0; i <= numbonds; i++){
yieldArray[i] = new double[history];
}
int days_data = bbg.runHistData(yieldArray, bond_vec, history);
std::wstring stemp = std::to_wstring(days_data);
LPCWSTR sw = stemp.c_str();
OutputDebugString(sw);
yieldData.resize(numbonds+1);
for (int i = 0; i <= numbonds; i++){
yieldData[i].resize(days_data);
}
for (int i = 0; i <= numbonds; i++){
for (int j = 0; j < days_data; j++){
yieldData.at(i).at(j) = yieldArray[i][j];
}
}
DoubleMatrix microMatrix;
DoubleMatrix clusterMatrix;
for (int i = 0; i < numbonds; i++){
double microLocal[8];
double clusterLocal[8];
getFlyMetrics(microLocal, false, i, yieldData, maturities, dateTolerance, microWidth, microWidth, days_data);
getFlyMetrics(clusterLocal, true, i, yieldData, maturities, 0, clusterLower, clusterUpper, days_data);
double flyLocal[16];
for (int j = 0; j < 8; j++){
flyLocal[j] = microLocal[j];
flyLocal[8 + j] = clusterLocal[j];
}
for (int k = 0; k < 16; k++){
arr[i + k*(numbonds + 1)] = flyLocal[k];
}
}
delete[] yieldArray;
return 0;
}
void BackwardParabolicIBVP::gridMethod(DoubleMatrix &p, SweepMethodDirection direction) const
{
typedef void (*t_algorithm)(const double*, const double*, const double*, const double*, double*, unsigned int);
t_algorithm algorithm = &tomasAlgorithm;
if (direction == ForwardSweep) algorithm = &tomasAlgorithmL2R;
if (direction == BackwardSweep) algorithm = &tomasAlgorithmR2L;
Dimension time = mtimeDimension;
Dimension dim1 = mspaceDimension.at(0);
double ht = time.step();
unsigned int minM = time.min();
unsigned int maxM = time.max();
unsigned int M = maxM-minM;
double hx = dim1.step();
unsigned int minN = dim1.min();
unsigned int maxN = dim1.max();
unsigned int N = maxN-minN;
double h = ht/(hx*hx);
p.clear();
p.resize(M+1, N+1);
double *ka = (double*) malloc(sizeof(double)*(N-1));
double *kb = (double*) malloc(sizeof(double)*(N-1));
double *kc = (double*) malloc(sizeof(double)*(N-1));
double *kd = (double*) malloc(sizeof(double)*(N-1));
double *rx = (double*) malloc(sizeof(double)*(N-1));
/* initial condition */
SpaceNodePDE isn;
for (unsigned int n=0; n<=N; n++)
{
isn.i = n+minN;
isn.x = isn.i*hx;
p[M][n] = initial(isn);
}
layerInfo(p, M);
SpaceNodePDE lsn;
lsn.i = minN;
lsn.x = minN*hx;
SpaceNodePDE rsn;
rsn.i = maxN;
rsn.x = maxN*hx;
TimeNodePDE tn;
for (unsigned int m=M-1; m!=UINT32_MAX; m--)
{
tn.i = m+minM;
tn.t = tn.i*ht;
for (unsigned int n=1; n<=N-1; n++)
{
isn.i = n+minN;
isn.x = isn.i*hx;
double alpha = -a(isn,tn)*h;
double betta = 1.0 - 2.0*alpha;
ka[n-1] = alpha;
kb[n-1] = betta;
kc[n-1] = alpha;
kd[n-1] = p[m+1][n] - ht * f(isn, tn);
}
ka[0] = 0.0;
kc[N-2] = 0.0;
/* border conditions */
p[m][0] = boundary(lsn, tn);
p[m][N] = boundary(rsn, tn);
kd[0] += a(lsn,tn) * h * p[m][0];
kd[N-2] += a(rsn,tn) * h * p[m][N];
(*algorithm)(ka, kb, kc, kd, rx, N-1);
for (unsigned int n=1; n<=N-1; n++) p[m][n] = rx[n-1];
layerInfo(p, m);
}
free(ka);
free(kb);
free(kc);
free(kd);
free(rx);
}
void ppedOpt( SpdModel& model,
Optimizer& xOptInfo,
const DoubleMatrix& dvecXLow,
const DoubleMatrix& dvecXUp,
const DoubleMatrix& dvecXIn,
DoubleMatrix* pdvecXOut,
const DoubleMatrix& dvecXStep,
Optimizer& alpOptInfo,
const DoubleMatrix& dvecAlpLow,
const DoubleMatrix& dvecAlpUp,
const DoubleMatrix& dvecAlpIn,
DoubleMatrix* pdvecAlpOut,
const DoubleMatrix& dvecAlpStep,
double* pdPhiTildeOut,
DoubleMatrix* pdrowPhiTilde_xOut,
DoubleMatrix* pdmatPhiTilde_x_xOut )
{
//------------------------------------------------------------
// Preliminaries.
//------------------------------------------------------------
using namespace std;
// If no evaluation is requested, return immediately.
if ( !pdvecXOut &&
!pdPhiTildeOut &&
!pdrowPhiTilde_xOut &&
!pdmatPhiTilde_x_xOut )
{
return;
}
// Get the number of design and fixed population parameters.
int nX = dvecXIn.nr();
int nAlp = dvecAlpIn.nr();
//------------------------------------------------------------
// Validate the inputs (Debug mode).
//------------------------------------------------------------
// Check the length of the design parameter vector.
assert( nX == model.getNDesPar() );
//------------------------------------------------------------
// Validate the inputs (All modes).
//------------------------------------------------------------
// [Revisit - Warm Start Disabled - Mitch]
// In order to simplify the testing of this function,
// warm starts have been disabled for now.
if ( xOptInfo.getIsWarmStart() || alpOptInfo.getIsWarmStart() )
{
throw SpkException(
SpkError::SPK_USER_INPUT_ERR,
"One of the input Optimizer objects requested a warm start, which have been disabled for now.",
__LINE__,
__FILE__ );
}
//------------------------------------------------------------
// Prepare the values required to calculate the output values.
//------------------------------------------------------------
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
DoubleMatrix dvecXOutTemp;
DoubleMatrix* pdvecXOutTemp = &dvecXOutTemp;
if ( pdvecXOut )
{
dvecXOutTemp.resize( nX, 1 );
}
else
{
pdvecXOutTemp = 0;
}
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
DoubleMatrix dvecAlpOutTemp;
DoubleMatrix* pdvecAlpOutTemp = &dvecAlpOutTemp;
if ( pdvecAlpOut )
{
dvecAlpOutTemp.resize( nAlp, 1 );
}
else
{
pdvecAlpOutTemp = 0;
}
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
double dLTildeOut;
double* pdLTildeOut = &dLTildeOut;
if ( pdPhiTildeOut || pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
dLTildeOut = 0.0;
}
else
{
pdLTildeOut = 0;
}
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
DoubleMatrix drowLTilde_xOut;
DoubleMatrix* pdrowLTilde_xOut = &drowLTilde_xOut;
if ( pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
drowLTilde_xOut.resize( 1, nX );
}
else
{
pdrowLTilde_xOut = 0;
}
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
DoubleMatrix dmatLTilde_x_xOut;
DoubleMatrix* pdmatLTilde_x_xOut = &dmatLTilde_x_xOut;
if ( pdmatPhiTilde_x_xOut )
{
dmatLTilde_x_xOut.resize( nX, nX );
}
else
{
pdmatLTilde_x_xOut = 0;
}
//------------------------------------------------------------
// Set arguments related to using ppkaOpt for optimal design.
//------------------------------------------------------------
// ppkaOpt solves a two-level optimization problem, where the second
// level is made up of multiple optimization problems that are all
// solved for each iteration of the first level. The length of the
// vector N specifies the number of optimation problems that must be
// solved at the second level. In this use of ppkaOpt, the first
// level optimization is over the design parameter vector x, while the
// second level is over the fixed population vector alp. Since there
// is only a single fixed population vector alp, N has length one. Its
// only value is one because lTilde requires that there be at least
// one data value, but this criterion itself does not depend on the data.
int nIndPped = 1;
int nY_iPped = 1;
DoubleMatrix dvecN( nIndPped, 1 );
DoubleMatrix dvecY( nY_iPped, 1 );
dvecN.fill( (double) nY_iPped );
dvecY.fill( 0.0 );
// Choose the modified Laplace approximation.
enum Objective objective = MODIFIED_LAPLACE;
// Construct a model that evaluates first order approximations for
// the mean and covariance of the data, maps individual to population
// parameters, and maps population to design parameters.
FoMapsParSpkModel ppedOptModel( &model, dvecAlpStep.toValarray() );
//------------------------------------------------------------
// Optimize the modified Laplace approximation for the negative log of phi(x).
//------------------------------------------------------------
// The criterion phi(x) is optimized by replacing the definition of
// lambda(alp, b) and mapObj(b) by the negative natural logarithm
// of the integral with respect to alp and then calls the function
// ppkaOpt to optimize the Laplace approximation for the integral.
try
{
ppkaOpt( ppedOptModel,
objective,
dvecN,
dvecY,
xOptInfo,
dvecXLow,
dvecXUp,
dvecXIn,
&dvecXOutTemp,
dvecXStep,
alpOptInfo,
dvecAlpLow,
dvecAlpUp,
dvecAlpIn,
&dvecAlpOutTemp,
dvecAlpStep,
&dLTildeOut,
&drowLTilde_xOut,
&dmatLTilde_x_xOut );
}
catch( SpkException& e )
{
throw e.push(
SpkError::SPK_UNKNOWN_ERR,
"Optimization of the population expected determinant criterion failed.",
__LINE__,
__FILE__ );
}
catch( const std::exception& stde )
{
throw SpkException(
stde,
"A standard exception occurred during the optimization of the population expected determinant criterion.",
__LINE__,
__FILE__ );
}
catch( ... )
{
throw SpkException(
SpkError::SPK_UNKNOWN_ERR,
"An unknown exception occurred during the optimization of the population expected determinant criterion.",
__LINE__,
__FILE__ );
}
//------------------------------------------------------------
// Finish up.
//------------------------------------------------------------
// Don't set any of the values if the maximum number of
// iterations was reached for either optimization level.
if ( xOptInfo.getIsTooManyIter() || alpOptInfo.getIsTooManyIter() )
{
return;
}
// Set the final design parameter value, if necessary.
if ( pdvecXOut )
{
*pdvecXOut = dvecXOutTemp;
}
// Set the final fixed population parameter value, if necessary.
if ( pdvecAlpOut )
{
*pdvecAlpOut = dvecAlpOutTemp;
}
// Calculate and set the final population expected determinant
// criterion value, if necessary.
double dPhiTildeOutTemp;
if ( pdPhiTildeOut || pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
// Calculate
//
// phiTilde(x) = exp[ - LTilde(x) ]
//
// at x = xOut.
dPhiTildeOutTemp = exp( -dLTildeOut );
if ( pdPhiTildeOut )
{
*pdPhiTildeOut = dPhiTildeOutTemp;
}
}
// Calculate and set the first derivative of the population
// expected determinant criterion at the final parameter value,
// if necessary.
DoubleMatrix drowPhiTilde_xOutTemp;
if ( pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
// Calculate
//
// phiTilde_x(x) = - exp[ - LTilde(x) ] * LTilde_x(x)
//
// = - phiTilde(x) * LTilde_x(x)
//
// at x = xOut.
drowPhiTilde_xOutTemp.resize( 1, nX );
mulByScalar( drowLTilde_xOut, -dPhiTildeOutTemp, drowPhiTilde_xOutTemp );
if ( pdrowPhiTilde_xOut )
{
*pdrowPhiTilde_xOut = drowPhiTilde_xOutTemp;
}
}
// Calculate and set the second derivative of the population
// expected determinant criterion at the final parameter value, if necessary.
if ( pdmatPhiTilde_x_xOut )
{
// [Revisit - Hessian Mixes Analytic and Approximate Derivatives - Mitch]
// Would it be better to approximate the Hessian, phiTilde_x_x(x),
// by taking finite differences of the full derivative, phiTilde_x(x),
// rather than approximating one term in the Hessian, LTilde_x_xOut(x),
// by taking finite differences of LTilde_x(x)?
//
// Calculate
//
// phiTilde_x_x(x) = exp[ - LTilde(x) ] *
//
// - -
// | T |
// | - LTilde_x_x(x) + LTilde_x(x) * LTilde_x(x) |
// | |
// - -
//
// = phiTilde(x) *
//
// - -
// | T |
// | - LTilde_x_x(x) + LTilde_x(x) * LTilde_x(x) |
// | |
// - -
//
// at x = xOut.
//
DoubleMatrix dvecLTilde_xTrans;
DoubleMatrix temp1;
DoubleMatrix temp2;
transpose( drowLTilde_xOut, dvecLTilde_xTrans );
multiply( dvecLTilde_xTrans, drowLTilde_xOut, temp1 );
subtract( temp1, dmatLTilde_x_xOut, temp2 );
mulByScalar( temp2, dPhiTildeOutTemp, *pdmatPhiTilde_x_xOut );
}
}
/*
* y = [1]
* [1]
*/
void lambdaTest::setY(DoubleMatrix &y)
{
y.resize(2,1);
y.fill(rand()/(pow(2.0,32.0)) * 100.0 );
}
/*
* alpha = [1]
* [1]
*/
void lambdaTest::setAlp(DoubleMatrix &alp)
{
alp.resize(2,1);
alp.fill(rand()/(pow(2.0,32.0)) * 100.0);
}
void StopRule::cmpInvMat (DoubleMatrix &oriMat, DoubleMatrix &invMat, int size) {
//invMat.setLimit (size, size);
double eps = 1.0e-20; /* ! */
int i, j, k, l, maxi=0, idx, ix, jx;
double sum, tmp, maxb, aw;
invMat.resize(size);
for (i = 0; i < size; i++) invMat[i].resize(size);
IntVector index (size);
double *wk;
DoubleMatrix omtrx (size);
for (i = 0; i < size; i++) omtrx[i].resize(size);
/* copy oriMat to omtrx */
for (i = 0; i < size; i++)
for (j = 0; j < size; j++)
omtrx[i][j] = oriMat[i][j];
wk = (double *) calloc((size_t)size, sizeof(double));
aw = 1.0;
for (i = 0; i < size; i++) {
maxb = 0.0;
for (j = 0; j < size; j++) {
if (fabs(omtrx[i][j]) > maxb)
maxb = fabs(omtrx[i][j]);
}
if (maxb == 0.0) {
/* Singular matrix */
cout << "\n\n\nHALT: PLEASE REPORT ERROR D TO DEVELOPERS\n\n\n";
//OutStream::write(oriMat, cout);
exit(1);
}
wk[i] = 1.0 / maxb;
}
for (j = 0; j < size; j++) {
for (i = 0; i < j; i++) {
sum = omtrx[i][j];
for (k = 0; k < i; k++)
sum -= omtrx[i][k] * omtrx[k][j];
omtrx[i][j] = sum;
}
maxb = 0.0;
for (i = j; i < size; i++) {
sum = omtrx[i][j];
for (k = 0; k < j; k++)
sum -= omtrx[i][k] * omtrx[k][j];
omtrx[i][j] = sum;
tmp = wk[i] * fabs(sum);
if (tmp >= maxb) {
maxb = tmp;
maxi = i;
}
}
if (j != maxi) {
for (k = 0; k < size; k++) {
tmp = omtrx[maxi][k];
omtrx[maxi][k] = omtrx[j][k];
omtrx[j][k] = tmp;
}
aw = -aw;
wk[maxi] = wk[j];
}
index[j] = maxi;
if (omtrx[j][j] == 0.0)
omtrx[j][j] = eps;
if (j != size - 1) {
tmp = 1.0 / omtrx[j][j];
for (i = j + 1; i < size; i++)
omtrx[i][j] *= tmp;
}
}
for (jx = 0; jx < size; jx++) {
for (ix = 0; ix < size; ix++)
wk[ix] = 0.0;
wk[jx] = 1.0;
l = -1;
for (i = 0; i < size; i++) {
idx = index[i];
sum = wk[idx];
wk[idx] = wk[i];
if (l != -1) {
for (j = l; j < i; j++)
sum -= omtrx[i][j] * wk[j];
} else if (sum != 0.0)
l = i;
wk[i] = sum;
}
for (i = size - 1; i >= 0; i--) {
sum = wk[i];
for (j = i + 1; j < size; j++)
sum -= omtrx[i][j] * wk[j];
wk[i] = sum / omtrx[i][i];
}
for (ix = 0; ix < size; ix++)
invMat[ix][jx] = wk[ix];
}
free((char *)wk);
wk = NULL;
} /* luinverse */
void ppdOpt( SpdModel& model,
Optimizer& optInfo,
const DoubleMatrix& dvecXLow,
const DoubleMatrix& dvecXUp,
const DoubleMatrix& dvecXIn,
DoubleMatrix* pdvecXOut,
const DoubleMatrix& dvecXStep,
const DoubleMatrix& dvecAlp,
const DoubleMatrix& dvecAlpStep,
double* pdPhiTildeOut,
DoubleMatrix* pdrowPhiTilde_xOut,
DoubleMatrix* pdmatPhiTilde_x_xOut )
{
//------------------------------------------------------------
// Preliminaries.
//------------------------------------------------------------
using namespace std;
// If no evaluation is requested, return immediately.
if ( !pdvecXOut &&
!pdPhiTildeOut &&
!pdrowPhiTilde_xOut &&
!pdmatPhiTilde_x_xOut )
{
return;
}
// Get the number of design parameters.
int nX = dvecXIn.nr();
//------------------------------------------------------------
// Validate the inputs (Debug mode).
//------------------------------------------------------------
// Check the length of the design parameter vector.
assert( nX == model.getNDesPar() );
//------------------------------------------------------------
// Validate the inputs (All modes).
//------------------------------------------------------------
// [Revisit - Warm Start Disabled - Mitch]
// In order to simplify the testing of this function,
// warm starts have been disabled for now.
if ( optInfo.getIsWarmStart() )
{
throw SpkException(
SpkError::SPK_USER_INPUT_ERR,
"The input Optimizer object requested a warm start, which have been disabled for now.",
__LINE__,
__FILE__ );
}
//------------------------------------------------------------
// Prepare the values required to calculate the output values.
//------------------------------------------------------------
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
DoubleMatrix dvecXOutTemp;
DoubleMatrix* pdvecXOutTemp = &dvecXOutTemp;
if ( pdvecXOut || pdmatPhiTilde_x_xOut )
{
dvecXOutTemp.resize( nX, 1 );
}
else
{
pdvecXOutTemp = 0;
}
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
double dNegLogOut;
double* pdNegLogOut = &dNegLogOut;
if ( pdPhiTildeOut || pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
dNegLogOut = 0.0;
}
else
{
pdNegLogOut = 0;
}
// If this value is required to calculate the output values,
// initialize it so that it wil be calculated. Otherwise,
// set its pointer to zero so that it won't be calculated.
DoubleMatrix drowNegLog_xOut;
DoubleMatrix* pdrowNegLog_xOut = &drowNegLog_xOut;
if ( pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
drowNegLog_xOut.resize( 1, nX );
}
else
{
pdrowNegLog_xOut = 0;
}
//------------------------------------------------------------
// Prepare the objective function.
//------------------------------------------------------------
// Construct the objective function, which will evaluate the
// negative logarithm of the population determinant criterion.
PpdOptObj ppdOptObj( nX, &model, &dvecAlp, &dvecAlpStep );
//------------------------------------------------------------
// Handle nonzero iterations for the optimization problem.
//------------------------------------------------------------
// If the number of iterations is not zero, then optimize the
// objective function to determine the optimal parameter value.
if ( optInfo.getNMaxIter() > 0 )
{
try
{
// The criterion phi is maximized by finding
// the minumum of its negative logarithm.
quasiNewtonAnyBox( ppdOptObj,
optInfo,
dvecXLow,
dvecXUp,
dvecXIn,
pdvecXOutTemp,
pdNegLogOut,
pdrowNegLog_xOut );
}
catch( SpkException& e )
{
throw e.push(
SpkError::SPK_UNKNOWN_ERR,
"Optimization of the population determinant criterion failed.",
__LINE__,
__FILE__ );
}
catch( const std::exception& stde )
{
throw SpkException(
stde,
"A standard exception occurred during the optimization of the population determinant criterion.",
__LINE__,
__FILE__ );
}
catch( ... )
{
throw SpkException(
SpkError::SPK_UNKNOWN_ERR,
"An unknown exception occurred during the optimization of the population determinant criterion.",
__LINE__,
__FILE__ );
}
}
//------------------------------------------------------------
// Handle zero iterations for the optimization problem.
//------------------------------------------------------------
// If the number of iterations is zero, then the final
// value for the parameter is equal to its initial value.
if ( optInfo.getNMaxIter() == 0 )
{
// Set the final value.
dvecXOutTemp = dvecXIn;
try
{
// Evaluate the negative logarithm of the criterion phi,
// and/or its derivative, at the final value.
if ( pdPhiTildeOut || pdrowPhiTilde_xOut )
{
// The objective function must be called first to set x.
ppdOptObj.function( dvecXOutTemp, pdNegLogOut );
// Calculate the derivative, if necessary.
if ( pdrowPhiTilde_xOut )
{
ppdOptObj.gradient( pdrowNegLog_xOut );
}
}
}
catch( SpkException& e )
{
throw e.push(
SpkError::SPK_UNKNOWN_ERR,
"Evaluation of the population determinant criterion failed.",
__LINE__,
__FILE__ );
}
catch( const std::exception& stde )
{
throw SpkException(
stde,
"A standard exception occurred during the evaluation of the population determinant criterion.",
__LINE__,
__FILE__ );
}
catch( ... )
{
throw SpkException(
SpkError::SPK_UNKNOWN_ERR,
"An unknown exception occurred during the evaluation of the population determinant criterion.",
__LINE__,
__FILE__ );
}
}
//------------------------------------------------------------
// Finish up.
//------------------------------------------------------------
// Don't set any of the values if the maximum number of
// iterations was reached.
if ( optInfo.getIsTooManyIter() )
{
return;
}
// Set the final parameter value, if necessary.
if ( pdvecXOut )
{
*pdvecXOut = dvecXOutTemp;
}
// Calculate and set the final population determinant criterion
// value, if necessary.
double dPhiTildeOutTemp;
if ( pdPhiTildeOut || pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
// Calculate
//
// phiTilde(x) = exp[ - negLogVal(x) ]
//
// at x = xOut.
dPhiTildeOutTemp = exp( -dNegLogOut );
if ( pdPhiTildeOut )
{
*pdPhiTildeOut = dPhiTildeOutTemp;
}
}
// Calculate and set the first derivative of the population
// determinant criterion at the final parameter value, if necessary.
DoubleMatrix drowPhiTilde_xOutTemp;
if ( pdrowPhiTilde_xOut || pdmatPhiTilde_x_xOut )
{
// Calculate
//
// phiTilde_x(x) = - exp[ - negLogVal(x) ] * negLogVal_x(x)
//
// = - phiTilde(x) * negLogVal_x(x)
//
// at x = xOut.
drowPhiTilde_xOutTemp.resize( 1, nX );
mulByScalar( drowNegLog_xOut, -dPhiTildeOutTemp, drowPhiTilde_xOutTemp );
if ( pdrowPhiTilde_xOut )
{
*pdrowPhiTilde_xOut = drowPhiTilde_xOutTemp;
}
}
// Calculate and set the second derivative of the population
// determinant criterion at the final parameter value, if necessary.
if ( pdmatPhiTilde_x_xOut )
{
// [Revisit - Hessian Mixes Analytic and Approximate Derivatives - Mitch]
// Would it be better to approximate the Hessian, phiTilde_x_x(x),
// by taking finite differences of the full derivative, phiTilde_x(x),
// rather than approximating one term in the Hessian, negLog_x_xOut(x),
// by taking finite differences of negLog_x(x)?
//
// Calculate
//
// phiTilde_x_x(x) = exp[ - negLogVal(x) ] *
//
// - -
// | T |
// | - negLogVal_x_x(x) + negLogVal_x(x) * negLogVal_x(x) |
// | |
// - -
//
// = phiTilde(x) *
//
// - -
// | T |
// | - negLogVal_x_x(x) + negLogVal_x(x) * negLogVal_x(x) |
// | |
// - -
//
// at x = xOut.
//
// Calculate the central difference of the analytic derivative
// of the negative log of the criterion.
DoubleMatrix dmatNegLog_x_xTilde;
PpdOptObj_xFuncObj ppdOptObj_xFuncObj( &ppdOptObj );
try
{
dmatNegLog_x_xTilde = centdiff<PpdOptObj_xFuncObj>(
ppdOptObj_xFuncObj,
dvecXOutTemp,
dvecXStep );
}
catch( SpkException& e )
{
throw e.push(
SpkError::SPK_UNKNOWN_ERR,
"Evaluation of the Hessian of the population determinant criterion failed.",
__LINE__,
__FILE__ );
}
catch( const std::exception& stde )
{
throw SpkException(
stde,
"A standard exception occurred during the evaluation of the Hessian of the population determinant criterion.",
__LINE__,
__FILE__ );
}
catch( ... )
{
throw SpkException(
SpkError::SPK_UNKNOWN_ERR,
"An unknown exception occurred during the evaluation of the Hessian of the population determinant criterion.",
__LINE__,
__FILE__ );
}
// Switch the order of differentiation so that the central
// difference comes before the analytic derivative.
DoubleMatrix dmatNegLog_xTilde_x;
dmatNegLog_xTilde_x = transposeDerivative(
drowNegLog_xOut,
dmatNegLog_x_xTilde );
DoubleMatrix dvecNegLogVal_xTrans;
DoubleMatrix temp1;
DoubleMatrix temp2;
// Construct the second derivative of the population
// determinant criterion.
transpose( drowNegLog_xOut, dvecNegLogVal_xTrans );
multiply( dvecNegLogVal_xTrans, drowNegLog_xOut, temp1 );
subtract( temp1, dmatNegLog_xTilde_x, temp2 );
mulByScalar( temp2, dPhiTildeOutTemp, *pdmatPhiTilde_x_xOut );
}
}
void DiscreteHeat::calculateP(const DoubleVector &f, const DoubleVector &u, DoubleMatrix &psi, DoubleVector &g)
{
C_UNUSED(f);
C_UNUSED(g);
double lamda = -(a*ht)/(hx*hx);
double k = 1.0-2.0*lamda;
psi.clear();
psi.resize(M+1, N+1);
DoubleVector a1(N-1);
DoubleVector b1(N-1);
DoubleVector c1(N-1);
DoubleVector d1(N-1);
DoubleVector x1(N-1);
for (unsigned int m=0; m<=M; m++)
{
unsigned int j = M-m;
if (j==M)
{
for (unsigned int i=1; i<=N-1; i++)
{
a1[i-1] = lamda;
b1[i-1] = k;
c1[i-1] = lamda;
d1[i-1] = -2.0*hx*(u[i]-U[i]);
}
a1[0] = 0.0;
c1[N-2] = 0.0;
tomasAlgorithm(a1.data(), b1.data(), c1.data(), d1.data(), x1.data(), x1.size());
for (unsigned int i=1; i<=N-1; i++)
{
psi[j][i] = x1[i-1];
}
psi[j][0] = -lamda*psi[j][1] -2.0*hx*0.5*(u[0]-U[0]);
psi[j][N] = -lamda*psi[j][N-1] -2.0*hx*0.5*(u[N]-U[N]);
}
else if (j==0)
{
psi[j][0] = -lamda*psi[j][1];
psi[j][N] = -lamda*psi[j][N-1];
for (unsigned int i=1; i<=N-1; i++)
{
psi[j][i] = psi[j+1][i];
}
}
else
{
for (unsigned int i=1; i<=N-1; i++)
{
a1[i-1] = lamda;
b1[i-1] = k;
c1[i-1] = lamda;
d1[i-1] = +psi[j+1][i];
}
a1[0] = 0.0;
c1[N-2] = 0.0;
tomasAlgorithm(a1.data(), b1.data(), c1.data(), d1.data(), x1.data(), x1.size());
for (unsigned int i=1; i<=N-1; i++)
{
psi[j][i] = x1[i-1];
}
psi[j][0] = -lamda*psi[j][1];
psi[j][N] = -lamda*psi[j][N-1];
}
}
a1.clear();
b1.clear();
c1.clear();
d1.clear();
x1.clear();
}
