source: stable/0.1/Couenne/src/readnl/nl2e.cpp @ 81

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

merged changes from Couenne-trunk:80 (fix casts for AMPL function pointers)

File size: 4.7 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.
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: notimpl ("tanh");
67  case OP_tan: {
68    expression *arg;
69    arg = nl2e (e -> L.e, asl);
70    return new exprDiv (new exprSin (arg), new exprCos (new exprClone (arg)));
71  }
72  case OP_sqrt:    return new exprPow (nl2e (e -> L.e, asl), new exprConst (0.5));
73  case OP_sinh:    return new exprMul (new exprConst (0.5),
74                                       new exprSub (new exprExp (nl2e (e -> L.e, asl)),
75                                                    new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
76  case OP_sin:     return new exprSin (nl2e (e -> L.e, asl));
77  case OP_log10:   return new exprMul (new exprConst (1.0 / log (10.0)), 
78                                       new exprLog (nl2e (e -> L.e, asl)));
79  case OP_log:     return new exprLog (nl2e (e -> L.e, asl));
80  case OP_exp:     return new exprExp (nl2e (e -> L.e, asl));
81  case OP_cosh:    return new exprMul (new exprConst (0.5),
82                                       new exprSum (new exprExp (nl2e (e -> L.e, asl)),
83                                                    new exprExp (new exprOpp (nl2e (e->L.e, asl)))));
84
85  case OP_cos:   return new exprCos (nl2e (e -> L.e, asl));
86  case OP_atanh: notimpl ("atanh");
87  case OP_atan2: notimpl ("atan2");
88  case OP_atan:  notimpl ("atan");
89  case OP_asinh: notimpl ("asinh");
90  case OP_asin:  notimpl ("asin");
91  case OP_acosh: notimpl ("acosh");
92  case OP_acos:  notimpl ("acos");
93
94  case OPSUMLIST: {
95    int i=0;
96    expression **al = new expression * [(e->R.ep - e->L.ep)];
97    for (expr **ep = e->L.ep; ep < e->R.ep; ep++)
98      al [i++] = nl2e (*ep, asl);
99    return new exprSum (al, i);
100  }
101  case OPintDIV: notimpl ("intdiv");
102  case OPprecision: notimpl ("precision");
103  case OPround:  notimpl ("round");
104  case OPtrunc:  notimpl ("trunc");
105
106  case OP1POW: return new exprPow (nl2e (e -> L.e, asl), 
107                                   new exprConst (((expr_n *)e->R.e)->v));
108  case OP2POW: return new exprPow (nl2e (e -> L.e, asl), 
109                                   new exprConst (2.));
110  case OPCPOW: return new exprPow (new exprConst (((expr_n *)e->L.e)->v),
111                                   nl2e (e -> R.e, asl));
112  case OPFUNCALL: notimpl ("function call");
113  case OPNUM:     return new exprConst (((expr_n *)e)->v);
114  case OPPLTERM:  notimpl ("plterm");
115  case OPIFSYM:   notimpl ("ifsym");
116  case OPHOL:     notimpl ("hol");
117  case OPVARVAL:  {
118
119    int j = ((expr_v *) e) -> a;
120
121    if (j >= nOrigVars_) // common expression
122      // use base pointer otherwise the .a field returns an awkward, out-of-bound index
123      j = ((expr_v *) e) - ((const ASL_fg *) asl) -> I.var_e_; 
124
125    if (j >= nOrigVars_ + ndefined_) {
126      printf ("error: unknown variable x_%d\n", j);
127      //return new exprClone (variables_ [0]);
128      exit (-1);
129    }
130
131    return new exprClone (variables_ [j]);
132  }
133
134  default: 
135    printf ("ERROR: unknown operator (address %p), aborting.\n", Intcast (e -> op)); 
136    exit (-1);
137    //return new exprConst (0);
138  }
139
140  return new exprConst (0.);
141}
Note: See TracBrowser for help on using the repository browser.