Back to index

salome-med  6.5.0
InterpKernelFunction.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D
00002 //
00003 // This library is free software; you can redistribute it and/or
00004 // modify it under the terms of the GNU Lesser General Public
00005 // License as published by the Free Software Foundation; either
00006 // version 2.1 of the License.
00007 //
00008 // This library is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011 // Lesser General Public License for more details.
00012 //
00013 // You should have received a copy of the GNU Lesser General Public
00014 // License along with this library; if not, write to the Free Software
00015 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00016 //
00017 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00018 //
00019 
00020 #include "InterpKernelFunction.hxx"
00021 #include "InterpKernelValue.hxx"
00022 
00023 #include <cmath>
00024 
00025 using namespace INTERP_KERNEL;
00026 
00027 const char IdentityFunction::REPR[]="Id";
00028 
00029 const char PositiveFunction::REPR[]="+";
00030 
00031 const char NegateFunction::REPR[]="-";
00032 
00033 const char CosFunction::REPR[]="cos";
00034 
00035 const char SinFunction::REPR[]="sin";
00036 
00037 const char TanFunction::REPR[]="tan";
00038 
00039 const char SqrtFunction::REPR[]="sqrt";
00040 
00041 const char AbsFunction::REPR[]="abs";
00042 
00043 const char PlusFunction::REPR[]="+";
00044 
00045 const char MinusFunction::REPR[]="-";
00046 
00047 const char MultFunction::REPR[]="*";
00048 
00049 const char DivFunction::REPR[]="/";
00050 
00051 const char PowFunction::REPR[]="^";
00052 
00053 const char ExpFunction::REPR[]="exp";
00054 
00055 const char LnFunction::REPR[]="ln";
00056 
00057 const char LogFunction::REPR[]="log";
00058 
00059 const char Log10Function::REPR[]="log10";
00060 
00061 const char MaxFunction::REPR[]="max";
00062 
00063 const char MinFunction::REPR[]="min";
00064 
00065 const char GreaterThanFunction::REPR[]=">";
00066 
00067 const char LowerThanFunction::REPR[]="<";
00068 
00069 const char IfFunction::REPR[]="if";
00070 
00071 Function *FunctionsFactory::buildFuncFromString(const char *type, int nbOfParams) throw(INTERP_KERNEL::Exception)
00072 {
00073   switch(nbOfParams)
00074     {
00075     case 1:
00076       return buildUnaryFuncFromString(type);
00077     case 2:
00078       return buildBinaryFuncFromString(type);
00079     case 3:
00080       return buildTernaryFuncFromString(type);
00081     default:
00082       throw INTERP_KERNEL::Exception("Invalid number of params detected : limited to 2 !");
00083     }
00084 }
00085 
00086 Function *FunctionsFactory::buildUnaryFuncFromString(const char *type) throw(INTERP_KERNEL::Exception)
00087 {
00088   std::string tmp(type);
00089   if(tmp.empty())
00090     return new IdentityFunction;
00091   if(tmp==CosFunction::REPR)
00092     return new CosFunction;
00093   if(tmp==SinFunction::REPR)
00094     return new SinFunction;
00095   if(tmp==TanFunction::REPR)
00096     return new TanFunction;
00097   if(tmp==SqrtFunction::REPR)
00098     return new SqrtFunction;
00099   if(tmp==AbsFunction::REPR)
00100     return new AbsFunction;
00101   if(tmp==PositiveFunction::REPR)
00102     return new PositiveFunction;
00103   if(tmp==NegateFunction::REPR)
00104     return new NegateFunction;
00105   if(tmp==ExpFunction::REPR)
00106     return new ExpFunction;
00107   if(tmp==LnFunction::REPR)
00108     return new LnFunction;
00109   if(tmp==LogFunction::REPR)
00110     return new LogFunction;
00111   if(tmp==Log10Function::REPR)
00112     return new Log10Function;
00113   //
00114   std::string msg("Invalid unary function detected : \"");
00115   msg+=type; msg+="\"";
00116   throw INTERP_KERNEL::Exception(msg.c_str());
00117 }
00118 
00119 Function *FunctionsFactory::buildBinaryFuncFromString(const char *type) throw(INTERP_KERNEL::Exception)
00120 {
00121   std::string tmp(type);
00122   if(tmp==PositiveFunction::REPR)
00123     return new PlusFunction;
00124   if(tmp==NegateFunction::REPR)
00125     return new MinusFunction;
00126   if(tmp==MultFunction::REPR)
00127     return new MultFunction;
00128   if(tmp==DivFunction::REPR)
00129     return new DivFunction;
00130   if(tmp==PowFunction::REPR)
00131     return new PowFunction;
00132   if(tmp==MaxFunction::REPR)
00133     return new MaxFunction;
00134   if(tmp==MinFunction::REPR)
00135     return new MinFunction;
00136   if(tmp==GreaterThanFunction::REPR)
00137     return new GreaterThanFunction;
00138   if(tmp==LowerThanFunction::REPR)
00139     return new LowerThanFunction;
00140   std::string msg("Invalid binary function detected : \"");
00141   msg+=type; msg+="\"";
00142   throw INTERP_KERNEL::Exception(msg.c_str());
00143 }
00144 
00145 Function *FunctionsFactory::buildTernaryFuncFromString(const char *type) throw(INTERP_KERNEL::Exception)
00146 {
00147   std::string tmp(type);
00148   if(tmp==IfFunction::REPR)
00149     return new IfFunction();
00150   std::string msg("Invalid ternary function detected : \"");
00151   msg+=type; msg+="\"";
00152   throw INTERP_KERNEL::Exception(msg.c_str());
00153 }
00154 
00155 Function *FunctionsFactory::buildBinaryFuncFromString(char type) throw(INTERP_KERNEL::Exception)
00156 {
00157   char tmp[2]; tmp[0]=type; tmp[1]='\0';
00158   return buildBinaryFuncFromString(tmp);
00159 }
00160 
00161 Function::~Function()
00162 {
00163 }
00164 
00165 IdentityFunction::~IdentityFunction()
00166 {
00167 }
00168 
00169 void IdentityFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00170 {
00171 }
00172 
00173 void IdentityFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00174 {
00175 }
00176 
00177 const char *IdentityFunction::getRepr() const
00178 {
00179   return REPR;
00180 }
00181 
00182 bool IdentityFunction::isACall() const
00183 {
00184   return false;
00185 }
00186 
00187 PositiveFunction::~PositiveFunction()
00188 {
00189 }
00190 
00191 int UnaryFunction::getNbInputParams() const
00192 {
00193   return 1;
00194 }
00195 
00196 void PositiveFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00197 {
00198 }
00199 
00200 void PositiveFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00201 {
00202 }
00203 
00204 const char *PositiveFunction::getRepr() const
00205 {
00206   return REPR;
00207 }
00208 
00209 bool PositiveFunction::isACall() const
00210 {
00211   return false;
00212 }
00213 
00214 NegateFunction::~NegateFunction()
00215 {
00216 }
00217 
00218 void NegateFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00219 {
00220   Value *val=stack.back();
00221   val->negate();
00222 }
00223 
00224 void NegateFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00225 {
00226   asmb.push_back("fchs");
00227 }
00228 
00229 const char *NegateFunction::getRepr() const
00230 {
00231   return REPR;
00232 }
00233 
00234 bool NegateFunction::isACall() const
00235 {
00236   return false;
00237 }
00238 
00239 CosFunction::~CosFunction()
00240 {
00241 }
00242 
00243 void CosFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00244 {
00245   Value *val=stack.back();
00246   val->cos();
00247 }
00248 
00249 void CosFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00250 {
00251   asmb.push_back("fcos");
00252 }
00253 
00254 const char *CosFunction::getRepr() const
00255 {
00256   return REPR;
00257 }
00258 
00259 bool CosFunction::isACall() const
00260 {
00261   return true;
00262 }
00263 
00264 SinFunction::~SinFunction()
00265 {
00266 }
00267 
00268 void SinFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00269 {
00270   Value *val=stack.back();
00271   val->sin();
00272 }
00273 
00274 void SinFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00275 {
00276   asmb.push_back("fsin");
00277 }
00278 
00279 const char *SinFunction::getRepr() const
00280 {
00281   return REPR;
00282 }
00283 
00284 bool SinFunction::isACall() const
00285 {
00286   return true;
00287 }
00288 
00289 TanFunction::~TanFunction()
00290 {
00291 }
00292 
00293 void TanFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00294 {
00295   Value *val=stack.back();
00296   val->tan();
00297 }
00298 
00299 void TanFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00300 {
00301   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00302 }
00303 
00304 const char *TanFunction::getRepr() const
00305 {
00306   return REPR;
00307 }
00308 
00309 bool TanFunction::isACall() const
00310 {
00311   return true;
00312 }
00313 
00314 SqrtFunction::~SqrtFunction()
00315 {
00316 }
00317 
00318 void SqrtFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00319 {
00320   Value *val=stack.back();
00321   val->sqrt();
00322 }
00323 
00324 void SqrtFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00325 {
00326   asmb.push_back("fsqrt");
00327 }
00328 
00329 const char *SqrtFunction::getRepr() const
00330 {
00331   return REPR;
00332 }
00333 
00334 bool SqrtFunction::isACall() const
00335 {
00336   return true;
00337 }
00338 
00339 AbsFunction::~AbsFunction()
00340 {
00341 }
00342 
00343 void AbsFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00344 {
00345   Value *val=stack.back();
00346   val->abs();
00347 }
00348 
00349 void AbsFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00350 {
00351   asmb.push_back("fabs");
00352 }
00353 
00354 const char *AbsFunction::getRepr() const
00355 {
00356   return REPR;
00357 }
00358 
00359 bool AbsFunction::isACall() const
00360 {
00361   return false;
00362 }
00363 
00364 void ExpFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00365 {
00366   Value *val=stack.back();
00367   val->exp();
00368 }
00369 
00370 void ExpFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00371 {
00372   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00373 }
00374 
00375 const char *ExpFunction::getRepr() const
00376 {
00377   return REPR;
00378 }
00379 
00380 bool ExpFunction::isACall() const
00381 {
00382   return true;
00383 }
00384 
00385 LnFunction::~LnFunction()
00386 {
00387 }
00388 
00389 void LnFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00390 {
00391   Value *val=stack.back();
00392   val->ln();
00393 }
00394 
00395 void LnFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00396 {
00397   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00398 }
00399 
00400 const char *LnFunction::getRepr() const
00401 {
00402   return REPR;
00403 }
00404 
00405 bool LnFunction::isACall() const
00406 {
00407   return true;
00408 }
00409 
00410 LogFunction::~LogFunction()
00411 {
00412 }
00413 
00414 void LogFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00415 {
00416   Value *val=stack.back();
00417   val->ln();
00418 }
00419 
00420 void LogFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00421 {
00422   throw INTERP_KERNEL::Exception("Assembly for log Not implemented yet !");
00423 }
00424 
00425 const char *LogFunction::getRepr() const
00426 {
00427   return REPR;
00428 }
00429 
00430 bool LogFunction::isACall() const
00431 {
00432   return true;
00433 }
00434 
00435 Log10Function::~Log10Function()
00436 {
00437 }
00438 
00439 void Log10Function::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00440 {
00441   Value *val=stack.back();
00442   val->log10();
00443 }
00444 
00445 void Log10Function::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00446 {
00447   throw INTERP_KERNEL::Exception("Assembly for log Not implemented yet !");
00448 }
00449 
00450 const char *Log10Function::getRepr() const
00451 {
00452   return REPR;
00453 }
00454 
00455 bool Log10Function::isACall() const
00456 {
00457   return true;
00458 }
00459 
00460 int BinaryFunction::getNbInputParams() const
00461 {
00462   return 2;
00463 }
00464 
00465 PlusFunction::~PlusFunction()
00466 {
00467 }
00468 
00469 void PlusFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00470 {
00471   Value *val1=stack.back();
00472   stack.pop_back();
00473   Value *& val2=stack.back();
00474   Value *val3;
00475   try
00476     {
00477       val3=val1->plus(val2);
00478     }
00479   catch(INTERP_KERNEL::Exception& e)
00480     {
00481       delete val1;
00482       throw e;
00483     }
00484   delete val1;
00485   delete val2;
00486   val2=val3;
00487 }
00488 
00489 void PlusFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00490 {
00491   asmb.push_back("faddp st1");
00492 }
00493 
00494 const char *PlusFunction::getRepr() const
00495 {
00496   return REPR;
00497 }
00498 
00499 bool PlusFunction::isACall() const
00500 {
00501   return false;
00502 }
00503 
00504 MinusFunction::~MinusFunction()
00505 {
00506 }
00507 
00508 void MinusFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00509 {
00510   Value *val1=stack.back();
00511   stack.pop_back();
00512   Value *& val2=stack.back();
00513   Value *val3;
00514   try
00515     {
00516       val3=val1->minus(val2);
00517     }
00518   catch(INTERP_KERNEL::Exception& e)
00519     {
00520       delete val1;
00521       throw e;
00522     }
00523   delete val1;
00524   delete val2;
00525   val2=val3;
00526 }
00527 
00528 void MinusFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00529 {
00530   asmb.push_back("fsubp st1");
00531 }
00532 
00533 const char *MinusFunction::getRepr() const
00534 {
00535   return REPR;
00536 }
00537 
00538 bool MinusFunction::isACall() const
00539 {
00540   return false;
00541 }
00542 
00543 MultFunction::~MultFunction()
00544 {
00545 }
00546 
00547 void MultFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00548 {
00549   Value *val1=stack.back();
00550   stack.pop_back();
00551   Value *& val2=stack.back();
00552   Value *val3=val1->mult(val2);
00553   delete val1;
00554   delete val2;
00555   val2=val3;
00556 }
00557 
00558 void MultFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00559 {
00560   asmb.push_back("fmulp st1");
00561 }
00562 
00563 const char *MultFunction::getRepr() const
00564 {
00565   return REPR;
00566 }
00567 
00568 bool MultFunction::isACall() const
00569 {
00570   return false;
00571 }
00572 
00573 DivFunction::~DivFunction()
00574 {
00575 }
00576 
00577 void DivFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00578 {
00579   Value *val1=stack.back();
00580   stack.pop_back();
00581   Value *& val2=stack.back();
00582   Value *val3;
00583   try
00584     {
00585       val3=val1->div(val2);
00586     }
00587   catch(INTERP_KERNEL::Exception& e)
00588     {
00589       delete val1;
00590       throw e;
00591     }
00592   delete val1;
00593   delete val2;
00594   val2=val3;
00595 }
00596 
00597 void DivFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00598 {
00599   asmb.push_back("fdivp st1");
00600 }
00601 
00602 const char *DivFunction::getRepr() const
00603 {
00604   return REPR;
00605 }
00606 
00607 bool DivFunction::isACall() const
00608 {
00609   return false;
00610 }
00611 
00612 PowFunction::~PowFunction()
00613 {
00614 }
00615 
00616 void PowFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00617 {
00618   Value *val1=stack.back();
00619   stack.pop_back();
00620   Value *& val2=stack.back();
00621   Value *val3;
00622   try
00623     {
00624       val3=val1->pow(val2);
00625     }
00626   catch(INTERP_KERNEL::Exception& e)
00627     {
00628       delete val1;
00629       throw e;
00630     }
00631   delete val1;
00632   delete val2;
00633   val2=val3;
00634 }
00635 
00636 void PowFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00637 {
00638   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00639 }
00640 
00641 const char *PowFunction::getRepr() const
00642 {
00643   return REPR;
00644 }
00645 
00646 bool PowFunction::isACall() const
00647 {
00648   return true;
00649 }
00650 
00651 ExpFunction::~ExpFunction()
00652 {
00653 }
00654 
00655 MaxFunction::~MaxFunction()
00656 {
00657 }
00658 
00659 void MaxFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00660 {
00661   Value *val1=stack.back();
00662   stack.pop_back();
00663   Value *& val2=stack.back();
00664   Value *val3;
00665   try
00666     {
00667       val3=val1->max(val2);
00668     }
00669   catch(INTERP_KERNEL::Exception& e)
00670     {
00671       delete val1;
00672       throw e;
00673     }
00674   delete val1;
00675   delete val2;
00676   val2=val3;
00677 }
00678 
00679 void MaxFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00680 {
00681   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00682 }
00683 
00684 const char *MaxFunction::getRepr() const
00685 {
00686   return REPR;
00687 }
00688 
00689 bool MaxFunction::isACall() const
00690 {
00691   return false;
00692 }
00693 
00694 MinFunction::~MinFunction()
00695 {
00696 }
00697 
00698 void MinFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00699 {
00700   Value *val1=stack.back();
00701   stack.pop_back();
00702   Value *& val2=stack.back();
00703   Value *val3;
00704   try
00705     {
00706       val3=val1->min(val2);
00707     }
00708   catch(INTERP_KERNEL::Exception& e)
00709     {
00710       delete val1;
00711       throw e;
00712     }
00713   delete val1;
00714   delete val2;
00715   val2=val3;
00716 }
00717 
00718 void MinFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00719 {
00720   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00721 }
00722 
00723 const char *MinFunction::getRepr() const
00724 {
00725   return REPR;
00726 }
00727 
00728 bool MinFunction::isACall() const
00729 {
00730   return false;
00731 }
00732 
00733 GreaterThanFunction::~GreaterThanFunction()
00734 {
00735 }
00736 
00737 void GreaterThanFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00738 {
00739   Value *val1=stack.back();
00740   stack.pop_back();
00741   Value *& val2=stack.back();
00742   Value *val3;
00743   try
00744     {
00745       val3=val1->greaterThan(val2);
00746     }
00747   catch(INTERP_KERNEL::Exception& e)
00748     {
00749       delete val1;
00750       throw e;
00751     }
00752   delete val1;
00753   delete val2;
00754   val2=val3;
00755 }
00756 
00757 void GreaterThanFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00758 {
00759   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00760 }
00761 
00762 const char *GreaterThanFunction::getRepr() const
00763 {
00764   return REPR;
00765 }
00766 
00767 bool GreaterThanFunction::isACall() const
00768 {
00769   return false;
00770 }
00771 
00772 LowerThanFunction::~LowerThanFunction()
00773 {
00774 }
00775 
00776 void LowerThanFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00777 {
00778   Value *val1=stack.back();
00779   stack.pop_back();
00780   Value *& val2=stack.back();
00781   Value *val3;
00782   try
00783     {
00784       val3=val1->lowerThan(val2);
00785     }
00786   catch(INTERP_KERNEL::Exception& e)
00787     {
00788       delete val1;
00789       throw e;
00790     }
00791   delete val1;
00792   delete val2;
00793   val2=val3;
00794 }
00795 
00796 void LowerThanFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00797 {
00798   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00799 }
00800 
00801 const char *LowerThanFunction::getRepr() const
00802 {
00803   return REPR;
00804 }
00805 
00806 bool LowerThanFunction::isACall() const
00807 {
00808   return false;
00809 }
00810 
00811 int TernaryFunction::getNbInputParams() const
00812 {
00813   return 3;
00814 }
00815 
00816 IfFunction::~IfFunction()
00817 {
00818 }
00819 
00820 void IfFunction::operate(std::vector<Value *>& stack) const throw(INTERP_KERNEL::Exception)
00821 {
00822   Value *val1=stack.back();
00823   stack.pop_back();
00824   Value *val2=stack.back();
00825   stack.pop_back();
00826   Value *&val3=stack.back();
00827   Value *val4;
00828   try
00829     {
00830       val4=val1->ifFunc(val2,val3);
00831     }
00832   catch(INTERP_KERNEL::Exception& e)
00833     {
00834       delete val1;
00835       delete val2;
00836       throw e;
00837     }
00838   delete val1;
00839   delete val2;
00840   delete val3;
00841   val3=val4;
00842 }
00843 
00844 void IfFunction::operateX86(std::vector<std::string>& asmb) const throw(INTERP_KERNEL::Exception)
00845 {
00846   throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
00847 }
00848 
00849 const char *IfFunction::getRepr() const
00850 {
00851   return REPR;
00852 }
00853 
00854 bool IfFunction::isACall() const
00855 {
00856   return false;
00857 }
00858