# Calculator Class Reference

The almighty calculator class. More...

`#include <Calculator.h>`

List of all members.

## Public Member Functions

Constructor
| Calculator ()
virtual | ~Calculator ()
Functions for calculating expressions.
bool | calculate (MathStructure *mstruct, string str, int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL, MathStructure *to_struct=NULL, bool make_to_division=true)
MathStructure | calculate (string str, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL, MathStructure *to_struct=NULL, bool make_to_division=true)
string | printMathStructureTimeOut (const MathStructure &mstruct, int msecs=100000, const PrintOptions &op=default_print_options)
int | testCondition (string expression)
Functions for handling of threaded calculations
void | abort ()
void | abort_this ()
bool | busy ()
void | saveState ()
void | restoreState ()
void | clearBuffers ()
void | terminateThreads ()
Functions for manipulation of the RPN stack.
bool | calculateRPNRegister (size_t index, int msecs, const EvaluationOptions &eo=default_evaluation_options)
bool | calculateRPN (MathOperation op, int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
bool | calculateRPN (MathFunction *f, int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
bool | calculateRPNBitwiseNot (int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
bool | calculateRPNLogicalNot (int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
MathStructure * | calculateRPN (MathOperation op, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
MathStructure * | calculateRPN (MathFunction *f, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
MathStructure * | calculateRPNBitwiseNot (const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
MathStructure * | calculateRPNLogicalNot (const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL)
bool | RPNStackEnter (MathStructure *mstruct, int msecs, const EvaluationOptions &eo=default_evaluation_options)
bool | RPNStackEnter (string str, int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL, MathStructure *to_struct=NULL, bool make_to_division=true)
void | RPNStackEnter (MathStructure *mstruct, bool eval=false, const EvaluationOptions &eo=default_evaluation_options)
void | RPNStackEnter (string str, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL, MathStructure *to_struct=NULL, bool make_to_division=true)
bool | setRPNRegister (size_t index, MathStructure *mstruct, int msecs, const EvaluationOptions &eo=default_evaluation_options)
bool | setRPNRegister (size_t index, string str, int msecs, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL, MathStructure *to_struct=NULL, bool make_to_division=true)
void | setRPNRegister (size_t index, MathStructure *mstruct, bool eval=false, const EvaluationOptions &eo=default_evaluation_options)
void | setRPNRegister (size_t index, string str, const EvaluationOptions &eo=default_evaluation_options, MathStructure *parsed_struct=NULL, MathStructure *to_struct=NULL, bool make_to_division=true)
void | deleteRPNRegister (size_t index)
MathStructure * | getRPNRegister (size_t index=1) const
size_t | RPNStackSize () const
void | clearRPNStack ()
void | moveRPNRegister (size_t old_index, size_t new_index)
void | moveRPNRegisterUp (size_t index)
void | moveRPNRegisterDown (size_t index)
Functions for expression parsing.
string | localizeExpression (string str) const
string | unlocalizeExpression (string str, const ParseOptions &po=default_parse_options) const
bool | separateToExpression (string &str, string &to_str, const EvaluationOptions &eo) const
void | parseSigns (string &str) const
MathStructure | parse (string str, const ParseOptions &po=default_parse_options)
void | parse (MathStructure *mstruct, string str, const ParseOptions &po=default_parse_options)
bool | parseNumber (MathStructure *mstruct, string str, const ParseOptions &po=default_parse_options)
bool | parseOperators (MathStructure *mstruct, string str, const ParseOptions &po=default_parse_options)
bool | parseAdd (string &str, MathStructure *mstruct, const ParseOptions &po, MathOperation s)
bool | parseAdd (string &str, MathStructure *mstruct, const ParseOptions &po)
Functions converting epxressions between units.
MathStructure | convert (const MathStructure &mstruct, string composite_, const EvaluationOptions &eo=default_evaluation_options)
MathStructure | convert (const MathStructure &mstruct, Unit *to_unit, const EvaluationOptions &eo=default_evaluation_options, bool always_convert=true)
MathStructure | convert (double value, Unit *from_unit, Unit *to_unit, const EvaluationOptions &eo=default_evaluation_options)
MathStructure | convert (string str, Unit *from_unit, Unit *to_unit, const EvaluationOptions &eo=default_evaluation_options)
MathStructure | convertToBaseUnits (const MathStructure &mstruct, const EvaluationOptions &eo=default_evaluation_options)
Unit * | getBestUnit (Unit *u, bool allow_only_div=false)
MathStructure | convertToBestUnit (const MathStructure &mstruct, const EvaluationOptions &eo=default_evaluation_options)
MathStructure | convertToCompositeUnit (const MathStructure &mstruct, CompositeUnit *cu, const EvaluationOptions &eo=default_evaluation_options, bool always_convert=true)
Functions for default assumptions for unknown variables and symbols
void | setDefaultAssumptions (Assumptions *ass)
Assumptions * | defaultAssumptions ()
Functions for retrieval of angle units
Unit * | getGraUnit ()
Unit * | getRadUnit ()
Unit * | getDegUnit ()
Functions for finding a suitable prefix.
DecimalPrefix * | getExactDecimalPrefix (int exp10, int exp=1) const
BinaryPrefix * | getExactBinaryPrefix (int exp2, int exp=1) const
Prefix * | getExactPrefix (const Number &o, int exp=1) const
DecimalPrefix * | getNearestDecimalPrefix (int exp10, int exp=1) const
DecimalPrefix * | getBestDecimalPrefix (int exp10, int exp=1, bool all_prefixes=true) const
DecimalPrefix * | getBestDecimalPrefix (const Number &exp10, const Number &exp, bool all_prefixes=true) const
BinaryPrefix * | getNearestBinaryPrefix (int exp2, int exp=1) const
BinaryPrefix * | getBestBinaryPrefix (int exp2, int exp=1) const
BinaryPrefix * | getBestBinaryPrefix (const Number &exp2, const Number &exp) const
Prefix * | addPrefix (Prefix *p)
void | prefixNameChanged (Prefix *p, bool new_item=false)
Functions for managing functions, variables, units, prefixes and data sets.
void | expressionItemActivated (ExpressionItem *item)
void | expressionItemDeactivated (ExpressionItem *item)
void | expressionItemDeleted (ExpressionItem *item)
void | nameChanged (ExpressionItem *item, bool new_item=false)
void | deleteName (string name_, ExpressionItem *object=NULL)
void | deleteUnitName (string name_, Unit *object=NULL)
Unit * | addUnit (Unit *u, bool force=true, bool check_names=true)
void | delPrefixUFV (Prefix *object)
void | delUFV (ExpressionItem *object)
bool | hasVariable (Variable *v)
bool | hasUnit (Unit *u)
bool | hasFunction (MathFunction *f)
bool | stillHasVariable (Variable *v)
bool | stillHasUnit (Unit *u)
bool | stillHasFunction (MathFunction *f)
void | saveFunctionCalled ()
bool | checkSaveFunctionCalled ()
ExpressionItem * | getActiveExpressionItem (string name, ExpressionItem *item=NULL)
ExpressionItem * | getInactiveExpressionItem (string name, ExpressionItem *item=NULL)
ExpressionItem * | getActiveExpressionItem (ExpressionItem *item)
ExpressionItem * | getExpressionItem (string name, ExpressionItem *item=NULL)
Unit * | getUnit (string name_)
Unit * | getActiveUnit (string name_)
Unit * | getCompositeUnit (string internal_name_)
Prefix * | getPrefix (size_t index) const
Prefix * | getPrefix (string name_) const
Variable * | addVariable (Variable *v, bool force=true, bool check_names=true)
void | variableNameChanged (Variable *v, bool new_item=false)
void | functionNameChanged (MathFunction *f, bool new_item=false)
void | unitNameChanged (Unit *u, bool new_item=false)
Variable * | getVariable (string name_)
Variable * | getActiveVariable (string name_)
ExpressionItem * | addExpressionItem (ExpressionItem *item, bool force=true)
MathFunction * | addFunction (MathFunction *f, bool force=true, bool check_names=true)
DataSet * | addDataSet (DataSet *dc, bool force=true, bool check_names=true)
DataSet * | getDataSet (size_t index)
DataSet * | getDataSet (string name)
MathFunction * | getFunction (string name_)
MathFunction * | getActiveFunction (string name_)
Variable * | getVariable (size_t index) const
Unit * | getUnit (size_t index) const
MathFunction * | getFunction (size_t index) const
bool | unitIsUsedByOtherUnits (const Unit *u) const
Functions for handling of builtin expression items
void | resetVariables ()
void | resetFunctions ()
void | resetUnits ()
void | reset ()
void | addBuiltinVariables ()
void | addBuiltinFunctions ()
void | addBuiltinUnits ()
Functions for testing validity of functions, variable and unit names.
bool | variableNameIsValid (const string &name_)
bool | variableNameIsValid (const char *name_)
bool | variableNameIsValid (const char *name_, int version_numbers[3], bool is_user_defs)
bool | variableNameIsValid (const string &name_, int version_numbers[3], bool is_user_defs)
string | convertToValidVariableName (string name_)
bool | functionNameIsValid (const string &name_)
bool | functionNameIsValid (const char *name_)
bool | functionNameIsValid (const char *name_, int version_numbers[3], bool is_user_defs)
bool | functionNameIsValid (const string &name_, int version_numbers[3], bool is_user_defs)
string | convertToValidFunctionName (string name_)
bool | unitNameIsValid (const string &name_)
bool | unitNameIsValid (const char *name_)
bool | unitNameIsValid (const char *name_, int version_numbers[3], bool is_user_defs)
bool | unitNameIsValid (const string &name_, int version_numbers[3], bool is_user_defs)
bool | utf8_pos_is_valid_in_name (char *pos)
string | convertToValidUnitName (string name_)
bool | nameTaken (string name, ExpressionItem *object=NULL)
bool | variableNameTaken (string name, Variable *object=NULL)
bool | unitNameTaken (string name, Unit *object=NULL)
bool | functionNameTaken (string name, MathFunction *object=NULL)
string | getName (string name="", ExpressionItem *object=NULL, bool force=false, bool always_append=false)
Functions for message handling.
void | error (bool critical, const char *TEMPLATE,...)
void | message (MessageType mtype, const char *TEMPLATE,...)
CalculatorMessage * | message ()
CalculatorMessage * | nextMessage ()
bool | showArgumentErrors () const
void | beginTemporaryStopMessages ()
int | endTemporaryStopMessages (int *message_count=NULL, int *warning_count=NULL)
Functions for loading and saving definitions (variables, functions, units, etc.).
bool | loadGlobalDefinitions ()
bool | loadGlobalDefinitions (string filename)
bool | loadGlobalPrefixes ()
bool | loadGlobalCurrencies ()
bool | loadGlobalUnits ()
bool | loadGlobalVariables ()
bool | loadGlobalFunctions ()
bool | loadGlobalDataSets ()
bool | loadLocalDefinitions ()
int | loadDefinitions (const char *file_name, bool is_user_defs=true)
bool | saveDefinitions ()
int | saveDataObjects ()
int | savePrefixes (const char *file_name, bool save_global=false)
int | saveVariables (const char *file_name, bool save_global=false)
int | saveUnits (const char *file_name, bool save_global=false)
int | saveFunctions (const char *file_name, bool save_global=false)
int | saveDataSets (const char *file_name, bool save_global=false)
Functions for CSV file import/export.
bool | importCSV (MathStructure &mstruct, const char *file_name, int first_row=1, string delimiter=",", vector< string > *headers=NULL)
bool | importCSV (const char *file_name, int first_row=1, bool headers=true, string delimiter=",", bool to_matrix=false, string name="", string title="", string category="")
bool | exportCSV (const MathStructure &mstruct, const char *file_name, string delimiter=",")
Functions for exchange rates.
bool | canFetch ()
bool | hasGnomeVFS ()
bool | loadExchangeRates ()
string | getExchangeRatesFileName ()
string | getExchangeRatesUrl ()
bool | fetchExchangeRates (int timeout, string wget_args)
bool | fetchExchangeRates (int timeout=15)
bool | checkExchangeRatesDate ()
Functions for plotting
bool | canPlot ()
MathStructure | expressionToPlotVector (string expression, const MathStructure &min, const MathStructure &max, int steps, MathStructure *x_vector=NULL, string x_var="\\x", const ParseOptions &po=default_parse_options)
MathStructure | expressionToPlotVector (string expression, float min, float max, int steps, MathStructure *x_vector=NULL, string x_var="\\x", const ParseOptions &po=default_parse_options)
MathStructure | expressionToPlotVector (string expression, const MathStructure &min, const MathStructure &max, const MathStructure &step, MathStructure *x_vector=NULL, string x_var="\\x", const ParseOptions &po=default_parse_options)
MathStructure | expressionToPlotVector (string expression, float min, float max, float step, MathStructure *x_vector=NULL, string x_var="\\x", const ParseOptions &po=default_parse_options)
MathStructure | expressionToPlotVector (string expression, const MathStructure &x_vector, string x_var="\\x", const ParseOptions &po=default_parse_options)
bool | plotVectors (PlotParameters *param, const vector< MathStructure > &y_vectors, const vector< MathStructure > &x_vectors, vector< PlotDataParameters * > &pdps, bool persistent=false)
bool | invokeGnuplot (string commands, string commandline_extra="", bool persistent=false)
bool | closeGnuplot ()
bool | gnuplotOpen ()
Functions for global precision
void | setPrecision (int precision=DEFAULT_PRECISION)
int | getPrecision () const
Functions for localization
const string & | getDecimalPoint () const
const string & | getComma () const
void | setLocale ()
void | useDecimalComma ()
void | useDecimalPoint ()
void | unsetLocale ()
string | localToString () const
Functions adding alternative symbols for operators and such
void | addStringAlternative (string replacement, string standard)
bool | delStringAlternative (string replacement, string standard)
void | addDefaultStringAlternative (string replacement, string standard)
bool | delDefaultStringAlternative (string replacement, string standard)
Functions for storing values with associated identifiers
size_t | addId (MathStructure *mstruct, bool persistent=false)
size_t | parseAddId (MathFunction *f, const string &str, const ParseOptions &po, bool persistent=false)
size_t | parseAddIdAppend (MathFunction *f, const MathStructure &append_mstruct, const string &str, const ParseOptions &po, bool persistent=false)
size_t | parseAddVectorId (const string &str, const ParseOptions &po, bool persistent=false)
MathStructure * | getId (size_t id)
void | delId (size_t id)

## Public Attributes

KnownVariable * | v_pi
KnownVariable * | v_e
KnownVariable * | v_i
KnownVariable * | v_inf
KnownVariable * | v_pinf
KnownVariable * | v_minf
KnownVariable * | v_undef
UnknownVariable * | v_x
UnknownVariable * | v_y
UnknownVariable * | v_z
MathFunction * | f_vector
MathFunction * | f_sort
MathFunction * | f_rank
MathFunction * | f_limits
MathFunction * | f_component
MathFunction * | f_dimension
MathFunction * | f_merge_vectors
MathFunction * | f_matrix
MathFunction * | f_matrix_to_vector
MathFunction * | f_area
MathFunction * | f_rows
MathFunction * | f_columns
MathFunction * | f_row
MathFunction * | f_column
MathFunction * | f_elements
MathFunction * | f_element
MathFunction * | f_transpose
MathFunction * | f_identity
MathFunction * | f_determinant
MathFunction * | f_permanent
MathFunction * | f_adjoint
MathFunction * | f_cofactor
MathFunction * | f_inverse
MathFunction * | f_factorial
MathFunction * | f_factorial2
MathFunction * | f_multifactorial
MathFunction * | f_binomial
MathFunction * | f_xor
MathFunction * | f_bitxor
MathFunction * | f_even
MathFunction * | f_odd
MathFunction * | f_shift
MathFunction * | f_abs
MathFunction * | f_gcd
MathFunction * | f_lcm
MathFunction * | f_signum
MathFunction * | f_round
MathFunction * | f_floor
MathFunction * | f_ceil
MathFunction * | f_trunc
MathFunction * | f_int
MathFunction * | f_frac
MathFunction * | f_rem
MathFunction * | f_mod
MathFunction * | f_polynomial_unit
MathFunction * | f_polynomial_primpart
MathFunction * | f_polynomial_content
MathFunction * | f_coeff
MathFunction * | f_lcoeff
MathFunction * | f_tcoeff
MathFunction * | f_degree
MathFunction * | f_ldegree
MathFunction * | f_re
MathFunction * | f_im
MathFunction * | f_arg
MathFunction * | f_numerator
MathFunction * | f_denominator
MathFunction * | f_sqrt
MathFunction * | f_sq
MathFunction * | f_exp
MathFunction * | f_ln
MathFunction * | f_logn
MathFunction * | f_lambert_w
MathFunction * | f_sin
MathFunction * | f_cos
MathFunction * | f_tan
MathFunction * | f_asin
MathFunction * | f_acos
MathFunction * | f_atan
MathFunction * | f_sinh
MathFunction * | f_cosh
MathFunction * | f_tanh
MathFunction * | f_asinh
MathFunction * | f_acosh
MathFunction * | f_atanh
MathFunction * | f_radians_to_default_angle_unit
MathFunction * | f_zeta
MathFunction * | f_gamma
MathFunction * | f_beta
MathFunction * | f_total
MathFunction * | f_percentile
MathFunction * | f_min
MathFunction * | f_max
MathFunction * | f_mode
MathFunction * | f_rand
MathFunction * | f_isodate
MathFunction * | f_localdate
MathFunction * | f_timestamp
MathFunction * | f_stamptodate
MathFunction * | f_days
MathFunction * | f_yearfrac
MathFunction * | f_week
MathFunction * | f_weekday
MathFunction * | f_month
MathFunction * | f_day
MathFunction * | f_year
MathFunction * | f_yearday
MathFunction * | f_time
MathFunction * | f_add_days
MathFunction * | f_add_months
MathFunction * | f_add_years
MathFunction * | f_bin
MathFunction * | f_oct
MathFunction * | f_hex
MathFunction * | f_base
MathFunction * | f_roman
MathFunction * | f_ascii
MathFunction * | f_char
MathFunction * | f_length
MathFunction * | f_concatenate
MathFunction * | f_replace
MathFunction * | f_stripunits
MathFunction * | f_genvector
MathFunction * | f_for
MathFunction * | f_sum
MathFunction * | f_product
MathFunction * | f_process
MathFunction * | f_process_matrix
MathFunction * | f_csum
MathFunction * | f_if
MathFunction * | f_is_number
MathFunction * | f_is_real
MathFunction * | f_is_rational
MathFunction * | f_is_integer
MathFunction * | f_represents_number
MathFunction * | f_represents_real
MathFunction * | f_represents_rational
MathFunction * | f_represents_integer
MathFunction * | f_function
MathFunction * | f_select
MathFunction * | f_diff
MathFunction * | f_integrate
MathFunction * | f_solve
MathFunction * | f_multisolve
MathFunction * | f_error
MathFunction * | f_warning
MathFunction * | f_message
MathFunction * | f_save
MathFunction * | f_load
MathFunction * | f_export
MathFunction * | f_title
MathFunction * | f_register
MathFunction * | f_stack
MathFunction * | f_uncertainty
Unit * | u_rad
Unit * | u_gra
Unit * | u_deg
Unit * | u_euro
DecimalPrefix * | decimal_null_prefix
BinaryPrefix * | binary_null_prefix
bool | place_currency_code_before
bool | place_currency_sign_before
bool | place_currency_code_before_negative
bool | place_currency_sign_before_negative
bool | default_dot_as_separator
bool | b_busy
bool | calculate_thread_stopped
bool | print_thread_stopped
string | expression_to_calculate
string | tmp_print_result
PrintOptions | tmp_printoptions
EvaluationOptions | tmp_evaluationoptions
MathStructure * | tmp_parsedstruct
MathStructure * | tmp_tostruct
MathStructure * | tmp_rpn_mstruct
bool | tmp_maketodivision
int | tmp_proc_command
size_t | tmp_rpnindex
PrintOptions | save_printoptions
vector< Variable * > | variables
vector< MathFunction * > | functions
vector< Unit * > | units
vector< Prefix * > | prefixes
vector< DecimalPrefix * > | decimal_prefixes
vector< BinaryPrefix * > | binary_prefixes

## Protected Member Functions

bool | calculateRPN (MathStructure *mstruct, int command, size_t index, int msecs, const EvaluationOptions &eo)
bool | calculateRPN (string str, int command, size_t index, int msecs, const EvaluationOptions &eo, MathStructure *parsed_struct, MathStructure *to_struct, bool make_to_division)

## Protected Attributes

vector< CalculatorMessage > | messages
int | ianglemode
int | i_precision
char | vbuffer [200]
vector< void * > | ufvl
vector< char > | ufvl_t
vector< size_t > | ufvl_i
vector< void * > | ufv [4][UFV_LENGTHS]
vector< size_t > | ufv_i [4][UFV_LENGTHS]
vector< DataSet * > | data_sets
Sgi::hash_map< size_t, MathStructure * > | id_structs
Sgi::hash_map< size_t, bool > | ids_p
vector< size_t > | freed_ids
size_t | ids_i
vector< string > | signs
vector< string > | real_signs
vector< string > | default_signs
vector< string > | default_real_signs
char * | saved_locale
int | disable_errors_ref
vector< int > | stopped_errors_count
vector< int > | stopped_warnings_count
vector< int > | stopped_messages_count
pthread_t | calculate_thread
pthread_attr_t | calculate_thread_attr
pthread_t | print_thread
pthread_attr_t | print_thread_attr
bool | b_functions_was
bool | b_variables_was
bool | b_units_was
bool | b_unknown_was
bool | b_calcvars_was
bool | b_rpn_was
string | NAME_NUMBER_PRE_S
string | NAME_NUMBER_PRE_STR
string | DOT_STR
string | DOT_S
string | COMMA_S
string | COMMA_STR
string | ILLEGAL_IN_NAMES
string | ILLEGAL_IN_UNITNAMES
string | ILLEGAL_IN_NAMES_MINUS_SPACE_STR
bool | b_argument_errors
bool | exchange_rates_warning_issued
int | has_gnomevfs
bool | b_gnuplot_open
string | gnuplot_cmdline
FILE * | gnuplot_pipe
FILE * | calculate_pipe_r
FILE * | calculate_pipe_w
FILE * | print_pipe_r
FILE * | print_pipe_w
bool | local_to
Assumptions * | default_assumptions
vector< Variable * > | deleted_variables
vector< MathFunction * > | deleted_functions
vector< Unit * > | deleted_units
bool | b_save_called
string | per_str
string | times_str
string | plus_str
string | minus_str
string | and_str
string | AND_str
string | or_str
string | OR_str
string | XOR_str
size_t | per_str_len
size_t | times_str_len
size_t | plus_str_len
size_t | minus_str_len
size_t | and_str_len
size_t | AND_str_len
size_t | or_str_len
size_t | OR_str_len
size_t | XOR_str_len
vector< MathStructure * > | rpn_stack

## Detailed Description

The almighty calculator class.

The calculator class is responsible for loading functions, variables and units, and keeping track of them, as well as parsing expressions and much more. A calculator object must be created before any other Qalculate! class is used. There should never be more than one calculator object, accessed with CALCULATOR.

A simple application using libqalculate need only create a calculator object, perhaps load definitions (functions, variables, units, etc.) and use the calculate function as follows:

     new Calculator();
     CALCULATOR->loadGlobalDefinitions();
     CALCULATOR->loadLocalDefinitions();
     MathStructure result = CALCULATOR->calculate("1 + 1");

## Member Function Documentation

bool Calculator::calculate | ( | MathStructure * | mstruct,
|  | string | str,
|  | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL`,
|  | MathStructure * | to_struct = `NULL`,
|  | bool | make_to_division = `true` |
| ) |  |  |

Calculates an expression. The expression should be unlocalized first with unlocalizeExpression(). This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  `[out]` | mstruct | Math structure to fill with the result.
  | str | Expression.
  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the result of the parsing of the expression.
  `[out]` | to_struct | NULL or a math structure to fill with unit expression parsed after "to".
  | make_to_division | If true, the expression after "to" will be interpreted as a unit epxression to convert the result to.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

MathStructure Calculator::calculate | ( | string | str,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL`,
|  | MathStructure * | to_struct = `NULL`,
|  | bool | make_to_division = `true` |
| ) |  |  |

Calculates an expression. The expression should be unlocalized first with unlocalizeExpression().

Parameters:

  | str | Expression.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the result of the parsing of the expression.
  `[out]` | to_struct | NULL or a math structure to fill with unit expression parsed after "to".
  | make_to_division | If true, the expression after "to" will be interpreted as a unit epxression to convert the result to.

Returns:
  The result of the calculation.

void Calculator::abort | ( |  | ) |

Aborts the current calculation.

void Calculator::abort_this | ( |  | ) |

Aborts the current calculation. Used from within the calculation thread.

bool Calculator::busy | ( |  | ) |

Returns true if the calculate or print thread is busy.

void Calculator::saveState | ( |  | ) |

Saves the state of the calculator. Used internally to be able to restore the state after aborted calculation.

void Calculator::restoreState | ( |  | ) |

Restores the saved state of the calculator. Used internally to restore the state after aborted calculation.

void Calculator::clearBuffers | ( |  | ) |

Clears all stored values. Used internally after aborted calculation.

void Calculator::terminateThreads | ( |  | ) |

Terminate calculation and print threads if started. Do not use to terminate calculation.

bool Calculator::calculateRPNRegister | ( | size_t | index,
|  | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options` |
| ) |  |  |

Evaluates a value on the RPN stack. This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | index | Index, starting at 1, on the RPN stack.
  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

bool Calculator::calculateRPN | ( | MathOperation | op,
|  | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies a mathematical operation to the first and second value on the RPN stack. The the second value is changed with input from the first value. For example, with OPERATION_SUBTRACT the first value is subtracted from the second. The first value on the stack is removed. If not enough registers is available, then zeros are added. This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | op | Operation.
  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

bool Calculator::calculateRPN | ( | MathFunction * | f,
|  | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies a mathematical operation to the first value on the RPN stack. The value is set as the first argument of the function. If no register is available, then zero is added. This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | f | Mathematical function.
  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

bool Calculator::calculateRPNBitwiseNot | ( | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies bitwise not to the first value on the RPN stack. If no register is available, then zero is added. This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

bool Calculator::calculateRPNLogicalNot | ( | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies logical not to the first value on the RPN stack. If no register is available, then zero is added. This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

MathStructure* Calculator::calculateRPN | ( | MathOperation | op,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies a mathematical operation to the first and second value on the RPN stack. The the second value is changed with input from the first value. For example, with OPERATION_SUBTRACT the first value is subtracted from the second. The first value on the stack is removed. If not enough registers is available, then zeros are added.

Parameters:

  | op | Operation.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  The first value on the stack.

MathStructure* Calculator::calculateRPN | ( | MathFunction * | f,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies a mathematical operation to the first value on the RPN stack. The value is set as the first argument of the function. If no register is available, then zero is added.

Parameters:

  | f | Mathematical function.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  The first value on the stack.

MathStructure* Calculator::calculateRPNBitwiseNot | ( | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies bitwise not to the first value on the RPN stack. If no register is available, then zero is added.

Parameters:

  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  The first value on the stack.

MathStructure* Calculator::calculateRPNLogicalNot | ( | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL` |
| ) |  |  |

Applies logical not to the first value on the RPN stack. If no register is available, then zero is added.

Parameters:

  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the unevaluated result.

Returns:
  The first value on the stack.

bool Calculator::RPNStackEnter | ( | MathStructure * | mstruct,
|  | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options` |
| ) |  |  |

Evaluates a value and adds the result first on the RPN stack. This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | mstruct | Value.
  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation of the expression.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

bool Calculator::RPNStackEnter | ( | string | str,
|  | int | msecs,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL`,
|  | MathStructure * | to_struct = `NULL`,
|  | bool | make_to_division = `true` |
| ) |  |  |

Calculates an expression and adds the result first on the RPN stack. The expression should be unlocalized first with unlocalizeExpression(). This function starts the calculation in a separate thread and will return when the calculation has started unless a maximum time has been specified. The calculation can then be stopped with abort().

Parameters:

  | str | Expression.
  | msecs | The maximum time for the calculation in milliseconds. If msecs <= 0 the time will be unlimited.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the result of the parsing of the expression.
  `[out]` | to_struct | NULL or a math structure to fill with unit expression parsed after "to".
  | make_to_division | If true, the expression after "to" will be interpreted as a unit epxression to convert the result to.

Returns:
  true if the calculation was successfully started (and finished if msecs > 0).

void Calculator::RPNStackEnter | ( | MathStructure * | mstruct,
|  | bool | eval = `false`,
|  | const EvaluationOptions & | eo = `default_evaluation_options` |
| ) |  |  |

Adds a value first on the RPN stack.

Parameters:

  | mstruct | Value.
  | eval | If true, the the mathematical structure will be evaluated first.

void Calculator::RPNStackEnter | ( | string | str,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | MathStructure * | parsed_struct = `NULL`,
|  | MathStructure * | to_struct = `NULL`,
|  | bool | make_to_division = `true` |
| ) |  |  |

Calculates an expression adds the result first on the RPN stack. The expression should be unlocalized first with unlocalizeExpression().

Parameters:

  | str | Expression.
  | eo | Options for the evaluation and parsing of the expression.
  `[out]` | parsed_struct | NULL or a math structure to fill with the result of the parsing of the expression.
  `[out]` | to_struct | NULL or a math structure to fill with unit expression parsed after "to".
  | make_to_division | If true, the expression after "to" will be interpreted as a unit epxression to convert the result to.

string Calculator::localizeExpression | ( | string | str | ) | const

Returns a localized expressions. Affects decimal signs and argument separators.

Parameters:

  | str | The expression to localize.

Returns:
  A localized expression.

string Calculator::unlocalizeExpression | ( | string | str,
|  | const ParseOptions & | po = `default_parse_options` |
| ) |  |  | const

Returns an unlocalized expressions. Affects decimal signs and argument separators.

Parameters:

  | str | The expression to unlocalize.

Returns:
  An unlocalized expression.

bool Calculator::separateToExpression | ( | string & | str,
|  | string & | to_str,
|  | const EvaluationOptions & | eo |
| ) |  |  | const

Split an expression string after and before " to ".

Parameters:

  `[out]` | str | The expression. Will be set to the string before " to ".
  `[out]` | to_str | Will be set to the string after " to ".
  | eo | Options for the evaluation and parsing of the expression (nothing will be done if units are not enabled).

Returns:
  true if " to " was found and the expression split.

MathStructure Calculator::parse | ( | string | str,
|  | const ParseOptions & | po = `default_parse_options` |
| ) |  |  |

Parse an expression and place in a MathStructure object.

Parameters:

  | str | Expression
  | po | Parse options.

Returns:
  MathStructure with result of parse.

MathStructure Calculator::convert | ( | const MathStructure & | mstruct,
|  | string | composite_,
|  | const EvaluationOptions & | eo = `default_evaluation_options` |
| ) |  |  |

Converts to a unit expression. The converted value is evaluated.

Parameters:

  | mstruct | The value to convert.
  | composite_ | Unit expression.
  | eo | Evaluation options.

Returns:
  Converted value.

MathStructure Calculator::convert | ( | const MathStructure & | mstruct,
|  | Unit * | to_unit,
|  | const EvaluationOptions & | eo = `default_evaluation_options`,
|  | bool | always_convert = `true` |
| ) |  |  |

Converts to a unit. The converted value is evaluated.

Parameters:

  | mstruct | The value to convert.
  | composite_ | Unit to convert to.
  | eo | Evaluation options.
  | always_convert | ...

Returns:
  Converted value.

void Calculator::setDefaultAssumptions | ( | Assumptions * | ass | ) |

Set assumptions for objects without own assumptions (unknown variables and symbols).

Assumptions* Calculator::defaultAssumptions | ( |  | ) |

Returns the default assumptions for objects without own assumptions (unknown variables and symbols).

Unit* Calculator::getGraUnit | ( |  | ) |

Returns the gradians unit.

Unit* Calculator::getRadUnit | ( |  | ) |

Returns the radians unit.

Unit* Calculator::getDegUnit | ( |  | ) |

Returns the degrees unit.

DecimalPrefix* Calculator::getExactDecimalPrefix | ( | int | exp10,
|  | int | exp = `1` |
| ) |  |  | const

Returns a decimal prefix with exactly the provided value, that fulfils the condition prefix->exponent(exp) == exp10.

Parameters:

  | exp10 | Base-10 exponent of the requested prefix.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if not found.

BinaryPrefix* Calculator::getExactBinaryPrefix | ( | int | exp2,
|  | int | exp = `1` |
| ) |  |  | const

Returns a binary prefix with exactly the provided value, that fulfils the condition prefix->exponent(exp) == exp2.

Parameters:

  | exp2 | Base-2 exponent of the requested prefix.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if not found.

Prefix* Calculator::getExactPrefix | ( | const Number & | o,
|  | int | exp = `1` |
| ) |  |  | const

Returns a prefix with exactly the provided value, that fulfils the condition prefix->value(exp) == o.

Parameters:

  | o | Value of the requested prefix.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if not found.

DecimalPrefix* Calculator::getNearestDecimalPrefix | ( | int | exp10,
|  | int | exp = `1` |
| ) |  |  | const

Returns the nearest decimal prefix for a value.

Parameters:

  | exp10 | Base-10 exponent of the value.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if no decimal prefix is available.

DecimalPrefix* Calculator::getBestDecimalPrefix | ( | int | exp10,
|  | int | exp = `1`,
|  | bool | all_prefixes = `true` |
| ) |  |  | const

Returns the best suited decimal prefix for a value.

Parameters:

  | exp10 | Base-10 exponent of the value.
  | exp | The exponent of the unit.
  | all_prefixes | If false, prefixes which is not a multiple of thousand (centi, deci, deka, hekto) will be skipped.

Returns:
  A prefix or NULL if the unit should be left without prefix.

DecimalPrefix* Calculator::getBestDecimalPrefix | ( | const Number & | exp10,
|  | const Number & | exp,
|  | bool | all_prefixes = `true` |
| ) |  |  | const

Returns the best suited decimal prefix for a value.

Parameters:

  | exp10 | Base-10 exponent of the value.
  | exp | The exponent of the unit.
  | all_prefixes | If false, prefixes which is not a multiple of thousand (centi, deci, deka, hekto) will be skipped.

Returns:
  A prefix or NULL if the unit should be left without prefix.

BinaryPrefix* Calculator::getNearestBinaryPrefix | ( | int | exp2,
|  | int | exp = `1` |
| ) |  |  | const

Returns the nearest binary prefix for a value.

Parameters:

  | exp10 | Base-2 exponent of the value.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if no binary prefix is available.

BinaryPrefix* Calculator::getBestBinaryPrefix | ( | int | exp2,
|  | int | exp = `1` |
| ) |  |  | const

Returns the best suited binary prefix for a value.

Parameters:

  | exp10 | Base-2 exponent of the value.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if the unit should be left without prefix.

BinaryPrefix* Calculator::getBestBinaryPrefix | ( | const Number & | exp2,
|  | const Number & | exp |
| ) |  |  | const

Returns the best suited binary prefix for a value.

Parameters:

  | exp10 | Base-2 exponent of the value.
  | exp | The exponent of the unit.

Returns:
  A prefix or NULL if the unit should be left without prefix.

Prefix* Calculator::addPrefix | ( | Prefix * | p | ) |

Add a new prefix to the calculator.

void Calculator::prefixNameChanged | ( | Prefix * | p,
|  | bool | new_item = `false` |
| ) |  |  |

Used internally.

bool Calculator::hasVariable | ( | Variable * | v | ) |

Checks if a variable exists/is registered in the calculator.

bool Calculator::hasUnit | ( | Unit * | u | ) |

Checks if a unit exists/is registered in the calculator.

bool Calculator::hasFunction | ( | MathFunction * | f | ) |

Checks if a function exists/is registered in the calculator.

bool Calculator::stillHasVariable | ( | Variable * | v | ) |

Checks if a pointer points to a variable that still exists in the calculator. As opposed to hasFunction(), this function only checks if the mathematical function has been deleted.

bool Calculator::stillHasUnit | ( | Unit * | u | ) |

Checks if a pointer points to a unit that still exists in the calculator. As opposed to hasUnit(), this function only checks if the unit has been deleted.

bool Calculator::stillHasFunction | ( | MathFunction * | f | ) |

Checks if a pointer points to a mathematical function that still exists in the calculator. As opposed to hasFunction(), this function only checks if the mathematical function has been deleted.

Prefix* Calculator::getPrefix | ( | size_t | index | ) | const

Returns prefix for an index (starting at zero). All prefixes can be traversed by starting at index zero and increasing the index until NULL is returned.

Parameters:

  | index | Index of prefix.

Returns:
  Prefix for index or NULL if not found.

Prefix* Calculator::getPrefix | ( | string | name_ | ) | const

Returns prefix with provided name.

Parameters:

  | name_ | Name of prefix to retrieve.

Returns:
  Prefix with provided name or NULL if not found.

Variable* Calculator::getVariable | ( | size_t | index | ) | const

Returns variable for an index (starting at zero). All variables can be traversed by starting at index zero and increasing the index until NULL is returned.

Parameters:

  | index | Index of variable.

Returns:
  Variable for index or NULL if not found.

Unit* Calculator::getUnit | ( | size_t | index | ) | const

Returns unit for an index (starting at zero). All units can be traversed by starting at index zero and increasing the index until NULL is returned.

Parameters:

  | index | Index of unit.

Returns:
  Unit for index or NULL if not found.

MathFunction* Calculator::getFunction | ( | size_t | index | ) | const

Returns function for an index (starting at zero). All functions can be traversed by starting at index zero and increasing the index until NULL is returned.

Parameters:

  | index | Index of function.

Returns:
  Function for index or NULL if not found.

void Calculator::resetVariables | ( |  | ) |

Unloads all non-builtin variables.

void Calculator::resetFunctions | ( |  | ) |

Unloads all non-builtin functions.

void Calculator::resetUnits | ( |  | ) |

Unloads all non-builtin units.

void Calculator::reset | ( |  | ) |

Unloads all non-builtin variables, functions and units.

void Calculator::addBuiltinVariables | ( |  | ) |

Adds builtin variables. Called automatically when the calculator is created.

void Calculator::addBuiltinFunctions | ( |  | ) |

Adds builtin functions. Called automatically when the calculator is created.

void Calculator::addBuiltinUnits | ( |  | ) |

Adds builtin units. Called automatically when the calculator is created.

bool Calculator::variableNameIsValid | ( | const string & | name_ | ) |

Tests if a name is valid for a variable.

Parameters:

  | name_ | Variable name.

Returns:
  true if the name is valid for a variable.

bool Calculator::variableNameIsValid | ( | const char * | name_ | ) |

Tests if a name is valid for a variable.

Parameters:

  | name_ | Variable name.

Returns:
  true if the name is valid for a variable.

bool Calculator::nameTaken | ( | string | name,
|  | ExpressionItem * | object = `NULL` |
| ) |  |  |

Checks if a name is used by another object which is not allowed to have the same name.

Parameters:

  | name | Name.
  | object | Object to exclude from check.

Returns:
  true if the name is used.

void Calculator::message | ( | MessageType | mtype,
|  | const char * | TEMPLATE,
|  |  | ... |
| ) |  |  |

Put a message in the message queue.

CalculatorMessage* Calculator::message | ( |  | ) |

Returns the first message in queue.

CalculatorMessage* Calculator::nextMessage | ( |  | ) |

Removes the first message in queue and returns the next.

bool Calculator::loadGlobalDefinitions | ( |  | ) |

Load all standard global (system wide) definitions from the global data directory ($PREFIX/share/qalculate).

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalDefinitions | ( | string | filename | ) |

Load global (system wide) definitions from a file in the global data directory ($PREFIX/share/qalculate).

Parameters:

  | filename | Name of the file in the global data directory.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalPrefixes | ( |  | ) |

Load prefixes.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalCurrencies | ( |  | ) |

Load currencies.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalUnits | ( |  | ) |

Load units.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalVariables | ( |  | ) |

Load variables.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalFunctions | ( |  | ) |

Load functions.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadGlobalDataSets | ( |  | ) |

Load data sets.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::loadLocalDefinitions | ( |  | ) |

Load local, user specific, definitions from the local definitions directory (~/.qalculate/definitions). All files in the directory and in the datasets subdirectory are loaded.

Returns:
  true if the definitions were successfully loaded.

int Calculator::loadDefinitions | ( | const char * | file_name,
|  | bool | is_user_defs = `true` |
| ) |  |  |

Load definitions from a file.

Parameters:

  | file_name | The path to the file to load.
  | is_user_defs | true if the definitions are local, false if they are global.

Returns:
  true if the definitions were successfully loaded.

bool Calculator::saveDefinitions | ( |  | ) |

Save local definitions to ~/.qalculate/definitions/

Returns:
  true if definitions was successfully saved.

bool Calculator::canFetch | ( |  | ) |

Checks if gnomevfs-copy or wget is available for downloading exchange rates from the Internet.

Returns:
  true if gnomevfs-copy or wget was found.

bool Calculator::hasGnomeVFS | ( |  | ) |

Checks if gnomevfs-copy available.

Returns:
  true if gnomevfs-copy was found.

bool Calculator::loadExchangeRates | ( |  | ) |

Load saved (local) currency units and exchange rates.

Returns:
  true if operation successful.

string Calculator::getExchangeRatesFileName | ( |  | ) |

Name of the exchange rates file on local disc.

Returns:
  name of local exchange rates file.

string Calculator::getExchangeRatesUrl | ( |  | ) |

Url of the exchange rates file on the Internet.

Returns:
  Url of exchange rates file.

bool Calculator::fetchExchangeRates | ( | int | timeout,
|  | string | wget_args |
| ) |  |  |

Download current exchange rates from the Internet to local disc.

Parameters:

  | timeout | Timeout for donwload try (only used by wget)
  | wget_args | Extra arguments to pass to wget.

Returns:
  true if operation was successful.

bool Calculator::fetchExchangeRates | ( | int | timeout = `15` | ) |

Download current exchange rates from the Internet to local disc with default wget arguments.

Parameters:

  | timeout | Timeout for donwload try (only used by wget)

Returns:
  true if operation was successful.

bool Calculator::checkExchangeRatesDate | ( |  | ) |

Returns true if the exchange rates on local disc is older than one week.

bool Calculator::canPlot | ( |  | ) |

Checks if gnuplot is available.

Returns:
  true if gnuplot was found.

void Calculator::setPrecision | ( | int | precision = `DEFAULT_PRECISION` | ) |

Set default precision for approximate calculations.

Parameters:

  | precision | Precision.

int Calculator::getPrecision | ( |  | ) | const

Returns default precision for approximate calculations.

const string& Calculator::getDecimalPoint | ( |  | ) | const

Returns the preferred decimal point character.

const string& Calculator::getComma | ( |  | ) | const

Returns the preferred comma character for separating arguments.

void Calculator::setLocale | ( |  | ) |

Sets argument separator and decimal sign from the current locale. Mainly for internal use.

void Calculator::unsetLocale | ( |  | ) |

Resets argument separator and decimal sign. Mainly for internal use.

string Calculator::localToString | ( |  | ) | const

Returns the translated text string used in expressions for converting to a specific unit expression (ex "5 meters to feet.

size_t Calculator::addId | ( | MathStructure * | mstruct,
|  | bool | persistent = `false` |
| ) |  |  |

Stores a value with an associated id. Mainly for internal use.

Parameters:

  | mstruct | The value to store.
  | persistent | If false the values will be removed from storage when retrieved with getId().

Returns:
  Storage id.

size_t Calculator::parseAddId | ( | MathFunction * | f,
|  | const string & | str,
|  | const ParseOptions & | po,
|  | bool | persistent = `false` |
| ) |  |  |

Stores a function value with arguments parsed from a text string using Function::parse(), with an associated id. Mainly for internal use.

Parameters:

  | f | Mathematical function.
  | str | Arguments.
  | po | Parse options.
  | persistent | If false the values will be removed from storage when retrieved with getId().

Returns:
  Storage id.

MathStructure* Calculator::getId | ( | size_t | id | ) |

Returns a stored value. Mainly for internal use.

Parameters:

  | id | Storage id.

Returns:
  A stored value.

void Calculator::delId | ( | size_t | id | ) |

Removes and unreferences (value->unref() will be called) a value from storage. Mainly for internal use.

Parameters:

  | id | Storage id.

The documentation for this class was generated from the following file:

- libqalculate/Calculator.h