Public API

View Module Index

class sire.cas.Expression

An Expression is the base class of all algebraic entities.

Author: Christopher Woods

add((Expression)arg1, (Expression)ex) → Expression :

Return this expression added to ex

C++ signature :

SireCAS::Expression add(SireCAS::Expression {lvalue},SireCAS::Expression)

add( (Expression)arg1, (float)val) -> Expression :

Return this expression added to val

C++ signature :

SireCAS::Expression add(SireCAS::Expression {lvalue},double)

add( (Expression)arg1, (Complex)val) -> Expression :

Return this expression added to val

C++ signature :

SireCAS::Expression add(SireCAS::Expression {lvalue},SireMaths::Complex)

assign((Expression)arg1, (Expression)other) → Expression :

C++ signature :

SireCAS::Expression {lvalue} assign(SireCAS::Expression {lvalue},SireCAS::Expression)

base((Expression)arg1) → ExpressionBase :

Return the ExpressionBase base-part of this expression

C++ signature :

SireCAS::ExpressionBase base(SireCAS::Expression {lvalue})

children((Expression)arg1) → object :

Return the child expressions that make up this expression

C++ signature :

SireCAS::Expressions children(SireCAS::Expression {lvalue})

clone((Expression)arg1) → Expression :

C++ signature :

SireCAS::Expression clone(SireCAS::Expression)

conjugate((Expression)arg1) → Expression :

Return the complex conjugate of this expression

C++ signature :

SireCAS::Expression conjugate(SireCAS::Expression {lvalue})

cubed((Expression)arg1) → Expression :

Return the cube of this expression

C++ signature :

SireCAS::Expression cubed(SireCAS::Expression {lvalue})

diff((Expression)arg1, (Symbol)symbol[, (int)level=1]) → Expression :

Synonym for differentiate

C++ signature :

SireCAS::Expression diff(SireCAS::Expression {lvalue},SireCAS::Symbol [,int=1])

differentiate((Expression)arg1, (Symbol)symbol[, (int)level=1]) → Expression :

Differentiate this expression with respect to symbol and return the resulting expression. Throw: SireCAS::unavailable_differential

C++ signature :

SireCAS::Expression differentiate(SireCAS::Expression {lvalue},SireCAS::Symbol [,int=1])

divide((Expression)arg1, (Expression)ex) → Expression :

Return an expression that is this ex

C++ signature :

SireCAS::Expression divide(SireCAS::Expression {lvalue},SireCAS::Expression)

divide( (Expression)arg1, (float)val) -> Expression :

Return an expression that is this divided by val

C++ signature :

SireCAS::Expression divide(SireCAS::Expression {lvalue},double)

divide( (Expression)arg1, (Complex)val) -> Expression :

Return an expression that is divided by the complex number z

C++ signature :

SireCAS::Expression divide(SireCAS::Expression {lvalue},SireMaths::Complex)

evaluate((Expression)arg1, (Values)values) → float :

Evaluate the numerical value of this expression, using the values

supplied in values. Any unidentified symbols or functions are assumed to be equal to zero. Note that this only performs real-arithmetic, so an exception will be thrown if any part of this expression generates a complex result. Throw: SireMaths::domain_error

C++ signature :

double evaluate(SireCAS::Expression {lvalue},SireCAS::Values)

evaluate( (Expression)arg1, (ComplexValues)values) -> Complex :

Evaluate the numerical value of this expression using complex arithmetic. Any unidentified symbols or functions are assumed to be equal to zero.

C++ signature :

SireMaths::Complex evaluate(SireCAS::Expression {lvalue},SireCAS::ComplexValues)

expand((Expression)arg1, (Symbol)symbol) → object :

Return the factors and powers for the symbol symbol, given the values of the other symbols in values. This attempts to rearrange this equation so that it is of the form m symbol^i + n symbol^j … + constant, and it returns the values of m,i, n,j etc.. Note that this will fail if such a rearrangement is not possible Throw: SireCAS::rearrangement_error

C++ signature :

QList<SireCAS::Factor> expand(SireCAS::Expression {lvalue},SireCAS::Symbol)

factor((Expression)arg1) → float :

Return the factor of this expression

C++ signature :

double factor(SireCAS::Expression {lvalue})

functions((Expression)arg1) → object :

Return all of the functions used in this expression

C++ signature :

SireCAS::Functions functions(SireCAS::Expression {lvalue})

hash((Expression)arg1) → int :

C++ signature :

unsigned int hash(SireCAS::Expression {lvalue})

integ((Expression)arg1, (Symbol)symbol) → Expression :

Synonym for integrate

C++ signature :

SireCAS::Expression integ(SireCAS::Expression {lvalue},SireCAS::Symbol)

integrate((Expression)arg1, (Symbol)symbol) → Expression :

Integrate this expression with respect to symbol and return the resulting expression. Throw: SireCAS::unavailable_integral

C++ signature :

SireCAS::Expression integrate(SireCAS::Expression {lvalue},SireCAS::Symbol)

invert((Expression)arg1) → Expression :

Return 1 expression

C++ signature :

SireCAS::Expression invert(SireCAS::Expression {lvalue})

is_complex()

isComplex( (Expression)arg1) -> bool :

Return whether or not this expression has complex parts

C++ signature :

bool isComplex(SireCAS::Expression {lvalue})

is_compound()

isCompound( (Expression)arg1) -> bool :

Return whether or not this is a compound expression (contains more than a single expression, e.g. Sum, Product or PowerFunction)

C++ signature :

bool isCompound(SireCAS::Expression {lvalue})

is_constant()

isConstant( (Expression)arg1) -> bool :

Return whether or not this expression is constant for all values

C++ signature :

bool isConstant(SireCAS::Expression {lvalue})

is_function()

isFunction( (Expression)arg1, (Symbol)symbol) -> bool :

Return whether or not this is a function of symbol

C++ signature :

bool isFunction(SireCAS::Expression {lvalue},SireCAS::Symbol)

is_zero()

isZero( (Expression)arg1) -> bool :

Return whether or not this expression is equal to 0 for all values

C++ signature :

bool isZero(SireCAS::Expression {lvalue})

multiply((Expression)arg1, (Expression)ex) → Expression :

Return an expression that is this multiplied by ex

C++ signature :

SireCAS::Expression multiply(SireCAS::Expression {lvalue},SireCAS::Expression)

multiply( (Expression)arg1, (float)val) -> Expression :

Return an expression that is this multipled by val

C++ signature :

SireCAS::Expression multiply(SireCAS::Expression {lvalue},double)

multiply( (Expression)arg1, (Complex)val) -> Expression :

Return an expression that is this multiplied by the complex value z

C++ signature :

SireCAS::Expression multiply(SireCAS::Expression {lvalue},SireMaths::Complex)

negate((Expression)arg1) → Expression :

Return the negative of this expression

C++ signature :

SireCAS::Expression negate(SireCAS::Expression {lvalue})

pow((Expression)arg1, (int)n) → Expression :

Return this expression raised to the power n

C++ signature :

SireCAS::Expression pow(SireCAS::Expression {lvalue},int)

pow( (Expression)arg1, (float)n) -> Expression :

Return this expression raised to a real number power

C++ signature :

SireCAS::Expression pow(SireCAS::Expression {lvalue},double)

pow( (Expression)arg1, (Complex)n) -> Expression :

Return this expresssion raised to a complex power

C++ signature :

SireCAS::Expression pow(SireCAS::Expression {lvalue},SireMaths::Complex)

pow( (Expression)arg1, (Rational)n) -> Expression :

Return this expression raised to the rational power n

C++ signature :

SireCAS::Expression pow(SireCAS::Expression {lvalue},SireMaths::Rational)

pow( (Expression)arg1, (Expression)n) -> Expression :

Return this expression raised to a function

C++ signature :

SireCAS::Expression pow(SireCAS::Expression {lvalue},SireCAS::Expression)

root((Expression)arg1, (int)n) → Expression :

Return the nth root of this expression

C++ signature :

SireCAS::Expression root(SireCAS::Expression {lvalue},int)

series((Expression)arg1, (Symbol)symbol, (int)order) → Expression :

Return a series expansion of this function with respect to symbol up to order n. If an expansion is not possible, then this just returns this expression

C++ signature :

SireCAS::Expression series(SireCAS::Expression {lvalue},SireCAS::Symbol,int)

simplify((Expression)arg1[, (int)options=0]) → Expression :

Try to simplify this expression by using built-in identities. If SireCAS::UNSAFE_COMPLEX_SIMPLIFICATIONS is passed, then allow the use of identities that are not necessarily true in the complex domain, e.g. z = sin(arcsin(z))

C++ signature :

SireCAS::Expression simplify(SireCAS::Expression {lvalue} [,int=0])

squared((Expression)arg1) → Expression :

Return the square of this expression

C++ signature :

SireCAS::Expression squared(SireCAS::Expression {lvalue})

substitute((Expression)arg1, (Identities)identities) → Expression :

Return an expression whereby the identities in identities have been substituted into this expression

C++ signature :

SireCAS::Expression substitute(SireCAS::Expression {lvalue},SireCAS::Identities)

subtract((Expression)arg1, (Expression)ex) → Expression :

Return an expression that is this - ex

C++ signature :

SireCAS::Expression subtract(SireCAS::Expression {lvalue},SireCAS::Expression)

subtract( (Expression)arg1, (float)val) -> Expression :

Return an expression that is this - val

C++ signature :

SireCAS::Expression subtract(SireCAS::Expression {lvalue},double)

subtract( (Expression)arg1, (Complex)val) -> Expression :

Return an expression that is this - val

C++ signature :

SireCAS::Expression subtract(SireCAS::Expression {lvalue},SireMaths::Complex)

symbols((Expression)arg1) → object :

Return all of the symbols used in this expression

C++ signature :

SireCAS::Symbols symbols(SireCAS::Expression {lvalue})

to_open_m_m_string()

toOpenMMString( (Expression)arg1) -> object :

Return a string representation of this expression in the OpenMM syntax

C++ signature :

QString toOpenMMString(SireCAS::Expression {lvalue})

to_string()

toString( (Expression)arg1) -> object :

Return a string representation of this expression

C++ signature :

QString toString(SireCAS::Expression {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((Expression)arg1) → str :

C++ signature :

char const* what(SireCAS::Expression {lvalue})

class sire.cas.Symbol

This class represents an algebraic symbol in the equation (e.g. x or y)

Author: Christopher Woods

assign((Symbol)arg1, (Symbol)other) → Symbol :

C++ signature :

SireCAS::Symbol {lvalue} assign(SireCAS::Symbol {lvalue},SireCAS::Symbol)

assign( (Symbol)arg1, (int)symid) -> Symbol :

C++ signature :

SireCAS::Symbol {lvalue} assign(SireCAS::Symbol {lvalue},unsigned int)

children((Symbol)arg1) → object :

There are no child expressions in a symbol

C++ signature :

SireCAS::Expressions children(SireCAS::Symbol {lvalue})

clone((Symbol)arg1) → Symbol :

C++ signature :

SireCAS::Symbol clone(SireCAS::Symbol)

differentiate((Symbol)arg1, (Symbol)symbol) → Expression :

Differentiate this symbol with respect to sym. This returns 1.0 if this is sym, else it returns 0.0

C++ signature :

SireCAS::Expression differentiate(SireCAS::Symbol {lvalue},SireCAS::Symbol)

evaluate((Symbol)arg1, (Values)values) → float :

Evaluate this symbol - returns the value of the symbol in values if

it is present, else it returns 0.0

C++ signature :

double evaluate(SireCAS::Symbol {lvalue},SireCAS::Values)

evaluate( (Symbol)arg1, (ComplexValues)values) -> Complex :

Evaluate this symbol - returns the value of the symbol in values if it is present, else it returns 0

C++ signature :

SireMaths::Complex evaluate(SireCAS::Symbol {lvalue},SireCAS::ComplexValues)

expand((Symbol)arg1, (Symbol)symbol) → object :

C++ signature :

QList<SireCAS::Factor> expand(SireCAS::Symbol {lvalue},SireCAS::Symbol)

functions((Symbol)arg1) → object :

This is not a function

C++ signature :

SireCAS::Functions functions(SireCAS::Symbol {lvalue})

hash((Symbol)arg1) → int :

Hash a symbol

C++ signature :

unsigned int hash(SireCAS::Symbol {lvalue})

id()

ID( (Symbol)arg1) -> int :

Return the unique ID number of the symbol

C++ signature :

unsigned int ID(SireCAS::Symbol {lvalue})

integrate((Symbol)arg1, (Symbol)symbol) → Expression :

Integrate this symbol with respect to sym. If sym == this, then return 0.5 sym^2, else return this sym

C++ signature :

SireCAS::Expression integrate(SireCAS::Symbol {lvalue},SireCAS::Symbol)

is_constant()

isConstant( (Symbol)arg1) -> bool :

A symbol is by definition not constant

C++ signature :

bool isConstant(SireCAS::Symbol {lvalue})

is_function()

isFunction( (Symbol)arg1, (Symbol)arg0) -> bool :

Is this a function of symbol

C++ signature :

bool isFunction(SireCAS::Symbol {lvalue},SireCAS::Symbol)

is_null()

isNull( (Symbol)arg1) -> bool :

Return whether or not the symbol is null

C++ signature :

bool isNull(SireCAS::Symbol {lvalue})

substitute((Symbol)arg1, (Identities)identities) → Expression :

Return the expression that matches this symbol in identities - or return an expression holding only this symbol if it does no exist in identities

C++ signature :

SireCAS::Expression substitute(SireCAS::Symbol {lvalue},SireCAS::Identities)

symbols((Symbol)arg1) → object :

Return this symbol

C++ signature :

SireCAS::Symbols symbols(SireCAS::Symbol {lvalue})

to_string()

toString( (Symbol)arg1) -> object :

Return a string representation of this symbol

C++ signature :

QString toString(SireCAS::Symbol {lvalue})

typename()

typeName() -> str :

C++ signature :

char const* typeName()

what((Symbol)arg1) → str :

C++ signature :

char const* what(SireCAS::Symbol {lvalue})

sire.cas.lam A Symbol representing λ.

This class represents an algebraic symbol in the equation (e.g. x or y)

Author: Christopher Woods

sire.cas.x A Symbol representing x

This class represents an algebraic symbol in the equation (e.g. x or y)

Author: Christopher Woods

sire.cas.y A Symbol representing y

This class represents an algebraic symbol in the equation (e.g. x or y)

Author: Christopher Woods