/home/coin/svn-release/OS-2.10.0/OS/src/OSModelInterfaces/OSgams2osil.cpp Source File

00001 // Copyright (C) GAMS Development and others 2007-2009
00002 // All Rights Reserved.
00003 // This code is published under the Eclipse Public License.
00004 //
00005 // $Id: OSgams2osil.cpp 4940 2015-02-03 22:19:22Z Gassmann $
00006 //
00007 // Author: Stefan Vigerske
00008 
00009 #include "OSgams2osil.hpp"
00010 #include "GAMSlinksConfig.h"
00011 #include "GamsNLinstr.h"
00012 
00013 #include "OSInstance.h"
00014 #include "CoinHelperFunctions.hpp"
00015 
00016 #include "gmomcc.h"
00017 #include "gevmcc.h"
00018 
00019 #include <sstream>
00020 
00021 OSgams2osil::OSgams2osil(gmoHandle_t gmo_)
00022     : gev(gmo_ ? (gevHandle_t)gmoEnvironment(gmo_) : NULL), gmo(gmo_), osinstance(NULL)
00023 {
00024     //assert(gev_ == NULL); // TODO better
00025     assert(gmo_ == NULL); // TODO better
00026 }
00027 
00028 OSgams2osil::OSgams2osil(std::string gamsControlFile)
00029     : gev(NULL), gmo(NULL), osinstance(NULL)
00030 {
00031     initGMO( gamsControlFile.c_str() ) ;
00032 }
00033 
00034 OSgams2osil::~OSgams2osil()
00035 {
00036     delete osinstance;
00037 
00038     //close output channels
00039 //      gmoCloseGms(gmo);
00040     gmoFree(&gmo);
00041     gevFree(&gev);
00042     gmoLibraryUnload();
00043     gevLibraryUnload();
00044 }
00045 
00046 bool OSgams2osil::initGMO(const char* datfile)
00047 {
00048     assert(gmo == NULL);
00049     assert(gev == NULL);
00050 
00051     char msg[1024];
00052     int rc;
00053 
00054     if (!gmoCreate(&gmo, msg, sizeof(msg)))
00055     {
00056             osresult->setGeneralMessage(msg);
00057             osresult->setGeneralStatusType("error");
00058             osrl = osrlwriter->writeOSrL( osresult);
00059             throw ErrorClass( osrl);
00060     }
00061 
00062     if (!gevCreate(&gev, msg, sizeof(msg)))
00063     {
00064             osresult->setGeneralMessage(msg);
00065             osresult->setGeneralStatusType("error");
00066             osrl = osrlwriter->writeOSrL( osresult);
00067             throw ErrorClass( osrl);
00068     }
00069 
00070 
00071     gmoIdentSet(gmo, "OS link object");
00072 
00073     // load control file
00074     if ((rc = gevInitEnvironmentLegacy(gev, datfile)))
00075     {
00076         ostringstream outStr;
00077         outStr << "Could not initialize GAMS environment: " << datfile << " Rc = " << rc << std::endl;
00078         osresult->setGeneralMessage(outStr.str());
00079         osresult->setGeneralStatusType("error");
00080         osrl = osrlwriter->writeOSrL( osresult);
00081         gmoFree(&gmo);
00082         gevFree(&gev);
00083         throw ErrorClass( osrl);
00084     }
00085 
00086     if ((rc = gmoRegisterEnvironment(gmo, gev, msg)))
00087     {
00088         osresult->setGeneralMessage("Could not register GAMS environment.");
00089         osresult->setGeneralStatusType("error");
00090         osrl = osrlwriter->writeOSrL( osresult);
00091         gmoFree(&gmo);
00092         gevFree(&gev);
00093         throw ErrorClass( osrl);
00094     }
00095 
00096     if ((rc = gmoLoadDataLegacy(gmo, msg)))
00097     {
00098         osresult->setGeneralMessage("Could not load model data.");
00099         osresult->setGeneralStatusType("error");
00100         osrl = osrlwriter->writeOSrL( osresult);
00101         gmoFree(&gmo);
00102         gevFree(&gev);
00103         throw ErrorClass( osrl);
00104     }
00105 
00106     gmoMinfSet(gmo, -OSDBL_MAX);
00107     gmoPinfSet(gmo,  OSDBL_MAX);
00108     gmoObjReformSet(gmo, 1);
00109     gmoObjStyleSet(gmo, ObjType_Fun);
00110     gmoIndexBaseSet(gmo, 0);
00111 
00112     return true;
00113 }
00114 
00115 bool OSgams2osil::createOSInstance()
00116 {
00117     assert(gmo != NULL);
00118     assert(gev != NULL);
00119 
00120     osinstance = new OSInstance();
00121     int i, j;
00122     char buffer[255];
00123 
00124     // unfortunately, we do not know the model name
00125     osinstance->setInstanceDescription("Generated from GAMS modeling object");
00126     osinstance->setVariableNumber(gmoN(gmo));
00127 
00128     char*        vartypes = new char[gmoN(gmo)];
00129     std::string* varnames = new std::string[gmoN(gmo)];
00130     for(i = 0; i < gmoN(gmo); ++i)
00131     {
00132         switch (gmoGetVarTypeOne(gmo, i))
00133         {
00134         case var_X:
00135             vartypes[i] = 'C';
00136             break;
00137         case var_B:
00138             vartypes[i] = 'B';
00139             break;
00140         case var_I:
00141             vartypes[i] = 'I';
00142             break;
00143         default :
00144         {
00145             // TODO: how to represent semicontinuous var. and SOS in OSiL ?
00146             gevLogStat(gev, "Error: Unsupported variable type.");
00147             return false;
00148         }
00149         }
00150         gmoGetVarNameOne(gmo, i, buffer);
00151         varnames[i] = buffer;
00152     }
00153 
00154     double* varlow = new double[gmoN(gmo)];
00155     double* varup  = new double[gmoN(gmo)];
00156     gmoGetVarLower(gmo, varlow);
00157     gmoGetVarUpper(gmo, varup);
00158 
00159     if (!osinstance->setVariables(gmoN(gmo), varnames, varlow, varup, vartypes))
00160         return false;
00161 
00162     delete[] vartypes;
00163     delete[] varnames;
00164     delete[] varlow;
00165     delete[] varup;
00166 
00167     if (gmoModelType(gmo) == Proc_cns)   // no objective in constraint satisfaction models
00168     {
00169         osinstance->setObjectiveNumber(0);
00170     }
00171     else     // setup objective
00172     {
00173         osinstance->setObjectiveNumber(1);
00174 
00175         SparseVector* objectiveCoefficients = new SparseVector(gmoObjNZ(gmo) - gmoObjNLNZ(gmo));
00176 
00177         int* colidx = new int[gmoObjNZ(gmo)];
00178         double* val = new double[gmoObjNZ(gmo)];
00179         int* nlflag = new int[gmoObjNZ(gmo)];
00180         int* dummy  = new int[gmoObjNZ(gmo)];
00181 
00182         if (gmoObjNZ(gmo)) nlflag[0] = 0; // workaround for gmo bug
00183         gmoGetObjSparse(gmo, colidx, val, nlflag, dummy, dummy);
00184         for (i = 0, j = 0; i < gmoObjNZ(gmo); ++i)
00185         {
00186             if (nlflag[i]) continue;
00187             objectiveCoefficients->indexes[j] = colidx[i];
00188             objectiveCoefficients->values[j]  = val[i];
00189             j++;
00190             assert(j <= gmoObjNZ(gmo) - gmoObjNLNZ(gmo));
00191         }
00192         assert(j == gmoObjNZ(gmo) - gmoObjNLNZ(gmo));
00193 
00194         delete[] colidx;
00195         delete[] val;
00196         delete[] nlflag;
00197         delete[] dummy;
00198 
00199         std::string objname = "objective"; //TODO
00200         if (!osinstance->addObjective(-1, objname, gmoSense(gmo) == Obj_Min ? "min" : "max", gmoObjConst(gmo), 1., objectiveCoefficients))
00201         {
00202             delete objectiveCoefficients;
00203             return false;
00204         }
00205         delete objectiveCoefficients;
00206     }
00207 
00208     osinstance->setConstraintNumber(gmoM(gmo));
00209 
00210     double lb, ub;
00211     for (i = 0;  i < gmoM(gmo);  ++i)
00212     {
00213         switch (gmoGetEquTypeOne(gmo, i))
00214         {
00215         case equ_E:
00216             lb = ub = gmoGetRhsOne(gmo, i);
00217             break;
00218         case equ_L:
00219             lb = -OSDBL_MAX;
00220             ub =  gmoGetRhsOne(gmo, i);
00221             break;
00222         case equ_G:
00223             lb = gmoGetRhsOne(gmo, i);
00224             ub = OSDBL_MAX;
00225             break;
00226         case equ_N:
00227             lb = -OSDBL_MAX;
00228             ub =  OSDBL_MAX;
00229             break;
00230         default:
00231             gevLogStat(gev, "Error: Unknown row type. Exiting ...");
00232             return false;
00233         }
00234         std::string conname;
00235         gmoGetEquNameOne(gmo, i, buffer);
00236         conname = buffer;
00237         if (!osinstance->addConstraint(i, conname, lb, ub, 0.))
00238             return false;
00239     }
00240 
00241     int nz = gmoNZ(gmo);
00242     double* values  = new double[nz];
00243     int* colstarts  = new int[gmoN(gmo)+1];
00244     int* rowindexes = new int[nz];
00245     int* nlflags    = new int[nz];
00246 
00247     gmoGetMatrixCol(gmo, colstarts, rowindexes, values, nlflags);
00248 //      for (i = 0; i < gmoNZ(gmo); ++i)
00249 //              if (nlflags[i]) values[i] = 0.;
00250     colstarts[gmoN(gmo)] = nz;
00251 
00252     int shift = 0;
00253     for (int col = 0; col < gmoN(gmo); ++col)
00254     {
00255         colstarts[col+1] -= shift;
00256         int k = colstarts[col];
00257         while (k < colstarts[col+1])
00258         {
00259             values[k] = values[k+shift];
00260             rowindexes[k] = rowindexes[k+shift];
00261             if (nlflags[k+shift])
00262             {
00263                 ++shift;
00264                 --colstarts[col+1];
00265             }
00266             else
00267             {
00268                 ++k;
00269             }
00270         }
00271     }
00272     nz -= shift;
00273 
00274     if (!osinstance->setLinearConstraintCoefficients(nz, true,
00275             values, 0, nz-1,
00276             rowindexes, 0, nz-1,
00277             colstarts, 0, gmoN(gmo)))
00278     {
00279         delete[] nlflags;
00280         return false;
00281     }
00282 
00283     // values, colstarts, rowindexes are deleted by OSInstance
00284     delete[] nlflags;
00285 
00286     if (!gmoObjNLNZ(gmo) && !gmoNLNZ(gmo)) // everything linear -> finished
00287         return true;
00288 
00289     osinstance->instanceData->nonlinearExpressions->numberOfNonlinearExpressions = gmoNLM(gmo) + (gmoObjNLNZ(gmo) ? 1 : 0);
00290     osinstance->instanceData->nonlinearExpressions->nl = CoinCopyOfArrayOrZero((Nl**)NULL, osinstance->instanceData->nonlinearExpressions->numberOfNonlinearExpressions);
00291     int iNLidx = 0;
00292 
00293     int* opcodes = new int[gmoMaxSingleFNL(gmo)+1];
00294     int* fields  = new int[gmoMaxSingleFNL(gmo)+1];
00295     int constantlen = gmoNLConst(gmo);
00296     double* constants = (double*)gmoPPool(gmo);
00297     int codelen;
00298 
00299     OSnLNode* nl;
00300     if (gmoObjNLNZ(gmo))
00301     {
00302         std::clog << "parsing nonlinear objective instructions" << std::endl;
00303         gmoDirtyGetObjFNLInstr(gmo, &codelen, opcodes, fields);
00304 
00305         nl = parseGamsInstructions(codelen, opcodes, fields, constantlen, constants);
00306         if (!nl) return false;
00307 
00308         double objjacval = gmoObjJacVal(gmo);
00309         std::clog << "obj jac val: " << objjacval << std::endl;
00310         if (objjacval == 1.)   // scale by -1/objjacval = negate
00311         {
00312             OSnLNode* negnode = new OSnLNodeNegate;
00313             negnode->m_mChildren[0] = nl;
00314             nl = negnode;
00315         }
00316         else if (objjacval != -1.)     // scale by -1/objjacval
00317         {
00318             OSnLNodeNumber* numbernode = new OSnLNodeNumber();
00319             numbernode->value = -1/objjacval;
00320             OSnLNodeTimes* timesnode = new OSnLNodeTimes();
00321             timesnode->m_mChildren[0] = nl;
00322             timesnode->m_mChildren[1] = numbernode;
00323             nl = timesnode;
00324         }
00325         assert(iNLidx < osinstance->instanceData->nonlinearExpressions->numberOfNonlinearExpressions);
00326         osinstance->instanceData->nonlinearExpressions->nl[iNLidx] = new Nl();
00327         osinstance->instanceData->nonlinearExpressions->nl[iNLidx]->idx = -1;
00328         osinstance->instanceData->nonlinearExpressions->nl[iNLidx]->osExpressionTree = new ScalarExpressionTree();
00329         osinstance->instanceData->nonlinearExpressions->nl[iNLidx]->osExpressionTree->m_treeRoot = nl;
00330         ++iNLidx;
00331     }
00332 
00333     for (i = 0; i < gmoM(gmo); ++i)
00334     {
00335         if (gmoDirtyGetRowFNLInstr(gmo, i, &codelen, opcodes, fields))
00336         {
00337             std::clog << "got nonzero return at constraint " << i << std::endl;
00338         }
00339         if (!codelen) continue;
00340         std::clog << "parsing " << codelen << " nonlinear instructions of constraint " << osinstance->getConstraintNames()[i] << std::endl;
00341         nl = parseGamsInstructions(codelen, opcodes, fields, constantlen, constants);
00342         if (!nl) return false;
00343         assert(iNLidx < osinstance->instanceData->nonlinearExpressions->numberOfNonlinearExpressions);
00344         osinstance->instanceData->nonlinearExpressions->nl[iNLidx] = new Nl();
00345         osinstance->instanceData->nonlinearExpressions->nl[iNLidx]->idx = i; // correct that this is the con. number?
00346         osinstance->instanceData->nonlinearExpressions->nl[iNLidx]->osExpressionTree = new OSExpressionTree();
00347         osinstance->instanceData->nonlinearExpressions->nl[iNLidx]->osExpressionTree->m_treeRoot = nl;
00348         ++iNLidx;
00349     }
00350     assert(iNLidx == osinstance->instanceData->nonlinearExpressions->numberOfNonlinearExpressions);
00351 
00352     return true;
00353 }
00354 
00355 OSInstance* OSgams2osil::takeOverOSInstance()
00356 {
00357     OSInstance* osinst = osinstance;
00358     osinstance = NULL;
00359     return osinst;
00360 }
00361 
00362 OSnLNode* OSgams2osil::parseGamsInstructions(int codelen, int* opcodes, int* fields, int constantlen, double* constants)
00363 {
00364     std::vector<OSnLNode*> nlNodeVec;
00365 
00366     const bool debugoutput = false;
00367 
00368 //      for (int i=0; i<codelen; ++i)
00369 //              std::clog << i << '\t' << GamsOpCodeName[opcodes[i+1]] << '\t' << fields[i+1] << std::endl;
00370 
00371     nlNodeVec.reserve(codelen);
00372 
00373     for (int i=0; i<codelen; ++i)
00374     {
00375         GamsOpCode opcode = (GamsOpCode)opcodes[i];
00376         int address = fields[i]-1;
00377 
00378         if (debugoutput) std::clog << '\t' << GamsOpCodeName[opcode] << ": ";
00379 //              if (opcode == nlStore) {
00380 //                      std::clog << "stop" << std::endl;
00381 //                      break;
00382 //              }
00383         switch(opcode)
00384         {
00385         case nlNoOp :   // no operation
00386         {
00387             if (debugoutput) std::clog << "ignored" << std::endl;
00388         }
00389         break;
00390         case nlPushV :   // push variable
00391         {
00392             address = gmoGetjSolver(gmo, address);
00393             if (debugoutput) std::clog << "push variable " << osinstance->getVariableNames()[address] << std::endl;
00394             OSnLNodeVariable *nlNode = new OSnLNodeVariable();
00395             nlNode->idx=address;
00396             nlNodeVec.push_back( nlNode );
00397         }
00398         break;
00399         case nlPushI :   // push constant
00400         {
00401             if (debugoutput) std::clog << "push constant " << constants[address] << std::endl;
00402             OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00403             nlNode->value = constants[address];
00404             nlNodeVec.push_back( nlNode );
00405         }
00406         break;
00407         case nlStore:   // store row
00408         {
00409             if (debugoutput) std::clog << "ignored" << std::endl;
00410         }
00411         break;
00412         case nlAdd :   // add
00413         {
00414             if (debugoutput) std::clog << "add" << std::endl;
00415             nlNodeVec.push_back( new OSnLNodePlus() );
00416         }
00417         break;
00418         case nlAddV:   // add variable
00419         {
00420             address = gmoGetjSolver(gmo, address);
00421             if (debugoutput) std::clog << "add variable " << osinstance->getVariableNames()[address] << std::endl;
00422             OSnLNodeVariable *nlNode = new OSnLNodeVariable();
00423             nlNode->idx=address;
00424             nlNodeVec.push_back( nlNode );
00425             nlNodeVec.push_back( new OSnLNodePlus() );
00426         }
00427         break;
00428         case nlAddI:   // add immediate
00429         {
00430             if (debugoutput) std::clog << "add constant " << constants[address] << std::endl;
00431             OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00432             nlNode->value = constants[address];
00433             nlNodeVec.push_back( nlNode );
00434             nlNodeVec.push_back( new OSnLNodePlus() );
00435         }
00436         break;
00437         case nlSub:   // minus
00438         {
00439             if (debugoutput) std::clog << "minus" << std::endl;
00440             nlNodeVec.push_back( new OSnLNodeMinus() );
00441         }
00442         break;
00443         case nlSubV:   // subtract variable
00444         {
00445             address = gmoGetjSolver(gmo, address);
00446             if (debugoutput) std::clog << "substract variable " << osinstance->getVariableNames()[address] << std::endl;
00447             OSnLNodeVariable *nlNode = new OSnLNodeVariable();
00448             nlNode->idx=address;
00449             nlNodeVec.push_back( nlNode );
00450             nlNodeVec.push_back( new OSnLNodeMinus() );
00451         }
00452         break;
00453         case nlSubI:   // subtract immediate
00454         {
00455             if (debugoutput) std::clog << "substract constant " << constants[address] << std::endl;
00456             OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00457             nlNode->value = constants[address];
00458             nlNodeVec.push_back( nlNode );
00459             nlNodeVec.push_back( new OSnLNodeMinus() );
00460         }
00461         break;
00462         case nlMul:   // multiply
00463         {
00464             if (debugoutput) std::clog << "multiply" << std::endl;
00465             nlNodeVec.push_back( new OSnLNodeTimes() );
00466         }
00467         break;
00468         case nlMulV:   // multiply variable
00469         {
00470             address = gmoGetjSolver(gmo, address);
00471             if (debugoutput) std::clog << "multiply variable " << osinstance->getVariableNames()[address] << std::endl;
00472             OSnLNodeVariable *nlNode = new OSnLNodeVariable();
00473             nlNode->idx=address;
00474             nlNodeVec.push_back( nlNode );
00475             nlNodeVec.push_back( new OSnLNodeTimes() );
00476         }
00477         break;
00478         case nlMulI:   // multiply immediate
00479         {
00480             if (debugoutput) std::clog << "multiply constant " << constants[address] << std::endl;
00481             OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00482             nlNode->value = constants[address];
00483             nlNodeVec.push_back( nlNode );
00484             nlNodeVec.push_back( new OSnLNodeTimes() );
00485         }
00486         break;
00487         case nlDiv:   // divide
00488         {
00489             if (debugoutput) std::clog << "divide" << std::endl;
00490             nlNodeVec.push_back( new OSnLNodeDivide() );
00491         }
00492         break;
00493         case nlDivV:   // divide variable
00494         {
00495             address = gmoGetjSolver(gmo, address);
00496             if (debugoutput) std::clog << "divide variable " << osinstance->getVariableNames()[address] << std::endl;
00497             OSnLNodeVariable *nlNode = new OSnLNodeVariable();
00498             nlNode->idx=address;
00499             nlNodeVec.push_back( nlNode );
00500             nlNodeVec.push_back( new OSnLNodeDivide() );
00501         }
00502         break;
00503         case nlDivI:   // divide immediate
00504         {
00505             if (debugoutput) std::clog << "divide constant " << constants[address] << std::endl;
00506             OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00507             nlNode->value = constants[address];
00508             nlNodeVec.push_back( nlNode );
00509             nlNodeVec.push_back( new OSnLNodeDivide() );
00510         }
00511         break;
00512         case nlUMin:   // unary minus
00513         {
00514             if (debugoutput) std::clog << "negate" << std::endl;
00515             nlNodeVec.push_back( new OSnLNodeNegate() );
00516         }
00517         break;
00518         case nlUMinV:   // unary minus variable
00519         {
00520             address = gmoGetjSolver(gmo, address);
00521             if (debugoutput) std::clog << "push negated variable " << osinstance->getVariableNames()[address] << std::endl;
00522             OSnLNodeVariable *nlNode = new OSnLNodeVariable();
00523             nlNode->idx = address;
00524             nlNode->coef = -1.;
00525             nlNodeVec.push_back( nlNode );
00526         }
00527         break;
00528         case nlCallArg1 :
00529         case nlCallArg2 :
00530         case nlCallArgN :
00531         {
00532             if (debugoutput) std::clog << "call function ";
00533             GamsFuncCode func = GamsFuncCode(address+1); // here the shift by one was not a good idea
00534             switch (func)
00535             {
00536             case fnmin :
00537             {
00538                 if (debugoutput) std::clog << "min" << std::endl;
00539                 nlNodeVec.push_back( new OSnLNodeMin() );
00540             }
00541             break;
00542             case fnmax :
00543             {
00544                 if (debugoutput) std::clog << "max" << std::endl;
00545                 nlNodeVec.push_back( new OSnLNodeMax() );
00546             }
00547             break;
00548             case fnsqr :
00549             {
00550                 if (debugoutput) std::clog << "square" << std::endl;
00551                 nlNodeVec.push_back( new OSnLNodeSquare() );
00552             }
00553             break;
00554             case fnexp:
00555             case fnslexp:
00556             case fnsqexp:
00557             {
00558                 if (debugoutput) std::clog << "exp" << std::endl;
00559                 nlNodeVec.push_back( new OSnLNodeExp() );
00560             }
00561             break;
00562             case fnlog :
00563             {
00564                 if (debugoutput) std::clog << "ln" << std::endl;
00565                 nlNodeVec.push_back( new OSnLNodeLn() );
00566             }
00567             break;
00568             case fnlog10:
00569             case fnsllog10:
00570             case fnsqlog10:
00571             {
00572                 if (debugoutput) std::clog << "log10 = ln * 1/ln(10)" << std::endl;
00573                 nlNodeVec.push_back( new OSnLNodeLn() );
00574                 OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00575                 nlNode->value = 1./log(10.);
00576                 nlNodeVec.push_back( nlNode );
00577                 nlNodeVec.push_back( new OSnLNodeTimes() );
00578             }
00579             break;
00580             case fnlog2 :
00581             {
00582                 if (debugoutput) std::clog << "log2 = ln * 1/ln(2)" << std::endl;
00583                 nlNodeVec.push_back( new OSnLNodeLn() );
00584                 OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00585                 nlNode->value = 1./log(2.);
00586                 nlNodeVec.push_back( nlNode );
00587                 nlNodeVec.push_back( new OSnLNodeTimes() );
00588             }
00589             break;
00590             case fnsqrt:
00591             {
00592                 if (debugoutput) std::clog << "sqrt" << std::endl;
00593                 nlNodeVec.push_back( new OSnLNodeSqrt() );
00594             }
00595             break;
00596             case fnabs:
00597             {
00598                 if (debugoutput) std::clog << "abs" << std::endl;
00599                 nlNodeVec.push_back( new OSnLNodeAbs() );
00600             }
00601             break;
00602             case fncos:
00603             {
00604                 if (debugoutput) std::clog << "cos" << std::endl;
00605                 nlNodeVec.push_back( new OSnLNodeCos() );
00606             }
00607             break;
00608             case fnsin:
00609             {
00610                 if (debugoutput) std::clog << "sin" << std::endl;
00611                 nlNodeVec.push_back( new OSnLNodeSin() );
00612             }
00613             break;
00614             case fnpower:
00615             case fnrpower: // x ^ y
00616             case fncvpower: // constant ^ x
00617             case fnvcpower:   // x ^ constant {
00618             {
00619                 if (debugoutput) std::clog << "power" << std::endl;
00620                 nlNodeVec.push_back( new OSnLNodePower() );
00621             }
00622             break;
00623             case fnpi:
00624             {
00625                 if (debugoutput) std::clog << "pi" << std::endl;
00626                 nlNodeVec.push_back( new OSnLNodePI() );
00627             }
00628             break;
00629             case fndiv:
00630             case fndiv0:
00631             {
00632                 nlNodeVec.push_back( new OSnLNodeDivide() );
00633             }
00634             break;
00635             case fnslrec: // 1/x
00636             case fnsqrec:   // 1/x
00637             {
00638                 if (debugoutput) std::clog << "divide" << std::endl;
00639                 nlNodeVec.push_back( new OSnLNodeLn() );
00640                 OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00641                 nlNode->value = 1.;
00642                 nlNodeVec.push_back( nlNode );
00643                 nlNodeVec.push_back( new OSnLNodeDivide() );
00644             }
00645             break;
00646             case fnceil:
00647             case fnfloor:
00648             case fnround:
00649             case fnmod:
00650             case fntrunc:
00651             case fnsign:
00652             case fnarctan:
00653             case fnerrf:
00654             case fndunfm:
00655             case fndnorm:
00656             case fnerror:
00657             case fnfrac:
00658             case fnerrorl:
00659             case fnfact /* factorial */:
00660             case fnunfmi /* uniform random number */:
00661             case fnncpf /* fischer: sqrt(x1^2+x2^2+2*x3) */:
00662             case fnncpcm /* chen-mangasarian: x1-x3*ln(1+exp((x1-x2)/x3))*/:
00663             case fnentropy /* x*ln(x) */:
00664             case fnsigmoid /* 1/(1+exp(-x)) */:
00665             case fnboolnot:
00666             case fnbooland:
00667             case fnboolor:
00668             case fnboolxor:
00669             case fnboolimp:
00670             case fnbooleqv:
00671             case fnrelopeq:
00672             case fnrelopgt:
00673             case fnrelopge:
00674             case fnreloplt:
00675             case fnrelople:
00676             case fnrelopne:
00677             case fnifthen:
00678             case fnedist /* euclidian distance */:
00679             case fncentropy /* x*ln((x+d)/(y+d))*/:
00680             case fngamma:
00681             case fnloggamma:
00682             case fnbeta:
00683             case fnlogbeta:
00684             case fngammareg:
00685             case fnbetareg:
00686             case fnsinh:
00687             case fncosh:
00688             case fntanh:
00689             case fnsignpower /* sign(x)*abs(x)^c */:
00690             case fnncpvusin /* veelken-ulbrich */:
00691             case fnncpvupow /* veelken-ulbrich */:
00692             case fnbinomial:
00693             case fntan:
00694             case fnarccos:
00695             case fnarcsin:
00696             case fnarctan2 /* arctan(x2/x1) */:
00697             case fnpoly: /* simple polynomial */
00698             default :
00699             {
00700                 if (debugoutput) std::cerr << "nr. " << func << " - unsupported. Error." << std::endl;
00701                 return NULL;
00702             }
00703             }
00704         }
00705         break;
00706         case nlMulIAdd:
00707         {
00708             if (debugoutput) std::clog << "multiply constant " << constants[address] << " and add " << std::endl;
00709             OSnLNodeNumber *nlNode = new OSnLNodeNumber();
00710             nlNode->value = constants[address];
00711             nlNodeVec.push_back( nlNode );
00712             nlNodeVec.push_back( new OSnLNodeTimes() );
00713             nlNodeVec.push_back( new OSnLNodePlus() );
00714         }
00715         break;
00716         case nlFuncArgN :
00717         {
00718             if (debugoutput) std::clog << "ignored" << std::endl;
00719         }
00720         break;
00721         case nlArg:
00722         {
00723             if (debugoutput) std::clog << "ignored" << std::endl;
00724         }
00725         break;
00726         case nlHeader:   // header
00727         {
00728             if (debugoutput) std::clog << "ignored" << std::endl;
00729         }
00730         break;
00731         case nlPushZero:
00732         {
00733             if (debugoutput) std::clog << "push constant zero" << std::endl;
00734             nlNodeVec.push_back( new OSnLNodeNumber() );
00735         }
00736         break;
00737         case nlStoreS:   // store scaled row
00738         {
00739             if (debugoutput) std::clog << "ignored" << std::endl;
00740         }
00741         break;
00742         // the following three should have been taken out by reorderInstr above; the remaining ones seem to be unused by now
00743         case nlPushS: // duplicate value from address levels down on top of stack
00744         case nlPopup: // duplicate value from this level to at address levels down and pop entries in between
00745         case nlSwap: // swap two positions on top of stack
00746         case nlAddL: // add local
00747         case nlSubL: // subtract local
00748         case nlMulL: // multiply local
00749         case nlDivL: // divide local
00750         case nlPushL: // push local
00751         case nlPopL: // pop local
00752         case nlPopDeriv: // pop derivative
00753         case nlUMinL: // push umin local
00754         case nlPopDerivS: // store scaled gradient
00755         case nlEquScale: // equation scale
00756         case nlEnd: // end of instruction list
00757         default:
00758         {
00759             std::cerr << "not supported - Error." << std::endl;
00760             return NULL;
00761         }
00762         }
00763     }
00764 
00765     if (!nlNodeVec.size()) return NULL;
00766     // the vector is in postfix format - create expression tree and return it
00767     return nlNodeVec[0]->createExpressionTreeFromPostfix(nlNodeVec);
00768 }