Logo Search packages:      
Sourcecode: libqalculate version File versions  Download package

includes.h

Go to the documentation of this file.
/*
    Qalculate    

    Copyright (C) 2003-2006  Niklas Knutsson (nq@altern.org)

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
*/

#ifndef INCLUDES_H
#define INCLUDES_H

/** @file */

/// \cond
using namespace std;
/// \endcond

#include <vector>
#include <string>
#include <stack>
#include <list>
#include <errno.h>
#include <stddef.h>
#include <math.h>
#include <float.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>


#ifdef __GNUC__
#   if __GNUC__ < 3
#      include <hash_map.h>
       namespace Sgi { using ::hash_map; }; // inherit globals
#   else
#      include <ext/hash_map>
#      if __GNUC__ == 3 && __GNUC_MINOR__ == 0
          namespace Sgi = std;               // GCC 3.0
#      else
          namespace Sgi = ::__gnu_cxx;       // GCC 3.1 and later
#      endif
#   endif
#else      // ...  there are other compilers, right?
    namespace Sgi = std;
#endif

static string empty_string;

struct ExpressionName;
class Calculator;
class MathStructure;
class Manager;
class Unit;
class Variable;
class KnownVariable;
class UnknownVariable;
class Assumptions;
class DynamicVariable;
class ExpressionItem;
class Number;
class Prefix;
class DecimalPrefix;
class BinaryPrefix;
class NumberPrefix;
class CompositeUnit;
class AliasUnit;
class AliasUnit_Composite;
class MathFunction;
class Matrix;
class Vector;
class UserFunction;
class EqItem;
class EqNumber;
class EqContainer;
class Argument;
class DataSet;
class DataProperty;
class DataObject;

00084 /// Type of ExpressionItem
typedef enum {
00086       /// class Variable
      TYPE_VARIABLE,
00088       /// class MathFunction
      TYPE_FUNCTION,
00090       /// class Unit
      TYPE_UNIT
} ExpressionItemType;

#define COMPARISON_MIGHT_BE_LESS_OR_GREATER(i)  (i == COMPARISON_RESULT_UNKNOWN || i == COMPARISON_RESULT_NOT_EQUAL)
#define COMPARISON_NOT_FULLY_KNOWN(i)           (i == COMPARISON_RESULT_UNKNOWN || i == COMPARISON_RESULT_NOT_EQUAL || i == COMPARISON_RESULT_EQUAL_OR_LESS || i == COMPARISON_RESULT_EQUAL_OR_GREATER)
#define COMPARISON_IS_EQUAL_OR_GREATER(i) (i == COMPARISON_RESULT_EQUAL || i == COMPARISON_RESULT_GREATER || i == COMPARISON_RESULT_EQUAL_OR_GREATER)
#define COMPARISON_IS_EQUAL_OR_LESS(i)          (i == COMPARISON_RESULT_EQUAL || i == COMPARISON_RESULT_LESS || i == COMPARISON_RESULT_EQUAL_OR_LESS)
#define COMPARISON_IS_NOT_EQUAL(i)        (i == COMPARISON_RESULT_NOT_EQUAL || i == COMPARISON_RESULT_LESS || i == COMPARISON_RESULT_GREATER)
#define COMPARISON_MIGHT_BE_EQUAL(i)            (i == COMPARISON_RESULT_UNKNOWN || i == COMPARISON_RESULT_EQUAL_OR_LESS || i == COMPARISON_RESULT_EQUAL_OR_GREATER)
#define COMPARISON_MIGHT_BE_NOT_EQUAL(i)  (i == COMPARISON_RESULT_UNKNOWN || i == COMPARISON_RESULT_EQUAL_OR_LESS || i == COMPARISON_RESULT_EQUAL_OR_GREATER)

#define NR_OF_PRIMES 174

static const int PRIMES[] = {
2, 3, 5, 7, 11, 13, 17, 19, 21, 23, 29, 31, 37, 41, 31, 37, 
41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 
107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 
173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 
239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 
311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 
383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 
457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523,
541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 
613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 
683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 
769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 
857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 
941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013
};

#define SQP_LT_1000 11
#define SQP_LT_2000 17
#define SQP_LT_10000 28
#define SQP_LT_25000 40
#define SQP_LT_100000 68

static const int SQUARE_PRIMES[] = {
4, 9, 25, 49, 121, 169, 289, 361, 441, 529, 
841, 961, 1369, 1681, 961, 1369, 1681, 1849, 2209, 2809, 
3481, 3721, 4489, 5041, 5329, 6241, 6889, 7921, 9409, 10201, 
10609, 11449, 11881, 12769, 16129, 17161, 18769, 19321, 22201, 22801, 
24649, 26569, 27889, 29929, 32041, 32761, 36481, 37249, 38809, 39601, 
44521, 49729, 51529, 52441, 54289, 57121, 58081, 63001, 66049, 69169, 
72361, 73441, 76729, 78961, 80089, 85849, 94249, 96721, 97969, 100489, 
109561, 113569, 120409, 121801, 124609, 128881, 134689, 139129, 143641, 146689, 
151321, 157609, 160801, 167281, 175561, 177241, 185761, 187489, 192721, 196249, 
201601, 208849, 212521, 214369, 218089, 229441, 237169, 241081, 249001, 253009, 
259081, 271441, 273529, 292681, 299209, 310249, 316969, 323761, 326041, 332929, 
344569, 351649, 358801, 361201, 368449, 375769, 380689, 383161, 398161, 410881, 
413449, 418609, 426409, 434281, 436921, 452929, 458329, 466489, 477481, 491401, 
502681, 516961, 528529, 537289, 546121, 552049, 564001, 573049, 579121, 591361, 
597529, 619369, 635209, 654481, 657721, 674041, 677329, 683929, 687241, 703921, 
727609, 734449, 737881, 744769, 769129, 776161, 779689, 786769, 822649, 829921, 
844561, 863041, 877969, 885481, 896809, 908209, 935089, 942841, 954529, 966289, 
982081, 994009, 1018081, 1026169
};

00148 /// The result of a comparison of two values
typedef enum {
      COMPARISON_RESULT_EQUAL,
      COMPARISON_RESULT_GREATER,
      COMPARISON_RESULT_LESS,
      COMPARISON_RESULT_EQUAL_OR_GREATER,
      COMPARISON_RESULT_EQUAL_OR_LESS,
      COMPARISON_RESULT_NOT_EQUAL,
      COMPARISON_RESULT_UNKNOWN
} ComparisonResult;

00159 /// Placement of legend
typedef enum {
      PLOT_LEGEND_NONE,
      PLOT_LEGEND_TOP_LEFT,
      PLOT_LEGEND_TOP_RIGHT,
      PLOT_LEGEND_BOTTOM_LEFT,
      PLOT_LEGEND_BOTTOM_RIGHT,
      PLOT_LEGEND_BELOW,
      PLOT_LEGEND_OUTSIDE
} PlotLegendPlacement;

00170 /// Plot type/style
typedef enum {
      PLOT_STYLE_LINES,
      PLOT_STYLE_POINTS,
      PLOT_STYLE_POINTS_LINES,
      PLOT_STYLE_BOXES,
      PLOT_STYLE_HISTOGRAM,
      PLOT_STYLE_STEPS,
      PLOT_STYLE_CANDLESTICKS,
      PLOT_STYLE_DOTS
} PlotStyle;

00182 /// Smoothing a plotted lines
typedef enum {
      PLOT_SMOOTHING_NONE,
      PLOT_SMOOTHING_UNIQUE,
      PLOT_SMOOTHING_CSPLINES,
      PLOT_SMOOTHING_BEZIER,
      PLOT_SMOOTHING_SBEZIER
} PlotSmoothing;

00191 /// File type for saving plot to image
typedef enum {
      PLOT_FILETYPE_AUTO,
      PLOT_FILETYPE_PNG,
      PLOT_FILETYPE_PS,
      PLOT_FILETYPE_EPS,
      PLOT_FILETYPE_LATEX,
      PLOT_FILETYPE_SVG,
      PLOT_FILETYPE_FIG
} PlotFileType;

00202 /// Mathematical operations
typedef enum {
      OPERATION_MULTIPLY,
      OPERATION_DIVIDE,
      OPERATION_ADD,
      OPERATION_SUBTRACT,
      OPERATION_RAISE,
      OPERATION_EXP10,
      OPERATION_LOGICAL_AND,
      OPERATION_LOGICAL_OR,
      OPERATION_LOGICAL_XOR,
      OPERATION_BITWISE_AND,
      OPERATION_BITWISE_OR,
      OPERATION_BITWISE_XOR,
      OPERATION_LESS,
      OPERATION_GREATER,
      OPERATION_EQUALS_LESS,
      OPERATION_EQUALS_GREATER,
      OPERATION_EQUALS,
      OPERATION_NOT_EQUALS
} MathOperation;

00224 /// Comparison signs for comparison structures
typedef enum {
      COMPARISON_LESS,
      COMPARISON_GREATER,
      COMPARISON_EQUALS_LESS,
      COMPARISON_EQUALS_GREATER,
      COMPARISON_EQUALS,
      COMPARISON_NOT_EQUALS
} ComparisonType;

typedef enum {
      SORT_DEFAULT                        = 1 << 0,
      SORT_SCIENTIFIC                     = 1 << 1
} SortFlags;

#define BASE_ROMAN_NUMERALS   -1
#define BASE_TIME       -2
#define BASE_BINARY           2
#define BASE_OCTAL            8
#define BASE_DECIMAL          10
#define BASE_HEXADECIMAL      16
#define BASE_SEXAGESIMAL      60

#define EXP_PRECISION         -1
#define EXP_NONE        0
#define EXP_PURE        1
#define EXP_SCIENTIFIC        3
00251 
typedef enum {
00253       /// Display numbers in decimal, not fractional, format (ex. 0.333333)
      FRACTION_DECIMAL,
00255       /// Display as fraction if necessary to get an exact display of the result (ex. 1/3, but 0.25)
      FRACTION_DECIMAL_EXACT,
00257       /// Display as fraction (ex. 4/3)
      FRACTION_FRACTIONAL,
00259       /// Display as an integer and a fraction (ex. 3 + 1/2)
      FRACTION_COMBINED
} NumberFractionFormat;

00263 /// Options for ordering the parts of a mathematical expression/result before display
static const struct SortOptions {
00265       /// Put currency units before quantity. Default: true
      bool prefix_currencies;
00267       /// If true, avoid placing negative terms first. Default: true
      bool minus_last;
      SortOptions() : prefix_currencies(true), minus_last(true) {}
} default_sort_options;

typedef enum {
      MULTIPLICATION_SIGN_ASTERISK,
      MULTIPLICATION_SIGN_DOT,
      MULTIPLICATION_SIGN_X
} MultiplicationSign;

typedef enum {
      DIVISION_SIGN_SLASH,
      DIVISION_SIGN_DIVISION_SLASH,
      DIVISION_SIGN_DIVISION
} DivisionSign;

typedef enum {
      BASE_DISPLAY_NONE,
      BASE_DISPLAY_NORMAL,
      BASE_DISPLAY_ALTERNATIVE
} BaseDisplay;

00290 /// Options for formatting and display of mathematical structures/results.
static const struct PrintOptions {
      int min_exp;
00293       /// Number base for displaying numbers. Default: 10
      int base;
00295       /// How prefixes for numbers in non-decimal bases will be displayed
      BaseDisplay base_display;
00297       /// Use lower case for non-numeric characters for bases > 10. Default: false
      bool lower_case_numbers;
00299       /// Use lower case e for base-10 exponent (ex. 1.2e8 instead of 1.2E8). Default: false
      bool lower_case_e;
00301       /// If rational numbers will be displayed with decimals, as a fraction, or something in between. Default: FRACTION_DECIMAL
      NumberFractionFormat number_fraction_format;
00303       /// Show that the digit series of a number continues forever with three dots, instead of rounding (ex. 2/3 displays as 0.666666... instead of 0.666667). Default: false
      bool indicate_infinite_series;
00305       /// Show ending zeroes for approximate numbers to indicate precision (ex.1.2300000 instead of 1.23) . Default: false
      bool show_ending_zeroes;
00307       /// Prefer abbreviated names of variables, units, functions etc. Default: true
      bool abbreviate_names;
00309       /// Prefer reference names of variables, units, functions etc. Default: false
      bool use_reference_names;
00311       /// Isolate units at the end of the displayed expression (ex. x/y m/s instead of (x m)/(y s)). Default: true
      bool place_units_separately;
00313       /// Use prefixes for units when appropriate. Default: true
      bool use_unit_prefixes;
00315       /// Use prefixes for currencies if unit prefixes are om. Default: false
      bool use_prefixes_for_currencies;
00317       /// Use all decimal SI prefixes. If false, prefixes which is not a multiple of thousand (centi, deci, deka, hekto) will not be used automatically. Default: false
      bool use_all_prefixes;
00319       /// If set to true, prefixes will be split between numerator and denominator in a unit expression (millimeter per kilogram instead of micrometer per gram). Default: true
      bool use_denominator_prefix;
00321       /// If true, negative exponents will be used instead of division (ex. 5/x^2 becomes 5*x^-2). Default: false
      bool negative_exponents;
00323       /// Avoid using multiplication sign, when appropriate. Default: true
      bool short_multiplication;
00325       /// Use a format compatible with ParseOptions::limit_implicit_multiplication. Default: false
      bool limit_implicit_multiplication;
00327       /// If it is not necessary that the displayed expression can be parsed correctly. Default: false
      bool allow_non_usable;
00329       /// If unicode signs can be displayed. Default: false
      bool use_unicode_signs;
00331       /// Sign used for display of multiplication. Default: MULTIPLICATION_SIGN_DOT
      MultiplicationSign multiplication_sign;
00333       /// Sign used for display of division. Default: DIVISION_SIGN_DIVISION_SLASH
      DivisionSign division_sign;
00335       /// If space will be used to make the output look nicer. Default: true
      bool spacious;
00337       /// Use parentheses even when not necessary. Default: false
      bool excessive_parenthesis;
00339       /// Transform raised to 1/2 to square root function. Default: true
      bool halfexp_to_sqrt;
00341       /// Minimum number of decimals to display for numbers. Default: 0
      int min_decimals;
00343       /// Maximum number of decimals to display for numbers. A negative value disables the limit. Default: -1
      int max_decimals;
00345       /// Enable use of min_decimals. False is equivalent to a min_decimals value of zero. Default: true
      bool use_min_decimals;
00347       /// Enable use of max_decimals. False is equivalent to a negative max_decimals value. Default: true
      bool use_max_decimals;
00349       /// If true round halfway numbers to nearest even number, otherwise round upwards. Default: false
      bool round_halfway_to_even;
00351       /// Multiply numerator and denominator to get integers (ex. (6x+y)/2z instead of (3x+0.5y)/z). Default: true
      bool improve_division_multipliers;
00353       /// Force use of a specific prefix for units if not NULL. Default: NULL
      Prefix *prefix;
00355       /// If not NULL will be set to true if the output is approximate. Default: NULL
      bool *is_approximate;
00357       /// Options for the order of values in the displayed expression. Default: default_sort_options
      SortOptions sort_options;
00359       /// Comma sign or empty string to use default comma sign. Default: empty string
      string comma_sign;
00361       /// Decimal sign or empty string to use default decimal sign. Default: empty string
      string decimalpoint_sign;
      /// Function that returns true if a text string with unicode signs can be properly displayed. Default: NULL
      bool (*can_display_unicode_string_function) (const char*, void*);
00365       /// Argument passed to can_display_unicode_string_function. Default: NULL
      void *can_display_unicode_string_arg;
00367       /// Replace underscores in names with spaces, unless name has suffix. Default: false
      bool hide_underscore_spaces;
00369       /// Preserves the format of the structure (no sorting, no changed prefixes, no improved division multipliers, etc.). Default: false
      bool preserve_format;
00371       /// Allows factorization to occur in the output (should be set to true if the structure has been factorized). Default: false
      bool allow_factorization;
00373       /// If logical operators will be spelled as AND and OR instead of && and ||. Default: false
      bool spell_out_logical_operators;
00375       /// Displays children of the structure with no higher precision than the parent. Default: true
      bool restrict_to_parent_precision;
      PrintOptions() : min_exp(EXP_PRECISION), base(BASE_DECIMAL), lower_case_numbers(false), lower_case_e(false), number_fraction_format(FRACTION_DECIMAL), indicate_infinite_series(false), show_ending_zeroes(false), abbreviate_names(true), use_reference_names(false), place_units_separately(true), use_unit_prefixes(true), use_prefixes_for_currencies(false), use_all_prefixes(false), use_denominator_prefix(true), negative_exponents(false), short_multiplication(true), limit_implicit_multiplication(false), allow_non_usable(false), use_unicode_signs(false), multiplication_sign(MULTIPLICATION_SIGN_DOT), division_sign(DIVISION_SIGN_DIVISION_SLASH), spacious(true), excessive_parenthesis(false), halfexp_to_sqrt(true), min_decimals(0), max_decimals(-1), use_min_decimals(true), use_max_decimals(true), round_halfway_to_even(false), improve_division_multipliers(true), prefix(NULL), is_approximate(NULL), can_display_unicode_string_function(NULL), can_display_unicode_string_arg(NULL), hide_underscore_spaces(false), preserve_format(false), allow_factorization(false), spell_out_logical_operators(false), restrict_to_parent_precision(true) {}
      /// Returns the comma sign used (default sign or comma_sign)
      const string &comma() const;
      /// Returns the decimal sign used (default sign or decimalpoint_sign)
      const string &decimalpoint() const;
} default_print_options;

static const struct InternalPrintStruct {
      int depth, power_depth, division_depth;
      bool wrap;
      string *num, *den, *re, *im, *exp;
      bool *minus, *exp_minus;
      bool parent_approximate;
      int parent_precision;
      InternalPrintStruct() : depth(0), power_depth(0), division_depth(0), wrap(false), num(NULL), den(NULL), re(NULL), im(NULL), exp(NULL), minus(NULL), exp_minus(NULL), parent_approximate(false), parent_precision(-1) {}
} top_ips;
00393 
typedef enum {
00395       /// Allow only exact results
      APPROXIMATION_EXACT,
00397       /// Try to make the result as exact as possible
      APPROXIMATION_TRY_EXACT,
00399       /// Calculate the result approximately directly
      APPROXIMATION_APPROXIMATE
} ApproximationMode;
00402 
typedef enum {
00404       /// Do not do any factorization or additional simplifications
      STRUCTURING_NONE,
00406       /// Simplify the result as much as possible
      STRUCTURING_SIMPLIFY,
00408       /// Factorize the result
      STRUCTURING_FACTORIZE
} StructuringMode;
00411 
typedef enum {
00413       /// Do not do any conversion of units in addition to syncing
      POST_CONVERSION_NONE,
00415       /// Convert to the best suited SI units (the least amount of units)
      POST_CONVERSION_BEST,
00417       /// Convert to base units
      POST_CONVERSION_BASE
} AutoPostConversion;

typedef enum {
      DONT_READ_PRECISION,
      ALWAYS_READ_PRECISION,
      READ_PRECISION_WHEN_DECIMALS
} ReadPrecisionMode;

typedef enum {
      ANGLE_UNIT_NONE,
      ANGLE_UNIT_RADIANS,
      ANGLE_UNIT_DEGREES,
      ANGLE_UNIT_GRADIANS
} AngleUnit;

00434 /// Options for parsing expressions.
static const struct ParseOptions {
00436       /// If variables will be parsed. Default: true
      bool variables_enabled;
00438       /// If functions will be parsed. Default: true
      bool functions_enabled;
00440       /// If left-over characters will be parsed as symbols. Default: true
      bool unknowns_enabled;
00442       /// If units will be parsed. Default: true
      bool units_enabled;
00444       /// If Reverse Polish Notation syntax will be used. Default: false
      bool rpn;
00446       /// Base of parsed numbers. Default: 10
      int base;
      /// When implicit multiplication is limited variables, functions and units must be separated by a space, operator or parenthesis ("xy" does not equal "x * y").  Default: false
      /**
      * If the limit implicit multiplication mode is activated, the use of implicite multiplication when parsing expressions and displaying results will be limited to avoid confusion. For example, if this mode is not activated and "integrte(5x)" is accidently typed instead of "integrate(5x)", the expression is interpreted as "int(e * e * (5 * x) * gr * t)". If limit implicit multiplication is turned on to mistyped expression would instead show an error telling that "integrte" is not a valid variable, function or unit (unless unknowns is not enabled in which case the result will be "5 'integrate' * x".
00451       */
      bool limit_implicit_multiplication;
00453       /// If and when precisions will be read from number of digits in a number. Default: DONT_READ_PRECISION
      ReadPrecisionMode read_precision;
00455       /// If true. dots will ignored if another character is the default decimal sign, to allow dots to be used as thousand separator. Default: false
      bool dot_as_separator;
00457       /// Default angle unit for trigonometric functions. Default: ANGLE_UNIT_NONE
      AngleUnit angle_unit;
00459       /// If non-NULL will be set to unfinished function at the end of the expression (if there is one). Default: NULL
      MathStructure *unended_function;
00461       /// Preserve the expression structure as much as possible. Default: false
      bool preserve_format;
      ParseOptions() : variables_enabled(true), functions_enabled(true), unknowns_enabled(true), units_enabled(true), rpn(false), base(BASE_DECIMAL), limit_implicit_multiplication(false), read_precision(DONT_READ_PRECISION), dot_as_separator(false), angle_unit(ANGLE_UNIT_NONE), unended_function(NULL), preserve_format(false) {}
} default_parse_options;

00466 /// Options for calculation.
static const struct EvaluationOptions {
00468       /// How exact the result must be. Default: TRY_EXACT
      ApproximationMode approximation;
00470       /// If units will be synced/converted to allow evaluation (ex. 1 min + 1 s=60 s+ 1 s = 61 s). Default: true
      bool sync_units;
00472       /// If units with complex/non-linear relations (ex. degress celsius and fahrenheit) will synced/converted. Default: true
      bool sync_complex_unit_relations;
00474       /// If unit prefixes in original expression will be kept. Default: false
      bool keep_prefixes;
00476       /// If known variables will be replaced by their value. Default: true
      bool calculate_variables;
00478       /// If functions will be calculated. Default: true
      bool calculate_functions;
00480       /// If comparisons will be evaluated (ex. 5>2 => 1). Default: true
      bool test_comparisons;
00482       /// If a varaible will be isolated to the left side in equations/comparisons (ex. x+y=2 => x=2-y). Default: true
      bool  isolate_x;
00484       /// If factors (and bases) containing addition will be expanded (ex. z(x+y)=zx+zy). Default: true
      bool expand;
00486       /// If non-numerical parts of a fraction will be reduced (ex. (5x)/(3xy) =5/(3y) .  Default: true
      bool reduce_divisions;
00488       /// If complex numbers will be used for evaluation. Default: true
      bool allow_complex;
00490       /// If infinite numbers will be used for evaluation. Default: true
      bool allow_infinite;
00492       /// If simplification will be made easier by assuming that denominators with unknown value not is zero. Default: false
      bool assume_denominators_nonzero;
00494       /// Warn if a denominator with unknown value was assumed non-zero (with assume_denominators_nonzero set to true) to allow simplification. Default: false
      bool warn_about_denominators_assumed_nonzero;
00496       /// If powers with exponent 1/2 that only have an approximate result will be split to the least base (sqrt(8) = 2 * sqrt(2)). Default: true
      bool split_squares;
00498       /// If units with zero quantity will be preserved. Default: true
      bool keep_zero_units;
00500       /// If and how units will be automatically converted. Does not affect syncing of units. Default: POST_CONVERSION_NONE
      AutoPostConversion auto_post_conversion;
00502       /// If the evaluation result will be simplified or factorized
      StructuringMode structuring;
00504       /// Options for parsing of expression. Default: default_parse_options
      ParseOptions parse_options;
00506       /// If set will decide which variable to isolate in an equation. Default: NULL
      const MathStructure *isolate_var;
      EvaluationOptions() : approximation(APPROXIMATION_TRY_EXACT), sync_units(true), sync_complex_unit_relations(true), keep_prefixes(false), calculate_variables(true), calculate_functions(true), test_comparisons(true), isolate_x(true), expand(true), reduce_divisions(true), allow_complex(true), allow_infinite(true), assume_denominators_nonzero(false), warn_about_denominators_assumed_nonzero(false), split_squares(true), keep_zero_units(true), auto_post_conversion(POST_CONVERSION_NONE), structuring(STRUCTURING_SIMPLIFY), isolate_var(NULL) {}
} default_evaluation_options;

extern MathStructure m_undefined, m_empty_vector, m_empty_matrix, m_zero, m_one, m_minus_one;
extern Number nr_zero, nr_one, nr_minus_one;
extern EvaluationOptions no_evaluation;
extern ExpressionName empty_expression_name;

extern Calculator *calculator;

#define CALCULATOR      calculator

#define DEFAULT_PRECISION     8
#define PRECISION       CALCULATOR->getPrecision()

#define SIGN_POWER_0                "°"
#define SIGN_POWER_1                "¹"
#define SIGN_POWER_2                "²"
#define SIGN_POWER_3                "³"
#define SIGN_EURO             "€"
#define SIGN_POUND                  "£"
#define SIGN_CENT             "¢"
#define SIGN_YEN              "¥"
#define SIGN_MICRO                  "µ"
#define SIGN_PI                     "π"
#define SIGN_MULTIPLICATION         "×"
#define SIGN_MULTIDOT               "⋅"
#define SIGN_MULTIBULLET            "∙"
#define SIGN_SMALLCIRCLE            "•"
#define SIGN_DIVISION_SLASH         "∕"
#define SIGN_DIVISION               "÷"
#define SIGN_MINUS                  "−"
#define SIGN_PLUS             "+"
#define SIGN_SQRT             "√"
#define SIGN_ALMOST_EQUAL           "≈"
#define SIGN_APPROXIMATELY_EQUAL    "≅"
#define     SIGN_ZETA               "ζ"
#define SIGN_GAMMA                  "γ"
#define SIGN_PHI              "φ"
#define     SIGN_LESS_OR_EQUAL            "≤"
#define     SIGN_GREATER_OR_EQUAL         "≥"
#define     SIGN_NOT_EQUAL                "≠"
#define SIGN_CAPITAL_SIGMA          "Σ"
#define SIGN_CAPITAL_PI             "Π"
#define SIGN_CAPITAL_OMEGA          "Ω"
#define SIGN_CAPITAL_GAMMA          "Γ"
#define SIGN_CAPITAL_BETA           "Β"
#define SIGN_INFINITY               "∞"

#define ID_WRAP_LEFT_CH       '{'
#define ID_WRAP_RIGHT_CH      '}'

#define DOT_CH                '.'
#define ZERO_CH               '0'
#define ONE_CH                '1'
#define TWO_CH                '2'
#define THREE_CH        '3'
#define FOUR_CH               '4'
#define FIVE_CH               '5'
#define SIX_CH                '6'
#define SEVEN_CH        '7'
#define EIGHT_CH        '8'
#define NINE_CH               '9'
#define PLUS_CH               '+'
#define MINUS_CH        '-'
#define MULTIPLICATION_CH     '*'
#define MULTIPLICATION_2_CH   ' '
#define DIVISION_CH           '/'
#define EXP_CH                'E'
#define EXP2_CH               'e'
#define POWER_CH        '^'
#define SPACE_CH        ' '
#define LEFT_PARENTHESIS_CH   '('
#define RIGHT_PARENTHESIS_CH  ')'
#define LEFT_VECTOR_WRAP_CH   '['
#define RIGHT_VECTOR_WRAP_CH  ']'
#define FUNCTION_VAR_PRE_CH   '\\'
#define COMMA_CH        ','
#define NAME_NUMBER_PRE_CH    '_'
#define UNIT_DIVISION_CH      '/'
#define     AND_CH                  '&'
#define     OR_CH             '|'
#define     LESS_CH                 '<'
#define     GREATER_CH        '>'
#define     BITWISE_NOT_CH          '~'
#define     LOGICAL_NOT_CH          '!'
#define     NOT_CH                  '!'
#define EQUALS_CH       '='

#define ID_WRAP_LEFT          "{"   
#define ID_WRAP_RIGHT         "}"   
#define ID_WRAPS        "{}"  
#define DOT             "."
#define SEXADOT               ":"
#define COMMA                 ","
#define COMMAS                ",;"
#define NUMBERS               "0123456789"
#define NUMBER_ELEMENTS       "0123456789.:"
#define SIGNS                 "+-*/^"
#define OPERATORS       "~+-*/^&|!<>="
#define     PARENTHESISS            "()"
#define LEFT_PARENTHESIS      "("
#define     RIGHT_PARENTHESIS ")"
#define     VECTOR_WRAPS            "[]"
#define LEFT_VECTOR_WRAP      "["
#define     RIGHT_VECTOR_WRAP "]"
#define     SPACES                  " \t\n"
#define SPACE                 " "
#define RESERVED        "\'@?\\{}\""
#define PLUS                  "+"
#define MINUS                 "-"
#define MULTIPLICATION        "*"
#define MULTIPLICATION_2      " "
#define DIVISION        "/"
#define EXP             "E"
#define EXPS                  "Ee"
#define     POWER             "^"
#define     LOGICAL_AND       "&&"
#define     LOGICAL_OR        "||"
#define     LOGICAL_NOT       "!"
#define     BITWISE_AND       "&"
#define     BITWISE_OR        "|"
#define     BITWISE_NOT       "~"
#define SHIFT_RIGHT           ">>"
#define SHIFT_LEFT            "<<"
#define     LESS              "<"
#define     GREATER                 ">"
#define     NOT               "!"
#define     EQUALS                  "="
#define SINF                  "INF"
#define SNAN                  "NAN"
#define UNDERSCORE            "_"

#define NOT_IN_NAMES    RESERVED OPERATORS SPACES SEXADOT DOT VECTOR_WRAPS PARENTHESISS COMMAS

#endif

Generated by  Doxygen 1.6.0   Back to index