Reference

Complete_expr_tree{T} <: AbstractTree

Implementation of an expression tree. Complete_expr_tree is the same than Type_expr_tree with the additions in each node of a Bounds and Convexity_wrapper. A Complete_expr_tree has fields:

• field::Complete_node{T} representing an operator, a constant or a variable alongide its bounds and its convexity status;
• children::Vector{Complete_expr_tree{T}} a vector of children, each of them being a Complete_expr_tree{T}.

Type_calculus_tree

Represent the different types that a expression can be :

• constant
• linear
• quadratic
• cubic
• more which means non-linear, non-quadratic and non-cubic.

Type_expr_tree{T} <: AbstractTree

Basic implementation of an expression tree. Every expression tree supported must be able to return Type_expr_tree with transform_to_expr_tree. A Type_expr_tree has fields:

• field::Abstract_expr_node representing an operator, a constant or a variable;
• children::Vector{Type_expr_tree{T}} a vector of children, each of them being a Type_expr_tree{T}.

Type_node{T} <: AbstractTree

Basic implementation of a tree. A Type_node has fields:

• field gathering the informations about the current node;
• children a vector of children, each of them being a Type_node.

cast_type_of_constant(expr_tree, type::DataType)

Cast to type the constants of expr_tree. expr_tree may be an Expr, a Type_expr_tree or a Complete_expr_tree.

complete_tree = complete_tree(expression_tree::Type_expr_tree)

Create a complete_tree::Complete_expr_tree from expression_tree.

concave = concave_type()

Return the value concave from the enumerative type M_implementation_convexity_type.Convexity_type.

constant = constant_type()

Return the value constant from the enumerative type M_implementation_convexity_type.Convexity_type.

convex = convex_type()

Return the value convex from the enumerative type M_implementation_convexity_type.Convexity_type.

bound_tree = create_bounds_tree(tree)

Return a convexity tree shaped as tree, where each node has an undefined bounds.

convex_tree = create_convex_tree(tree::Type_expr_tree)

Return bounds' tree with the same shaped than tree, where each node has an undefined convexity status.

evaluate_expr_tree(expr_tree::Type_expr_tree, x::AbstractVector)
evaluate_expr_tree(expr_tree::Complete_expr_tree, x::AbstractVector)

Evaluate the expr_tree given the vector x.

Example:

julia> evaluate_expr_tree(:(x[1] + x[2]), ones(2))
2.

evaluate_expr_tree_multiple_points(expression_tree::Any, x::AbstractVector{AbstractVector}})
evaluate_expr_tree_multiple_points(expression_tree::Any)

Evaluate the expression_tree for several points, represented as x.

separated_terms = extract_element_functions(expr_tree)

Return the element functions of expr_tree as a vector of its subexpressions. expr_tree may be an Expr, a Type_expr_tree or a Complete_expr_tree.

Example:

julia> extract_element_functions(:(x[1] + x[2] + x[3]*x[4]))
3-element Vector{Expr}:
 :(x[1])
 :(x[2])
 :(x[3] * x[4])

Ui = get_Ui(indices::Vector{Int}, n::Int)

Create a SparseMatrix Ui from indices computed by get_elemental_variables. Every index i (of indices) form a line of Ui corresponding to i-th Euclidian vector.

(inf_bound, sup_bound) = get_bounds(bound_tree::Bound_tree)

Retrieve the bounds from the root of bound_tree (a given bounds' tree).

convexity_status = get_convexity_status(convexity_tree::M_convexity_detection.Convexity_tree)
convexity_status = get_convexity_status(complete_tree::Complete_expr_tree)

Return the convexity status of either a convexity_tree or a complete_tree. The status can be:

• constant
• linear
• convex
• concave
• unknown

indices = get_elemental_variables(expr_tree)

Return the indices of the variable appearing in expr_tree. This function is used to find the elemental variables from the expression tree of an element function. expr_tree may be an Expr, a Type_expr_tree or a Complete_expr_tree.

Example:

julia> get_elemental_variables(:(x[1] + x[3]) )
[1, 3]
julia> get_elemental_variables(:(x[1]^2 + x[6] + x[2]) )
[1, 6, 2]

expr = get_expression_tree(monlp::MathOptNLPModel)
expr = get_expression_tree(adnlp::ADNLPModel)
expr = get_expression_tree(model::JuMP.Model)
expr = get_expression_tree(evaluator::MOI.Nonlinear.Evaluator)

Return the objective function as a Type_expr_tree for: a MathOptNLPModel, a ADNLPModel, a JuMP.Model or a MOI.Nonlinear.Evaluator.

eval_expression_tree = get_function_of_evaluation(expression_tree::Type_expr_tree)

Return and evaluation function of expression_tree with better performance than the actual evaluate_expr_tree.

type = get_type_tree(expr_tree)

Return the type of expr_tree. It can either be: constant, linear, quadratic, cubic or more. expr_tree may be an Expr, a Type_expr_tree or a Complete_expr_tree.

Example:

julia> get_type_tree(:(5+4)) == constant
true
julia> get_type_tree(:(x[1])) == linear
true
julia> get_type_tree(:(x[1]* x[2])) == quadratic
true

gradient = gradient_forward(expr_tree, x)

Evaluate the gradient of expr_tree at the point x with a forward automatic differentiation method.

Example:

julia> gradient_forward(:(x[1] + x[2]), rand(2))
[1.0 1.0]

gradient = gradient_reverse(expr_tree, x)

Evaluate the gradient of expr_tree at the point x with a reverse automatic differentiation method.

Example:

julia> gradient_reverse(:(x[1] + x[2]), rand(2))
[1.0 1.0]

hess = hessian(expr_tree, x)

Evaluate the Hessian of expr_tree at the point x with a forward automatic differentiation.

Example:

julia> hessian(:(x[1]^2 + x[2]), rand(2))
[2.0 0.0; 0.0 0.0]

bool = is_concave(status::Convexity_type)
bool = is_concave(convexity::Convexity_wrapper)

Check if convexity or status is equal to concave.

bool = is_constant(status::Convexity_type)
bool = is_constant(convexity::Convexity_wrapper)

Check if convexity or status is equal to constant.

bool = is_constant(type::Type_calculus_tree)

Check if type values constant from the enumerative type Type_calculus_tree.

bool = is_convex(status::Convexity_type)
bool = is_convex(convexity::Convexity_wrapper)

Check if convexity or status is equal to convex.

bool = is_cubic(type::Type_calculus_tree)

Check if type values cubic from the enumerative type Type_calculus_tree.

bool = is_linear(status::Convexity_type)
bool = is_linear(convexity::Convexity_wrapper)

Check if convexity or status is equal to linear.

bool = is_linear(type::Type_calculus_tree)

Check if type values linear from the enumerative type Type_calculus_tree.

bool = is_more(type::Type_calculus_tree)

Check if type values more from the enumerative type Type_calculus_tree.

bool = is_not_treated(status::Convexity_type)
bool = is_not_treated(convexity::Convexity_wrapper)

Check if convexity or status is equal to not_treated.

bool = is_quadratic(type::Type_calculus_tree)

Check if type values quadratic from the enumerative type Type_calculus_tree.

bool = is_treated(status::Convexity_type)
bool = is_treated(convexity::Convexity_wrapper)

Check if convexity or status is equal to different of not_treated.

bool = is_unknown(status::Convexity_type)
bool = is_unknown(convexity::Convexity_wrapper)

Check if convexity or status is equal to unknown.

linear = linear_type()

Return the value linear from the enumerative type M_implementation_convexity_type.Convexity_type.

evaluator = non_linear_JuMP_model_evaluator(expr_tree; variables::Vector{Int})

Return a MathOptInterface.Nonlinear.Model and its initialized evaluator for any expr_tree supported. variables informs the indices of the variables appearing in expr_tree. If variables is not provided, it is determined automatically through sort!(get_elemental_variables(expr_tree)). Warning: variables must be sorted! Example:

expr_tree = :(x[1]^2 + x[3]^3)
variables = [1,3]
evaluator = non_linear_JuMP_model_evaluator(expr_tree; variables)

Afterward, you may evaluate the function and the gradient from expr_tree with:

x = rand(2)
MOI.eval_objective(evaluator, x)
grad = similar(x)
MOI.eval_objective_gradient(evaluator, grad, x)

Warning: The size of x depends on the number of variables of expr_tree and not from the highest variable's index.

normalize_indices!(expr_tree, vector_indices::Vector{Int})

Change the indices of the variables from expr_tree to follow the order given by vector_indices. It is paired with get_elemental_variables to define the elemental element function expression tree. expr_tree may be an Expr, a Type_expr_tree or a Complete_expr_tree.

Example:

julia> normalize_indices!(:(x[4] + x[5]), [4,5])
:(x[1] + x[2])

print_tree(tree::AbstractTree)

Print a tree as long as it satisfies the interface M_interface_tree.

set_bounds!(tree::Type_expr_tree, bound_tree::Bound_tree)
set_bounds!(complete_tree::Complete_expr_tree)

Set the bounds of bound_tree by walking tree and propagate the bounds' computation from the leaves to the root. As a Complete_expr_tree contains a precompiled bound_tree, it can be used alone.

set_convexity!(tree::Type_expr_tree, convexity_tree::Convexity_tree, bound_tree::Bound_tree)
set_convexity!(complete_tree::Complete_expr_tree)

Deduce from elementary rules the convexity status of tree nodes or complete_tree nodes. complete_tree stores a bounds tree and can run the convexity detection standalone whereas tree requires the bound_tree (see create_bounds_tree) and convexity_tree (see create_convex_tree).

evaluator = sparse_jacobian_JuMP_model(expr_trees)

Return the evaluator of a MathOptInterface.Nonlinear.Model defined by expr_tree, as long as it is supported. The evaluator considers the objective function as the sum of expr_trees and a constraint for each expr_tree contained in expr_trees. If the expression trees in expr_trees depend on a subset of variables, the Jacobian of the constraints will be sparse.

summed_tree = sum_expr_trees(trees::Vector{::AbstractExprTree})

Sum every trees.

expr = transform_to_Expr(expr_tree)

Transform expr_tree into an Expr. expr_tree may be a Type_expr_tree or a Complete_expr_tree. Warning: This function return an Expr with variables as MathOptInterface.VariableIndex. In order to get an standard Expr use transform_to_Expr_julia.

expr = transform_to_Expr_JuMP(expr_tree)

Transform expr_tree into an Expr. expr_tree may be a Type_expr_tree or a Complete_expr_tree.

expr = transform_to_Expr_julia(expr_tree)

Transform expr_tree into an Expr. expr_tree may be a Type_expr_tree or a Complete_expr_tree.

expr_tree = transform_to_expr_tree(expr::Expr)

Transform expr into an expr_tree::Type_expr_tree.

unknown = unknown_type()

Return the value unknown from the enumerative type M_implementation_convexity_type.Convexity_type.

Supertype of every expression tree.

Bounds{T <: Number}

Structure representing the upper-bound and the lower-bound of a node.

expr = create_expr_tree(tree)

Create an Expr from tree. Several types of tree are supported. For now, it supports Expr and ModelingToolkit.Operation, as well as the internal expression trees defined. The variables of the Expr use MathOptInterface variables.

expr = create_expr_tree(tree)

Create a Julia Expr from tree. Several types of tree are supported. For now, it supports Expr and ModelingToolkit.Operation, as well as the internal expression trees defined.

expr = create_expr_tree(tree)

Create an Expr from tree. Several types of tree are supported. For now, it supports Expr and ModelingToolkit.Operation, as well as the internal expression trees defined. The variables of the Expr use MathOptInterface.VariableIndex(i).

bound = create_empty_bounds(type::DataType)

Create a Bounds structure of type.

expr_tree = create_expr_tree(tree)

Create an Type_expr_tree from tree. Several types of tree are supported. For now, it supports Expr and ModelingToolkit.Operation, as well as the internal expression trees defined.

(inf_bound, sup_bound) = get_bounds(bound::Bounds{T}) where {T <: Number}

Retrieve both inf_bound and sup_bound from bound.

set_bound!(bound::Bounds{T}, inf_bound::T, sup_bound::T) where {T <: Number}

Set bound to inf_bound and sup_bound.

Type instantiated dynamically representeing that an argument is an expression tree.

Type instantiated dynamically representeing that an argument is not an expression tree.

bool = expr_tree_equal(expr_tree1, expr_tree2, eq::Atomic{Bool} = Atomic{Bool}(true))

Check if both expr_tree1 and expr_tree2 represent the same expression tree.

expr_tree = expr_tree_to_create(tree1::AbstractExprTree, tree2::AbstractExprTree)

Return expr_tree, a expression tree of the type from tree2 with the values of tree1. It is supported for few expression-tree structure.

children = get_expr_children(tree::AbstractExprTree)

Return the children from the root of tree.

node = get_expr_node(tree::AbstractExprTree)

Return the root node of tree.

_get_real_node(tree::AbstractExprTree)

Return the value of a leaf in a suitable format for particular algorithm.

minus_tree = inverse_expr_tree(tree::AbstractExprTree)

Return minus_tree which apply a unary minus onto tree.

verifier_type = is_expr_tree(arg)

Return Is_expr_tree if arg is considered as an implementation of an expression tree, it returns Is_not_expr_tree otherwise.

summed_tree = sum_expr_trees(trees::Vector{::AbstractExprTree})

Sum every trees.

expr = transform_to_Expr(expr_tree)

Return expr::Expr from the expression tree expr_tree.

expr = transform_to_Expr_JuMP(expr_tree)

Return expr::Expr from the expression tree expr_tree. The variable in expr are provided using MathOptInterface.VariableIndex.

expr_tree = _transform_to_expr_tree(tree::AbstractExprTree)

Return expr_tree::Type_expr_tree from tree. Type_expr_tree is the internal expression tree structure.

expr_tree = _expr_tree_to_create(tree1::AbstractExprTree, tree2::AbstractExprTree)

Return expr_tree, a expression tree of the type from tree2 with the values of tree1. It is supported for few expression-tree structure.

children = _get_expr_children(tree::AbstractExprTree)

Return the children from the root of tree.

node = _get_expr_node(tree::AbstractExprTree)

Return the root node of tree.

_get_real_node(tree::AbstractExprTree)

Return the value of a leaf in a suitable format for particular algorithm.

minus_tree = _inverse_expr_tree(tree::AbstractExprTree)

Apply a unary minus on tree.

summed_tree = _sum_expr_trees(trees::Vector{::AbstractExprTree})

Sum every trees.

expr_tree = _transform_to_expr_tree(tree::AbstractExprTree)

Return expr_tree::Type_expr_tree from tree. Type_expr_tree is the internal expression tree structure.

Variable_counter

Associate the index of the symbol variable to their integer index.

Type_expr_tree{T} <: AbstractTree

Basic implementation of an expression tree. Every expression tree supported must be able to return Type_expr_tree with transform_to_expr_tree. A Type_expr_tree has fields:

• field::Abstract_expr_node representing an operator, a constant or a variable;
• children::Vector{Type_expr_tree{T}} a vector of children, each of them being a Type_expr_tree{T}.

Complete_expr_tree{T} <: AbstractTree

Implementation of an expression tree similar to Type_expr_tree. Complete_expr_tree considers a Complete_node which adds the Bounds and a Convexity_wrapper to each node. A Complete_expr_tree has fields:

• field::Complete_node{T} representing an operator, a constant or a variable alongide its bounds and its convexity status;
• children::Vector{Complete_expr_tree{T}} a vector of children, each of them being a Complete_expr_tree{T}.

Complete_node{T <: Number}

Gather in a single structure:

• op::M_abstract_expr_node.Abstract_expr_node an arithmetic operator;
• bounds::M_abstract_expr_tree.Bounds{T} the bounds of this operator depending on its children;
• convexity_status::M_implementation_convexity_type.Convexity_wrapper the convexity status of this operator depending on its children.

gradient_forward(expr_tree, x)

Evaluate the gradient of the function represented by `expr_tree at the point x.

hess = hessian(expr_tree, x)

Compute the hessian matrix of the function represented by expr_tree at the point x.

Bound_tree

A tree where each node is a pair (bound_inf, bound_sup). Must be paired with an expression tree.

bound_tree = create_bounds_tree(tree)

Return a convexity tree shaped as tree, where each node has an undefined bounds.

(inf_bound, sup_bound) = get_bounds(bound_tree::Bound_tree)

Retrieve the bounds from the root of bound_tree (a given bounds' tree).

set_bounds!(tree, bound_tree::Bound_tree)
set_bounds!(complete_tree::Complete_expr_tree)

Set the bounds of bound_tree by walking tree and by propagating the computations from the leaves to the root. A Complete_expr_tree contains a precompiled bound_tree, and then can be use alone.

Convexity_tree

A tree where each node is a convexity status. Must be paired with an expression tree.

concave = concave_type()

Return the value concave from the enumerative type M_implementation_convexity_type.Convexity_type.

constant = constant_type()

Return the value constant from the enumerative type M_implementation_convexity_type.Convexity_type.

convex = convex_type()

Return the value convex from the enumerative type M_implementation_convexity_type.Convexity_type.

convex_tree = create_convex_tree(tree::Type_node)

Return bounds' tree with the same shaped than tree, where each node has an undefined convexity status.

convexity_status = get_convexity_status(convexity_tree::M_convexity_detection.Convexity_tree)
convexity_status = get_convexity_status(complete_tree::M_implementation_complete_expr_tree.Complete_expr_tree)

Return the convexity status of either a convexity_tree or a complete_tree. The status can be:

• constant
• linear
• strictly convex
• strictly concave
• unknown

linear = linear_type()

Return the value linear from the enumerative type M_implementation_convexity_type.Convexity_type.

set_convexity!(tree, convexity_tree, bound_tree)
set_convexity!(complete_tree)

Deduce from elementary rules the convexity status of tree nodes or complete_tree nodes. complete_tree stores a bounds tree and can run the convexity detection standalone whereas tree requires the bound_tree (see create_bounds_tree) and convexity_tree (see create_convex_tree).

unknown = unknown_type()

Return the value unknown from the enumerative type M_implementation_convexity_type.Convexity_type.

dic = N_to_Ni(elemental_var::Vector{Int}; initial_index=0)

Return a dictionnary informing the index changes of an element expression tree. If element_var = [4,5] then dic == Dict([4=>initial_index+1, 5=>initial_index+2]).

cast_type_of_constant(expr_tree, type::DataType)

Cast to type the constants of expr_tree.

separated_terms = extract_element_functions(expr_tree)

Divide the expression tree as a terms of a sum if possible. It returns a vector where each component is a subexpression tree of expr_tree.

Example:

julia> extract_element_functions(:(x[1] + x[2] + x[3]*x[4] ) )
3-element Vector{Expr}:
 :(x[1])
 :(x[2])
 :(x[3] * x[4])

Ui = get_Ui(indices::Vector{Int}, n::Int)

Create a SparseMatrix Ui from indices computed by get_elemental_variables. Every index i (of indices) form a line of Ui corresponding to i-th Euclidian vector.

indices = get_elemental_variables(expr_tree)

Return the indices of the variable appearing in expr_tree. This function finds the elemental variables from the expression tree of an element function.

Example:

julia> get_elemental_variables(:(x[1] + x[3]) )
[1, 3]
julia> get_elemental_variables(:(x[1]^2 + x[6] + x[2]) )
[1, 6, 2]

type = get_type_tree(expr_tree)

Return the type of expr_tree. It can either be: constant, linear, quadratic, cubic or more.

Example:

julia> get_type_tree(:(5+4)) == constant
true
julia> get_type_tree(:(x[1])) == linear
true
julia> get_type_tree(:(x[1]* x[2])) == quadratic
true

evaluator = non_linear_JuMP_model_evaluator(expr_tree; variables::Vector{Int})

Return the evaluator of a MOI.Nonlinear.Model defined by expr_tree, as long as it is supported. variables informs the indices of the variables appearing in expr_tree. If variables is not provided, it is determined automatically through sort!(get_elemental_variables(expr_tree)). Warning: variables must be sorted! Example:

expr_tree = :(x[1]^2 + x[3]^3)
variables = [1,3]
evaluator = non_linear_JuMP_model_evaluator(expr_tree; variables)

Afterward, you may evaluate the function and the gradient from expr_tree with:

x = rand(2)
MOI.eval_objective(evaluator, x)
grad = similar(x)
MOI.eval_objective_gradient(evaluator, grad, x)

Warning: The size of x depends on the number of variables of expr_tree and not from the highest variable's index.

normalize_indices!(expr_tree, vector_indices; initial_index=0)

Change the indices of the variables from expr_tree to follow the order given by vector_indices. It is paired with get_elemental_variables to define the elemental element function expression tree.

Example:

julia> normalize_indices!(:(x[4] + x[5]), [4,5]; initial_index::Int)
:(x[1+initial_index] + x[2+initial_index])

evaluator = sparse_jacobian_JuMP_model(expr_trees)

Return the evaluator of a MOI.Nonlinear.Model defined by expr_tree, as long as it is supported. The evaluator considers the objective function as the sum of expr_trees and a constraint for each expr_tree contained in expr_trees. If the expression trees in expr_trees depend on a subset of variables, the Jacobian of the constraints will be sparse.

Type instantiated dynamically representeing that an argument is an expression node.

Type instantiated dynamically representeing that an argument is a not an expression node.

bool = cast_constant!(node::Abstract_expr_node, type::Datatype)

Rewrite the Numbers composing node as type.

change_from_N_to_Ni!(node::Abstract_expr_node, dic_new_indices::Dict{Int, Int})

Change the index of the variables following the index given by dic_new_indices.

value = _evaluate_node(node::Abstract_expr_node, value_children::AbstractVector{T}) where T<:Number

Evaluate node depending on value_children.

type = get_type_node(node::Abstract_expr_node, children_types::AbstractVector{Type_expr_basic})

Return the type of node given the type of its children children_types. The types avaible areconstant, linear, quadratic, cubic or more.

index = get_var_index(variable::Abstract_expr_node)

Return the index of the variable.

(lowerbound, upper_bound) = node_bound(node::Abstract_expr_node, children_bounds::AbstractVector{Tuple{T, T}}, type::DataType)

Return the bounds of node given the children_bounds.

bool = _node_is_operator(node::Abstract_expr_node, children_convex_status::AbstractVector{M_implementation_convexity_type.Convexity_type})

Return the convexity status of node given the children_convex_status.

bool = node_is_constant(node::Abstract_expr_node)

Check if node is a constant.

bool = node_is_cos(node::Abstract_expr_node)

Check if node is a cos operator.

bool = node_is_minus(node::Abstract_expr_node)

Check if node is a - operator.

bool = node_is_operator(node::Abstract_expr_node)

Check if node is an operator. It could be also a variable or a constant.

bool = node_is_plus(node::Abstract_expr_node)

Check if node is a + operator.

bool = node_is_power(node::Abstract_expr_node)

Check if node is a ^ operator.

bool = node_is_sin(node::Abstract_expr_node)

Check if node is a sin operator.

bool = node_is_tan(node::Abstract_expr_node)

Check if node is a tan operator.

bool = _node_is_times(node::Abstract_expr_node)

Check if node is a * operator.

bool = _node_is_variable(node::Abstract_expr_node)

Check if node is a variable. It could be also an operator or a constant.

bool = node_to_Expr(node::Abstract_expr_node)

Return the information required to build later on a Julia Expr. An operator node returns the operator symbol (ex: + -> :+). A variable node returns a variable as a MathOptInterface variable. A constant node returns its value.

bool = node_to_Expr2(node::Abstract_expr_node)

Return the information required to build later on a Julia Expr. An operator node returns the operator symbol (ex: + -> :+). A variable return a variable. A constant node returns its value.

bool = _node_to_Expr_JuMP(node::Abstract_expr_node)

Return the information required to build later on a Julia Expr. An operator node returns the operator symbol (ex: + -> :+). A variable parametrized with the index i returns a variable as a MathOptInterface.Variable(i). A constant node returns its value.

bool = _cast_constant!(node::Abstract_expr_node, type::Datatype)

Rewrite the Numbers composing node as type.

_change_from_N_to_Ni!(node::Abstract_expr_node, dic_new_indices::Dict{Int, Int})

Change the index of the variables following the index given by dic_new_indices. Must be implemented for leaf nodes.

_evaluate_node!(node::Abstract_expr_node, value_children::AbstractVector{T}, ref::MyRef{T}) where T<:Number

Evaluate node depending on value_children and store the result in ref.

value = _evaluate_node(node::Abstract_expr_node, value_children::AbstractVector{T}) where T<:Number

Evaluate node depending on value_children.

type = _get_type_node(node::Abstract_expr_node, children_types::AbstractVector{Type_expr_basic})

Return the type of node given the type of its children children_types. The types available are constant, linear, quadratic, cubic or more.

index = _get_var_index(variable::Abstract_expr_node)

Return the index of the variable.

(lowerbound, upper_bound) = _node_bound(node::Abstract_expr_node, children_bounds::AbstractVector{Tuple{T, T}}, type::DataType)

Return the bounds of node given the children_bounds.

bool = _node_is_operator(node::Abstract_expr_node, children_convex_status::AbstractVector{M_implementation_convexity_type.Convexity_type})

Return the convexity status of node given the children_convex_status.

bool = _node_is_constant(node::Abstract_expr_node)

Check if node is a constant.

bool = _node_is_cos(node::Abstract_expr_node)

Check if node is a cos operator.

bool = _node_is_minus(node::Abstract_expr_node)

Check if node is a - operator.

bool = _node_is_operator(node::Abstract_expr_node)

Check if node is an operator. It could be also a variable or a constant.

bool = _node_is_plus(node::Abstract_expr_node)

Check if node is a + operator.

bool = _node_is_power(node::Abstract_expr_node)

Check if node is a ^ operator.

bool = _node_is_sin(node::Abstract_expr_node)

Check if node is a sin operator.

bool = _node_is_tan(node::Abstract_expr_node)

Check if node is a tan operator.

bool = _node_is_times(node::Abstract_expr_node)

Check if node is a * operator.

bool = _node_is_variable(node::Abstract_expr_node)

Check if node is a variable. It could be also an operator or a constant.

[symbols] = _node_to_Expr(node::Abstract_expr_node)

Return the information required to build later on a Julia Expr. An operator node returns the operator symbol (ex: + -> :+). A variable node returns a variable as a MathOptInterface variable. A constant node returns its value.

[symbols] = _node_to_Expr2(node::Abstract_expr_node)

Return the information required to build later on a Julia Expr. An operator node returns the operator symbol (ex: + -> :+). A variable return a variable. A constant node returns its value.

[symbols] = _node_to_Expr2(node::Abstract_expr_node)

Return the information required to build later on a Julia Expr. An operator node returns the operator symbol (ex: + -> :+). A variable return a MathOptInterface.VariableIndex(). A constant node returns its value.

Supertype of every node.

MyRef{Y <: Number}

Sort of pointer. Contain the field:

• value which points to the desired structure.

vector_myref = create_new_vector_myRef(n::Int, type::DataType = Float64)

Create a vector of n myRef{type} components.

create_node_expr(arg::UnionAll)

Create a node from arg. See the different implementation in the src/node_expr_tree/impl_operators.jl.

my_ref_matrix = create_undef_array_myRef(n::Int, m::Int, type::DataType = Float64)

Create a n×m array composed of myRef{type} components.

vector_vector_myref = create_undef_array_myRef(l::Int, c::Int, type::DataType = Float64)

Create a vector of size l, each component is a Vector{myRef{type}} of c components.

equalize_vec_vec_myRef!(a::Vector{Vector{MyRef{T}}}, b::Vector{Vector{MyRef{T}}}) where {T <: Number}

Set the references of b to those of a.

value = get_myRef(reference::MyRef{Y}) where {Y <: Number}

Get the value of the reference.

myref = new_ref(value::Y) where {Y <: Number}
myref = new_ref(type::DataType)

Create a new reference myRef from value or type.

set_myRef!(reference::MyRef{Y}, value::Y) where {Y <: Number}

Set the reference to value.

Type instantiated dynamically representeing that an argument is not a tree.

Type instantiated dynamically representeing that an argument is a tree.

children = _get_children(tree, trait_tree)

Get the children from the root node of tree, if trait_tree::Type_trait_tree.

node = _get_node(tree, trait_tree)

Get the root node of tree, if trait_tree::Type_trait_tree.

children = get_children(tree)

Get the children from the root node of tree.

node = get_node(tree)

Get the root node of tree.

Type_trait_tree = is_type_trait_tree(a::AbstractTree)
Type_trait_tree = is_type_trait_tree(a::Expr)
Type_trait_tree = is_type_trait_tree(a::Number)
Type_not_trait_tree = is_type_trait_tree(a::Any)

Return a Type_trait_tree only for AbstractTree, Expr or Number (a leaf of a tree). In the other cases it returns Type_not_trait_tree.

show(tree::AbstractTree; deepth)
show(io::IO, tree::AbstractTree; deepth)

Print tree in the Julia console with a suitable form.

print_tree(tree::AbstractTree)

Print a tree as long as it satisfies the interface M_interface_tree.

children = _get_children(tree)

Get the children from the root node of tree.

node = _get_node(tree)

Get the root node of tree.

Type_node{T} <: AbstractTree

Basic implementation of a tree. A Type_node has fields:

• field gathering the informations about the current node;
• children a vector of children, each of them being a Type_node.

bool = equal_tree(tree1::Type_node{T}, tree2::Type_node{T})

Check recursively if every node from tree1 is the same for tree2.

Supertype of every tree.

tree = create_tree(field::T, children::Vector{Type_node{T}}) where {T}
tree = create_tree(field::T, children::Array{Any, 1}) where {T}
tree = create_tree(ex::Expr)

Create a tree of type Type_node. field will be the root node with some children. create_tree can also translate an Expr to a Type_node.

Type instantiated dynamically that checks if an argument is not a Type_expr_basic

Type instantiated dynamically that checks if an argument is a Type_expr_basic

bool = _is_constant(type)

Return true if type is a constant type.

bool = _is_cubic(type)

Return true if type is a cubic type.

bool = _is_linear(type)

Return true if type is a linear type.

bool = _is_more(type)

Return true if type is more non linear than a cubic.

bool = _is_quadratic(type)

Return true if type is a quadratic type.

type = is_trait_type_expr(arg)

Return type::Type_type_expr if arg is an Type_expr_basic otherwise is return type::Type_not_type_expr

result_type = type_power(index, type)

Return the type resulting of type to power index.

result_type = type_product(type1, type2)

Return the type resulting of a product between type1 and type2.

bool = _is_constant(type)

Return true if type is a constant type.

bool = _is_cubic(type)

Return true if type is a cubic type.

bool = _is_linear(type)

Return true if type is a linear type.

bool = _is_more(type)

Return true if type is more non linear than a cubic type.

bool = _is_quadratic(type)

Return true if type is a quadratic type.

result_type = _type_power(index, type)

Return the type resulting of type to power index.

result_type = _type_product(type1, type2)

Return the type resulting of a product between type1 and type2.

constant = return_constant()

Return constantype::Type_expr_basic.

cubic = return_cubic()

Return cubic::Type_expr_basic.

linear = return_linear()

Return linear::Type_expr_basic.

more = return_more()

Return more::Type_expr_basic.

quadratic = return_quadratic()

Return quadratic::Type_expr_basic.

bool = _is_constant(type::Type_expr_basic)

Check if type equals constant.

bool = _is_cubic(type::Type_expr_basic)

Check if type equals cubic.

bool = _is_linear(type::Type_expr_basic)

Check if type equals linear.

bool = _is_more(type::Type_expr_basic)

Check if type equals more.

bool = _is_quadratic(type::Type_expr_basic)

Check if type equals quadratic.

result_type = _type_power(index_power::Number, b::Type_expr_basic)

Return result_type::Type_expr_basic, resulting of b^(index_power).

result_type = _type_product(a::Type_expr_basic, b::Type_expr_basic)

Return result_type::Type_expr_basic, the type resulting of the product a*b.

Convexity_type

Type representing wether an expression is not_treated, constant, linear, convex, concave or unknown.

Convexity_wrapper

Wrapper around Convexity_type.

concave = concave_type()

Return concave::Convexity_type.

concave_wrapper = concave_wrapper()

Return a Convexity_wrapper wich values concave.

constant = constant_type()

Return constant::Convexity_type.

constant_wrapper = constant_wrapper()

Return a Convexity_wrapper wich values constant.

convex = convex_type()

Return convex::Convexity_type.

convex_wrapper = convex_wrapper()

Return a Convexity_wrapper wich values convex.

convexity_status = get_convexity_wrapper(convexity::Convexity_wrapper)

Return the convexity status of convexity.

untreated_wrapper = init_conv_status()

Return a Convexity_wrapper wich values not_treated.

bool = is_concave(status::Convexity_type)
bool = is_concave(convexity::Convexity_wrapper)

Check if status or convexity.status equals concave.

bool = is_constant(status::Convexity_type)
bool = is_constant(convexity::Convexity_wrapper)

Check if status or convexity.status equals constant.

bool = is_convex(status::Convexity_type)
bool = is_convex(convexity::Convexity_wrapper)

Check if status or convexity.status equals convex.

bool = is_linear(status::Convexity_type)
bool = is_linear(convexity::Convexity_wrapper)

Check if status or convexity.status equals linear.

bool = is_not_treated(status::Convexity_type)
bool = is_not_treated(convexity::Convexity_wrapper)

Check if status or convexity.status equals not_treated.

bool = is_treated(status::Convexity_type)
bool = is_treated(convexity::Convexity_wrapper)

Check if status or convexity.status equals not_treated.

bool = is_unknown(status::Convexity_type)
bool = is_unknown(convexity::Convexity_wrapper)

Check if status or convexity.status equals unknown.

linear = linear_type()

Return linear::Convexity_type.

linear_wrapper = linear_wrapper()

Return a Convexity_wrapper wich values linear.

not_treated = not_treated_type()

Return not_treated::Convexity_type.

set_convexity_wrapper!(convexity::Convexity_wrapper, t::Convexity_type)

Set the convexity status of convexity to type.

unknown = unknown_type()

Return unknown::Convexity_type.

unknown_wrapper = unknown_wrapper()

Return a Convexity_wrapper wich values unknown.