-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#include "InterpKernelValue.hxx"
#include <cmath>
+#include <limits>
using namespace INTERP_KERNEL;
{
}
-void IdentityFunction::operate(std::vector<Value *>& stack) const
+void IdentityFunction::operate(std::vector<Value *>& stck) const
{
}
{
}
+void IdentityFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+}
+
const char *IdentityFunction::getRepr() const
{
return REPR;
return 1;
}
-void PositiveFunction::operate(std::vector<Value *>& stack) const
+void PositiveFunction::operate(std::vector<Value *>& stck) const
{
}
{
}
+void PositiveFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+}
+
const char *PositiveFunction::getRepr() const
{
return REPR;
{
}
-void NegateFunction::operate(std::vector<Value *>& stack) const
+void NegateFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->negate();
}
asmb.push_back("fchs");
}
+void NegateFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=-v;
+}
+
const char *NegateFunction::getRepr() const
{
return REPR;
{
}
-void CosFunction::operate(std::vector<Value *>& stack) const
+void CosFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->cos();
}
asmb.push_back("fcos");
}
+void CosFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=cos(v);
+}
+
const char *CosFunction::getRepr() const
{
return REPR;
{
}
-void SinFunction::operate(std::vector<Value *>& stack) const
+void SinFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->sin();
}
asmb.push_back("fsin");
}
+void SinFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=sin(v);
+}
+
const char *SinFunction::getRepr() const
{
return REPR;
{
}
-void TanFunction::operate(std::vector<Value *>& stack) const
+void TanFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->tan();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void TanFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=tan(v);
+}
+
const char *TanFunction::getRepr() const
{
return REPR;
{
}
-void ACosFunction::operate(std::vector<Value *>& stack) const
+void ACosFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->acos();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void ACosFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=acos(v);
+}
+
+void ACosFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ if(fabs(v)>1.)
+ throw INTERP_KERNEL::Exception("acos on a value which absolute is > 1 !");
+ stck.back()=acos(v);
+}
+
const char *ACosFunction::getRepr() const
{
return REPR;
{
}
-void ASinFunction::operate(std::vector<Value *>& stack) const
+void ASinFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->asin();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void ASinFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=asin(v);
+}
+
+void ASinFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ if(fabs(v)>1.)
+ throw INTERP_KERNEL::Exception("asin on a value which absolute is > 1 !");
+ stck.back()=asin(v);
+}
+
const char *ASinFunction::getRepr() const
{
return REPR;
{
}
-void ATanFunction::operate(std::vector<Value *>& stack) const
+void ATanFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->atan();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void ATanFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=atan(v);
+}
+
const char *ATanFunction::getRepr() const
{
return REPR;
{
}
-void CoshFunction::operate(std::vector<Value *>& stack) const
+void CoshFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->cosh();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void CoshFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=cosh(v);
+}
+
const char *CoshFunction::getRepr() const
{
return REPR;
{
}
-void SinhFunction::operate(std::vector<Value *>& stack) const
+void SinhFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->sinh();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void SinhFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=sinh(v);
+}
+
const char *SinhFunction::getRepr() const
{
return REPR;
{
}
-void TanhFunction::operate(std::vector<Value *>& stack) const
+void TanhFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->tanh();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void TanhFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=tanh(v);
+}
+
const char *TanhFunction::getRepr() const
{
return REPR;
{
}
-void SqrtFunction::operate(std::vector<Value *>& stack) const
+void SqrtFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->sqrt();
}
asmb.push_back("fsqrt");
}
+void SqrtFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=sqrt(v);
+}
+
+void SqrtFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ if(v<0.)
+ throw INTERP_KERNEL::Exception("sqrt on a value < 0. !");
+ stck.back()=sqrt(v);
+}
+
const char *SqrtFunction::getRepr() const
{
return REPR;
{
}
-void AbsFunction::operate(std::vector<Value *>& stack) const
+void AbsFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->abs();
}
asmb.push_back("fabs");
}
+void AbsFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=fabs(v);
+}
+
const char *AbsFunction::getRepr() const
{
return REPR;
return false;
}
-void ExpFunction::operate(std::vector<Value *>& stack) const
+void ExpFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->exp();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void ExpFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=std::exp(v);
+}
+
const char *ExpFunction::getRepr() const
{
return REPR;
{
}
-void LnFunction::operate(std::vector<Value *>& stack) const
+void LnFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->ln();
}
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void LnFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=std::log(v);
+}
+
+void LnFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ if(v<0.)
+ throw INTERP_KERNEL::Exception("ln on a value < 0. !");
+ stck.back()=std::log(v);
+}
+
const char *LnFunction::getRepr() const
{
return REPR;
{
}
-void LogFunction::operate(std::vector<Value *>& stack) const
+void LogFunction::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->ln();
}
throw INTERP_KERNEL::Exception("Assembly for log Not implemented yet !");
}
+void LogFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=std::log(v);
+}
+
+void LogFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ if(v<0.)
+ throw INTERP_KERNEL::Exception("log on a value < 0. !");
+ stck.back()=std::log(v);
+}
+
const char *LogFunction::getRepr() const
{
return REPR;
{
}
-void Log10Function::operate(std::vector<Value *>& stack) const
+void Log10Function::operate(std::vector<Value *>& stck) const
{
- Value *val=stack.back();
+ Value *val=stck.back();
val->log10();
}
throw INTERP_KERNEL::Exception("Assembly for log Not implemented yet !");
}
+void Log10Function::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ stck.back()=std::log10(v);
+}
+
+void Log10Function::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double v(stck.back());
+ if(v<0.)
+ throw INTERP_KERNEL::Exception("log10 on a value < 0. !");
+ stck.back()=std::log10(v);
+}
+
const char *Log10Function::getRepr() const
{
return REPR;
{
}
-void PlusFunction::operate(std::vector<Value *>& stack) const
+void PlusFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
asmb.push_back("faddp st1");
}
+void PlusFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=a+stck.back();
+}
+
const char *PlusFunction::getRepr() const
{
return REPR;
{
}
-void MinusFunction::operate(std::vector<Value *>& stack) const
+void MinusFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
asmb.push_back("fsubp st1");
}
+void MinusFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=a-stck.back();
+}
+
const char *MinusFunction::getRepr() const
{
return REPR;
{
}
-void MultFunction::operate(std::vector<Value *>& stack) const
+void MultFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3=val1->mult(val2);
delete val1;
delete val2;
asmb.push_back("fmulp st1");
}
+void MultFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=a*stck.back();
+}
+
const char *MultFunction::getRepr() const
{
return REPR;
{
}
-void DivFunction::operate(std::vector<Value *>& stack) const
+void DivFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
asmb.push_back("fdivp st1");
}
+void DivFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=a/stck.back();
+}
+
+void DivFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ if(stck.back()==0.)
+ throw INTERP_KERNEL::Exception("division by 0. !");
+ stck.back()=a/stck.back();
+}
+
const char *DivFunction::getRepr() const
{
return REPR;
{
}
-void PowFunction::operate(std::vector<Value *>& stack) const
+void PowFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void PowFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=std::pow(a,stck.back());
+}
+
+void PowFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ double b(stck.back());
+ if(a<0.)
+ throw INTERP_KERNEL::Exception("pow with val < 0. !");
+ stck.back()=std::pow(a,b);
+}
+
const char *PowFunction::getRepr() const
{
return REPR;
{
}
-void MaxFunction::operate(std::vector<Value *>& stack) const
+void MaxFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void MaxFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=std::max(stck.back(),a);
+}
+
const char *MaxFunction::getRepr() const
{
return REPR;
{
}
-void MinFunction::operate(std::vector<Value *>& stack) const
+void MinFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void MinFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ stck.back()=std::min(stck.back(),a);
+}
+
const char *MinFunction::getRepr() const
{
return REPR;
{
}
-void GreaterThanFunction::operate(std::vector<Value *>& stack) const
+void GreaterThanFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void GreaterThanFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ double b(stck.back());
+ stck.back()=a>b?std::numeric_limits<double>::max():-std::numeric_limits<double>::max();
+}
+
const char *GreaterThanFunction::getRepr() const
{
return REPR;
{
}
-void LowerThanFunction::operate(std::vector<Value *>& stack) const
+void LowerThanFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *& val2=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *& val2=stck.back();
Value *val3;
try
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void LowerThanFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double a(stck.back());
+ stck.pop_back();
+ double b(stck.back());
+ stck.back()=a<b?std::numeric_limits<double>::max():-std::numeric_limits<double>::max();
+}
+
const char *LowerThanFunction::getRepr() const
{
return REPR;
{
}
-void IfFunction::operate(std::vector<Value *>& stack) const
+void IfFunction::operate(std::vector<Value *>& stck) const
{
- Value *val1=stack.back();
- stack.pop_back();
- Value *val2=stack.back();
- stack.pop_back();
- Value *&val3=stack.back();
+ Value *val1=stck.back();
+ stck.pop_back();
+ Value *val2=stck.back();
+ stck.pop_back();
+ Value *&val3=stck.back();
Value *val4;
try
{
throw INTERP_KERNEL::Exception("Assembly Not implemented yet !");
}
+void IfFunction::operateStackOfDouble(std::vector<double>& stck) const
+{
+ double cond(stck.back());
+ stck.pop_back();
+ double the(stck.back());
+ stck.pop_back();
+ if(cond==std::numeric_limits<double>::max())
+ stck.back()=the;
+}
+
+void IfFunction::operateStackOfDoubleSafe(std::vector<double>& stck) const
+{
+ double cond(stck.back());
+ stck.pop_back();
+ double the(stck.back());
+ stck.pop_back();
+ if(cond!=std::numeric_limits<double>::max() && cond!=-std::numeric_limits<double>::max())
+ throw INTERP_KERNEL::Exception("ifFunc : first parameter of ternary func is NOT a consequence of a boolean op !");
+ if(cond==std::numeric_limits<double>::max())
+ stck.back()=the;
+}
+
const char *IfFunction::getRepr() const
{
return REPR;