00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #include "CouenneTypes.hpp"
00012
00013 #include "exprAbs.hpp"
00014 #include "exprSum.hpp"
00015 #include "exprSub.hpp"
00016 #include "exprMul.hpp"
00017 #include "exprDiv.hpp"
00018 #include "exprInv.hpp"
00019 #include "exprSin.hpp"
00020 #include "exprPow.hpp"
00021 #include "exprClone.hpp"
00022 #include "exprLog.hpp"
00023 #include "exprOpp.hpp"
00024 #include "exprCos.hpp"
00025 #include "exprExp.hpp"
00026
00027 #include "asl.h"
00028 #include "nlp.h"
00029 #include "opcode.hd"
00030
00031
00032 int getOperator (efunc *);
00033
00034
00035
00036
00037 void notimpl (const std::string &fname) {
00038 std::cerr << "*** Error: " << fname << " not implemented" << std::endl;
00039 exit (-1);
00040 }
00041
00042
00043
00044 expression *CouenneProblem::nl2e (expr *e, const ASL *asl) {
00045
00046 switch (getOperator (e -> op)) {
00047
00048 case OPPLUS: return new exprSum (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
00049 case OPMINUS: return new exprSub (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
00050 case OPMULT: return new exprMul (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
00051 case OPDIV: return new exprDiv (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
00052
00053 case OPPOW: return new exprPow (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
00054
00055
00056
00057
00058
00059 case ABS: return new exprAbs (nl2e (e -> L.e, asl));
00060 case OPUMINUS:return new exprOpp (nl2e (e -> L.e, asl));
00061
00062
00063
00064
00065
00066
00067 case OP_tanh: return new exprDiv
00068 (new exprSub (new exprExp (nl2e (e -> L.e, asl)),
00069 new exprExp (new exprOpp (nl2e (e->L.e, asl)))),
00070 new exprSum (new exprExp (nl2e (e -> L.e, asl)),
00071 new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
00072
00073 case OP_tan: {
00074 expression *arg;
00075 arg = nl2e (e -> L.e, asl);
00076 return new exprDiv (new exprSin (arg), new exprCos (new exprClone (arg)));
00077 }
00078 case OP_sqrt: return new exprPow (nl2e (e -> L.e, asl), new exprConst (0.5));
00079 case OP_sinh: return new exprMul (new exprConst (0.5),
00080 new exprSub (new exprExp (nl2e (e -> L.e, asl)),
00081 new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
00082 case OP_sin: return new exprSin (nl2e (e -> L.e, asl));
00083 case OP_log10: return new exprMul (new exprConst (1.0 / log (10.0)),
00084 new exprLog (nl2e (e -> L.e, asl)));
00085 case OP_log: return new exprLog (nl2e (e -> L.e, asl));
00086 case OP_exp: return new exprExp (nl2e (e -> L.e, asl));
00087 case OP_cosh: return new exprMul (new exprConst (0.5),
00088 new exprSum (new exprExp (nl2e (e -> L.e, asl)),
00089 new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
00090
00091 case OP_cos: return new exprCos (nl2e (e -> L.e, asl));
00092
00093
00094
00095
00096
00097
00098
00099
00100 case OPSUMLIST: {
00101 int i=0;
00102 expression **al = new expression * [(e->R.ep - e->L.ep)];
00103 for (expr **ep = e->L.ep; ep < e->R.ep; ep++)
00104 al [i++] = nl2e (*ep, asl);
00105 return new exprSum (al, i);
00106 }
00107
00108
00109
00110
00111
00112 case OP1POW: return new exprPow (nl2e (e -> L.e, asl),
00113 new exprConst (((expr_n *)e->R.e)->v));
00114 case OP2POW: return new exprPow (nl2e (e -> L.e, asl),
00115 new exprConst (2.));
00116 case OPCPOW: return new exprPow (new exprConst (((expr_n *)e->L.e)->v),
00117 nl2e (e -> R.e, asl));
00118
00119 case OPNUM: return new exprConst (((expr_n *)e)->v);
00120
00121
00122
00123 case OPVARVAL: {
00124
00125 int j = ((expr_v *) e) -> a;
00126
00127 if (j >= nOrigVars_)
00128
00129 j = ((expr_v *) e) - ((const ASL_fg *) asl) -> I.var_e_;
00130
00131 if (j >= nOrigVars_ + ndefined_) {
00132 printf ("error: unknown variable x_%d\n", j);
00133
00134 exit (-1);
00135 }
00136
00137 return new exprClone (variables_ [j]);
00138 }
00139
00140 default:
00141 printf ("ERROR: unknown operator (address %p), aborting.\n", Intcast (e -> op));
00142 exit (-1);
00143
00144 }
00145
00146 return new exprConst (0.);
00147 }