public override void Eval(ref IValue ret, IValue[] a_pArg)
{
ParserXBase parser = GetParent();
Console.WriteLine("\nParser functions:");
Console.WriteLine("-----------------\n");
var funcs = parser.GetFunDef();
if (funcs.Count == 0)
{
Console.WriteLine("No functions defined\n");
}
else
{
foreach (var item in funcs)
{
var v = (ICallback)item.Value;
if (v.GetDesc() == "")
{
continue;
}
Console.WriteLine($" {v.GetDesc()}");
}
}
ret = funcs.Count;
}
public void AddToParser(ParserXBase pParser)
{
pParser.DefineConst("i", new Complex(0.0, 1.0));
pParser.AddValueReader(new CmplxValReader());
// Complex valued functions
pParser.DefineFun(new FunCmplxReal());
pParser.DefineFun(new FunCmplxImag());
pParser.DefineFun(new FunCmplxConj());
pParser.DefineFun(new FunCmplxArg());
pParser.DefineFun(new FunCmplxNorm());
pParser.DefineFun(new FunCmplxSin());
pParser.DefineFun(new FunCmplxCos());
pParser.DefineFun(new FunCmplxTan());
pParser.DefineFun(new FunCmplxSinH());
pParser.DefineFun(new FunCmplxCosH());
pParser.DefineFun(new FunCmplxTanH());
pParser.DefineFun(new FunCmplxSqrt());
pParser.DefineFun(new FunCmplxExp());
pParser.DefineFun(new FunCmplxLn());
pParser.DefineFun(new FunCmplxLog());
pParser.DefineFun(new FunCmplxLog2());
pParser.DefineFun(new FunCmplxLog10());
pParser.DefineFun(new FunCmplxAbs());
pParser.DefineFun(new FunCmplxPow());
// Complex valued operators
pParser.DefineOprt(new OprtAddCmplx());
pParser.DefineOprt(new OprtSubCmplx());
pParser.DefineOprt(new OprtMulCmplx());
pParser.DefineOprt(new OprtDivCmplx());
pParser.DefineOprt(new OprtPowCmplx());
pParser.DefineInfixOprt(new OprtSignCmplx());
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
ParserXBase parser = GetParent();
parser.EnableOptimizer(a_pArg[0].GetBool());
ret = a_pArg[0].GetBool();
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
ParserXBase parser = GetParent();
Console.WriteLine("\nParser variables:");
Console.WriteLine("-----------------\n");
var vars = parser.GetVar();
if (vars.Count == 0)
{
Console.WriteLine("Expression does not contain variables\n");
}
else
{
foreach (var item in vars)
{
var v = (Variable)item.Value;
Console.Write($" {item.Key} = {item.Value}");
Console.WriteLine($" (type=\"{v.GetValueType()}\"; ptr=0x{v.MemoryAddress()})");
}
}
ret = vars.Count;
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
ParserXBase.EnableDebugDump(false, false);
var pt = new ParserTester();
pt.Run();
ret = 0;
}
public void AddToParser(ParserXBase pParser)
{
pParser.DefinePostfixOprt(new OprtNano());
pParser.DefinePostfixOprt(new OprtMicro());
pParser.DefinePostfixOprt(new OprtMilli());
pParser.DefinePostfixOprt(new OprtKilo());
pParser.DefinePostfixOprt(new OprtMega());
pParser.DefinePostfixOprt(new OprtGiga());
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
bool bo = a_pArg[0].GetBool();
bool so = a_pArg[1].GetBool();
Console.WriteLine($"Bytecode output {(bo ? "de" : "")}activated.");
Console.WriteLine($"Stack output {(so ? "de" : "")}activated.");
ParserXBase.EnableDebugDump(so, bo);
ret = 0;
}
public void AddToParser(ParserXBase pParser)
{
// Matrix functions
pParser.DefineFun(new FunMatrixOnes());
pParser.DefineFun(new FunMatrixZeros());
pParser.DefineFun(new FunMatrixEye());
pParser.DefineFun(new FunMatrixSize());
// Matrix Operators
pParser.DefinePostfixOprt(new OprtTranspose());
// Colon operator
pParser.DefineOprt(new OprtColon());
//pParser->DefineAggregator(new AggColon());
}
public void AddToParser(ParserXBase parser)
{
parser.AddValueReader(new StrValReader());
parser.AddValueReader(new CharacterReader());
// Functions
parser.DefineFun(new FunStrLen());
parser.DefineFun(new FunStrToDbl());
parser.DefineFun(new FunStrToUpper());
parser.DefineFun(new FunStrToLower());
parser.DefineFun(new FunStrSplit());
parser.DefineFun(new FunStrJoin());
// Operators
parser.DefineOprt(new OprtStrAdd());
}
public void AddToParser(ParserXBase pParser)
{
pParser.AddValueReader(new NumericReader());
pParser.DefineFun(new FunSin());
pParser.DefineFun(new FunCos());
pParser.DefineFun(new FunTan());
pParser.DefineFun(new FunSinH());
pParser.DefineFun(new FunCosH());
pParser.DefineFun(new FunTanH());
pParser.DefineFun(new FunASin());
pParser.DefineFun(new FunACos());
pParser.DefineFun(new FunATan());
pParser.DefineFun(new FunASinH());
pParser.DefineFun(new FunACosH());
pParser.DefineFun(new FunATanH());
pParser.DefineFun(new FunLog());
pParser.DefineFun(new FunLog10());
pParser.DefineFun(new FunLog2());
pParser.DefineFun(new FunLn());
pParser.DefineFun(new FunExp());
pParser.DefineFun(new FunSqrt());
pParser.DefineFun(new FunCbrt());
pParser.DefineFun(new FunAbs());
// binary functions
pParser.DefineFun(new FunPow());
pParser.DefineFun(new FunHypot());
pParser.DefineFun(new FunAtan2());
pParser.DefineFun(new FunFmod());
pParser.DefineFun(new FunRemainder());
// Operator callbacks
pParser.DefineInfixOprt(new OprtSign());
pParser.DefineInfixOprt(new OprtSignPos());
pParser.DefineOprt(new OprtAdd());
pParser.DefineOprt(new OprtSub());
pParser.DefineOprt(new OprtMul());
pParser.DefineOprt(new OprtDiv());
pParser.DefineOprt(new OprtPow());
}
static void DrawSplash()
{
Console.WriteLine(@"
##################################################################
# ____ _ _ #
# | __ \ _| || |_ #
# _ _| |__) |_ _ _ _ ________ _ _|_ __ _| #
# | | | | ___/ _` | '__|_ / _ \ '__|| || |_ #
# | |_| | | | (_| | | / / __/ | |_ __ _| #
# | ._,_|_| \__,_|_| /___\___|_| |_||_| #
# | | #
# |_| #
# #
##################################################################
");
Console.Write($"Welcome to μParzer#.\n\t(c) John Cleary, {ParserXBase.GetVersion()}\n");
#if DEBUG
Console.WriteLine("\tDEBUG Build");
#else
Console.WriteLine();
#endif
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
ParserXBase parser = GetParent();
Console.WriteLine("\nParser constants:");
Console.WriteLine("-----------------\n");
var consts = parser.GetConst();
if (consts.Count == 0)
{
Console.WriteLine("No constants defined\n");
}
else
{
foreach (var item in consts)
{
var v = (Value)item.Value;
Console.WriteLine($" {item.Key} = {item.Value}");
}
}
ret = consts.Count;
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
string sVer = "muParser# V" + ParserXBase.GetVersion();
ret = sVer;
}
public void AddToParser(ParserXBase pParser)
{
// Readers that need fancy decorations on their values must
// be added first (i.e. hex . "0x...") Otherwise the
// zero in 0x will be read as a value of zero!
pParser.AddValueReader(new HexValReader());
pParser.AddValueReader(new BinValReader());
pParser.AddValueReader(new BoolValReader());
// Constants
pParser.DefineConst("pi", Math.PI);
pParser.DefineConst("e", Math.E);
// Vector
pParser.DefineFun(new FunSizeOf());
// Generic functions
pParser.DefineFun(new FunMax());
pParser.DefineFun(new FunMin());
pParser.DefineFun(new FunSum());
// misc
pParser.DefineFun(new FunParserID());
// integer package
pParser.DefineOprt(new OprtLAnd());
pParser.DefineOprt(new OprtLOr());
pParser.DefineOprt(new OprtAnd());
pParser.DefineOprt(new OprtOr());
pParser.DefineOprt(new OprtShr());
pParser.DefineOprt(new OprtShl());
// booloean package
pParser.DefineOprt(new OprtLE());
pParser.DefineOprt(new OprtGE());
pParser.DefineOprt(new OprtLT());
pParser.DefineOprt(new OprtGT());
pParser.DefineOprt(new OprtEQ());
pParser.DefineOprt(new OprtNEQ());
pParser.DefineOprt(new OprtLAnd("and")); // add logic and with a different identifier
pParser.DefineOprt(new OprtLOr("or")); // add logic and with a different identifier
// pParser.DefineOprt(new OprtBXor());
// assignement operators
pParser.DefineOprt(new OprtAssign());
pParser.DefineOprt(new OprtAssignAdd());
pParser.DefineOprt(new OprtAssignSub());
pParser.DefineOprt(new OprtAssignMul());
pParser.DefineOprt(new OprtAssignDiv());
// infix operators
pParser.DefineInfixOprt(new OprtCastToFloat());
pParser.DefineInfixOprt(new OprtCastToInt());
pParser.DefineInfixOprt(new OprtCastToChar());
// postfix operators
pParser.DefinePostfixOprt(new OprtFact());
// <ibg 20130708> commented: "%" is a reserved sign for either the
// modulo operator or comment lines.
pParser.DefinePostfixOprt(new OprtPercentage());
// </ibg>
}
public override void Eval(ref IValue ret, IValue[] a_pArg)
{
// Debug.Assert(a_pArg.Length <= 1);
StreamWriter pFile = null;
bool logToFile = false;
int iCount = 400000;
if (a_pArg.Length > 0)
{
if (a_pArg[0].IsInteger())
{
iCount = (int)a_pArg[0].GetInteger();
}
else
{
logToFile = a_pArg[0].GetBool();
}
}
string[] sExpr =
{
"sin(a)", "cos(a)", "tan(a)", "sqrt(a)", "(a+b)*3", "a^2+b^2", "a^3+b^3", "a^4+b^4",
"a^5+b^5", "a*2.43854357347+b*2.43854357347", "-(b^1.1)", "a + b * c", "a * b + c", "a+b*(a+b)", "(1+b)*(-3.43854357347)",
"e^log(7.43854357347*a)", "10^log(3+b)", "a+b-e*pi/5^6", "a^b/e*pi-5+6", "sin(a)+sin(b)",
"(cos(2.41)/b)", "-(sin(pi+a)+1.43854357347)", "a-(e^(log(7+b)))", "sin(((a-a)+b)+a)",
"((0.09/a)+2.58)-1.67", "abs(sin(sqrt(a^2+b^2))*255)", "abs(sin(sqrt(a*a+b*b))*255)",
"cos(0.90-((cos(b)/2.89)/e)/a)", "(1*(2*(3*(4*(5*(6*(a+b)))))))",
"abs(sin(sqrt(a^2.1+b^2.1))*255)", "(1.43854357347*(2.43854357347*(3.43854357347*(4.43854357347*(5.43854357347*(6.43854357347*(7.43854357347*(a+b))))))))",
"1.43854357347/(a*sqrt(2.43854357347*pi))*e^(-0.543854357347*((b-a)/a)^2.43854357347)", "1.43854357347+2.43854357347-3.43854357347*4.43854357347/5.43854357347^6.43854357347*(2.43854357347*(1.43854357347-5.43854357347+(3.43854357347*7.43854357347^9.43854357347)*(4.43854357347+6.43854357347*7.43854357347-3.43854357347)))+12",
"1+b-3*4.0/5.43854357347^6*(2*(1.43854357347-5.43854357347+(3.43854357347*7.43854357347^9.43854357347)*(4+6*7-3)))+12.43854357347*a",
"(b+1)*(b+2)*(b+3)*(b+4)*(b+5)*(b+6)*(b+7)*(b+8)*(b+9)*(b+10)*(b+11)*(b+12)",
"(a/((((b+(((e*(((((pi*((((3.43854357347*((pi+a)+pi))+b)+b)*a))+0.43854357347)+e)+a)/a))+a)+b))+b)*a)-pi))",
"(((-9.43854357347))-e/(((((((pi-(((-7.43854357347)+(-3.1238723947329)/4.43897589288/e))))/(((-5.43854357347))-2.43854357347)-((pi+(-0))*(sqrt((e+e))*(-8.43854357347))*(((-pi)+(-pi)-(-9.43854357347)*(6.43854357347*5.43854357347))/(-e)-e))/2.43854357347)/((((sqrt(2.43854357347/(-e)+6.43854357347)-(4.43854357347-2.43854357347))+((5.43854357347/(-2.43854357347))/(1*(-pi)+3.43854357347))/8.43854357347)*pi*((pi/((-2.43854357347)/(-6.43854357347)*1.43854357347*(-1.43854357347))*(-6.43854357347)+(-e)))))/((e+(-2.43854357347)+(-e)*((((-3.43854357347)*9.43854357347+(-e)))+(-9)))))))-((((e-7.43854357347+(((5.43854357347/pi-(3.43854357347/1.43854357347+pi)))))/e)/(-5))/(sqrt((((((1+(-7))))+((((-e)*(-e)))-8.43854357347))*(-5.43854357347)/((-e)))*(-6.43854357347)-((((((-2.43854357347)-(-9.43854357347)-(-e)-1)/3))))/(sqrt((8.43854357347+(e-((-6.43854357347))+(9.43854357347*(-9.43854357347))))*(((3.43854357347+2.43854357347-8.43854357347))*(7.43854357347+6.43854357347+(-5.43854357347))+((0/(-e)*(-pi))+7)))+(((((-e)/e/e)+((-6)*5)*e+(3+(-5)/pi))))+pi))/sqrt((((9.43854357347))+((((pi))-8.43854357347+2.43854357347))+pi))/e*4.43854357347)*((-5.43854357347)/(((-pi))*(sqrt(e)))))-(((((((-e)*(e)-pi))/4.43854357347+(pi)*(-9.43854357347)))))))+(-pi)"
};
#if DEBUG
var outstr = $"{Directory.GetCurrentDirectory()}/Result_{DateTime.Now.ToString(CultureInfo.InvariantCulture).Replace(':', '-').Replace(' ', '-').Replace('/', '-')}_debug.txt";
#else
var outstr = $"{Directory.GetCurrentDirectory()}/Result_{DateTime.Now.ToString(CultureInfo.InvariantCulture).Replace(':', '-').Replace(' ', '-').Replace('/', '-')}_release.txt";
#endif
var parser = new ParserX(EPackages.pckALL_NON_COMPLEX);
Value a = new Value(1.0);
Value b = new Value(2.0);
Value c = new Value(3.0);
parser.DefineVar("a", new Variable(a));
parser.DefineVar("b", new Variable(b));
parser.DefineVar("c", new Variable(c));
// parser.DefineConst("pi", 3.14159265);
// parser.DefineConst("e", 2.718281828459);
var timer = new Timer();
#if DEBUG
string sMode = "# debug mode\n";
#else
string sMode = "# release mode\n";
#endif
if (logToFile)
{
pFile = new StreamWriter(outstr);
pFile.Write("{0}; muParserX V{1}\n", sMode, ParserXBase.GetVersion());
pFile.Write("\"Eqn no.\", \"number\", \"result\", \"time in ms\", \"eval per second\", \"expr\"\n");
}
Console.Write(sMode);
Console.Write("\"Eqn no.\", \"number\", \"result\", \"time in ms\", \"eval per second\", \"expr\"\n");
double avgEvalPerSec = 0;
int ct = 0;
for (int i = 0; i < sExpr.Length; ++i)
{
ct++;
timer.Start();
IValue value = 0;
parser.SetExpr(sExpr[i]);
// implicitely create reverse polish notation
parser.Eval();
for (int n = 0; n < iCount; ++n)
{
value = parser.Eval();
}
timer.Stop();
double diff = (double)timer.Duration(iCount);
double evalPerSec = iCount * 1000.0 / diff;
avgEvalPerSec += evalPerSec;
if (logToFile)
{
pFile.Write("Eqn_{0}, {1:n}, {2,-5:n}, {3,-10:n}, {4,-10:n}, {5}\n", i, iCount, value.AsFloat(), diff, evalPerSec, sExpr[i]);
}
Console.Write("Eqn_{0}, {1:n}, {2,-5:n}, {3,-10:n}, {4,-10:n}, {5}\n", i, iCount, value.AsFloat(), diff, evalPerSec, sExpr[i]);
}
avgEvalPerSec /= ct;
if (logToFile)
{
pFile.Write("# Eval per s: {0}", (long)avgEvalPerSec);
}
Console.WriteLine("# Eval per s: {0}", (long)avgEvalPerSec);
if (logToFile)
{
pFile.Flush();
pFile.Close();
}
ret = avgEvalPerSec;
}
//------------------------------------------------------------------------------
/* Assign a parser object to the callback.
* \param a_pParent The parser that belongs to this callback object.
*
* The parent object can be used in order to access internals of the parser
* from within a callback object. Thus enabling callbacks to delete
* variables or functions if this is desired.
*/
internal void SetParent(ParserXBase a_pParent)
{
Global.MUP_VERIFY(a_pParent != null);
m_pParent = a_pParent;
}
private static void Initialise(ParserX parser)
{
// Create an array variable
Value arr1 = new Value(3, 0);
arr1[0] = (1.0);
arr1[1] = 2.0;
arr1[2] = 3.0;
Value arr2 = new Value(3, 0);
arr2[0] = 4.0;
arr2[1] = 3.0;
arr2[2] = 2.0;
Value arr3 = new Value(4, 0);
arr3[0] = 1.0;
arr3[1] = 2.0;
arr3[2] = 3.0;
arr3[3] = 4.0;
Value arr4 = new Value(3, 0);
arr4[0] = 4.0;
arr4[1] = false;
arr4[2] = "hallo";
// Create a 3x3 matrix with zero elements
Value m1 = new Value(3, 3, 0);
m1[0, 0] = 1.0;
m1[1, 1] = 1.0;
m1[2, 2] = 1.0;
Value m2 = new Value(3, 3, 0);
m2[0, 0] = 1.0;
m2[0, 1] = 2.0;
m2[0, 2] = 3.0;
m2[1, 0] = 4.0;
m2[1, 1] = 5.0;
m2[1, 2] = 6.0;
m2[2, 0] = 7.0;
m2[2, 1] = 8.0;
m2[2, 2] = 9.0;
Value[] val = new Value[5];
val[0] = 1.1;
val[1] = 1.0;
val[2] = false;
val[3] = "Hello";
val[4] = "World";
Value[] fVal = new Value[3];
fVal[0] = 1;
fVal[1] = 2.22;
fVal[2] = 3.33;
Value[] sVal = new Value[3];
sVal[0] = "hello";
sVal[1] = "world";
sVal[2] = "test";
Value[] cVal = new Value[3];
cVal[0] = new Complex(1, 1);
cVal[1] = new Complex(2, 2);
cVal[2] = new Complex(3, 3);
var size_3x1 = new Value(1, 2, 0);
size_3x1.At(0, 0) = 3.0;
size_3x1.At(0, 1) = 1.0;
parser.DefineVar("s31", new Variable(size_3x1));
Value ans = new Value(0);
parser.DefineVar("ans", new Variable(ans));
// some tests for vectors
parser.DefineVar("va", new Variable(arr1));
parser.DefineVar("vb", new Variable(arr2));
parser.DefineVar("vc", new Variable(arr3));
parser.DefineVar("vd", new Variable(arr4));
parser.DefineVar("m1", new Variable(m1));
parser.DefineVar("m2", new Variable(m2));
parser.DefineVar("a", new Variable(fVal[0]));
parser.DefineVar("b", new Variable(fVal[1]));
parser.DefineVar("c", new Variable(fVal[2]));
parser.DefineVar("ca", new Variable(cVal[0]));
parser.DefineVar("cb", new Variable(cVal[1]));
parser.DefineVar("cc", new Variable(cVal[2]));
parser.DefineVar("sa", new Variable(sVal[0]));
parser.DefineVar("sb", new Variable(sVal[1]));
// Add functions for inspecting the parser properties
parser.DefineFun(new FunListVar());
parser.DefineFun(new FunListFunctions());
parser.DefineFun(new FunListConst());
parser.DefineFun(new FunBenchmark());
parser.DefineFun(new FunEnableOptimizer());
parser.DefineFun(new FunSelfTest());
parser.DefineFun(new FunEnableDebugDump());
parser.DefineFun(new FunTest0());
parser.DefineFun(new FunPrint());
parser.DefineFun(new FunLang());
parser.EnableAutoCreateVar(true);
#if DEBUG
ParserXBase.EnableDebugDump(bDumpStack: false, bDumpRPN: false);
#endif
Value x = 1.0;
Value y = new Complex(0, 1);
parser.DefineVar("x", new Variable(x));
parser.DefineVar("y", new Variable(y));
}
