expression_parser¶

Bindings for numeric::expression_parser namespace

class pyrosetta.rosetta.numeric.expression_parser.ASTPrinter¶

Bases: ASTVisitor

Traverse the AST and print it to standard out

assign(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ASTVisitor) → pyrosetta.rosetta.numeric.expression_parser.ASTVisitor¶: C++: numeric::expression_parser::ASTVisitor::operator=(const class numeric::expression_parser::ASTVisitor &) –> class numeric::expression_parser::ASTVisitor &

ast_string(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, node: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) → str¶: C++: numeric::expression_parser::ASTPrinter::ast_string(const class numeric::expression_parser::ArithmeticASTNode &) –> std::string

pretty(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, setting: bool) → None¶: C++: numeric::expression_parser::ASTPrinter::pretty(bool) –> void

visit(*args, **kwargs)¶

Overloaded function.

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTFunction &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTFactor &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTValue &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTRestTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTRestAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTRestOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTRestExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTPrinter, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) -> None

C++: numeric::expression_parser::ASTPrinter::visit(const class numeric::expression_parser::ArithmeticASTNode &) –> void

class pyrosetta.rosetta.numeric.expression_parser.ASTVisitor¶

Bases: pybind11_object

Double-dispatch visitor pattern for abstract syntax tree

assign(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ASTVisitor) → pyrosetta.rosetta.numeric.expression_parser.ASTVisitor¶: C++: numeric::expression_parser::ASTVisitor::operator=(const class numeric::expression_parser::ASTVisitor &) –> class numeric::expression_parser::ASTVisitor &

visit(*args, **kwargs)¶

Overloaded function.

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTFunction &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTFactor &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTValue &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTRestTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTRestAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTRestOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTRestExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ASTVisitor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) -> None

C++: numeric::expression_parser::ASTVisitor::visit(const class numeric::expression_parser::ArithmeticASTNode &) –> void

class pyrosetta.rosetta.numeric.expression_parser.AbsoluteValueExpression¶

Bases: UnaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::UnaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.AbsoluteValueExpression, : pyrosetta.rosetta.numeric.expression_parser.AbsoluteValueExpression) → pyrosetta.rosetta.numeric.expression_parser.AbsoluteValueExpression¶: C++: numeric::expression_parser::AbsoluteValueExpression::operator=(const class numeric::expression_parser::AbsoluteValueExpression &) –> class numeric::expression_parser::AbsoluteValueExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.AbsoluteValueExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::AbsoluteValueExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

ex(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::UnaryExpression::ex() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_expression(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression, ex: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::UnaryExpression::set_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.AddExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.AddExpression, : pyrosetta.rosetta.numeric.expression_parser.AddExpression) → pyrosetta.rosetta.numeric.expression_parser.AddExpression¶: C++: numeric::expression_parser::AddExpression::operator=(const class numeric::expression_parser::AddExpression &) –> class numeric::expression_parser::AddExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.AddExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::AddExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.AndExpression¶

Bases: BinaryExpression

Boolean Logic Operators

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.AndExpression, : pyrosetta.rosetta.numeric.expression_parser.AndExpression) → pyrosetta.rosetta.numeric.expression_parser.AndExpression¶: C++: numeric::expression_parser::AndExpression::operator=(const class numeric::expression_parser::AndExpression &) –> class numeric::expression_parser::AndExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.AndExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::AndExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause¶: C++: numeric::expression_parser::ArithmeticASTAndClause::operator=(const class numeric::expression_parser::ArithmeticASTAndClause &) –> class numeric::expression_parser::ArithmeticASTAndClause &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTAndClause::parse(class numeric::expression_parser::TokenSet &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTAndClause::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression¶: C++: numeric::expression_parser::ArithmeticASTExpression::operator=(const class numeric::expression_parser::ArithmeticASTExpression &) –> class numeric::expression_parser::ArithmeticASTExpression &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTExpression::parse(class numeric::expression_parser::TokenSet &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTExpression::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor¶: C++: numeric::expression_parser::ArithmeticASTFactor::operator=(const class numeric::expression_parser::ArithmeticASTFactor &) –> class numeric::expression_parser::ArithmeticASTFactor &

child(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode¶: C++: numeric::expression_parser::ArithmeticASTFactor::child() const –> class std::shared_ptr<const class numeric::expression_parser::ArithmeticASTNode>

not_token(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::ArithmeticASTFactor::not_token() const –> enum numeric::expression_parser::TokenType

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTFactor::parse(class numeric::expression_parser::TokenSet &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTFactor::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction¶: C++: numeric::expression_parser::ArithmeticASTFunction::operator=(const class numeric::expression_parser::ArithmeticASTFunction &) –> class numeric::expression_parser::ArithmeticASTFunction &

function(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) → pyrosetta.rosetta.numeric.expression_parser.FunctionToken¶: C++: numeric::expression_parser::ArithmeticASTFunction::function() const –> class std::shared_ptr<const class numeric::expression_parser::FunctionToken>

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTFunction::parse(class numeric::expression_parser::TokenSet &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTFunction::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode¶

Bases: pybind11_object

Base class for Abstract Syntax Tree (AST) for the simple Arithmetic language defined here.

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode¶: C++: numeric::expression_parser::ArithmeticASTNode::operator=(const class numeric::expression_parser::ArithmeticASTNode &) –> class numeric::expression_parser::ArithmeticASTNode &

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTNode::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause¶: C++: numeric::expression_parser::ArithmeticASTOrClause::operator=(const class numeric::expression_parser::ArithmeticASTOrClause &) –> class numeric::expression_parser::ArithmeticASTOrClause &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTOrClause::parse(class numeric::expression_parser::TokenSet &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTOrClause::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause¶: C++: numeric::expression_parser::ArithmeticASTRestAndClause::operator=(const class numeric::expression_parser::ArithmeticASTRestAndClause &) –> class numeric::expression_parser::ArithmeticASTRestAndClause &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTRestAndClause::parse(class numeric::expression_parser::TokenSet &) –> void

rest_and_clause_token(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::ArithmeticASTRestAndClause::rest_and_clause_token() const –> enum numeric::expression_parser::TokenType

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTRestAndClause::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression¶: C++: numeric::expression_parser::ArithmeticASTRestExpression::operator=(const class numeric::expression_parser::ArithmeticASTRestExpression &) –> class numeric::expression_parser::ArithmeticASTRestExpression &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTRestExpression::parse(class numeric::expression_parser::TokenSet &) –> void

rest_expression_token(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::ArithmeticASTRestExpression::rest_expression_token() const –> enum numeric::expression_parser::TokenType

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTRestExpression::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause¶: C++: numeric::expression_parser::ArithmeticASTRestOrClause::operator=(const class numeric::expression_parser::ArithmeticASTRestOrClause &) –> class numeric::expression_parser::ArithmeticASTRestOrClause &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTRestOrClause::parse(class numeric::expression_parser::TokenSet &) –> void

rest_or_clause_token(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::ArithmeticASTRestOrClause::rest_or_clause_token() const –> enum numeric::expression_parser::TokenType

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTRestOrClause::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm¶: C++: numeric::expression_parser::ArithmeticASTRestTerm::operator=(const class numeric::expression_parser::ArithmeticASTRestTerm &) –> class numeric::expression_parser::ArithmeticASTRestTerm &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTRestTerm::parse(class numeric::expression_parser::TokenSet &) –> void

rest_term_token(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::ArithmeticASTRestTerm::rest_term_token() const –> enum numeric::expression_parser::TokenType

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTRestTerm::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm¶

Bases: ArithmeticASTNode

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm¶: C++: numeric::expression_parser::ArithmeticASTTerm::operator=(const class numeric::expression_parser::ArithmeticASTTerm &) –> class numeric::expression_parser::ArithmeticASTTerm &

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTTerm::parse(class numeric::expression_parser::TokenSet &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTTerm::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue¶

Bases: ArithmeticASTNode

either a variable or a literal.

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue¶: C++: numeric::expression_parser::ArithmeticASTValue::operator=(const class numeric::expression_parser::ArithmeticASTValue &) –> class numeric::expression_parser::ArithmeticASTValue &

is_literal(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → bool¶: C++: numeric::expression_parser::ArithmeticASTValue::is_literal() const –> bool

literal_value(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → float¶: C++: numeric::expression_parser::ArithmeticASTValue::literal_value() const –> double

parse(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue, tokens: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::ArithmeticASTValue::parse(class numeric::expression_parser::TokenSet &) –> void

variable_name(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → str¶: C++: numeric::expression_parser::ArithmeticASTValue::variable_name() const –> std::string

visit(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue, visitor: numeric::expression_parser::ASTVisitor) → None¶: C++: numeric::expression_parser::ArithmeticASTValue::visit(class numeric::expression_parser::ASTVisitor &) const –> void

class pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner¶

Bases: pybind11_object

add_function(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, name: str, nargs: int) → None¶: C++: numeric::expression_parser::ArithmeticScanner::add_function(const std::string &, unsigned long) –> void

add_standard_functions(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner) → None¶

Add the functions min, max and sqrt.

C++: numeric::expression_parser::ArithmeticScanner::add_standard_functions() –> void

add_variable(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, name: str) → None¶: C++: numeric::expression_parser::ArithmeticScanner::add_variable(const std::string &) –> void

assign(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner) → pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner¶: C++: numeric::expression_parser::ArithmeticScanner::operator=(const class numeric::expression_parser::ArithmeticScanner &) –> class numeric::expression_parser::ArithmeticScanner &

scan(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, input_string: str) → pyrosetta.rosetta.numeric.expression_parser.TokenSet¶: C++: numeric::expression_parser::ArithmeticScanner::scan(const std::string &) –> class std::shared_ptr<class numeric::expression_parser::TokenSet>

treat_AND_and_OR_as_operators(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, setting: bool) → None¶: C++: numeric::expression_parser::ArithmeticScanner::treat_AND_and_OR_as_operators(bool) –> void

treat_NOT_as_operator(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, setting: bool) → None¶: C++: numeric::expression_parser::ArithmeticScanner::treat_NOT_as_operator(bool) –> void

class pyrosetta.rosetta.numeric.expression_parser.BinaryExpression¶

Bases: Expression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, : pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.BinaryExpression¶: C++: numeric::expression_parser::BinaryExpression::operator=(const class numeric::expression_parser::BinaryExpression &) –> class numeric::expression_parser::BinaryExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶

Returns the expression for the partial derivative of this expression: by the variable named varname. If the partial derivative is always zero with respect to varname, returns null.

C++: numeric::expression_parser::Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionCreator¶

Bases: SimpleExpressionCreator

add_variable(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, varname: str) → None¶: C++: numeric::expression_parser::SimpleExpressionCreator::add_variable(const std::string &) –> void

assign(self: pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionCreator) → pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionCreator¶: C++: numeric::expression_parser::BooleanExpressionCreator::operator=(const class numeric::expression_parser::BooleanExpressionCreator &) –> class numeric::expression_parser::BooleanExpressionCreator &

create_expression_tree(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) → numeric::expression_parser::Expression¶: C++: numeric::expression_parser::ExpressionCreator::create_expression_tree(const class numeric::expression_parser::ArithmeticASTExpression &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

get_variable(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, varname: str) → numeric::expression_parser::VariableExpression¶: C++: numeric::expression_parser::SimpleExpressionCreator::get_variable(const std::string &) –> class std::shared_ptr<class numeric::expression_parser::VariableExpression>

handle_function_expression(self: pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionCreator, function: pyrosetta.rosetta.numeric.expression_parser.FunctionToken, args: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_numeric_expression_parser_Expression_t) → numeric::expression_parser::Expression¶: C++: numeric::expression_parser::BooleanExpressionCreator::handle_function_expression(class std::shared_ptr<const class numeric::expression_parser::FunctionToken>, const class utility::vector1<class std::shared_ptr<const class numeric::expression_parser::Expression>, class std::allocator<class std::shared_ptr<const class numeric::expression_parser::Expression> > > &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

handle_variable_expression(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → numeric::expression_parser::Expression¶: C++: numeric::expression_parser::SimpleExpressionCreator::handle_variable_expression(const class numeric::expression_parser::ArithmeticASTValue &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

variables(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator) → pyrosetta.rosetta.std.map_std_string_std_shared_ptr_numeric_expression_parser_VariableExpression_t_std_allocator_std_pair_const_std_string_std_shared_ptr_numeric_expression_parser_VariableExpression_t¶: C++: numeric::expression_parser::SimpleExpressionCreator::variables() const –> class std::map<std::string, class std::shared_ptr<class numeric::expression_parser::VariableExpression>, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::shared_ptr<class numeric::expression_parser::VariableExpression> > > >

visit(*args, **kwargs)¶

Overloaded function.

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTFunction &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTFactor &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTValue &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTNode &) –> void

class pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionScanner¶

Bases: ArithmeticScanner

add_function(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, name: str, nargs: int) → None¶: C++: numeric::expression_parser::ArithmeticScanner::add_function(const std::string &, unsigned long) –> void

add_standard_functions(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner) → None¶

Add the functions min, max and sqrt.

C++: numeric::expression_parser::ArithmeticScanner::add_standard_functions() –> void

add_variable(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, name: str) → None¶: C++: numeric::expression_parser::ArithmeticScanner::add_variable(const std::string &) –> void

assign(self: pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionScanner, : pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionScanner) → pyrosetta.rosetta.numeric.expression_parser.BooleanExpressionScanner¶: C++: numeric::expression_parser::BooleanExpressionScanner::operator=(const class numeric::expression_parser::BooleanExpressionScanner &) –> class numeric::expression_parser::BooleanExpressionScanner &

scan(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, input_string: str) → pyrosetta.rosetta.numeric.expression_parser.TokenSet¶: C++: numeric::expression_parser::ArithmeticScanner::scan(const std::string &) –> class std::shared_ptr<class numeric::expression_parser::TokenSet>

treat_AND_and_OR_as_operators(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, setting: bool) → None¶: C++: numeric::expression_parser::ArithmeticScanner::treat_AND_and_OR_as_operators(bool) –> void

treat_NOT_as_operator(self: pyrosetta.rosetta.numeric.expression_parser.ArithmeticScanner, setting: bool) → None¶: C++: numeric::expression_parser::ArithmeticScanner::treat_NOT_as_operator(bool) –> void

class pyrosetta.rosetta.numeric.expression_parser.DivideExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.DivideExpression, : pyrosetta.rosetta.numeric.expression_parser.DivideExpression) → pyrosetta.rosetta.numeric.expression_parser.DivideExpression¶: C++: numeric::expression_parser::DivideExpression::operator=(const class numeric::expression_parser::DivideExpression &) –> class numeric::expression_parser::DivideExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.DivideExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::DivideExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.EqualsExpression¶

Bases: BinaryExpression

BEGIN PSEUDO-BOOLEAN EXPRESSIONS DO NOT TRY TO DIFFERENTIATE THEM 1. Arithmetic Comparison Operators

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.EqualsExpression, : pyrosetta.rosetta.numeric.expression_parser.EqualsExpression) → pyrosetta.rosetta.numeric.expression_parser.EqualsExpression¶: C++: numeric::expression_parser::EqualsExpression::operator=(const class numeric::expression_parser::EqualsExpression &) –> class numeric::expression_parser::EqualsExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.EqualsExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::EqualsExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.Expression¶

Bases: pybind11_object

Pure virtual base class to define arbitrary expressions for scripting arithmetic operations (e.g. addition and multipliction).

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.Expression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::Expression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.Expression, : pyrosetta.rosetta.numeric.expression_parser.Expression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::Expression::operator=(const class numeric::expression_parser::Expression &) –> class numeric::expression_parser::Expression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶

Returns the expression for the partial derivative of this expression: by the variable named varname. If the partial derivative is always zero with respect to varname, returns null.

C++: numeric::expression_parser::Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

class pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator¶

Bases: ASTVisitor

Class to traverse the abstract syntax tree produced by the parsing of a properly-formed string in the Arithmetic expression language. Produces an Expression tree capable of performing arithmetic. Connects the “variable” nodes in this tree to the owning WrapperOptEMultifunc so that their values can be retrieved during expression evaluation inside the WrapperOptEMultifunc functor.

assign(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator) → pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator¶: C++: numeric::expression_parser::ExpressionCreator::operator=(const class numeric::expression_parser::ExpressionCreator &) –> class numeric::expression_parser::ExpressionCreator &

create_expression_tree(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) → numeric::expression_parser::Expression¶: C++: numeric::expression_parser::ExpressionCreator::create_expression_tree(const class numeric::expression_parser::ArithmeticASTExpression &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

handle_function_expression(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, function: pyrosetta.rosetta.numeric.expression_parser.FunctionToken, args: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_numeric_expression_parser_Expression_t) → numeric::expression_parser::Expression¶

Factory method to be implemented by derived classes: which may wish to handle function expressions in a specific manner

C++: numeric::expression_parser::ExpressionCreator::handle_function_expression(class std::shared_ptr<const class numeric::expression_parser::FunctionToken>, const class utility::vector1<class std::shared_ptr<const class numeric::expression_parser::Expression>, class std::allocator<class std::shared_ptr<const class numeric::expression_parser::Expression> > > &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

handle_variable_expression(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → numeric::expression_parser::Expression¶

Factory method to be implemented by derived classes: which may wish to handle variable expressions in a specific manner

C++: numeric::expression_parser::ExpressionCreator::handle_variable_expression(const class numeric::expression_parser::ArithmeticASTValue &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

visit(*args, **kwargs)¶

Overloaded function.

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTFunction &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTFactor &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTValue &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTNode &) –> void

class pyrosetta.rosetta.numeric.expression_parser.FunctionToken¶

Bases: Token

assign(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken, : pyrosetta.rosetta.numeric.expression_parser.FunctionToken) → pyrosetta.rosetta.numeric.expression_parser.FunctionToken¶: C++: numeric::expression_parser::FunctionToken::operator=(const class numeric::expression_parser::FunctionToken &) –> class numeric::expression_parser::FunctionToken &

name(*args, **kwargs)¶

Overloaded function.

name(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken) -> str

C++: numeric::expression_parser::FunctionToken::name() const –> std::string

name(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken, name: str) -> None

C++: numeric::expression_parser::FunctionToken::name(const std::string &) –> void

nargs(*args, **kwargs)¶

Overloaded function.

nargs(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken) -> int

C++: numeric::expression_parser::FunctionToken::nargs() const –> unsigned long

nargs(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken, setting: int) -> None

C++: numeric::expression_parser::FunctionToken::nargs(unsigned long) –> void

to_string(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken) → str¶: C++: numeric::expression_parser::FunctionToken::to_string() const –> std::string

type(self: pyrosetta.rosetta.numeric.expression_parser.FunctionToken) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::FunctionToken::type() const –> enum numeric::expression_parser::TokenType

class pyrosetta.rosetta.numeric.expression_parser.GTE_Expression¶

Bases: BinaryExpression

Greater Than or Equal To

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.GTE_Expression, : pyrosetta.rosetta.numeric.expression_parser.GTE_Expression) → pyrosetta.rosetta.numeric.expression_parser.GTE_Expression¶: C++: numeric::expression_parser::GTE_Expression::operator=(const class numeric::expression_parser::GTE_Expression &) –> class numeric::expression_parser::GTE_Expression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.GTE_Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::GTE_Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.GT_Expression¶

Bases: BinaryExpression

Greater Than

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.GT_Expression, : pyrosetta.rosetta.numeric.expression_parser.GT_Expression) → pyrosetta.rosetta.numeric.expression_parser.GT_Expression¶: C++: numeric::expression_parser::GT_Expression::operator=(const class numeric::expression_parser::GT_Expression &) –> class numeric::expression_parser::GT_Expression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.GT_Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::GT_Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.ITEExpression¶

Bases: Expression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.ITEExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::ITEExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.ITEExpression, : pyrosetta.rosetta.numeric.expression_parser.ITEExpression) → pyrosetta.rosetta.numeric.expression_parser.ITEExpression¶: C++: numeric::expression_parser::ITEExpression::operator=(const class numeric::expression_parser::ITEExpression &) –> class numeric::expression_parser::ITEExpression &

condition(self: pyrosetta.rosetta.numeric.expression_parser.ITEExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::ITEExpression::condition() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.ITEExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::ITEExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

else_expression(self: pyrosetta.rosetta.numeric.expression_parser.ITEExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::ITEExpression::else_expression() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

then_expression(self: pyrosetta.rosetta.numeric.expression_parser.ITEExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::ITEExpression::then_expression() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

class pyrosetta.rosetta.numeric.expression_parser.LTE_Expression¶

Bases: BinaryExpression

Less Than or Equal To

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.LTE_Expression, : pyrosetta.rosetta.numeric.expression_parser.LTE_Expression) → pyrosetta.rosetta.numeric.expression_parser.LTE_Expression¶: C++: numeric::expression_parser::LTE_Expression::operator=(const class numeric::expression_parser::LTE_Expression &) –> class numeric::expression_parser::LTE_Expression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.LTE_Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::LTE_Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.LT_Expression¶

Bases: BinaryExpression

Less Than

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.LT_Expression, : pyrosetta.rosetta.numeric.expression_parser.LT_Expression) → pyrosetta.rosetta.numeric.expression_parser.LT_Expression¶: C++: numeric::expression_parser::LT_Expression::operator=(const class numeric::expression_parser::LT_Expression &) –> class numeric::expression_parser::LT_Expression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.LT_Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::LT_Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.LiteralExpression¶

Bases: Expression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.LiteralExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::LiteralExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.LiteralExpression, : pyrosetta.rosetta.numeric.expression_parser.LiteralExpression) → pyrosetta.rosetta.numeric.expression_parser.LiteralExpression¶: C++: numeric::expression_parser::LiteralExpression::operator=(const class numeric::expression_parser::LiteralExpression &) –> class numeric::expression_parser::LiteralExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.LiteralExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶

Returns null, since the derivative for a literal is always zero

C++: numeric::expression_parser::LiteralExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_value(self: pyrosetta.rosetta.numeric.expression_parser.LiteralExpression, value: float) → None¶: C++: numeric::expression_parser::LiteralExpression::set_value(double) –> void

class pyrosetta.rosetta.numeric.expression_parser.LiteralToken¶

Bases: Token

assign(self: pyrosetta.rosetta.numeric.expression_parser.LiteralToken, : pyrosetta.rosetta.numeric.expression_parser.LiteralToken) → pyrosetta.rosetta.numeric.expression_parser.LiteralToken¶: C++: numeric::expression_parser::LiteralToken::operator=(const class numeric::expression_parser::LiteralToken &) –> class numeric::expression_parser::LiteralToken &

to_string(self: pyrosetta.rosetta.numeric.expression_parser.LiteralToken) → str¶: C++: numeric::expression_parser::LiteralToken::to_string() const –> std::string

type(self: pyrosetta.rosetta.numeric.expression_parser.LiteralToken) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::LiteralToken::type() const –> enum numeric::expression_parser::TokenType

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.expression_parser.LiteralToken) -> float

C++: numeric::expression_parser::LiteralToken::value() const –> double

value(self: pyrosetta.rosetta.numeric.expression_parser.LiteralToken, setting: float) -> None

C++: numeric::expression_parser::LiteralToken::value(double) –> void

class pyrosetta.rosetta.numeric.expression_parser.MaxExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.MaxExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::MaxExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.MaxExpression, : pyrosetta.rosetta.numeric.expression_parser.MaxExpression) → pyrosetta.rosetta.numeric.expression_parser.MaxExpression¶: C++: numeric::expression_parser::MaxExpression::operator=(const class numeric::expression_parser::MaxExpression &) –> class numeric::expression_parser::MaxExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.MaxExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::MaxExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.MetaMaxExpression¶

Bases: Expression

Evaluates ee1 when e1 is larger than e2; evaluates ee2 otherwise.

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.MetaMaxExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::MetaMaxExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.MetaMaxExpression, : pyrosetta.rosetta.numeric.expression_parser.MetaMaxExpression) → pyrosetta.rosetta.numeric.expression_parser.MetaMaxExpression¶: C++: numeric::expression_parser::MetaMaxExpression::operator=(const class numeric::expression_parser::MetaMaxExpression &) –> class numeric::expression_parser::MetaMaxExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.MetaMaxExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::MetaMaxExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

class pyrosetta.rosetta.numeric.expression_parser.MetaMinExpression¶

Bases: Expression

Evaluates ee1 when e1 is less than e2; evaluates ee2 otherwise.

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.MetaMinExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::MetaMinExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.MetaMinExpression, : pyrosetta.rosetta.numeric.expression_parser.MetaMinExpression) → pyrosetta.rosetta.numeric.expression_parser.MetaMinExpression¶: C++: numeric::expression_parser::MetaMinExpression::operator=(const class numeric::expression_parser::MetaMinExpression &) –> class numeric::expression_parser::MetaMinExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.MetaMinExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::MetaMinExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

class pyrosetta.rosetta.numeric.expression_parser.MinExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.MinExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::MinExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.MinExpression, : pyrosetta.rosetta.numeric.expression_parser.MinExpression) → pyrosetta.rosetta.numeric.expression_parser.MinExpression¶: C++: numeric::expression_parser::MinExpression::operator=(const class numeric::expression_parser::MinExpression &) –> class numeric::expression_parser::MinExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.MinExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::MinExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.MultiplyExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.MultiplyExpression, : pyrosetta.rosetta.numeric.expression_parser.MultiplyExpression) → pyrosetta.rosetta.numeric.expression_parser.MultiplyExpression¶: C++: numeric::expression_parser::MultiplyExpression::operator=(const class numeric::expression_parser::MultiplyExpression &) –> class numeric::expression_parser::MultiplyExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.MultiplyExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::MultiplyExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.NaryExpression¶

Bases: Expression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.Expression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::Expression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.NaryExpression, : pyrosetta.rosetta.numeric.expression_parser.NaryExpression) → pyrosetta.rosetta.numeric.expression_parser.NaryExpression¶: C++: numeric::expression_parser::NaryExpression::operator=(const class numeric::expression_parser::NaryExpression &) –> class numeric::expression_parser::NaryExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶

Returns the expression for the partial derivative of this expression: by the variable named varname. If the partial derivative is always zero with respect to varname, returns null.

C++: numeric::expression_parser::Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

class pyrosetta.rosetta.numeric.expression_parser.NotExpression¶

Bases: UnaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::UnaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.NotExpression, : pyrosetta.rosetta.numeric.expression_parser.NotExpression) → pyrosetta.rosetta.numeric.expression_parser.NotExpression¶: C++: numeric::expression_parser::NotExpression::operator=(const class numeric::expression_parser::NotExpression &) –> class numeric::expression_parser::NotExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.NotExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::NotExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

ex(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::UnaryExpression::ex() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_expression(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression, ex: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::UnaryExpression::set_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.OrExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.OrExpression, : pyrosetta.rosetta.numeric.expression_parser.OrExpression) → pyrosetta.rosetta.numeric.expression_parser.OrExpression¶: C++: numeric::expression_parser::OrExpression::operator=(const class numeric::expression_parser::OrExpression &) –> class numeric::expression_parser::OrExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.OrExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::OrExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator¶

Bases: ExpressionCreator

add_variable(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, varname: str) → None¶: C++: numeric::expression_parser::SimpleExpressionCreator::add_variable(const std::string &) –> void

assign(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator) → pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator¶: C++: numeric::expression_parser::SimpleExpressionCreator::operator=(const class numeric::expression_parser::SimpleExpressionCreator &) –> class numeric::expression_parser::SimpleExpressionCreator &

create_expression_tree(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) → numeric::expression_parser::Expression¶: C++: numeric::expression_parser::ExpressionCreator::create_expression_tree(const class numeric::expression_parser::ArithmeticASTExpression &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

get_variable(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, varname: str) → numeric::expression_parser::VariableExpression¶: C++: numeric::expression_parser::SimpleExpressionCreator::get_variable(const std::string &) –> class std::shared_ptr<class numeric::expression_parser::VariableExpression>

handle_function_expression(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, function: pyrosetta.rosetta.numeric.expression_parser.FunctionToken, args: pyrosetta.rosetta.utility.vector1_std_shared_ptr_const_numeric_expression_parser_Expression_t) → numeric::expression_parser::Expression¶

Factory method to be implemented by derived classes: which may wish to handle function expressions in a specific manner

C++: numeric::expression_parser::ExpressionCreator::handle_function_expression(class std::shared_ptr<const class numeric::expression_parser::FunctionToken>, const class utility::vector1<class std::shared_ptr<const class numeric::expression_parser::Expression>, class std::allocator<class std::shared_ptr<const class numeric::expression_parser::Expression> > > &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

handle_variable_expression(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) → numeric::expression_parser::Expression¶: C++: numeric::expression_parser::SimpleExpressionCreator::handle_variable_expression(const class numeric::expression_parser::ArithmeticASTValue &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

variables(self: pyrosetta.rosetta.numeric.expression_parser.SimpleExpressionCreator) → pyrosetta.rosetta.std.map_std_string_std_shared_ptr_numeric_expression_parser_VariableExpression_t_std_allocator_std_pair_const_std_string_std_shared_ptr_numeric_expression_parser_VariableExpression_t¶: C++: numeric::expression_parser::SimpleExpressionCreator::variables() const –> class std::map<std::string, class std::shared_ptr<class numeric::expression_parser::VariableExpression>, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::shared_ptr<class numeric::expression_parser::VariableExpression> > > >

visit(*args, **kwargs)¶

Overloaded function.

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTExpression) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTAndClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTOrClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFunction) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTFunction &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTTerm) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTFactor) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTFactor &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTValue) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTValue &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestTerm) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestTerm &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestAndClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestAndClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestOrClause) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestOrClause &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTRestExpression) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTRestExpression &) –> void

visit(self: pyrosetta.rosetta.numeric.expression_parser.ExpressionCreator, : pyrosetta.rosetta.numeric.expression_parser.ArithmeticASTNode) -> None

C++: numeric::expression_parser::ExpressionCreator::visit(const class numeric::expression_parser::ArithmeticASTNode &) –> void

class pyrosetta.rosetta.numeric.expression_parser.SimpleToken¶

Bases: Token

assign(self: pyrosetta.rosetta.numeric.expression_parser.SimpleToken, : pyrosetta.rosetta.numeric.expression_parser.SimpleToken) → pyrosetta.rosetta.numeric.expression_parser.SimpleToken¶: C++: numeric::expression_parser::SimpleToken::operator=(const class numeric::expression_parser::SimpleToken &) –> class numeric::expression_parser::SimpleToken &

set_token_type(self: pyrosetta.rosetta.numeric.expression_parser.SimpleToken, type: pyrosetta.rosetta.numeric.expression_parser.TokenType) → None¶: C++: numeric::expression_parser::SimpleToken::set_token_type(enum numeric::expression_parser::TokenType) –> void

to_string(self: pyrosetta.rosetta.numeric.expression_parser.SimpleToken) → str¶: C++: numeric::expression_parser::SimpleToken::to_string() const –> std::string

type(self: pyrosetta.rosetta.numeric.expression_parser.SimpleToken) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::SimpleToken::type() const –> enum numeric::expression_parser::TokenType

class pyrosetta.rosetta.numeric.expression_parser.SquarerootExpression¶

Bases: UnaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::UnaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.SquarerootExpression, : pyrosetta.rosetta.numeric.expression_parser.SquarerootExpression) → pyrosetta.rosetta.numeric.expression_parser.SquarerootExpression¶: C++: numeric::expression_parser::SquarerootExpression::operator=(const class numeric::expression_parser::SquarerootExpression &) –> class numeric::expression_parser::SquarerootExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.SquarerootExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::SquarerootExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

ex(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::UnaryExpression::ex() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_expression(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression, ex: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::UnaryExpression::set_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.SubtractExpression¶

Bases: BinaryExpression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::BinaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.SubtractExpression, : pyrosetta.rosetta.numeric.expression_parser.SubtractExpression) → pyrosetta.rosetta.numeric.expression_parser.SubtractExpression¶: C++: numeric::expression_parser::SubtractExpression::operator=(const class numeric::expression_parser::SubtractExpression &) –> class numeric::expression_parser::SubtractExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.SubtractExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::SubtractExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e1(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e1() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

e2(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::BinaryExpression::e2() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_first_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e1: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_first_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

set_second_expression(self: pyrosetta.rosetta.numeric.expression_parser.BinaryExpression, e2: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::BinaryExpression::set_second_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.Token¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.expression_parser.Token, : pyrosetta.rosetta.numeric.expression_parser.Token) → pyrosetta.rosetta.numeric.expression_parser.Token¶: C++: numeric::expression_parser::Token::operator=(const class numeric::expression_parser::Token &) –> class numeric::expression_parser::Token &

to_string(self: pyrosetta.rosetta.numeric.expression_parser.Token) → str¶: C++: numeric::expression_parser::Token::to_string() const –> std::string

type(self: pyrosetta.rosetta.numeric.expression_parser.Token) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::Token::type() const –> enum numeric::expression_parser::TokenType

class pyrosetta.rosetta.numeric.expression_parser.TokenSet¶

Bases: pybind11_object

append(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet, token: pyrosetta.rosetta.numeric.expression_parser.Token) → None¶: C++: numeric::expression_parser::TokenSet::append(class std::shared_ptr<const class numeric::expression_parser::Token>) –> void

assign(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet, : pyrosetta.rosetta.numeric.expression_parser.TokenSet) → pyrosetta.rosetta.numeric.expression_parser.TokenSet¶: C++: numeric::expression_parser::TokenSet::operator=(const class numeric::expression_parser::TokenSet &) –> class numeric::expression_parser::TokenSet &

empty(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → bool¶

Are there no more tokens remaining?

C++: numeric::expression_parser::TokenSet::empty() const –> bool

log_error(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → str¶

Print contents after parser has encountered an error.

C++: numeric::expression_parser::TokenSet::log_error() const –> std::string

pop(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → None¶: C++: numeric::expression_parser::TokenSet::pop() –> void

print(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → str¶: C++: numeric::expression_parser::TokenSet::print() const –> std::string

top(self: pyrosetta.rosetta.numeric.expression_parser.TokenSet) → pyrosetta.rosetta.numeric.expression_parser.Token¶: C++: numeric::expression_parser::TokenSet::top() const –> class std::shared_ptr<const class numeric::expression_parser::Token>

class pyrosetta.rosetta.numeric.expression_parser.TokenType¶

Bases: pybind11_object

Members:

INVALID_TOKEN_TYPE

LITERAL

VARIABLE

FUNCTION

COMMA

LEFT_PAREN

RIGHT_PAREN

PLUS_SYMBOL

SUBTRACT_SYMBOL

MULTIPLY_SYMBOL

DIVIDE_SYMBOL

AND_SYMBOL

OR_SYMBOL

NOT_SYMBOL

AND_SYMBOL = <TokenType.AND_SYMBOL: 11>¶

COMMA = <TokenType.COMMA: 4>¶

DIVIDE_SYMBOL = <TokenType.DIVIDE_SYMBOL: 10>¶

FUNCTION = <TokenType.FUNCTION: 3>¶

INVALID_TOKEN_TYPE = <TokenType.INVALID_TOKEN_TYPE: 0>¶

LEFT_PAREN = <TokenType.LEFT_PAREN: 5>¶

LITERAL = <TokenType.LITERAL: 1>¶

MULTIPLY_SYMBOL = <TokenType.MULTIPLY_SYMBOL: 9>¶

NOT_SYMBOL = <TokenType.NOT_SYMBOL: 13>¶

OR_SYMBOL = <TokenType.OR_SYMBOL: 12>¶

PLUS_SYMBOL = <TokenType.PLUS_SYMBOL: 7>¶

RIGHT_PAREN = <TokenType.RIGHT_PAREN: 6>¶

SUBTRACT_SYMBOL = <TokenType.SUBTRACT_SYMBOL: 8>¶

VARIABLE = <TokenType.VARIABLE: 2>¶

property name¶

property value¶

class pyrosetta.rosetta.numeric.expression_parser.UnaryExpression¶

Bases: Expression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::UnaryExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression, : pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.numeric.expression_parser.UnaryExpression¶: C++: numeric::expression_parser::UnaryExpression::operator=(const class numeric::expression_parser::UnaryExpression &) –> class numeric::expression_parser::UnaryExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.Expression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶

Returns the expression for the partial derivative of this expression: by the variable named varname. If the partial derivative is always zero with respect to varname, returns null.

C++: numeric::expression_parser::Expression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

ex(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::UnaryExpression::ex() const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

set_expression(self: pyrosetta.rosetta.numeric.expression_parser.UnaryExpression, ex: pyrosetta.rosetta.numeric.expression_parser.Expression) → None¶: C++: numeric::expression_parser::UnaryExpression::set_expression(class std::shared_ptr<const class numeric::expression_parser::Expression>) –> void

class pyrosetta.rosetta.numeric.expression_parser.VariableExpression¶

Bases: Expression

active_variables(self: pyrosetta.rosetta.numeric.expression_parser.VariableExpression) → pyrosetta.rosetta.std.list_std_string_t¶: C++: numeric::expression_parser::VariableExpression::active_variables() const –> class std::list<std::string, class std::allocator<std::string > >

assign(self: pyrosetta.rosetta.numeric.expression_parser.VariableExpression, : pyrosetta.rosetta.numeric.expression_parser.VariableExpression) → pyrosetta.rosetta.numeric.expression_parser.VariableExpression¶: C++: numeric::expression_parser::VariableExpression::operator=(const class numeric::expression_parser::VariableExpression &) –> class numeric::expression_parser::VariableExpression &

differentiate(self: pyrosetta.rosetta.numeric.expression_parser.VariableExpression, varname: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶

Returns the literal expression 1 if name_ == varname_ and null otherwise

C++: numeric::expression_parser::VariableExpression::differentiate(const std::string &) const –> class std::shared_ptr<const class numeric::expression_parser::Expression>

name(self: pyrosetta.rosetta.numeric.expression_parser.VariableExpression) → str¶: C++: numeric::expression_parser::VariableExpression::name() const –> std::string

set_value(self: pyrosetta.rosetta.numeric.expression_parser.VariableExpression, value: float) → None¶: C++: numeric::expression_parser::VariableExpression::set_value(double) –> void

class pyrosetta.rosetta.numeric.expression_parser.VariableToken¶

Bases: Token

assign(self: pyrosetta.rosetta.numeric.expression_parser.VariableToken, : pyrosetta.rosetta.numeric.expression_parser.VariableToken) → pyrosetta.rosetta.numeric.expression_parser.VariableToken¶: C++: numeric::expression_parser::VariableToken::operator=(const class numeric::expression_parser::VariableToken &) –> class numeric::expression_parser::VariableToken &

name(*args, **kwargs)¶

Overloaded function.

name(self: pyrosetta.rosetta.numeric.expression_parser.VariableToken) -> str

C++: numeric::expression_parser::VariableToken::name() const –> std::string

name(self: pyrosetta.rosetta.numeric.expression_parser.VariableToken, name: str) -> None

C++: numeric::expression_parser::VariableToken::name(const std::string &) –> void

to_string(self: pyrosetta.rosetta.numeric.expression_parser.VariableToken) → str¶: C++: numeric::expression_parser::VariableToken::to_string() const –> std::string

type(self: pyrosetta.rosetta.numeric.expression_parser.VariableToken) → pyrosetta.rosetta.numeric.expression_parser.TokenType¶: C++: numeric::expression_parser::VariableToken::type() const –> enum numeric::expression_parser::TokenType

pyrosetta.rosetta.numeric.expression_parser.parse_string_to_boolean_expression(input_string: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::parse_string_to_boolean_expression(const std::string &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

pyrosetta.rosetta.numeric.expression_parser.parse_string_to_expression(input_string: str) → pyrosetta.rosetta.numeric.expression_parser.Expression¶: C++: numeric::expression_parser::parse_string_to_expression(const std::string &) –> class std::shared_ptr<const class numeric::expression_parser::Expression>

pyrosetta.rosetta.numeric.expression_parser.token_type_name(: pyrosetta.rosetta.numeric.expression_parser.TokenType) → str¶: C++: numeric::expression_parser::token_type_name(enum numeric::expression_parser::TokenType) –> std::string