/* libcalculator.h generated by valac 0.40.6, the Vala compiler, do not modify */


#ifndef __LIBCALCULATOR_H__
#define __LIBCALCULATOR_H__

#include <glib.h>
#include "mpfr.h"
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gtksourceview/gtksource.h>
#include <float.h>
#include <math.h>

G_BEGIN_DECLS

typedef struct _MPFRRealRef MPFRRealRef;

#define TYPE_CURRENCY_MANAGER (currency_manager_get_type ())
#define CURRENCY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CURRENCY_MANAGER, CurrencyManager))
#define CURRENCY_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CURRENCY_MANAGER, CurrencyManagerClass))
#define IS_CURRENCY_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CURRENCY_MANAGER))
#define IS_CURRENCY_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CURRENCY_MANAGER))
#define CURRENCY_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CURRENCY_MANAGER, CurrencyManagerClass))

typedef struct _CurrencyManager CurrencyManager;
typedef struct _CurrencyManagerClass CurrencyManagerClass;
typedef struct _CurrencyManagerPrivate CurrencyManagerPrivate;

#define TYPE_CURRENCY (currency_get_type ())
#define CURRENCY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CURRENCY, Currency))
#define CURRENCY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CURRENCY, CurrencyClass))
#define IS_CURRENCY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CURRENCY))
#define IS_CURRENCY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CURRENCY))
#define CURRENCY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CURRENCY, CurrencyClass))

typedef struct _Currency Currency;
typedef struct _CurrencyClass CurrencyClass;

#define TYPE_NUMBER (number_get_type ())
#define NUMBER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NUMBER, Number))
#define NUMBER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NUMBER, NumberClass))
#define IS_NUMBER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NUMBER))
#define IS_NUMBER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NUMBER))
#define NUMBER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NUMBER, NumberClass))

typedef struct _Number Number;
typedef struct _NumberClass NumberClass;
typedef struct _CurrencyPrivate CurrencyPrivate;

#define TYPE_ERROR_CODE (error_code_get_type ())

#define TYPE_EQUATION (equation_get_type ())
#define EQUATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_EQUATION, Equation))
#define EQUATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_EQUATION, EquationClass))
#define IS_EQUATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_EQUATION))
#define IS_EQUATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_EQUATION))
#define EQUATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_EQUATION, EquationClass))

typedef struct _Equation Equation;
typedef struct _EquationClass EquationClass;
typedef struct _EquationPrivate EquationPrivate;

#define TYPE_ANGLE_UNIT (angle_unit_get_type ())

#define TYPE_LEXER_TOKEN_TYPE (lexer_token_type_get_type ())

#define TYPE_PRE_LEXER (pre_lexer_get_type ())
#define PRE_LEXER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PRE_LEXER, PreLexer))
#define PRE_LEXER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PRE_LEXER, PreLexerClass))
#define IS_PRE_LEXER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PRE_LEXER))
#define IS_PRE_LEXER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PRE_LEXER))
#define PRE_LEXER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PRE_LEXER, PreLexerClass))

typedef struct _PreLexer PreLexer;
typedef struct _PreLexerClass PreLexerClass;
typedef struct _PreLexerPrivate PreLexerPrivate;

#define TYPE_LEXER_TOKEN (lexer_token_get_type ())
#define LEXER_TOKEN(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LEXER_TOKEN, LexerToken))
#define LEXER_TOKEN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LEXER_TOKEN, LexerTokenClass))
#define IS_LEXER_TOKEN(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LEXER_TOKEN))
#define IS_LEXER_TOKEN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LEXER_TOKEN))
#define LEXER_TOKEN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LEXER_TOKEN, LexerTokenClass))

typedef struct _LexerToken LexerToken;
typedef struct _LexerTokenClass LexerTokenClass;
typedef struct _LexerTokenPrivate LexerTokenPrivate;

#define TYPE_LEXER (lexer_get_type ())
#define LEXER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LEXER, Lexer))
#define LEXER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LEXER, LexerClass))
#define IS_LEXER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LEXER))
#define IS_LEXER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LEXER))
#define LEXER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LEXER, LexerClass))

typedef struct _Lexer Lexer;
typedef struct _LexerClass LexerClass;
typedef struct _LexerPrivate LexerPrivate;

#define TYPE_PARSER (parser_get_type ())
#define PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PARSER, Parser))
#define PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PARSER, ParserClass))
#define IS_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PARSER))
#define IS_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PARSER))
#define PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PARSER, ParserClass))

typedef struct _Parser Parser;
typedef struct _ParserClass ParserClass;

#define TYPE_ASSOCIATIVITY (associativity_get_type ())

#define TYPE_PARSE_NODE (parse_node_get_type ())
#define PARSE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PARSE_NODE, ParseNode))
#define PARSE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PARSE_NODE, ParseNodeClass))
#define IS_PARSE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PARSE_NODE))
#define IS_PARSE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PARSE_NODE))
#define PARSE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PARSE_NODE, ParseNodeClass))

typedef struct _ParseNode ParseNode;
typedef struct _ParseNodeClass ParseNodeClass;
typedef struct _ParseNodePrivate ParseNodePrivate;

#define TYPE_RNODE (rnode_get_type ())
#define RNODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_RNODE, RNode))
#define RNODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_RNODE, RNodeClass))
#define IS_RNODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_RNODE))
#define IS_RNODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_RNODE))
#define RNODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_RNODE, RNodeClass))

typedef struct _RNode RNode;
typedef struct _RNodeClass RNodeClass;
typedef struct _RNodePrivate RNodePrivate;

#define TYPE_LR_NODE (lr_node_get_type ())
#define LR_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_LR_NODE, LRNode))
#define LR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_LR_NODE, LRNodeClass))
#define IS_LR_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_LR_NODE))
#define IS_LR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_LR_NODE))
#define LR_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_LR_NODE, LRNodeClass))

typedef struct _LRNode LRNode;
typedef struct _LRNodeClass LRNodeClass;
typedef struct _LRNodePrivate LRNodePrivate;

#define TYPE_CONSTANT_NODE (constant_node_get_type ())
#define CONSTANT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CONSTANT_NODE, ConstantNode))
#define CONSTANT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CONSTANT_NODE, ConstantNodeClass))
#define IS_CONSTANT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CONSTANT_NODE))
#define IS_CONSTANT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CONSTANT_NODE))
#define CONSTANT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CONSTANT_NODE, ConstantNodeClass))

typedef struct _ConstantNode ConstantNode;
typedef struct _ConstantNodeClass ConstantNodeClass;
typedef struct _ConstantNodePrivate ConstantNodePrivate;

#define TYPE_ASSIGN_NODE (assign_node_get_type ())
#define ASSIGN_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ASSIGN_NODE, AssignNode))
#define ASSIGN_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ASSIGN_NODE, AssignNodeClass))
#define IS_ASSIGN_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ASSIGN_NODE))
#define IS_ASSIGN_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ASSIGN_NODE))
#define ASSIGN_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ASSIGN_NODE, AssignNodeClass))

typedef struct _AssignNode AssignNode;
typedef struct _AssignNodeClass AssignNodeClass;
typedef struct _AssignNodePrivate AssignNodePrivate;

#define TYPE_ASSIGN_FUNCTION_NODE (assign_function_node_get_type ())
#define ASSIGN_FUNCTION_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ASSIGN_FUNCTION_NODE, AssignFunctionNode))
#define ASSIGN_FUNCTION_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ASSIGN_FUNCTION_NODE, AssignFunctionNodeClass))
#define IS_ASSIGN_FUNCTION_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ASSIGN_FUNCTION_NODE))
#define IS_ASSIGN_FUNCTION_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ASSIGN_FUNCTION_NODE))
#define ASSIGN_FUNCTION_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ASSIGN_FUNCTION_NODE, AssignFunctionNodeClass))

typedef struct _AssignFunctionNode AssignFunctionNode;
typedef struct _AssignFunctionNodeClass AssignFunctionNodeClass;
typedef struct _AssignFunctionNodePrivate AssignFunctionNodePrivate;

#define TYPE_NAME_NODE (name_node_get_type ())
#define NAME_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NAME_NODE, NameNode))
#define NAME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NAME_NODE, NameNodeClass))
#define IS_NAME_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NAME_NODE))
#define IS_NAME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NAME_NODE))
#define NAME_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NAME_NODE, NameNodeClass))

typedef struct _NameNode NameNode;
typedef struct _NameNodeClass NameNodeClass;
typedef struct _NameNodePrivate NameNodePrivate;

#define TYPE_VARIABLE_NODE (variable_node_get_type ())
#define VARIABLE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_VARIABLE_NODE, VariableNode))
#define VARIABLE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_VARIABLE_NODE, VariableNodeClass))
#define IS_VARIABLE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_VARIABLE_NODE))
#define IS_VARIABLE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_VARIABLE_NODE))
#define VARIABLE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_VARIABLE_NODE, VariableNodeClass))

typedef struct _VariableNode VariableNode;
typedef struct _VariableNodeClass VariableNodeClass;
typedef struct _VariableNodePrivate VariableNodePrivate;

#define TYPE_VARIABLE_WITH_POWER_NODE (variable_with_power_node_get_type ())
#define VARIABLE_WITH_POWER_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_VARIABLE_WITH_POWER_NODE, VariableWithPowerNode))
#define VARIABLE_WITH_POWER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_VARIABLE_WITH_POWER_NODE, VariableWithPowerNodeClass))
#define IS_VARIABLE_WITH_POWER_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_VARIABLE_WITH_POWER_NODE))
#define IS_VARIABLE_WITH_POWER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_VARIABLE_WITH_POWER_NODE))
#define VARIABLE_WITH_POWER_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_VARIABLE_WITH_POWER_NODE, VariableWithPowerNodeClass))

typedef struct _VariableWithPowerNode VariableWithPowerNode;
typedef struct _VariableWithPowerNodeClass VariableWithPowerNodeClass;
typedef struct _VariableWithPowerNodePrivate VariableWithPowerNodePrivate;

#define TYPE_FUNCTION_NAME_NODE (function_name_node_get_type ())
#define FUNCTION_NAME_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FUNCTION_NAME_NODE, FunctionNameNode))
#define FUNCTION_NAME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FUNCTION_NAME_NODE, FunctionNameNodeClass))
#define IS_FUNCTION_NAME_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FUNCTION_NAME_NODE))
#define IS_FUNCTION_NAME_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FUNCTION_NAME_NODE))
#define FUNCTION_NAME_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FUNCTION_NAME_NODE, FunctionNameNodeClass))

typedef struct _FunctionNameNode FunctionNameNode;
typedef struct _FunctionNameNodeClass FunctionNameNodeClass;
typedef struct _FunctionNameNodePrivate FunctionNameNodePrivate;

#define TYPE_FUNCTION_ARGUMENTS_NODE (function_arguments_node_get_type ())
#define FUNCTION_ARGUMENTS_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FUNCTION_ARGUMENTS_NODE, FunctionArgumentsNode))
#define FUNCTION_ARGUMENTS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FUNCTION_ARGUMENTS_NODE, FunctionArgumentsNodeClass))
#define IS_FUNCTION_ARGUMENTS_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FUNCTION_ARGUMENTS_NODE))
#define IS_FUNCTION_ARGUMENTS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FUNCTION_ARGUMENTS_NODE))
#define FUNCTION_ARGUMENTS_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FUNCTION_ARGUMENTS_NODE, FunctionArgumentsNodeClass))

typedef struct _FunctionArgumentsNode FunctionArgumentsNode;
typedef struct _FunctionArgumentsNodeClass FunctionArgumentsNodeClass;
typedef struct _FunctionArgumentsNodePrivate FunctionArgumentsNodePrivate;

#define TYPE_FUNCTION_DESCRIPTION_NODE (function_description_node_get_type ())
#define FUNCTION_DESCRIPTION_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FUNCTION_DESCRIPTION_NODE, FunctionDescriptionNode))
#define FUNCTION_DESCRIPTION_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FUNCTION_DESCRIPTION_NODE, FunctionDescriptionNodeClass))
#define IS_FUNCTION_DESCRIPTION_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FUNCTION_DESCRIPTION_NODE))
#define IS_FUNCTION_DESCRIPTION_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FUNCTION_DESCRIPTION_NODE))
#define FUNCTION_DESCRIPTION_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FUNCTION_DESCRIPTION_NODE, FunctionDescriptionNodeClass))

typedef struct _FunctionDescriptionNode FunctionDescriptionNode;
typedef struct _FunctionDescriptionNodeClass FunctionDescriptionNodeClass;
typedef struct _FunctionDescriptionNodePrivate FunctionDescriptionNodePrivate;

#define TYPE_FUNCTION_NODE (function_node_get_type ())
#define FUNCTION_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FUNCTION_NODE, FunctionNode))
#define FUNCTION_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FUNCTION_NODE, FunctionNodeClass))
#define IS_FUNCTION_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FUNCTION_NODE))
#define IS_FUNCTION_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FUNCTION_NODE))
#define FUNCTION_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FUNCTION_NODE, FunctionNodeClass))

typedef struct _FunctionNode FunctionNode;
typedef struct _FunctionNodeClass FunctionNodeClass;
typedef struct _FunctionNodePrivate FunctionNodePrivate;

#define TYPE_UNARY_MINUS_NODE (unary_minus_node_get_type ())
#define UNARY_MINUS_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UNARY_MINUS_NODE, UnaryMinusNode))
#define UNARY_MINUS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_UNARY_MINUS_NODE, UnaryMinusNodeClass))
#define IS_UNARY_MINUS_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UNARY_MINUS_NODE))
#define IS_UNARY_MINUS_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_UNARY_MINUS_NODE))
#define UNARY_MINUS_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_UNARY_MINUS_NODE, UnaryMinusNodeClass))

typedef struct _UnaryMinusNode UnaryMinusNode;
typedef struct _UnaryMinusNodeClass UnaryMinusNodeClass;
typedef struct _UnaryMinusNodePrivate UnaryMinusNodePrivate;

#define TYPE_ABSOLUTE_VALUE_NODE (absolute_value_node_get_type ())
#define ABSOLUTE_VALUE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ABSOLUTE_VALUE_NODE, AbsoluteValueNode))
#define ABSOLUTE_VALUE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ABSOLUTE_VALUE_NODE, AbsoluteValueNodeClass))
#define IS_ABSOLUTE_VALUE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ABSOLUTE_VALUE_NODE))
#define IS_ABSOLUTE_VALUE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ABSOLUTE_VALUE_NODE))
#define ABSOLUTE_VALUE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ABSOLUTE_VALUE_NODE, AbsoluteValueNodeClass))

typedef struct _AbsoluteValueNode AbsoluteValueNode;
typedef struct _AbsoluteValueNodeClass AbsoluteValueNodeClass;
typedef struct _AbsoluteValueNodePrivate AbsoluteValueNodePrivate;

#define TYPE_FLOOR_NODE (floor_node_get_type ())
#define FLOOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FLOOR_NODE, FloorNode))
#define FLOOR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FLOOR_NODE, FloorNodeClass))
#define IS_FLOOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FLOOR_NODE))
#define IS_FLOOR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FLOOR_NODE))
#define FLOOR_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FLOOR_NODE, FloorNodeClass))

typedef struct _FloorNode FloorNode;
typedef struct _FloorNodeClass FloorNodeClass;
typedef struct _FloorNodePrivate FloorNodePrivate;

#define TYPE_CEILING_NODE (ceiling_node_get_type ())
#define CEILING_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CEILING_NODE, CeilingNode))
#define CEILING_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CEILING_NODE, CeilingNodeClass))
#define IS_CEILING_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CEILING_NODE))
#define IS_CEILING_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CEILING_NODE))
#define CEILING_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CEILING_NODE, CeilingNodeClass))

typedef struct _CeilingNode CeilingNode;
typedef struct _CeilingNodeClass CeilingNodeClass;
typedef struct _CeilingNodePrivate CeilingNodePrivate;

#define TYPE_FRACTIONAL_COMPONENT_NODE (fractional_component_node_get_type ())
#define FRACTIONAL_COMPONENT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FRACTIONAL_COMPONENT_NODE, FractionalComponentNode))
#define FRACTIONAL_COMPONENT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FRACTIONAL_COMPONENT_NODE, FractionalComponentNodeClass))
#define IS_FRACTIONAL_COMPONENT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FRACTIONAL_COMPONENT_NODE))
#define IS_FRACTIONAL_COMPONENT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FRACTIONAL_COMPONENT_NODE))
#define FRACTIONAL_COMPONENT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FRACTIONAL_COMPONENT_NODE, FractionalComponentNodeClass))

typedef struct _FractionalComponentNode FractionalComponentNode;
typedef struct _FractionalComponentNodeClass FractionalComponentNodeClass;
typedef struct _FractionalComponentNodePrivate FractionalComponentNodePrivate;

#define TYPE_ROUND_NODE (round_node_get_type ())
#define ROUND_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ROUND_NODE, RoundNode))
#define ROUND_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ROUND_NODE, RoundNodeClass))
#define IS_ROUND_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ROUND_NODE))
#define IS_ROUND_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ROUND_NODE))
#define ROUND_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ROUND_NODE, RoundNodeClass))

typedef struct _RoundNode RoundNode;
typedef struct _RoundNodeClass RoundNodeClass;
typedef struct _RoundNodePrivate RoundNodePrivate;

#define TYPE_PERCENT_NODE (percent_node_get_type ())
#define PERCENT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_PERCENT_NODE, PercentNode))
#define PERCENT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_PERCENT_NODE, PercentNodeClass))
#define IS_PERCENT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_PERCENT_NODE))
#define IS_PERCENT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_PERCENT_NODE))
#define PERCENT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_PERCENT_NODE, PercentNodeClass))

typedef struct _PercentNode PercentNode;
typedef struct _PercentNodeClass PercentNodeClass;
typedef struct _PercentNodePrivate PercentNodePrivate;

#define TYPE_FACTORIAL_NODE (factorial_node_get_type ())
#define FACTORIAL_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FACTORIAL_NODE, FactorialNode))
#define FACTORIAL_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FACTORIAL_NODE, FactorialNodeClass))
#define IS_FACTORIAL_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FACTORIAL_NODE))
#define IS_FACTORIAL_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FACTORIAL_NODE))
#define FACTORIAL_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FACTORIAL_NODE, FactorialNodeClass))

typedef struct _FactorialNode FactorialNode;
typedef struct _FactorialNodeClass FactorialNodeClass;
typedef struct _FactorialNodePrivate FactorialNodePrivate;

#define TYPE_ADD_NODE (add_node_get_type ())
#define ADD_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ADD_NODE, AddNode))
#define ADD_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ADD_NODE, AddNodeClass))
#define IS_ADD_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ADD_NODE))
#define IS_ADD_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ADD_NODE))
#define ADD_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ADD_NODE, AddNodeClass))

typedef struct _AddNode AddNode;
typedef struct _AddNodeClass AddNodeClass;
typedef struct _AddNodePrivate AddNodePrivate;

#define TYPE_SUBTRACT_NODE (subtract_node_get_type ())
#define SUBTRACT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SUBTRACT_NODE, SubtractNode))
#define SUBTRACT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SUBTRACT_NODE, SubtractNodeClass))
#define IS_SUBTRACT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SUBTRACT_NODE))
#define IS_SUBTRACT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SUBTRACT_NODE))
#define SUBTRACT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SUBTRACT_NODE, SubtractNodeClass))

typedef struct _SubtractNode SubtractNode;
typedef struct _SubtractNodeClass SubtractNodeClass;
typedef struct _SubtractNodePrivate SubtractNodePrivate;

#define TYPE_MULTIPLY_NODE (multiply_node_get_type ())
#define MULTIPLY_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MULTIPLY_NODE, MultiplyNode))
#define MULTIPLY_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MULTIPLY_NODE, MultiplyNodeClass))
#define IS_MULTIPLY_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MULTIPLY_NODE))
#define IS_MULTIPLY_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MULTIPLY_NODE))
#define MULTIPLY_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MULTIPLY_NODE, MultiplyNodeClass))

typedef struct _MultiplyNode MultiplyNode;
typedef struct _MultiplyNodeClass MultiplyNodeClass;
typedef struct _MultiplyNodePrivate MultiplyNodePrivate;

#define TYPE_DIVIDE_NODE (divide_node_get_type ())
#define DIVIDE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_DIVIDE_NODE, DivideNode))
#define DIVIDE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_DIVIDE_NODE, DivideNodeClass))
#define IS_DIVIDE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_DIVIDE_NODE))
#define IS_DIVIDE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_DIVIDE_NODE))
#define DIVIDE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_DIVIDE_NODE, DivideNodeClass))

typedef struct _DivideNode DivideNode;
typedef struct _DivideNodeClass DivideNodeClass;
typedef struct _DivideNodePrivate DivideNodePrivate;

#define TYPE_MODULUS_DIVIDE_NODE (modulus_divide_node_get_type ())
#define MODULUS_DIVIDE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MODULUS_DIVIDE_NODE, ModulusDivideNode))
#define MODULUS_DIVIDE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MODULUS_DIVIDE_NODE, ModulusDivideNodeClass))
#define IS_MODULUS_DIVIDE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MODULUS_DIVIDE_NODE))
#define IS_MODULUS_DIVIDE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MODULUS_DIVIDE_NODE))
#define MODULUS_DIVIDE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MODULUS_DIVIDE_NODE, ModulusDivideNodeClass))

typedef struct _ModulusDivideNode ModulusDivideNode;
typedef struct _ModulusDivideNodeClass ModulusDivideNodeClass;
typedef struct _ModulusDivideNodePrivate ModulusDivideNodePrivate;

#define TYPE_ROOT_NODE (root_node_get_type ())
#define ROOT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_ROOT_NODE, RootNode))
#define ROOT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_ROOT_NODE, RootNodeClass))
#define IS_ROOT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_ROOT_NODE))
#define IS_ROOT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_ROOT_NODE))
#define ROOT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_ROOT_NODE, RootNodeClass))

typedef struct _RootNode RootNode;
typedef struct _RootNodeClass RootNodeClass;
typedef struct _RootNodePrivate RootNodePrivate;

#define TYPE_XPOW_YNODE (xpow_ynode_get_type ())
#define XPOW_YNODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_XPOW_YNODE, XPowYNode))
#define XPOW_YNODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_XPOW_YNODE, XPowYNodeClass))
#define IS_XPOW_YNODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_XPOW_YNODE))
#define IS_XPOW_YNODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_XPOW_YNODE))
#define XPOW_YNODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_XPOW_YNODE, XPowYNodeClass))

typedef struct _XPowYNode XPowYNode;
typedef struct _XPowYNodeClass XPowYNodeClass;
typedef struct _XPowYNodePrivate XPowYNodePrivate;

#define TYPE_XPOW_YINTEGER_NODE (xpow_yinteger_node_get_type ())
#define XPOW_YINTEGER_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_XPOW_YINTEGER_NODE, XPowYIntegerNode))
#define XPOW_YINTEGER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_XPOW_YINTEGER_NODE, XPowYIntegerNodeClass))
#define IS_XPOW_YINTEGER_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_XPOW_YINTEGER_NODE))
#define IS_XPOW_YINTEGER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_XPOW_YINTEGER_NODE))
#define XPOW_YINTEGER_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_XPOW_YINTEGER_NODE, XPowYIntegerNodeClass))

typedef struct _XPowYIntegerNode XPowYIntegerNode;
typedef struct _XPowYIntegerNodeClass XPowYIntegerNodeClass;
typedef struct _XPowYIntegerNodePrivate XPowYIntegerNodePrivate;

#define TYPE_NOT_NODE (not_node_get_type ())
#define NOT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_NOT_NODE, NotNode))
#define NOT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_NOT_NODE, NotNodeClass))
#define IS_NOT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_NOT_NODE))
#define IS_NOT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_NOT_NODE))
#define NOT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_NOT_NODE, NotNodeClass))

typedef struct _NotNode NotNode;
typedef struct _NotNodeClass NotNodeClass;
typedef struct _NotNodePrivate NotNodePrivate;

#define TYPE_AND_NODE (and_node_get_type ())
#define AND_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_AND_NODE, AndNode))
#define AND_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_AND_NODE, AndNodeClass))
#define IS_AND_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_AND_NODE))
#define IS_AND_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_AND_NODE))
#define AND_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_AND_NODE, AndNodeClass))

typedef struct _AndNode AndNode;
typedef struct _AndNodeClass AndNodeClass;
typedef struct _AndNodePrivate AndNodePrivate;

#define TYPE_OR_NODE (or_node_get_type ())
#define OR_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_OR_NODE, OrNode))
#define OR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_OR_NODE, OrNodeClass))
#define IS_OR_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_OR_NODE))
#define IS_OR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_OR_NODE))
#define OR_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_OR_NODE, OrNodeClass))

typedef struct _OrNode OrNode;
typedef struct _OrNodeClass OrNodeClass;
typedef struct _OrNodePrivate OrNodePrivate;

#define TYPE_XOR_NODE (xor_node_get_type ())
#define XOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_XOR_NODE, XorNode))
#define XOR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_XOR_NODE, XorNodeClass))
#define IS_XOR_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_XOR_NODE))
#define IS_XOR_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_XOR_NODE))
#define XOR_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_XOR_NODE, XorNodeClass))

typedef struct _XorNode XorNode;
typedef struct _XorNodeClass XorNodeClass;
typedef struct _XorNodePrivate XorNodePrivate;

#define TYPE_CONVERT_NODE (convert_node_get_type ())
#define CONVERT_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CONVERT_NODE, ConvertNode))
#define CONVERT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CONVERT_NODE, ConvertNodeClass))
#define IS_CONVERT_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CONVERT_NODE))
#define IS_CONVERT_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CONVERT_NODE))
#define CONVERT_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CONVERT_NODE, ConvertNodeClass))

typedef struct _ConvertNode ConvertNode;
typedef struct _ConvertNodeClass ConvertNodeClass;
typedef struct _ConvertNodePrivate ConvertNodePrivate;

#define TYPE_CONVERT_BASE_NODE (convert_base_node_get_type ())
#define CONVERT_BASE_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CONVERT_BASE_NODE, ConvertBaseNode))
#define CONVERT_BASE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CONVERT_BASE_NODE, ConvertBaseNodeClass))
#define IS_CONVERT_BASE_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CONVERT_BASE_NODE))
#define IS_CONVERT_BASE_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CONVERT_BASE_NODE))
#define CONVERT_BASE_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CONVERT_BASE_NODE, ConvertBaseNodeClass))

typedef struct _ConvertBaseNode ConvertBaseNode;
typedef struct _ConvertBaseNodeClass ConvertBaseNodeClass;
typedef struct _ConvertBaseNodePrivate ConvertBaseNodePrivate;

#define TYPE_CONVERT_NUMBER_NODE (convert_number_node_get_type ())
#define CONVERT_NUMBER_NODE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_CONVERT_NUMBER_NODE, ConvertNumberNode))
#define CONVERT_NUMBER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_CONVERT_NUMBER_NODE, ConvertNumberNodeClass))
#define IS_CONVERT_NUMBER_NODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_CONVERT_NUMBER_NODE))
#define IS_CONVERT_NUMBER_NODE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_CONVERT_NUMBER_NODE))
#define CONVERT_NUMBER_NODE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_CONVERT_NUMBER_NODE, ConvertNumberNodeClass))

typedef struct _ConvertNumberNode ConvertNumberNode;
typedef struct _ConvertNumberNodeClass ConvertNumberNodeClass;
typedef struct _ConvertNumberNodePrivate ConvertNumberNodePrivate;
typedef struct _ParserPrivate ParserPrivate;

#define TYPE_FINANCIAL_DIALOG (financial_dialog_get_type ())

#define TYPE_MATH_EQUATION (math_equation_get_type ())
#define MATH_EQUATION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MATH_EQUATION, MathEquation))
#define MATH_EQUATION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MATH_EQUATION, MathEquationClass))
#define IS_MATH_EQUATION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MATH_EQUATION))
#define IS_MATH_EQUATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MATH_EQUATION))
#define MATH_EQUATION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MATH_EQUATION, MathEquationClass))

typedef struct _MathEquation MathEquation;
typedef struct _MathEquationClass MathEquationClass;

#define TYPE_FUNCTION_MANAGER (function_manager_get_type ())
#define FUNCTION_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FUNCTION_MANAGER, FunctionManager))
#define FUNCTION_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FUNCTION_MANAGER, FunctionManagerClass))
#define IS_FUNCTION_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FUNCTION_MANAGER))
#define IS_FUNCTION_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FUNCTION_MANAGER))
#define FUNCTION_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FUNCTION_MANAGER, FunctionManagerClass))

typedef struct _FunctionManager FunctionManager;
typedef struct _FunctionManagerClass FunctionManagerClass;
typedef struct _FunctionManagerPrivate FunctionManagerPrivate;

#define TYPE_MATH_FUNCTION (math_function_get_type ())
#define MATH_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MATH_FUNCTION, MathFunction))
#define MATH_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MATH_FUNCTION, MathFunctionClass))
#define IS_MATH_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MATH_FUNCTION))
#define IS_MATH_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MATH_FUNCTION))
#define MATH_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MATH_FUNCTION, MathFunctionClass))

typedef struct _MathFunction MathFunction;
typedef struct _MathFunctionClass MathFunctionClass;

#define TYPE_NUMBER_MODE (number_mode_get_type ())
typedef struct _MathEquationPrivate MathEquationPrivate;

#define TYPE_MATH_VARIABLES (math_variables_get_type ())
#define MATH_VARIABLES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MATH_VARIABLES, MathVariables))
#define MATH_VARIABLES_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MATH_VARIABLES, MathVariablesClass))
#define IS_MATH_VARIABLES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MATH_VARIABLES))
#define IS_MATH_VARIABLES_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MATH_VARIABLES))
#define MATH_VARIABLES_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MATH_VARIABLES, MathVariablesClass))

typedef struct _MathVariables MathVariables;
typedef struct _MathVariablesClass MathVariablesClass;

#define TYPE_SERIALIZER (serializer_get_type ())
#define SERIALIZER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_SERIALIZER, Serializer))
#define SERIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_SERIALIZER, SerializerClass))
#define IS_SERIALIZER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_SERIALIZER))
#define IS_SERIALIZER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_SERIALIZER))
#define SERIALIZER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_SERIALIZER, SerializerClass))

typedef struct _Serializer Serializer;
typedef struct _SerializerClass SerializerClass;

#define TYPE_DISPLAY_FORMAT (display_format_get_type ())
typedef struct _MathFunctionPrivate MathFunctionPrivate;

#define TYPE_EXPRESSION_PARSER (expression_parser_get_type ())
#define EXPRESSION_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_EXPRESSION_PARSER, ExpressionParser))
#define EXPRESSION_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_EXPRESSION_PARSER, ExpressionParserClass))
#define IS_EXPRESSION_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_EXPRESSION_PARSER))
#define IS_EXPRESSION_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_EXPRESSION_PARSER))
#define EXPRESSION_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_EXPRESSION_PARSER, ExpressionParserClass))

typedef struct _ExpressionParser ExpressionParser;
typedef struct _ExpressionParserClass ExpressionParserClass;
typedef struct _ExpressionParserPrivate ExpressionParserPrivate;

#define TYPE_BUILT_IN_MATH_FUNCTION (built_in_math_function_get_type ())
#define BUILT_IN_MATH_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BUILT_IN_MATH_FUNCTION, BuiltInMathFunction))
#define BUILT_IN_MATH_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BUILT_IN_MATH_FUNCTION, BuiltInMathFunctionClass))
#define IS_BUILT_IN_MATH_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BUILT_IN_MATH_FUNCTION))
#define IS_BUILT_IN_MATH_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BUILT_IN_MATH_FUNCTION))
#define BUILT_IN_MATH_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BUILT_IN_MATH_FUNCTION, BuiltInMathFunctionClass))

typedef struct _BuiltInMathFunction BuiltInMathFunction;
typedef struct _BuiltInMathFunctionClass BuiltInMathFunctionClass;
typedef struct _BuiltInMathFunctionPrivate BuiltInMathFunctionPrivate;
typedef struct _MathVariablesPrivate MathVariablesPrivate;
typedef struct _NumberPrivate NumberPrivate;
typedef struct _SerializerPrivate SerializerPrivate;

#define TYPE_UNIT_MANAGER (unit_manager_get_type ())
#define UNIT_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UNIT_MANAGER, UnitManager))
#define UNIT_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_UNIT_MANAGER, UnitManagerClass))
#define IS_UNIT_MANAGER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UNIT_MANAGER))
#define IS_UNIT_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_UNIT_MANAGER))
#define UNIT_MANAGER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_UNIT_MANAGER, UnitManagerClass))

typedef struct _UnitManager UnitManager;
typedef struct _UnitManagerClass UnitManagerClass;
typedef struct _UnitManagerPrivate UnitManagerPrivate;

#define TYPE_UNIT_CATEGORY (unit_category_get_type ())
#define UNIT_CATEGORY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UNIT_CATEGORY, UnitCategory))
#define UNIT_CATEGORY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_UNIT_CATEGORY, UnitCategoryClass))
#define IS_UNIT_CATEGORY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UNIT_CATEGORY))
#define IS_UNIT_CATEGORY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_UNIT_CATEGORY))
#define UNIT_CATEGORY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_UNIT_CATEGORY, UnitCategoryClass))

typedef struct _UnitCategory UnitCategory;
typedef struct _UnitCategoryClass UnitCategoryClass;

#define TYPE_UNIT (unit_get_type ())
#define UNIT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_UNIT, Unit))
#define UNIT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_UNIT, UnitClass))
#define IS_UNIT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_UNIT))
#define IS_UNIT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_UNIT))
#define UNIT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_UNIT, UnitClass))

typedef struct _Unit Unit;
typedef struct _UnitClass UnitClass;
typedef struct _UnitCategoryPrivate UnitCategoryPrivate;
typedef struct _UnitPrivate UnitPrivate;

struct _MPFRRealRef {
	__mpfr_struct val;
};

struct _CurrencyManager {
	GObject parent_instance;
	CurrencyManagerPrivate * priv;
};

struct _CurrencyManagerClass {
	GObjectClass parent_class;
};

struct _Currency {
	GObject parent_instance;
	CurrencyPrivate * priv;
};

struct _CurrencyClass {
	GObjectClass parent_class;
};

typedef enum  {
	ERROR_CODE_NONE,
	ERROR_CODE_INVALID,
	ERROR_CODE_OVERFLOW,
	ERROR_CODE_UNKNOWN_VARIABLE,
	ERROR_CODE_UNKNOWN_FUNCTION,
	ERROR_CODE_UNKNOWN_CONVERSION,
	ERROR_CODE_MP
} ErrorCode;

typedef enum  {
	ANGLE_UNIT_RADIANS,
	ANGLE_UNIT_DEGREES,
	ANGLE_UNIT_GRADIANS
} AngleUnit;

struct _Equation {
	GObject parent_instance;
	EquationPrivate * priv;
	gint base;
	gint wordlen;
	AngleUnit angle_units;
};

struct _EquationClass {
	GObjectClass parent_class;
	gboolean (*variable_is_defined) (Equation* self, const gchar* name);
	Number* (*get_variable) (Equation* self, const gchar* name);
	gboolean (*unit_is_defined) (Equation* self, const gchar* name);
	void (*set_variable) (Equation* self, const gchar* name, Number* x);
	gboolean (*function_is_defined) (Equation* self, const gchar* name);
	Number* (*convert) (Equation* self, Number* x, const gchar* x_units, const gchar* z_units);
};

typedef enum  {
	LEXER_TOKEN_TYPE_UNKNOWN,
	LEXER_TOKEN_TYPE_PL_DECIMAL,
	LEXER_TOKEN_TYPE_PL_DIGIT,
	LEXER_TOKEN_TYPE_PL_HEX,
	LEXER_TOKEN_TYPE_PL_SUPER_DIGIT,
	LEXER_TOKEN_TYPE_PL_SUPER_MINUS,
	LEXER_TOKEN_TYPE_PL_SUB_DIGIT,
	LEXER_TOKEN_TYPE_PL_FRACTION,
	LEXER_TOKEN_TYPE_PL_DEGREE,
	LEXER_TOKEN_TYPE_PL_MINUTE,
	LEXER_TOKEN_TYPE_PL_SECOND,
	LEXER_TOKEN_TYPE_PL_LETTER,
	LEXER_TOKEN_TYPE_PL_EOS,
	LEXER_TOKEN_TYPE_PL_SKIP,
	LEXER_TOKEN_TYPE_ADD,
	LEXER_TOKEN_TYPE_SUBTRACT,
	LEXER_TOKEN_TYPE_MULTIPLY,
	LEXER_TOKEN_TYPE_DIVIDE,
	LEXER_TOKEN_TYPE_MOD,
	LEXER_TOKEN_TYPE_L_FLOOR,
	LEXER_TOKEN_TYPE_R_FLOOR,
	LEXER_TOKEN_TYPE_L_CEILING,
	LEXER_TOKEN_TYPE_R_CEILING,
	LEXER_TOKEN_TYPE_ROOT,
	LEXER_TOKEN_TYPE_ROOT_3,
	LEXER_TOKEN_TYPE_ROOT_4,
	LEXER_TOKEN_TYPE_NOT,
	LEXER_TOKEN_TYPE_AND,
	LEXER_TOKEN_TYPE_OR,
	LEXER_TOKEN_TYPE_XOR,
	LEXER_TOKEN_TYPE_IN,
	LEXER_TOKEN_TYPE_NUMBER,
	LEXER_TOKEN_TYPE_SUP_NUMBER,
	LEXER_TOKEN_TYPE_NSUP_NUMBER,
	LEXER_TOKEN_TYPE_SUB_NUMBER,
	LEXER_TOKEN_TYPE_FUNCTION,
	LEXER_TOKEN_TYPE_UNIT,
	LEXER_TOKEN_TYPE_VARIABLE,
	LEXER_TOKEN_TYPE_ASSIGN,
	LEXER_TOKEN_TYPE_L_R_BRACKET,
	LEXER_TOKEN_TYPE_R_R_BRACKET,
	LEXER_TOKEN_TYPE_L_S_BRACKET,
	LEXER_TOKEN_TYPE_R_S_BRACKET,
	LEXER_TOKEN_TYPE_L_C_BRACKET,
	LEXER_TOKEN_TYPE_R_C_BRACKET,
	LEXER_TOKEN_TYPE_ABS,
	LEXER_TOKEN_TYPE_POWER,
	LEXER_TOKEN_TYPE_FACTORIAL,
	LEXER_TOKEN_TYPE_PERCENTAGE,
	LEXER_TOKEN_TYPE_ARGUMENT_SEPARATOR
} LexerTokenType;

struct _PreLexer {
	GObject parent_instance;
	PreLexerPrivate * priv;
	gchar* stream;
	gint index;
	gint mark_index;
};

struct _PreLexerClass {
	GObjectClass parent_class;
};

struct _LexerToken {
	GObject parent_instance;
	LexerTokenPrivate * priv;
	gchar* text;
	guint start_index;
	guint end_index;
	LexerTokenType type;
};

struct _LexerTokenClass {
	GObjectClass parent_class;
};

struct _Lexer {
	GObject parent_instance;
	LexerPrivate * priv;
	GList* tokens;
};

struct _LexerClass {
	GObjectClass parent_class;
};

typedef enum  {
	ASSOCIATIVITY_LEFT,
	ASSOCIATIVITY_RIGHT
} Associativity;

struct _ParseNode {
	GObject parent_instance;
	ParseNodePrivate * priv;
	Parser* parser;
	ParseNode* parent;
	ParseNode* left;
	ParseNode* right;
	GList* token_list;
	guint precedence;
	Associativity associativity;
	gchar* value;
};

struct _ParseNodeClass {
	GObjectClass parent_class;
	Number* (*solve) (ParseNode* self);
};

struct _RNode {
	ParseNode parent_instance;
	RNodePrivate * priv;
};

struct _RNodeClass {
	ParseNodeClass parent_class;
	Number* (*solve_r) (RNode* self, Number* r);
};

struct _LRNode {
	ParseNode parent_instance;
	LRNodePrivate * priv;
};

struct _LRNodeClass {
	ParseNodeClass parent_class;
	Number* (*solve_lr) (LRNode* self, Number* left, Number* r);
};

struct _ConstantNode {
	ParseNode parent_instance;
	ConstantNodePrivate * priv;
};

struct _ConstantNodeClass {
	ParseNodeClass parent_class;
};

struct _AssignNode {
	RNode parent_instance;
	AssignNodePrivate * priv;
};

struct _AssignNodeClass {
	RNodeClass parent_class;
};

struct _AssignFunctionNode {
	ParseNode parent_instance;
	AssignFunctionNodePrivate * priv;
};

struct _AssignFunctionNodeClass {
	ParseNodeClass parent_class;
};

struct _NameNode {
	ParseNode parent_instance;
	NameNodePrivate * priv;
};

struct _NameNodeClass {
	ParseNodeClass parent_class;
};

struct _VariableNode {
	ParseNode parent_instance;
	VariableNodePrivate * priv;
};

struct _VariableNodeClass {
	ParseNodeClass parent_class;
};

struct _VariableWithPowerNode {
	ParseNode parent_instance;
	VariableWithPowerNodePrivate * priv;
};

struct _VariableWithPowerNodeClass {
	ParseNodeClass parent_class;
};

struct _FunctionNameNode {
	NameNode parent_instance;
	FunctionNameNodePrivate * priv;
};

struct _FunctionNameNodeClass {
	NameNodeClass parent_class;
};

struct _FunctionArgumentsNode {
	NameNode parent_instance;
	FunctionArgumentsNodePrivate * priv;
};

struct _FunctionArgumentsNodeClass {
	NameNodeClass parent_class;
};

struct _FunctionDescriptionNode {
	NameNode parent_instance;
	FunctionDescriptionNodePrivate * priv;
};

struct _FunctionDescriptionNodeClass {
	NameNodeClass parent_class;
};

struct _FunctionNode {
	ParseNode parent_instance;
	FunctionNodePrivate * priv;
};

struct _FunctionNodeClass {
	ParseNodeClass parent_class;
};

struct _UnaryMinusNode {
	RNode parent_instance;
	UnaryMinusNodePrivate * priv;
};

struct _UnaryMinusNodeClass {
	RNodeClass parent_class;
};

struct _AbsoluteValueNode {
	RNode parent_instance;
	AbsoluteValueNodePrivate * priv;
};

struct _AbsoluteValueNodeClass {
	RNodeClass parent_class;
};

struct _FloorNode {
	RNode parent_instance;
	FloorNodePrivate * priv;
};

struct _FloorNodeClass {
	RNodeClass parent_class;
};

struct _CeilingNode {
	RNode parent_instance;
	CeilingNodePrivate * priv;
};

struct _CeilingNodeClass {
	RNodeClass parent_class;
};

struct _FractionalComponentNode {
	RNode parent_instance;
	FractionalComponentNodePrivate * priv;
};

struct _FractionalComponentNodeClass {
	RNodeClass parent_class;
};

struct _RoundNode {
	RNode parent_instance;
	RoundNodePrivate * priv;
};

struct _RoundNodeClass {
	RNodeClass parent_class;
};

struct _PercentNode {
	RNode parent_instance;
	PercentNodePrivate * priv;
};

struct _PercentNodeClass {
	RNodeClass parent_class;
};

struct _FactorialNode {
	RNode parent_instance;
	FactorialNodePrivate * priv;
};

struct _FactorialNodeClass {
	RNodeClass parent_class;
};

struct _AddNode {
	LRNode parent_instance;
	AddNodePrivate * priv;
	gboolean do_percentage;
};

struct _AddNodeClass {
	LRNodeClass parent_class;
};

struct _SubtractNode {
	LRNode parent_instance;
	SubtractNodePrivate * priv;
	gboolean do_percentage;
};

struct _SubtractNodeClass {
	LRNodeClass parent_class;
};

struct _MultiplyNode {
	LRNode parent_instance;
	MultiplyNodePrivate * priv;
};

struct _MultiplyNodeClass {
	LRNodeClass parent_class;
};

struct _DivideNode {
	LRNode parent_instance;
	DivideNodePrivate * priv;
};

struct _DivideNodeClass {
	LRNodeClass parent_class;
};

struct _ModulusDivideNode {
	LRNode parent_instance;
	ModulusDivideNodePrivate * priv;
};

struct _ModulusDivideNodeClass {
	LRNodeClass parent_class;
};

struct _RootNode {
	RNode parent_instance;
	RootNodePrivate * priv;
};

struct _RootNodeClass {
	RNodeClass parent_class;
};

struct _XPowYNode {
	LRNode parent_instance;
	XPowYNodePrivate * priv;
};

struct _XPowYNodeClass {
	LRNodeClass parent_class;
};

struct _XPowYIntegerNode {
	ParseNode parent_instance;
	XPowYIntegerNodePrivate * priv;
};

struct _XPowYIntegerNodeClass {
	ParseNodeClass parent_class;
};

struct _NotNode {
	RNode parent_instance;
	NotNodePrivate * priv;
};

struct _NotNodeClass {
	RNodeClass parent_class;
};

struct _AndNode {
	LRNode parent_instance;
	AndNodePrivate * priv;
};

struct _AndNodeClass {
	LRNodeClass parent_class;
};

struct _OrNode {
	LRNode parent_instance;
	OrNodePrivate * priv;
};

struct _OrNodeClass {
	LRNodeClass parent_class;
};

struct _XorNode {
	LRNode parent_instance;
	XorNodePrivate * priv;
};

struct _XorNodeClass {
	LRNodeClass parent_class;
};

struct _ConvertNode {
	LRNode parent_instance;
	ConvertNodePrivate * priv;
};

struct _ConvertNodeClass {
	LRNodeClass parent_class;
};

struct _ConvertBaseNode {
	ParseNode parent_instance;
	ConvertBaseNodePrivate * priv;
};

struct _ConvertBaseNodeClass {
	ParseNodeClass parent_class;
};

struct _ConvertNumberNode {
	ParseNode parent_instance;
	ConvertNumberNodePrivate * priv;
};

struct _ConvertNumberNodeClass {
	ParseNodeClass parent_class;
};

struct _Parser {
	GTypeInstance parent_instance;
	volatile int ref_count;
	ParserPrivate * priv;
	gint number_base;
	gint wordlen;
	AngleUnit angle_units;
};

struct _ParserClass {
	GTypeClass parent_class;
	void (*finalize) (Parser *self);
	gboolean (*variable_is_defined) (Parser* self, const gchar* name);
	Number* (*get_variable) (Parser* self, const gchar* name);
	void (*set_variable) (Parser* self, const gchar* name, Number* x);
	gboolean (*function_is_defined) (Parser* self, const gchar* name);
	gboolean (*unit_is_defined) (Parser* self, const gchar* name);
	Number* (*convert) (Parser* self, Number* x, const gchar* x_units, const gchar* z_units);
};

typedef enum  {
	FINANCIAL_DIALOG_CTRM_DIALOG,
	FINANCIAL_DIALOG_DDB_DIALOG,
	FINANCIAL_DIALOG_FV_DIALOG,
	FINANCIAL_DIALOG_GPM_DIALOG,
	FINANCIAL_DIALOG_PMT_DIALOG,
	FINANCIAL_DIALOG_PV_DIALOG,
	FINANCIAL_DIALOG_RATE_DIALOG,
	FINANCIAL_DIALOG_SLN_DIALOG,
	FINANCIAL_DIALOG_SYD_DIALOG,
	FINANCIAL_DIALOG_TERM_DIALOG
} FinancialDialog;

struct _FunctionManager {
	GObject parent_instance;
	FunctionManagerPrivate * priv;
};

struct _FunctionManagerClass {
	GObjectClass parent_class;
};

typedef enum  {
	NUMBER_MODE_NORMAL,
	NUMBER_MODE_SUPERSCRIPT,
	NUMBER_MODE_SUBSCRIPT
} NumberMode;

struct _MathEquation {
	GtkSourceBuffer parent_instance;
	MathEquationPrivate * priv;
};

struct _MathEquationClass {
	GtkSourceBufferClass parent_class;
};

typedef enum  {
	DISPLAY_FORMAT_AUTOMATIC,
	DISPLAY_FORMAT_FIXED,
	DISPLAY_FORMAT_SCIENTIFIC,
	DISPLAY_FORMAT_ENGINEERING
} DisplayFormat;

struct _MathFunction {
	GObject parent_instance;
	MathFunctionPrivate * priv;
};

struct _MathFunctionClass {
	GObjectClass parent_class;
	Number* (*evaluate) (MathFunction* self, Number** args, int args_length1, Parser* root_parser);
	gboolean (*is_custom_function) (MathFunction* self);
};

struct _ExpressionParser {
	Parser parent_instance;
	ExpressionParserPrivate * priv;
};

struct _ExpressionParserClass {
	ParserClass parent_class;
};

struct _BuiltInMathFunction {
	MathFunction parent_instance;
	BuiltInMathFunctionPrivate * priv;
};

struct _BuiltInMathFunctionClass {
	MathFunctionClass parent_class;
};

struct _MathVariables {
	GObject parent_instance;
	MathVariablesPrivate * priv;
};

struct _MathVariablesClass {
	GObjectClass parent_class;
};

struct _Number {
	GObject parent_instance;
	NumberPrivate * priv;
};

struct _NumberClass {
	GObjectClass parent_class;
};

struct _Serializer {
	GObject parent_instance;
	SerializerPrivate * priv;
};

struct _SerializerClass {
	GObjectClass parent_class;
};

struct _UnitManager {
	GObject parent_instance;
	UnitManagerPrivate * priv;
};

struct _UnitManagerClass {
	GObjectClass parent_class;
};

struct _UnitCategory {
	GObject parent_instance;
	UnitCategoryPrivate * priv;
};

struct _UnitCategoryClass {
	GObjectClass parent_class;
};

struct _Unit {
	GObject parent_instance;
	UnitPrivate * priv;
};

struct _UnitClass {
	GObjectClass parent_class;
};


void mpfr_real_ref_free (MPFRRealRef * self);
MPFRRealRef* mpfr_real_ref_new (void);
GType currency_manager_get_type (void) G_GNUC_CONST;
CurrencyManager* currency_manager_get_default (void);
GType currency_get_type (void) G_GNUC_CONST;
GList* currency_manager_get_currencies (CurrencyManager* self);
Currency* currency_manager_get_currency (CurrencyManager* self,
                                         const gchar* name);
GType number_get_type (void) G_GNUC_CONST;
Number* currency_manager_get_value (CurrencyManager* self,
                                    const gchar* currency);
CurrencyManager* currency_manager_new (void);
CurrencyManager* currency_manager_construct (GType object_type);
Currency* currency_new (const gchar* name,
                        const gchar* display_name,
                        const gchar* symbol);
Currency* currency_construct (GType object_type,
                              const gchar* name,
                              const gchar* display_name,
                              const gchar* symbol);
void currency_set_value (Currency* self,
                         Number* value);
Number* currency_get_value (Currency* self);
gchar* currency_get_name (Currency* self);
gchar* currency_get_display_name (Currency* self);
gchar* currency_get_symbol (Currency* self);
gchar* currency_get_source (Currency* self);
void currency_set_source (Currency* self,
                          gchar* value);
gint sub_atoi (const gchar* data);
gint super_atoi (const gchar* data);
GType error_code_get_type (void) G_GNUC_CONST;
gchar* mp_error_code_to_string (ErrorCode error_code);
GType equation_get_type (void) G_GNUC_CONST;
GType angle_unit_get_type (void) G_GNUC_CONST;
Equation* equation_new (const gchar* expression);
Equation* equation_construct (GType object_type,
                              const gchar* expression);
Number* equation_parse (Equation* self,
                        guint* representation_base,
                        ErrorCode* error_code,
                        gchar* * error_token,
                        guint** error_start,
                        guint** error_end);
gboolean equation_variable_is_defined (Equation* self,
                                       const gchar* name);
Number* equation_get_variable (Equation* self,
                               const gchar* name);
gboolean equation_unit_is_defined (Equation* self,
                                   const gchar* name);
void equation_set_variable (Equation* self,
                            const gchar* name,
                            Number* x);
gboolean equation_function_is_defined (Equation* self,
                                       const gchar* name);
Number* equation_convert (Equation* self,
                          Number* x,
                          const gchar* x_units,
                          const gchar* z_units);
GType lexer_token_type_get_type (void) G_GNUC_CONST;
GType pre_lexer_get_type (void) G_GNUC_CONST;
PreLexer* pre_lexer_new (const gchar* input);
PreLexer* pre_lexer_construct (GType object_type,
                               const gchar* input);
void pre_lexer_roll_back (PreLexer* self);
void pre_lexer_set_marker (PreLexer* self);
gchar* pre_lexer_get_marked_substring (PreLexer* self);
LexerTokenType pre_lexer_get_next_token (PreLexer* self);
GType lexer_token_get_type (void) G_GNUC_CONST;
LexerToken* lexer_token_new (void);
LexerToken* lexer_token_construct (GType object_type);
GType lexer_get_type (void) G_GNUC_CONST;
gpointer parser_ref (gpointer instance);
void parser_unref (gpointer instance);
GParamSpec* param_spec_parser (const gchar* name,
                               const gchar* nick,
                               const gchar* blurb,
                               GType object_type,
                               GParamFlags flags);
void value_set_parser (GValue* value,
                       gpointer v_object);
void value_take_parser (GValue* value,
                        gpointer v_object);
gpointer value_get_parser (const GValue* value);
GType parser_get_type (void) G_GNUC_CONST;
Lexer* lexer_new (const gchar* input,
                  Parser* parser,
                  gint number_base);
Lexer* lexer_construct (GType object_type,
                        const gchar* input,
                        Parser* parser,
                        gint number_base);
void lexer_scan (Lexer* self);
LexerToken* lexer_get_next_token (Lexer* self);
void lexer_roll_back (Lexer* self);
GType associativity_get_type (void) G_GNUC_CONST;
GType parse_node_get_type (void) G_GNUC_CONST;
LexerToken* parse_node_token (ParseNode* self);
LexerToken* parse_node_first_token (ParseNode* self);
LexerToken* parse_node_last_token (ParseNode* self);
ParseNode* parse_node_new_WithList (Parser* parser,
                                    GList* token_list,
                                    guint precedence,
                                    Associativity associativity,
                                    const gchar* value);
ParseNode* parse_node_construct_WithList (GType object_type,
                                          Parser* parser,
                                          GList* token_list,
                                          guint precedence,
                                          Associativity associativity,
                                          const gchar* value);
ParseNode* parse_node_new (Parser* parser,
                           LexerToken* token,
                           guint precedence,
                           Associativity associativity,
                           const gchar* value);
ParseNode* parse_node_construct (GType object_type,
                                 Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity,
                                 const gchar* value);
Number* parse_node_solve (ParseNode* self);
GType rnode_get_type (void) G_GNUC_CONST;
RNode* rnode_construct (GType object_type,
                        Parser* parser,
                        LexerToken* token,
                        guint precedence,
                        Associativity associativity);
Number* rnode_solve_r (RNode* self,
                       Number* r);
GType lr_node_get_type (void) G_GNUC_CONST;
LRNode* lr_node_construct (GType object_type,
                           Parser* parser,
                           LexerToken* token,
                           guint precedence,
                           Associativity associativity);
Number* lr_node_solve_lr (LRNode* self,
                          Number* left,
                          Number* r);
GType constant_node_get_type (void) G_GNUC_CONST;
ConstantNode* constant_node_new (Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
ConstantNode* constant_node_construct (GType object_type,
                                       Parser* parser,
                                       LexerToken* token,
                                       guint precedence,
                                       Associativity associativity);
GType assign_node_get_type (void) G_GNUC_CONST;
AssignNode* assign_node_new (Parser* parser,
                             LexerToken* token,
                             guint precedence,
                             Associativity associativity);
AssignNode* assign_node_construct (GType object_type,
                                   Parser* parser,
                                   LexerToken* token,
                                   guint precedence,
                                   Associativity associativity);
GType assign_function_node_get_type (void) G_GNUC_CONST;
AssignFunctionNode* assign_function_node_new (Parser* parser,
                                              LexerToken* token,
                                              guint precedence,
                                              Associativity associativity);
AssignFunctionNode* assign_function_node_construct (GType object_type,
                                                    Parser* parser,
                                                    LexerToken* token,
                                                    guint precedence,
                                                    Associativity associativity);
GType name_node_get_type (void) G_GNUC_CONST;
NameNode* name_node_new (Parser* parser,
                         LexerToken* token,
                         guint precedence,
                         Associativity associativity,
                         const gchar* text);
NameNode* name_node_construct (GType object_type,
                               Parser* parser,
                               LexerToken* token,
                               guint precedence,
                               Associativity associativity,
                               const gchar* text);
GType variable_node_get_type (void) G_GNUC_CONST;
VariableNode* variable_node_new (Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
VariableNode* variable_node_construct (GType object_type,
                                       Parser* parser,
                                       LexerToken* token,
                                       guint precedence,
                                       Associativity associativity);
GType variable_with_power_node_get_type (void) G_GNUC_CONST;
VariableWithPowerNode* variable_with_power_node_new (Parser* parser,
                                                     LexerToken* token,
                                                     guint precedence,
                                                     Associativity associativity,
                                                     const gchar* text);
VariableWithPowerNode* variable_with_power_node_construct (GType object_type,
                                                           Parser* parser,
                                                           LexerToken* token,
                                                           guint precedence,
                                                           Associativity associativity,
                                                           const gchar* text);
GType function_name_node_get_type (void) G_GNUC_CONST;
FunctionNameNode* function_name_node_new (Parser* parser,
                                          LexerToken* token,
                                          guint precedence,
                                          Associativity associativity,
                                          const gchar* name);
FunctionNameNode* function_name_node_construct (GType object_type,
                                                Parser* parser,
                                                LexerToken* token,
                                                guint precedence,
                                                Associativity associativity,
                                                const gchar* name);
GType function_arguments_node_get_type (void) G_GNUC_CONST;
FunctionArgumentsNode* function_arguments_node_new (Parser* parser,
                                                    GList* token_list,
                                                    guint precedence,
                                                    Associativity associativity,
                                                    const gchar* arguments);
FunctionArgumentsNode* function_arguments_node_construct (GType object_type,
                                                          Parser* parser,
                                                          GList* token_list,
                                                          guint precedence,
                                                          Associativity associativity,
                                                          const gchar* arguments);
GType function_description_node_get_type (void) G_GNUC_CONST;
FunctionDescriptionNode* function_description_node_new (Parser* parser,
                                                        LexerToken* token,
                                                        guint precedence,
                                                        Associativity associativity,
                                                        const gchar* description);
FunctionDescriptionNode* function_description_node_construct (GType object_type,
                                                              Parser* parser,
                                                              LexerToken* token,
                                                              guint precedence,
                                                              Associativity associativity,
                                                              const gchar* description);
GType function_node_get_type (void) G_GNUC_CONST;
FunctionNode* function_node_new (Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity,
                                 const gchar* text);
FunctionNode* function_node_construct (GType object_type,
                                       Parser* parser,
                                       LexerToken* token,
                                       guint precedence,
                                       Associativity associativity,
                                       const gchar* text);
GType unary_minus_node_get_type (void) G_GNUC_CONST;
UnaryMinusNode* unary_minus_node_new (Parser* parser,
                                      LexerToken* token,
                                      guint precedence,
                                      Associativity associativity);
UnaryMinusNode* unary_minus_node_construct (GType object_type,
                                            Parser* parser,
                                            LexerToken* token,
                                            guint precedence,
                                            Associativity associativity);
GType absolute_value_node_get_type (void) G_GNUC_CONST;
AbsoluteValueNode* absolute_value_node_new (Parser* parser,
                                            LexerToken* token,
                                            guint precedence,
                                            Associativity associativity);
AbsoluteValueNode* absolute_value_node_construct (GType object_type,
                                                  Parser* parser,
                                                  LexerToken* token,
                                                  guint precedence,
                                                  Associativity associativity);
GType floor_node_get_type (void) G_GNUC_CONST;
FloorNode* floor_node_new (Parser* parser,
                           LexerToken* token,
                           guint precedence,
                           Associativity associativity);
FloorNode* floor_node_construct (GType object_type,
                                 Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
GType ceiling_node_get_type (void) G_GNUC_CONST;
CeilingNode* ceiling_node_new (Parser* parser,
                               LexerToken* token,
                               guint precedence,
                               Associativity associativity);
CeilingNode* ceiling_node_construct (GType object_type,
                                     Parser* parser,
                                     LexerToken* token,
                                     guint precedence,
                                     Associativity associativity);
GType fractional_component_node_get_type (void) G_GNUC_CONST;
FractionalComponentNode* fractional_component_node_new (Parser* parser,
                                                        LexerToken* token,
                                                        guint precedence,
                                                        Associativity associativity);
FractionalComponentNode* fractional_component_node_construct (GType object_type,
                                                              Parser* parser,
                                                              LexerToken* token,
                                                              guint precedence,
                                                              Associativity associativity);
GType round_node_get_type (void) G_GNUC_CONST;
RoundNode* round_node_new (Parser* parser,
                           LexerToken* token,
                           guint precedence,
                           Associativity associativity);
RoundNode* round_node_construct (GType object_type,
                                 Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
GType percent_node_get_type (void) G_GNUC_CONST;
PercentNode* percent_node_new (Parser* parser,
                               LexerToken* token,
                               guint precedence,
                               Associativity associativity);
PercentNode* percent_node_construct (GType object_type,
                                     Parser* parser,
                                     LexerToken* token,
                                     guint precedence,
                                     Associativity associativity);
GType factorial_node_get_type (void) G_GNUC_CONST;
FactorialNode* factorial_node_new (Parser* parser,
                                   LexerToken* token,
                                   guint precedence,
                                   Associativity associativity);
FactorialNode* factorial_node_construct (GType object_type,
                                         Parser* parser,
                                         LexerToken* token,
                                         guint precedence,
                                         Associativity associativity);
GType add_node_get_type (void) G_GNUC_CONST;
AddNode* add_node_new (Parser* parser,
                       LexerToken* token,
                       guint precedence,
                       Associativity associativity);
AddNode* add_node_construct (GType object_type,
                             Parser* parser,
                             LexerToken* token,
                             guint precedence,
                             Associativity associativity);
GType subtract_node_get_type (void) G_GNUC_CONST;
SubtractNode* subtract_node_new (Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
SubtractNode* subtract_node_construct (GType object_type,
                                       Parser* parser,
                                       LexerToken* token,
                                       guint precedence,
                                       Associativity associativity);
GType multiply_node_get_type (void) G_GNUC_CONST;
MultiplyNode* multiply_node_new (Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
MultiplyNode* multiply_node_construct (GType object_type,
                                       Parser* parser,
                                       LexerToken* token,
                                       guint precedence,
                                       Associativity associativity);
GType divide_node_get_type (void) G_GNUC_CONST;
DivideNode* divide_node_new (Parser* parser,
                             LexerToken* token,
                             guint precedence,
                             Associativity associativity);
DivideNode* divide_node_construct (GType object_type,
                                   Parser* parser,
                                   LexerToken* token,
                                   guint precedence,
                                   Associativity associativity);
GType modulus_divide_node_get_type (void) G_GNUC_CONST;
ModulusDivideNode* modulus_divide_node_new (Parser* parser,
                                            LexerToken* token,
                                            guint precedence,
                                            Associativity associativity);
ModulusDivideNode* modulus_divide_node_construct (GType object_type,
                                                  Parser* parser,
                                                  LexerToken* token,
                                                  guint precedence,
                                                  Associativity associativity);
GType root_node_get_type (void) G_GNUC_CONST;
RootNode* root_node_new (Parser* parser,
                         LexerToken* token,
                         guint precedence,
                         Associativity associativity,
                         gint n);
RootNode* root_node_construct (GType object_type,
                               Parser* parser,
                               LexerToken* token,
                               guint precedence,
                               Associativity associativity,
                               gint n);
RootNode* root_node_new_WithToken (Parser* parser,
                                   LexerToken* token,
                                   guint precedence,
                                   Associativity associativity,
                                   LexerToken* token_n);
RootNode* root_node_construct_WithToken (GType object_type,
                                         Parser* parser,
                                         LexerToken* token,
                                         guint precedence,
                                         Associativity associativity,
                                         LexerToken* token_n);
GType xpow_ynode_get_type (void) G_GNUC_CONST;
XPowYNode* xpow_ynode_new (Parser* parser,
                           LexerToken* token,
                           guint precedence,
                           Associativity associativity);
XPowYNode* xpow_ynode_construct (GType object_type,
                                 Parser* parser,
                                 LexerToken* token,
                                 guint precedence,
                                 Associativity associativity);
GType xpow_yinteger_node_get_type (void) G_GNUC_CONST;
XPowYIntegerNode* xpow_yinteger_node_new (Parser* parser,
                                          LexerToken* token,
                                          guint precedence,
                                          Associativity associativity);
XPowYIntegerNode* xpow_yinteger_node_construct (GType object_type,
                                                Parser* parser,
                                                LexerToken* token,
                                                guint precedence,
                                                Associativity associativity);
GType not_node_get_type (void) G_GNUC_CONST;
NotNode* not_node_new (Parser* parser,
                       LexerToken* token,
                       guint precedence,
                       Associativity associativity);
NotNode* not_node_construct (GType object_type,
                             Parser* parser,
                             LexerToken* token,
                             guint precedence,
                             Associativity associativity);
GType and_node_get_type (void) G_GNUC_CONST;
AndNode* and_node_new (Parser* parser,
                       LexerToken* token,
                       guint precedence,
                       Associativity associativity);
AndNode* and_node_construct (GType object_type,
                             Parser* parser,
                             LexerToken* token,
                             guint precedence,
                             Associativity associativity);
GType or_node_get_type (void) G_GNUC_CONST;
OrNode* or_node_new (Parser* parser,
                     LexerToken* token,
                     guint precedence,
                     Associativity associativity);
OrNode* or_node_construct (GType object_type,
                           Parser* parser,
                           LexerToken* token,
                           guint precedence,
                           Associativity associativity);
GType xor_node_get_type (void) G_GNUC_CONST;
XorNode* xor_node_new (Parser* parser,
                       LexerToken* token,
                       guint precedence,
                       Associativity associativity);
XorNode* xor_node_construct (GType object_type,
                             Parser* parser,
                             LexerToken* token,
                             guint precedence,
                             Associativity associativity);
GType convert_node_get_type (void) G_GNUC_CONST;
ConvertNode* convert_node_new (Parser* parser,
                               LexerToken* token,
                               guint precedence,
                               Associativity associativity);
ConvertNode* convert_node_construct (GType object_type,
                                     Parser* parser,
                                     LexerToken* token,
                                     guint precedence,
                                     Associativity associativity);
GType convert_base_node_get_type (void) G_GNUC_CONST;
ConvertBaseNode* convert_base_node_new (Parser* parser,
                                        LexerToken* token,
                                        guint precedence,
                                        Associativity associativity,
                                        const gchar* value);
ConvertBaseNode* convert_base_node_construct (GType object_type,
                                              Parser* parser,
                                              LexerToken* token,
                                              guint precedence,
                                              Associativity associativity,
                                              const gchar* value);
GType convert_number_node_get_type (void) G_GNUC_CONST;
ConvertNumberNode* convert_number_node_new (Parser* parser,
                                            LexerToken* token,
                                            guint precedence,
                                            Associativity associativity);
ConvertNumberNode* convert_number_node_construct (GType object_type,
                                                  Parser* parser,
                                                  LexerToken* token,
                                                  guint precedence,
                                                  Associativity associativity);
Parser* parser_new (const gchar* input,
                    gint number_base,
                    gint wordlen,
                    AngleUnit angle_units);
Parser* parser_construct (GType object_type,
                          const gchar* input,
                          gint number_base,
                          gint wordlen,
                          AngleUnit angle_units);
gboolean parser_create_parse_tree (Parser* self,
                                   guint* representation_base,
                                   ErrorCode* error_code,
                                   gchar* * error_token,
                                   guint* error_start,
                                   guint* error_end);
void parser_set_error (Parser* self,
                       ErrorCode errorno,
                       const gchar* token,
                       guint token_start,
                       guint token_end);
void parser_set_representation_base (Parser* self,
                                     guint new_base);
gboolean parser_variable_is_defined (Parser* self,
                                     const gchar* name);
Number* parser_get_variable (Parser* self,
                             const gchar* name);
void parser_set_variable (Parser* self,
                          const gchar* name,
                          Number* x);
gboolean parser_function_is_defined (Parser* self,
                                     const gchar* name);
gboolean parser_unit_is_defined (Parser* self,
                                 const gchar* name);
Number* parser_convert (Parser* self,
                        Number* x,
                        const gchar* x_units,
                        const gchar* z_units);
Number* parser_parse (Parser* self,
                      guint* representation_base,
                      ErrorCode* error_code,
                      gchar* * error_token,
                      guint* error_start,
                      guint* error_end);
GType financial_dialog_get_type (void) G_GNUC_CONST;
GType math_equation_get_type (void) G_GNUC_CONST;
void do_finc_expression (MathEquation* equation,
                         FinancialDialog function,
                         Number* arg1,
                         Number* arg2,
                         Number* arg3,
                         Number* arg4);
GType function_manager_get_type (void) G_GNUC_CONST;
FunctionManager* function_manager_new (void);
FunctionManager* function_manager_construct (GType object_type);
FunctionManager* function_manager_get_default_function_manager (void);
gchar** function_manager_get_names (FunctionManager* self,
                                    int* result_length1);
gboolean function_manager_add_function_with_properties (FunctionManager* self,
                                                        const gchar* name,
                                                        const gchar* arguments,
                                                        const gchar* description,
                                                        Parser* root_parser);
GType math_function_get_type (void) G_GNUC_CONST;
MathFunction* function_manager_get (FunctionManager* self,
                                    const gchar* name);
void function_manager_delete (FunctionManager* self,
                              const gchar* name);
gboolean function_manager_is_function_defined (FunctionManager* self,
                                               const gchar* name);
Number* function_manager_evaluate_function (FunctionManager* self,
                                            const gchar* name,
                                            Number** arguments,
                                            int arguments_length1,
                                            Parser* parser);
MathFunction** function_manager_functions_eligible_for_autocompletion_for_text (FunctionManager* self,
                                                                                const gchar* display_text,
                                                                                int* result_length1);
GType number_mode_get_type (void) G_GNUC_CONST;
MathEquation* math_equation_new (void);
MathEquation* math_equation_construct (GType object_type);
void math_equation_display_selected (MathEquation* self,
                                     const gchar* selected);
void math_equation_remove_trailing_spaces (MathEquation* self);
void math_equation_copy (MathEquation* self);
void math_equation_paste (MathEquation* self);
gunichar math_equation_get_digit_text (MathEquation* self,
                                       guint digit);
void math_equation_store (MathEquation* self,
                          const gchar* name);
void math_equation_recall (MathEquation* self,
                           const gchar* name);
void math_equation_set (MathEquation* self,
                        const gchar* text);
void math_equation_set_number (MathEquation* self,
                               Number* x,
                               guint representation_base);
void math_equation_insert (MathEquation* self,
                           const gchar* text);
void math_equation_insert_selected (MathEquation* self,
                                    const gchar* answer);
void math_equation_insert_square (MathEquation* self);
void math_equation_insert_digit (MathEquation* self,
                                 guint digit);
void math_equation_insert_numeric_point (MathEquation* self);
void math_equation_insert_number (MathEquation* self,
                                  Number* x);
void math_equation_insert_exponent (MathEquation* self);
void math_equation_insert_subtract (MathEquation* self);
void math_equation_solve (MathEquation* self);
void math_equation_factorize (MathEquation* self);
void math_equation_delete_next (MathEquation* self);
void math_equation_backspace (MathEquation* self);
void math_equation_clear (MathEquation* self);
void math_equation_shift (MathEquation* self,
                          gint count);
void math_equation_toggle_bit (MathEquation* self,
                               guint bit);
gint math_equation_get_word_size (MathEquation* self);
void math_equation_set_word_size (MathEquation* self,
                                  gint value);
gchar* math_equation_get_source_currency (MathEquation* self);
void math_equation_set_source_currency (MathEquation* self,
                                        const gchar* value);
gchar* math_equation_get_target_currency (MathEquation* self);
void math_equation_set_target_currency (MathEquation* self,
                                        const gchar* value);
gchar* math_equation_get_source_units (MathEquation* self);
void math_equation_set_source_units (MathEquation* self,
                                     const gchar* value);
gchar* math_equation_get_target_units (MathEquation* self);
void math_equation_set_target_units (MathEquation* self,
                                     const gchar* value);
gchar* math_equation_get_display (MathEquation* self);
gboolean math_equation_get_in_solve (MathEquation* self);
GType math_variables_get_type (void) G_GNUC_CONST;
MathVariables* math_equation_get_variables (MathEquation* self);
GType serializer_get_type (void) G_GNUC_CONST;
Serializer* math_equation_get_serializer (MathEquation* self);
gint math_equation_get_accuracy (MathEquation* self);
void math_equation_set_accuracy (MathEquation* self,
                                 gint value);
gboolean math_equation_get_show_thousands_separators (MathEquation* self);
void math_equation_set_show_thousands_separators (MathEquation* self,
                                                  gboolean value);
gboolean math_equation_get_show_trailing_zeroes (MathEquation* self);
void math_equation_set_show_trailing_zeroes (MathEquation* self,
                                             gboolean value);
GType display_format_get_type (void) G_GNUC_CONST;
DisplayFormat math_equation_get_number_format (MathEquation* self);
void math_equation_set_number_format (MathEquation* self,
                                      DisplayFormat value);
gint math_equation_get_number_base (MathEquation* self);
void math_equation_set_number_base (MathEquation* self,
                                    gint value);
AngleUnit math_equation_get_angle_units (MathEquation* self);
void math_equation_set_angle_units (MathEquation* self,
                                    AngleUnit value);
gchar* math_equation_get_status (MathEquation* self);
void math_equation_set_status (MathEquation* self,
                               const gchar* value);
guint math_equation_get_error_token_start (MathEquation* self);
guint math_equation_get_error_token_end (MathEquation* self);
gboolean math_equation_get_is_empty (MathEquation* self);
gboolean math_equation_get_is_result (MathEquation* self);
gchar* math_equation_get_equation (MathEquation* self);
Number* math_equation_get_number (MathEquation* self);
NumberMode math_equation_get_number_mode (MathEquation* self);
void math_equation_set_number_mode (MathEquation* self,
                                    NumberMode value);
Number* math_equation_get_answer (MathEquation* self);
MathFunction* math_function_new (const gchar* function_name,
                                 gchar** arguments,
                                 int arguments_length1,
                                 const gchar* expression,
                                 const gchar* description);
MathFunction* math_function_construct (GType object_type,
                                       const gchar* function_name,
                                       gchar** arguments,
                                       int arguments_length1,
                                       const gchar* expression,
                                       const gchar* description);
Number* math_function_evaluate (MathFunction* self,
                                Number** args,
                                int args_length1,
                                Parser* root_parser);
gboolean math_function_validate (MathFunction* self,
                                 Parser* root_parser);
gboolean math_function_is_custom_function (MathFunction* self);
const gchar* math_function_get_name (MathFunction* self);
gchar** math_function_get_arguments (MathFunction* self,
                                     int* result_length1);
const gchar* math_function_get_expression (MathFunction* self);
const gchar* math_function_get_description (MathFunction* self);
GType expression_parser_get_type (void) G_GNUC_CONST;
ExpressionParser* expression_parser_new (const gchar* expression,
                                         Parser* root_parser);
ExpressionParser* expression_parser_construct (GType object_type,
                                               const gchar* expression,
                                               Parser* root_parser);
GType built_in_math_function_get_type (void) G_GNUC_CONST;
BuiltInMathFunction* built_in_math_function_new (const gchar* function_name,
                                                 const gchar* description);
BuiltInMathFunction* built_in_math_function_construct (GType object_type,
                                                       const gchar* function_name,
                                                       const gchar* description);
MathVariables* math_variables_new (void);
MathVariables* math_variables_construct (GType object_type);
gchar** math_variables_get_names (MathVariables* self,
                                  int* result_length1);
gchar** math_variables_variables_eligible_for_autocompletion (MathVariables* self,
                                                              const gchar* text,
                                                              int* result_length1);
void math_variables_set (MathVariables* self,
                         const gchar* name,
                         Number* value);
Number* math_variables_get (MathVariables* self,
                            const gchar* name);
void math_variables_delete (MathVariables* self,
                            const gchar* name);
Number* number_new_integer (gint64 real,
                            gint64 imag);
Number* number_construct_integer (GType object_type,
                                  gint64 real,
                                  gint64 imag);
Number* number_new_unsigned_integer (guint64 real,
                                     guint64 imag);
Number* number_construct_unsigned_integer (GType object_type,
                                           guint64 real,
                                           guint64 imag);
Number* number_new_fraction (gint64 numerator,
                             gint64 denominator);
Number* number_construct_fraction (GType object_type,
                                   gint64 numerator,
                                   gint64 denominator);
Number* number_new_mpreal (__mpfr_struct* real,
                           __mpfr_struct* imag);
Number* number_construct_mpreal (GType object_type,
                                 __mpfr_struct* real,
                                 __mpfr_struct* imag);
Number* number_new_double (gdouble real,
                           gdouble imag);
Number* number_construct_double (GType object_type,
                                 gdouble real,
                                 gdouble imag);
Number* number_new_complex (Number* r,
                            Number* i);
Number* number_construct_complex (GType object_type,
                                  Number* r,
                                  Number* i);
Number* number_new_polar (Number* r,
                          Number* theta,
                          AngleUnit unit);
Number* number_construct_polar (GType object_type,
                                Number* r,
                                Number* theta,
                                AngleUnit unit);
Number* number_new_eulers (void);
Number* number_construct_eulers (GType object_type);
Number* number_new_i (void);
Number* number_construct_i (GType object_type);
Number* number_new_pi (void);
Number* number_construct_pi (GType object_type);
Number* number_new_random (void);
Number* number_construct_random (GType object_type);
gint64 number_to_integer (Number* self);
guint64 number_to_unsigned_integer (Number* self);
gfloat number_to_float (Number* self);
gdouble number_to_double (Number* self);
gboolean number_is_zero (Number* self);
gboolean number_is_negative (Number* self);
gboolean number_is_integer (Number* self);
gboolean number_is_positive_integer (Number* self);
gboolean number_is_natural (Number* self);
gboolean number_is_complex (Number* self);
void number_check_flags (void);
gboolean number_equals (Number* self,
                        Number* y);
gint number_compare (Number* self,
                     Number* y);
Number* number_sgn (Number* self);
Number* number_invert_sign (Number* self);
Number* number_abs (Number* self);
Number* number_arg (Number* self,
                    AngleUnit unit);
Number* number_conjugate (Number* self);
Number* number_real_component (Number* self);
Number* number_imaginary_component (Number* self);
Number* number_integer_component (Number* self);
Number* number_fractional_component (Number* self);
Number* number_fractional_part (Number* self);
Number* number_floor (Number* self);
Number* number_ceiling (Number* self);
Number* number_round (Number* self);
Number* number_reciprocal (Number* self);
Number* number_epowy (Number* self);
Number* number_xpowy (Number* self,
                      Number* y);
Number* number_xpowy_integer (Number* self,
                              gint64 n);
Number* number_root (Number* self,
                     gint64 n);
Number* number_sqrt (Number* self);
Number* number_ln (Number* self);
Number* number_logarithm (Number* self,
                          gint64 n);
Number* number_factorial (Number* self);
Number* number_add (Number* self,
                    Number* y);
Number* number_subtract (Number* self,
                         Number* y);
Number* number_multiply (Number* self,
                         Number* y);
Number* number_multiply_integer (Number* self,
                                 gint64 y);
Number* number_divide (Number* self,
                       Number* y);
Number* number_divide_integer (Number* self,
                               gint64 y);
Number* number_modulus_divide (Number* self,
                               Number* y);
Number* number_modular_exponentiation (Number* self,
                                       Number* exp,
                                       Number* mod);
Number* number_sin (Number* self,
                    AngleUnit unit);
Number* number_cos (Number* self,
                    AngleUnit unit);
Number* number_tan (Number* self,
                    AngleUnit unit);
Number* number_asin (Number* self,
                     AngleUnit unit);
Number* number_acos (Number* self,
                     AngleUnit unit);
Number* number_atan (Number* self,
                     AngleUnit unit);
Number* number_sinh (Number* self);
Number* number_cosh (Number* self);
Number* number_tanh (Number* self);
Number* number_asinh (Number* self);
Number* number_acosh (Number* self);
Number* number_atanh (Number* self);
Number* number_and (Number* self,
                    Number* y);
Number* number_or (Number* self,
                   Number* y);
Number* number_xor (Number* self,
                    Number* y);
Number* number_not (Number* self,
                    gint wordlen);
Number* number_mask (Number* self,
                     Number* x,
                     gint wordlen);
Number* number_shift (Number* self,
                      gint count);
Number* number_ones_complement (Number* self,
                                gint wordlen);
Number* number_twos_complement (Number* self,
                                gint wordlen);
GList* number_factorize (Number* self);
GList* number_factorize_uint64 (Number* self,
                                guint64 n);
Number* number_new (void);
Number* number_construct (GType object_type);
mpfr_prec_t number_get_precision (void);
void number_set_precision (mpfr_prec_t value);
const gchar* number_get_error (void);
void number_set_error (const gchar* value);
Number* mp_set_from_string (const gchar* str,
                            gint default_base);
gboolean mp_is_overflow (Number* x,
                         gint wordlen);
Serializer* serializer_new (DisplayFormat format,
                            gint number_base,
                            gint trailing_digits);
Serializer* serializer_construct (GType object_type,
                                  DisplayFormat format,
                                  gint number_base,
                                  gint trailing_digits);
gchar* serializer_to_string (Serializer* self,
                             Number* x);
Number* serializer_from_string (Serializer* self,
                                const gchar* str);
void serializer_set_base (Serializer* self,
                          gint number_base);
gint serializer_get_base (Serializer* self);
void serializer_set_representation_base (Serializer* self,
                                         guint representation_base);
guint serializer_get_representation_base (Serializer* self);
void serializer_set_radix (Serializer* self,
                           gunichar radix);
gunichar serializer_get_radix (Serializer* self);
void serializer_set_thousands_separator (Serializer* self,
                                         gunichar separator);
gunichar serializer_get_thousands_separator (Serializer* self);
gint serializer_get_thousands_separator_count (Serializer* self);
void serializer_set_thousands_separator_count (Serializer* self,
                                               gint count);
void serializer_set_show_thousands_separators (Serializer* self,
                                               gboolean visible);
gboolean serializer_get_show_thousands_separators (Serializer* self);
void serializer_set_show_trailing_zeroes (Serializer* self,
                                          gboolean visible);
gboolean serializer_get_show_trailing_zeroes (Serializer* self);
gint serializer_get_leading_digits (Serializer* self);
void serializer_set_leading_digits (Serializer* self,
                                    gint leading_digits);
gint serializer_get_trailing_digits (Serializer* self);
void serializer_set_trailing_digits (Serializer* self,
                                     gint trailing_digits);
DisplayFormat serializer_get_number_format (Serializer* self);
void serializer_set_number_format (Serializer* self,
                                   DisplayFormat format);
const gchar* serializer_get_error (Serializer* self);
void serializer_set_error (Serializer* self,
                           const gchar* value);
GType unit_manager_get_type (void) G_GNUC_CONST;
UnitManager* unit_manager_new (void);
UnitManager* unit_manager_construct (GType object_type);
UnitManager* unit_manager_get_default (void);
GType unit_category_get_type (void) G_GNUC_CONST;
UnitCategory* unit_manager_add_category (UnitManager* self,
                                         const gchar* name,
                                         const gchar* display_name);
GList* unit_manager_get_categories (UnitManager* self);
UnitCategory* unit_manager_get_category (UnitManager* self,
                                         const gchar* category);
GType unit_get_type (void) G_GNUC_CONST;
Unit* unit_manager_get_unit_by_name (UnitManager* self,
                                     const gchar* name);
Unit* unit_manager_get_unit_by_symbol (UnitManager* self,
                                       const gchar* symbol);
gboolean unit_manager_unit_is_defined (UnitManager* self,
                                       const gchar* name);
Number* unit_manager_convert_by_symbol (UnitManager* self,
                                        Number* x,
                                        const gchar* x_symbol,
                                        const gchar* z_symbol);
UnitCategory* unit_category_new (const gchar* name,
                                 const gchar* display_name);
UnitCategory* unit_category_construct (GType object_type,
                                       const gchar* name,
                                       const gchar* display_name);
void unit_category_add_unit (UnitCategory* self,
                             Unit* unit);
Unit* unit_category_get_unit_by_name (UnitCategory* self,
                                      const gchar* name,
                                      gboolean case_sensitive);
Unit* unit_category_get_unit_by_symbol (UnitCategory* self,
                                        const gchar* symbol,
                                        gboolean case_sensitive);
GList* unit_category_get_units (UnitCategory* self);
Number* unit_category_convert (UnitCategory* self,
                               Number* x,
                               Unit* x_units,
                               Unit* z_units);
gchar* unit_category_get_name (UnitCategory* self);
gchar* unit_category_get_display_name (UnitCategory* self);
Unit* unit_new (const gchar* name,
                const gchar* display_name,
                const gchar* format,
                const gchar* from_function,
                const gchar* to_function,
                const gchar* symbols);
Unit* unit_construct (GType object_type,
                      const gchar* name,
                      const gchar* display_name,
                      const gchar* format,
                      const gchar* from_function,
                      const gchar* to_function,
                      const gchar* symbols);
gboolean unit_matches_symbol (Unit* self,
                              const gchar* symbol,
                              gboolean case_sensitive);
GList* unit_get_symbols (Unit* self);
Number* unit_convert_from (Unit* self,
                           Number* x);
Number* unit_convert_to (Unit* self,
                         Number* x);
gchar* unit_format (Unit* self,
                    Number* x);
gchar* unit_get_name (Unit* self);
gchar* unit_get_display_name (Unit* self);


G_END_DECLS

#endif
