Uses of Interface
calculator.Expression

Packages that use Expression

Package	Description
calculator
calculator.antlr
calculator.atoms
calculator.functions
calculator.operations

Uses of Expression in calculator

Methods in calculator with parameters of type Expression

Modifier and Type	Method	Description
Atom	Calculator.eval(Expression e)	Evaluates an arithmetic expression and returns its result
String	Calculator.format(Expression e, Notation notation)	Formats an arithmetic expression in a given notation
void	Calculator.print(Expression e)	Prints an arithmetic expression provided as input parameter.
void	Calculator.printExpressionDetails(Expression e)	Prints verbose details of an arithmetic expression provided as input parameter.

Uses of Expression in calculator.antlr

Subclasses with type arguments of type Expression in calculator.antlr

Modifier and Type	Class	Description
class	ParserVisitor	Builds Expression objects from the ANTLR parse tree.

Methods in calculator.antlr that return Expression

Modifier and Type	Method	Description
Expression	Parser.parse(String inputStr)	Analyze a string input and return an Expression object representing the parsed expression.
Expression	ParserVisitor.visitAtomComplex(calculatorParser.AtomComplexContext ctx)	Rule: atom : complex #AtomComplex
Expression	ParserVisitor.visitAtomNumber(calculatorParser.AtomNumberContext ctx)	Rule: atom : number #AtomNumber
Expression	ParserVisitor.visitCompleteInfix(calculatorParser.CompleteInfixContext ctx)	Rule: complete : expressionIN EOF #CompleteInfix
Expression	ParserVisitor.visitCompletePostfix(calculatorParser.CompletePostfixContext ctx)	Rule: complete : expressionPOST EOF #CompletePostfix
Expression	ParserVisitor.visitCompletePrefix(calculatorParser.CompletePrefixContext ctx)	Rule: complete : expressionPRE EOF #CompletePrefix
Expression	ParserVisitor.visitComplexNumber(calculatorParser.ComplexNumberContext ctx)	Rule: complex : number?
Expression	ParserVisitor.visitConstEuler(calculatorParser.ConstEulerContext ctx)	Rule: constant : EULER #ConstEuler
Expression	ParserVisitor.visitConstPi(calculatorParser.ConstPiContext ctx)	Rule: constant : PI #ConstPi
Expression	ParserVisitor.visitINAddSub(calculatorParser.INAddSubContext ctx)	Rule: expressionIN : multExp ((PLUS | MINUS) multExp)* #INAddSub
Expression	ParserVisitor.visitInfixFunctionCall(calculatorParser.InfixFunctionCallContext ctx)	Rule: functionIN : funcname LPAR expressionIN (COMMA expressionIN)* RPAR #InfixFunctionCall
Expression	ParserVisitor.visitINFunction(calculatorParser.INFunctionContext ctx)	Rule: atomIN : functionIN #INFunction
Expression	ParserVisitor.visitINImplicitMult(calculatorParser.INImplicitMultContext ctx)	Rule: atomIN : (LPAR expressionIN RPAR)?
Expression	ParserVisitor.visitINMult(calculatorParser.INMultContext ctx)	Rule: multExp : powExp (LPAR powExp RPAR)* #INMult
Expression	ParserVisitor.visitINParenthesis(calculatorParser.INParenthesisContext ctx)	Rule: atomIN : (LPAR expressionIN RPAR) #INParenthesis
Expression	ParserVisitor.visitINPow(calculatorParser.INPowContext ctx)	Rule: powExp : atomIN (POW atomIN)* #INPow
Expression	ParserVisitor.visitINSignedAtom(calculatorParser.INSignedAtomContext ctx)	Rule: atomIN : (PLUS | MINUS)* atom (constant)* #INSignedAtom
Expression	ParserVisitor.visitINTimesDiv(calculatorParser.INTimesDivContext ctx)	Rule: multExp : powExp ((TIMES | DIV) powExp)* #INTimesDiv
Expression	ParserVisitor.visitNumberConstant(calculatorParser.NumberConstantContext ctx)	Rule: number : constant #NumberConstant
Expression	ParserVisitor.visitNumberReal(calculatorParser.NumberRealContext ctx)	Rule: number : real #NumberReal
Expression	ParserVisitor.visitNumberScientific(calculatorParser.NumberScientificContext ctx)	Rule: number : scientific #NumberScientific
Expression	ParserVisitor.visitPost2Param(calculatorParser.Post2ParamContext ctx)	Rule: expressionPOST : expressionPOST expressionPOST operator #Post2Param
Expression	ParserVisitor.visitPostAtom(calculatorParser.PostAtomContext ctx)	Rule: expressionPOST : atom #PostAtom
Expression	ParserVisitor.visitPostFunc(calculatorParser.PostFuncContext ctx)	Rule: expressionPOST : LPAR expressionPOST+ RPAR funcname | LPAR expressionPOST (COMMA expressionPOST)* RPAR funcname #PostFunc
Expression	ParserVisitor.visitPostFunc1Param(calculatorParser.PostFunc1ParamContext ctx)	Rule: expressionPOST : expressionPOST funcname #PostFunc1Param
Expression	ParserVisitor.visitPostMult(calculatorParser.PostMultContext ctx)	Rule: expressionPOST : LPAR expressionPOST expressionPOST+ RPAR | LPAR expressionPOST (COMMA expressionPOST)+ RPAR #PostMult
Expression	ParserVisitor.visitPostPlus2Param(calculatorParser.PostPlus2ParamContext ctx)	Rule: expressionPOST : LPAR expressionPOST expressionPOST+ RPAR operator | LPAR expressionPOST (COMMA expressionPOST)+ RPAR operator #PostPlus2Param
Expression	ParserVisitor.visitPre2Param(calculatorParser.Pre2ParamContext ctx)	Rule: expressionPRE : operator expressionPRE expressionPRE #Pre2Param
Expression	ParserVisitor.visitPreAtom(calculatorParser.PreAtomContext ctx)	Rule: expressionPRE : atom #PreAtom
Expression	ParserVisitor.visitPreFunc(calculatorParser.PreFuncContext ctx)	Rule: expressionPRE : funcname LPAR expressionPRE+ RPAR | funcname LPAR expressionPRE (COMMA expressionPRE)* RPAR #PreFunc
Expression	ParserVisitor.visitPreFunc1Param(calculatorParser.PreFunc1ParamContext ctx)	Rule: expressionPRE : funcname expressionPRE #PreFunc1Param
Expression	ParserVisitor.visitPreMult(calculatorParser.PreMultContext ctx)	Rule: expressionPRE : LPAR expressionPRE expressionPRE+ RPAR | LPAR expressionPRE (COMMA expressionPRE)+ RPAR #PreMult
Expression	ParserVisitor.visitPrePlus2Param(calculatorParser.PrePlus2ParamContext ctx)	Rule: expressionPRE : operator LPAR expressionPRE expressionPRE+ RPAR | operator LPAR expressionPRE (COMMA expressionPRE)+ RPAR #PrePlus2Param
Expression	ParserVisitor.visitRealNumber(calculatorParser.RealNumberContext ctx)	Rule: real : INT (DOT INT)?
Expression	ParserVisitor.visitScientificNumber(calculatorParser.ScientificNumberContext ctx)	Rule: scientific : (real | INT) E (PLUS | MINUS)?

Uses of Expression in calculator.atoms

Subinterfaces of Expression in calculator.atoms

Modifier and Type	Interface	Description
interface	Atom	Atom abstract class An Atom represents a number (or an operand of operations).

Classes in calculator.atoms that implement Expression

Modifier and Type	Class	Description
class	Complex	Complex Number type is used to represent complex e.g. 3 + 2i
class	IntegerAtom	IntegerAtom is a concrete class that represents arithmetic (integer) numbers, which are Atoms, a special kind of Expressions, just like operations are.
class	Rationnal	Rationnal Number type is used to represent fractions e.g. 1/2
class	Real	Real is a concrete class that represents arithmetic (Real) numbers, which are Atoms, a special kind of Expressions.

Uses of Expression in calculator.functions

Classes in calculator.functions that implement Expression

Modifier and Type	Class	Description
final class	Arccosinus	This class represents the arithmetic unary operation "acos".
final class	Arcsinus	This class represents the arithmetic unary operation "asin".
final class	Arctangente	This class represents the arithmetic unary operation "atan".
class	BinaryFunction
final class	Cosh	This class represents the arithmetic unary operation "cosh".
final class	Cosinus	This class represents the arithmetic unary operation "cos".
final class	Ln	This class represents the natural logarithm unary operation "ln".
class	Log	This class represents the arithmetic binary operation "log(x, base)".
final class	Sinh	This class represents the arithmetic unary operation "sinh".
final class	Sinus	This class represents the arithmetic unary operation "sin".
final class	Sqrt	This class represents the square root unary operation "sqrt".
final class	Tangente	This class represents the arithmetic unary operation "tan".
final class	Tanh	This class represents the arithmetic unary operation "tanh".
class	UnaryFunction	UnaryFunction is an abstract class that represents unary arithmetic operations, which are a special kind of Expressions, just like binary operations are.

Fields in calculator.functions declared as Expression

Modifier and Type	Field	Description
Expression	UnaryFunction.arg	The expression passed as an argument to the arithmetic operation

Methods in calculator.functions that return Expression

Modifier and Type	Method	Description
Expression	UnaryFunction.getArg()	getter method to return the argument of an arithmetic operation.
Expression	BinaryFunction.getFirstArg()
Expression	BinaryFunction.getSecondArg()

Methods in calculator.functions with parameters of type Expression

Modifier and Type	Method	Description
void	BinaryFunction.setFirstArg(Expression firstArg)
void	BinaryFunction.setSecondArg(Expression secondArg)

Constructors in calculator.functions with parameters of type Expression

Modifier	Constructor	Description
	Arccosinus(Expression arg)	Class constructor specifying an Expression to apply the arccosine function.
	Arcsinus(Expression arg)	Class constructor specifying an Expression to apply the arcsine function.
	Arctangente(Expression arg)	Class constructor specifying an Expression to apply the arctangent function.
	BinaryFunction(Expression firstArg, Expression secondArg)
	Cosh(Expression arg)	Class constructor specifying an Expression to apply the hyperbolic cosine function.
	Cosinus(Expression arg)	Class constructor specifying an Expression to apply the cosine function.
	Ln(Expression arg)
	Log(Expression base, Expression number)
	Sinh(Expression arg)	Class constructor specifying an Expression to apply the hyperbolic sine function.
	Sinus(Expression arg)	Class constructor specifying an Expression to apply the sine function.
	Sqrt(Expression arg)
	Tangente(Expression arg)	Class constructor specifying an Expression to apply the tangent function.
	Tanh(Expression arg)	Class constructor specifying an Expression to apply the hyperbolic tangent function.
protected	UnaryFunction(Expression arg)	To construct a unary operation with an expression as argument

Uses of Expression in calculator.operations

Classes in calculator.operations that implement Expression

Modifier and Type	Class	Description
final class	Divides	This class represents the arithmetic division operation "/".
final class	Minus	This class represents the arithmetic operation "-".
class	Operation	Operation is an abstract class that represents arithmetic operations, which are a special kind of Expressions, just like numbers are.
final class	Plus	This class represents the arithmetic sum operation "+".
final class	Power
final class	Times	This class represents the arithmetic multiplication operation "*".

Fields in calculator.operations with type parameters of type Expression

Modifier and Type	Field	Description
List<Expression>	Operation.args	The list of expressions passed as an argument to the arithmetic operation

Methods in calculator.operations that return types with arguments of type Expression

Modifier and Type	Method	Description
List<Expression>	Operation.getArgs()	getter method to return the number of arguments of an arithmetic operation.

Method parameters in calculator.operations with type arguments of type Expression

Modifier and Type	Method	Description
void	Operation.addMoreParams(List<Expression> params)	Add more parameters to the existing list of parameters

Constructor parameters in calculator.operations with type arguments of type Expression

Modifier	Constructor	Description
	Divides(List<Expression> elist)	Class constructor specifying a number of Expressions to divide.
	Minus(List<Expression> elist)	Class constructor specifying a number of Expressions to subtract.
protected	Operation(List<Expression> elist)	To construct an operation with a list of expressions as arguments, as well as the Notation used to represent the operation.
	Plus(List<Expression> elist)	Class constructor specifying a number of Expressions to add.
	Power(List<Expression> elist)
	Times(List<Expression> elist)	Class constructor specifying a number of Expressions to multiply.