基于安卓android闹钟源码 多个AlarmClock闹钟程序源码合集.zip

Function parser for C++ v2.7 by Warp. ===================================== Optimization code contributed by Bisqwit (http://iki.fi/bisqwit/) The usage license of this library is located at the end of this text file. What's new in v2.7 ------------------ - Changed precedence rules for unary minus and the power operator (^) to make it closer in functionality to the power "operator" in mathematics (ie. superscript): * Consecutive power operators at the same precedence level are evaluated from right to left. That is, for example "2^3^4" is now evaluated as if it had been written as "2^(3^4)" (and not as "(2^3)^4" like in previous versions). * The unary minus in the base of the power has now a lower precedence than the power operator. That is, "-2^3" will be evaluated as if written as "-(2^3)", ie. the result is "-8" (and not "8" like in previous versions). The unary minus in the exponent is still evaluated first because of the right-left precedence change above (that is, "-2^-3" is evaluated as "-(2^(-3))"). - Fixed a bug in the copy-on-write engine. ============================================================================= - Preface ============================================================================= Often people need to ask some mathematical expression from the user and then evaluate values for that expression. The simplest example is a program which draws the graphic of a user-defined function on screen. This library adds C-style function string parsing to the program. This means that you can evaluate the string "sqrt(1-x^2+y^2)" with given values of 'x' and 'y'. The library is intended to be very fast. It byte-compiles the function string at parse time and interpretes this byte-code at evaluation time. The evaluation is straightforward and no recursions are done (uses stack arithmetic). Empirical tests show that it indeed is very fast (specially compared to libraries which evaluate functions by just interpreting the raw function string). The library is made in ISO C++ and requires a standard-conforming C++ compiler. ============================================================================= - Usage ============================================================================= To use the FunctionParser class, you have to include "fparser.hh". When compiling, you have to compile fparser.cc and link it to the main program. You can also make a library from the fparser.cc (see the help on your compiler to see how this is done). * Conditional compiling: --------------------- There is a set of precompiler options at the beginning of fparser.cc which can be used for setting certain features on or off. These lines can be commented or uncommented depending on the desired behaviour: NO_ASINH : (Default on) By default the library does not support the asinh(), acosh() and atanh() functions because they are not part of the ISO C++ standard. If your compiler supports them and you want the parser to support them as well, comment this line. DISABLE_EVAL : (Default off) The eval() function can be dangerous because it can cause an infinite recursion in the parser when not used properly (which causes the function stack created by the compiler to overflow). If this possibility should be prevented then the eval() function can be disabled completely by uncommenting this line. SUPPORT_OPTIMIZER : (Default on) If you are not going to use the Optimize() method, you can comment this line out to speed-up the compilation of fparser.cc a bit, as well as making the binary a bit smaller. (Optimize() can still be called, but it will not do anything.) * Copying and assignment: ---------------------- The class implements a safe copy constructor and assignment operator. It uses the copy-on-write technique for efficiency. This means that when copying or assigning a FunctionParser instance, the internal data (which in some cases can be quite lengthy) is not immediately copied but only when the contents of the copy (or the original) are changed. This means that copying/assigning is a very fast operation, and if the copies are never modified then actual data copying never happens either. The Eval() and EvalError() methods of the copy can be called without the internal data being copied. Calling Parse(), Optimize() or the user-defined constant/function adding methods will cause a deep-copy. (C++ basics: The copy constructor is called when a new FunctionParser instance is initialized with another, ie. like: FunctionParser fp2 = fp1; // or: FunctionParser fp2(fp1); or when a function takes a FunctionParser instance as parameter, eg: void foo(FunctionParser p) // takes an instance of FunctionParser { ... } The assignment operator is called when a FunctionParser instance is assigned to another, like "fp2 = fp1;".) * Short descriptions of FunctionParser methods: -------------------------------------------- int Parse(const std::string& Function, const std::string& Vars, bool useDegrees = false); Parses the given function and compiles it to internal format. Return value is -1 if successful, else the index value to the location of the error. const char* ErrorMsg(void) const; Returns an error message corresponding to the error in Parse(), or 0 if no such error occurred. ParseErrorType GetParseErrorType() const; Returns the type of parsing error which occurred. Possible return types are described in the long description. double Eval(const double* Vars); Evaluates the function given to Parse(). int EvalError(void) const; Returns 0 if no error happened in the previous call to Eval(), else an error code >0. void Optimize(); Tries to optimize the bytecode for faster evaluation. bool AddConstant(const std::string& name, double value); Add a constant to the parser. Returns false if the name of the constant is invalid, else true. bool AddFunction(const std::string& name, double (*functionPtr)(const double*), unsigned paramsAmount); Add a user-defined function to the parser (as a function pointer). Returns false if the name of the function is invalid, else true. bool AddFunction(const std::string& name, FunctionParser&); Add a user-defined function to the parser (as a FunctionParser instance). Returns false if the name of the function is invalid, else true. * Long descriptions of FunctionParser methods: ------------------------------------------- --------------------------------------------------------------------------- int Parse(const std::string& Function, const std::string& Vars, bool useDegrees = false); --------------------------------------------------------------------------- Parses the given function (and compiles it to internal format). Destroys previous function. Following calls to Eval() will evaluate the given function. The strings given as parameters are not needed anymore after parsing. Parameters: Function : String containing the function to parse. Vars : String containing the variable names, separated by commas. Eg. "x,y", "VarX,VarY,VarZ,n" or "x1,x2,x3,x4,__VAR__". useDegrees: (Optional.) Whether to use degrees or radians in trigonometric functions. (Default: radians) Variables can have any size and they are case sensitive (ie. "var", "VAR" and "Var" are *different* variable names). Letters, digits an