source: trunk/Couenne/src/readnl/nl2e.cpp @ 80

Last change on this file since 80 was 80, checked in by pbelotti, 11 years ago

trying again compatibility with MSVC

File size: 4.9 KB
Line 
1/*
2 * Name:    nl2e.cpp
3 * Author:  Pietro Belotti
4 * Purpose: converts a nl expression into a Couenne expression
5 *
6 * (C) Carnegie-Mellon University, 2006-09.
7 * This file is licensed under the Common Public License (CPL)
8 */
9
10#include "CouenneTypes.hpp"
11
12#include "exprAbs.hpp"
13#include "exprSum.hpp"
14#include "exprSub.hpp"
15#include "exprMul.hpp"
16#include "exprDiv.hpp"
17#include "exprInv.hpp"
18#include "exprSin.hpp"
19#include "exprPow.hpp"
20#include "exprClone.hpp"
21#include "exprLog.hpp"
22#include "exprOpp.hpp"
23#include "exprCos.hpp"
24#include "exprExp.hpp"
25
26#include "asl.h"
27#include "nlp.h"
28#include "opcode.hd"
29
30// get ASL op. code relative to function pointer passed as parameter
31int getOperator (efunc *);
32
33
34// warning for non-implemented functions -- return 0 constant expression
35//expression *notimpl (const std::string &fname) {
36void notimpl (const std::string &fname) {
37  std::cerr << "*** Error: " << fname << " not implemented" << std::endl;
38  exit (-1);
39}
40
41
42// converts an AMPL expression (sub)tree into an expression* (sub)tree
43expression *CouenneProblem::nl2e (expr *e, const ASL *asl) {
44
45  switch (getOperator (e -> op)) {
46
47  case OPPLUS:  return new exprSum (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
48  case OPMINUS: return new exprSub (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
49  case OPMULT:  return new exprMul (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
50  case OPDIV:   return new exprDiv (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
51  case OPREM:   notimpl ("remainder");
52  case OPPOW:   return new exprPow (nl2e (e -> L.e, asl), nl2e (e -> R.e, asl));
53  case OPLESS:  notimpl ("less");
54  case MINLIST: notimpl ("min");
55  case MAXLIST: notimpl ("max");
56  case FLOOR:   notimpl ("floor");
57  case CEIL:    notimpl ("ceil");
58  case ABS:     return new exprAbs (nl2e (e -> L.e, asl));
59  case OPUMINUS:return new exprOpp (nl2e (e -> L.e, asl));
60    //          return new exprOpp (nl2e (e -> L.e -> L.e, asl));
61  case OPIFnl:  { notimpl ("ifnl");
62
63  // see ASL/solvers/rops.c, IfNL
64  }
65
66  case OP_tanh: return new exprDiv
67      (new exprSub (new exprExp (nl2e (e -> L.e, asl)),
68                    new exprExp (new exprOpp (nl2e (e->L.e, asl)))),
69       new exprSum (new exprExp (nl2e (e -> L.e, asl)),
70                    new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
71
72  case OP_tan: {
73    expression *arg;
74    arg = nl2e (e -> L.e, asl);
75    return new exprDiv (new exprSin (arg), new exprCos (new exprClone (arg)));
76  }
77  case OP_sqrt:    return new exprPow (nl2e (e -> L.e, asl), new exprConst (0.5));
78  case OP_sinh:    return new exprMul (new exprConst (0.5),
79                                       new exprSub (new exprExp (nl2e (e -> L.e, asl)),
80                                                    new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
81  case OP_sin:     return new exprSin (nl2e (e -> L.e, asl));
82  case OP_log10:   return new exprMul (new exprConst (1.0 / log (10.0)), 
83                                       new exprLog (nl2e (e -> L.e, asl)));
84  case OP_log:     return new exprLog (nl2e (e -> L.e, asl));
85  case OP_exp:     return new exprExp (nl2e (e -> L.e, asl));
86  case OP_cosh:    return new exprMul (new exprConst (0.5),
87                                       new exprSum (new exprExp (nl2e (e -> L.e, asl)),
88                                                    new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
89
90  case OP_cos:   return new exprCos (nl2e (e -> L.e, asl));
91  case OP_atanh: notimpl ("atanh");
92  case OP_atan2: notimpl ("atan2");
93  case OP_atan:  notimpl ("atan");
94  case OP_asinh: notimpl ("asinh");
95  case OP_asin:  notimpl ("asin");
96  case OP_acosh: notimpl ("acosh");
97  case OP_acos:  notimpl ("acos");
98
99  case OPSUMLIST: {
100    int i=0;
101    expression **al = new expression * [(e->R.ep - e->L.ep)];
102    for (expr **ep = e->L.ep; ep < e->R.ep; ep++)
103      al [i++] = nl2e (*ep, asl);
104    return new exprSum (al, i);
105  }
106  case OPintDIV: notimpl ("intdiv");
107  case OPprecision: notimpl ("precision");
108  case OPround:  notimpl ("round");
109  case OPtrunc:  notimpl ("trunc");
110
111  case OP1POW: return new exprPow (nl2e (e -> L.e, asl), 
112                                   new exprConst (((expr_n *)e->R.e)->v));
113  case OP2POW: return new exprPow (nl2e (e -> L.e, asl), 
114                                   new exprConst (2.));
115  case OPCPOW: return new exprPow (new exprConst (((expr_n *)e->L.e)->v),
116                                   nl2e (e -> R.e, asl));
117  case OPFUNCALL: notimpl ("function call");
118  case OPNUM:     return new exprConst (((expr_n *)e)->v);
119  case OPPLTERM:  notimpl ("plterm");
120  case OPIFSYM:   notimpl ("ifsym");
121  case OPHOL:     notimpl ("hol");
122  case OPVARVAL:  {
123
124    int j = ((expr_v *) e) -> a;
125
126    if (j >= nOrigVars_) // common expression
127      // use base pointer otherwise the .a field returns an awkward, out-of-bound index
128      j = ((expr_v *) e) - ((const ASL_fg *) asl) -> I.var_e_; 
129
130    if (j >= nOrigVars_ + ndefined_) {
131      printf ("error: unknown variable x_%d\n", j);
132      //return new exprClone (variables_ [0]);
133      exit (-1);
134    }
135
136    return new exprClone (variables_ [j]);
137  }
138
139  default: 
140    printf ("ERROR: unknown operator (address %p), aborting.\n", Intcast (e -> op)); 
141    exit (-1);
142    //return new exprConst (0);
143  }
144
145  return new exprConst (0.);
146}
Note: See TracBrowser for help on using the repository browser.