🤖 Format .jl files

src/ExpressionTreeForge.jl

@@ -20,7 +20,8 @@ export concave_type, constant_type, convex_type, linear_type, not_treated_type,
 export is_concave, is_constant, is_convex, is_linear, is_not_treated, is_treated, is_unknown
 export get_convexity_status, set_convexity!, create_convex_tree
 export is_constant, is_linear, is_quadratic, is_cubic, is_more
-export transform_to_Expr, transform_to_Expr_julia, transform_to_Expr_JuMP, transform_to_expr_tree, complete_tree
+export transform_to_Expr,
+  transform_to_Expr_julia, transform_to_Expr_JuMP, transform_to_expr_tree, complete_tree
 export extract_element_functions,
   get_type_tree, get_elemental_variables, normalize_indices!, cast_type_of_constant!, sum_expr_trees
 export non_linear_JuMP_model_evaluator, sparse_jacobian_JuMP_model

src/export.jl

@@ -359,7 +359,8 @@ julia> normalize_indices!(:(x[4] + x[5]), [4,5])
 :(x[1] + x[2])
 ```
 """
-@inline normalize_indices!(a::Any, v::AbstractVector{Int}; kwargs...) = M_algo_expr_tree.normalize_indices!(a, v; kwargs...)
+@inline normalize_indices!(a::Any, v::AbstractVector{Int}; kwargs...) =
+  M_algo_expr_tree.normalize_indices!(a, v; kwargs...)
 
 """
     cast_type_of_constant(expr_tree, type::DataType)
@@ -391,7 +392,8 @@ 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.
 """
-@inline non_linear_JuMP_model_evaluator(ex::Any; kwargs...) = M_algo_expr_tree.non_linear_JuMP_model_evaluator(ex; kwargs...)
+@inline non_linear_JuMP_model_evaluator(ex::Any; kwargs...) =
+  M_algo_expr_tree.non_linear_JuMP_model_evaluator(ex; kwargs...)
 
 """
     evaluator = sparse_jacobian_JuMP_model(expr_trees)
@@ -400,8 +402,8 @@ Return the evaluator of a `MathOptInterface.Nonlinear.Model` defined by `expr_tr
 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.
 """
-@inline sparse_jacobian_JuMP_model(expr_trees::Any) = M_algo_expr_tree.sparse_jacobian_JuMP_model(expr_trees)
-
+@inline sparse_jacobian_JuMP_model(expr_trees::Any) =
+  M_algo_expr_tree.sparse_jacobian_JuMP_model(expr_trees)
 
 """
     evaluate_expr_tree(expr_tree::Type_expr_tree, x::AbstractVector)

src/expr_tree/abs_expr_tree.jl

@@ -18,7 +18,7 @@ mutable struct Bounds{T <: Number}
   sup_bound::T
 end
 
-copy(bounds::Bounds{T}) where T = Bounds{T}(bounds.inf_bound, bounds.sup_bound)
+copy(bounds::Bounds{T}) where {T} = Bounds{T}(bounds.inf_bound, bounds.sup_bound)
 
 """
     bound = create_empty_bounds(type::DataType)

src/expr_tree/algorithm_expr_tree.jl

@@ -2,7 +2,7 @@ module M_algo_expr_tree
 using SparseArrays
 using MathOptInterface
 
-const MOI=MathOptInterface
+const MOI = MathOptInterface
 
 using ..M_trait_expr_node, ..M_trait_expr_tree, ..M_trait_tree
 using ..M_abstract_expr_tree, ..M_abstract_expr_node, ..M_abstract_tree
@@ -179,28 +179,36 @@ julia> normalize_indices!(:(x[4] + x[5]), [4,5]; initial_index::Int)
 @inline _normalize_indices!(expr_tree, ::M_trait_expr_tree.Is_not_expr_tree, a::Vector{Int}) =
   error(" This is not an Expr tree")
 
-@inline _normalize_indices!(expr_tree, ::M_trait_expr_tree.Is_expr_tree, a::Vector{Int}; kwargs...) =
-  _normalize_indices!(expr_tree, a; kwargs...)
+@inline _normalize_indices!(
+  expr_tree,
+  ::M_trait_expr_tree.Is_expr_tree,
+  a::Vector{Int};
+  kwargs...,
+) = _normalize_indices!(expr_tree, a; kwargs...)
 
 @inline normalize_indices!(expr_tree, a::Dict{Int, Int}; kwargs...) =
   _normalize_indices!(expr_tree, M_trait_expr_tree.is_expr_tree(expr_tree), a; kwargs...)
 
 @inline _normalize_indices!(expr_tree, ::M_trait_expr_tree.Is_not_expr_tree, a::Dict{Int, Int}) =
   error(" This is not an Expr tree")
 
-@inline _normalize_indices!(expr_tree, ::M_trait_expr_tree.Is_expr_tree, a::Dict{Int, Int}; kwargs...) =
-  _normalize_indices!(expr_tree, a; kwargs...)
+@inline _normalize_indices!(
+  expr_tree,
+  ::M_trait_expr_tree.Is_expr_tree,
+  a::Dict{Int, Int};
+  kwargs...,
+) = _normalize_indices!(expr_tree, a; kwargs...)
 
 """
     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])`.
 """
-function N_to_Ni(elemental_var::Vector{Int}; initial_index=0, kwargs...)
+function N_to_Ni(elemental_var::Vector{Int}; initial_index = 0, kwargs...)
   dic_var_value = Dict{Int, Int}()
   for i = 1:length(elemental_var)
-    dic_var_value[elemental_var[i]] = initial_index+i
+    dic_var_value[elemental_var[i]] = initial_index + i
   end
   return dic_var_value
 end
@@ -327,7 +335,10 @@ 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.
 """
-function non_linear_JuMP_model_evaluator(expr_tree; variables=sort!(get_elemental_variables(expr_tree)))
+function non_linear_JuMP_model_evaluator(
+  expr_tree;
+  variables = sort!(get_elemental_variables(expr_tree)),
+)
   model = MOI.Nonlinear.Model()
   _variables = (index -> MOI.VariableIndex(index)).(variables)
   ex_jump = M_trait_expr_tree.transform_to_Expr_JuMP(expr_tree)
@@ -336,7 +347,7 @@ function non_linear_JuMP_model_evaluator(expr_tree; variables=sort!(get_elementa
   MOI.Nonlinear.set_objective(model, ex)
   evaluator = MOI.Nonlinear.Evaluator(model, MOI.Nonlinear.SparseReverseMode(), _variables)
   MOI.initialize(evaluator, [:Grad, :HessVec])
-  
+
   return evaluator
 end
 
@@ -355,9 +366,9 @@ function sparse_jacobian_JuMP_model(expr_trees)
   for expr in expr_trees
     variables = sort!(get_elemental_variables(expr))
     variables_constraints = unique(vcat(variables_constraints, variables))
-    expr_jump = M_trait_expr_tree.transform_to_Expr_JuMP(expr)    
+    expr_jump = M_trait_expr_tree.transform_to_Expr_JuMP(expr)
     expr_index = MOI.Nonlinear.add_expression(model, expr_jump)
-    constraint_index = MOI.Nonlinear.add_constraint(model, expr_index, MOI.EqualTo(0.))
+    constraint_index = MOI.Nonlinear.add_constraint(model, expr_index, MOI.EqualTo(0.0))
   end
   sort!(variables_constraints)
 
@@ -377,5 +388,4 @@ function sparse_jacobian_JuMP_model(expr_trees)
   return evaluator
 end
 
-
-end
+end

src/expr_tree/tr_expr_tree.jl

@@ -6,7 +6,8 @@ using ..M_abstract_expr_tree, ..M_implementation_expr_tree, ..M_implementation_c
 import ..M_interface_expr_tree:
   _get_expr_node, _get_expr_children, _inverse_expr_tree, _sum_expr_trees
 import ..M_implementation_expr_tree: Type_expr_tree, _get_real_node
-import ..M_interface_expr_tree: _transform_to_expr_tree, _expr_tree_to_create, _transform_to_Expr_JuMP
+import ..M_interface_expr_tree:
+  _transform_to_expr_tree, _expr_tree_to_create, _transform_to_Expr_JuMP
 import Base.==
 
 export is_expr_tree, get_expr_node, get_expr_children, inverse_expr_tree, sum_expr_trees

src/node_expr_tree/abs_expr_node.jl

@@ -14,7 +14,7 @@ export equalize_vec_vec_myRef!
 """ Supertype of every node. """
 abstract type Abstract_expr_node end
 
-function copy(node::T) where {T<:Abstract_expr_node}
+function copy(node::T) where {T <: Abstract_expr_node}
   names = fieldnames(T)
   fields = map(name -> getfield(node, name), names)
   return T(fields...)

src/node_expr_tree/tr_expr_node.jl

@@ -313,7 +313,8 @@ A `constant` node returns its value.
 """
 @inline node_to_Expr_JuMP(a) = _node_to_Expr_JuMP(a, is_expr_node(a))
 @inline _node_to_Expr_JuMP(a, ::Type_expr_node) = _node_to_Expr_JuMP(a)
-@inline _node_to_Expr_JuMP(a, ::Type_not_expr_node) = error("This node is not a expression tree node")
+@inline _node_to_Expr_JuMP(a, ::Type_not_expr_node) =
+  error("This node is not a expression tree node")
 
 """
     bool = cast_constant!(node::Abstract_expr_node, type::Datatype)

test/further_tests/general_tree.jl

@@ -32,7 +32,7 @@
   transform_to_Expr_julia(ex) # for coverage
 
   non_linear_JuMP_model_evaluator(ex) # for coverage
-  
+
   cex = complete_tree(ex)
 
   ExpressionTreeForge.set_bounds!(cex)

test/runtests.jl

@@ -2,7 +2,7 @@ using LinearAlgebra, SparseArrays, Test
 using JuMP, MathOptInterface, Symbolics
 using ExpressionTreeForge
 
-const MOI=MathOptInterface
+const MOI = MathOptInterface
 
 include("first_test.jl")
 include("test_on_tree/ordered_include.jl")

test/test_on_tree/algorithm.jl

@@ -20,15 +20,15 @@ using ..ExpressionTreeForge.M_trait_expr_tree
   element_functions = extract_element_functions(expr_tree_j)
   element_variables = get_elemental_variables.(element_functions)
 
-  ExpressionTreeForge.M_algo_expr_tree.get_Ui([1,3], n)
+  ExpressionTreeForge.M_algo_expr_tree.get_Ui([1, 3], n)
 
   map((fun, var) -> normalize_indices!(fun, var), element_functions, element_variables)
   @test ExpressionTreeForge.M_trait_expr_tree.expr_tree_equal(expr_tree, expr_tree_j) == false
 end
 
 @testset "MOI.Nonlinear.Model from trees" begin
   # unconstrained model
-  expr = :(5*x[3] + 3*x[1] + 4*x[4]^2 + 3)
+  expr = :(5 * x[3] + 3 * x[1] + 4 * x[4]^2 + 3)
   expr_tree = transform_to_expr_tree(expr)
   complete_expr_tree = complete_tree(expr_tree)
 
@@ -38,7 +38,7 @@ end
   evaluator_expr_tree = non_linear_JuMP_model_evaluator(expr_tree)
   evaluator_complete_tree = non_linear_JuMP_model_evaluator(complete_expr_tree)
 
-  x= Float64[0,1,2]
+  x = Float64[0, 1, 2]
   @test MOI.eval_objective(evaluator_expr, x) == 24
   @test MOI.eval_objective(evaluator_expr_tree, x) == 24
   @test MOI.eval_objective(evaluator_complete_tree, x) == 24
@@ -50,15 +50,15 @@ end
   MOI.eval_objective_gradient(evaluator_expr, grad_expr, x)
   MOI.eval_objective_gradient(evaluator_expr_tree, grad_expr_tree, x)
   MOI.eval_objective_gradient(evaluator_complete_tree, grad_complete_tree, x)
-  grad_sol = Float64[3,5,16]
+  grad_sol = Float64[3, 5, 16]
 
   @test grad_expr == grad_sol
   @test grad_expr_tree == grad_sol
   @test grad_complete_tree == grad_sol
 
   # constrained model
-  expr1 = :(5*x[3] + 3*x[1] + 4*x[4]^2 + 3)
-  expr2 = :(2*x[1] + 3*x[1]^3 + 4*x[2]^2 -2)
+  expr1 = :(5 * x[3] + 3 * x[1] + 4 * x[4]^2 + 3)
+  expr2 = :(2 * x[1] + 3 * x[1]^3 + 4 * x[2]^2 - 2)
 
   expr_tree1 = transform_to_expr_tree(expr1)
   expr_tree2 = transform_to_expr_tree(expr2)
@@ -70,10 +70,10 @@ end
   evaluator_tree = sparse_jacobian_JuMP_model([expr_tree1, expr_tree2])
   evaluator_complete = sparse_jacobian_JuMP_model([complete_expr_tree1, complete_expr_tree2])
 
-  x= Float64[0,1,2,3]
-  @test MOI.eval_objective(evaluator, x) == 51.
-  @test MOI.eval_objective(evaluator_tree, x) == 51.
-  @test MOI.eval_objective(evaluator_complete, x) == 51.
+  x = Float64[0, 1, 2, 3]
+  @test MOI.eval_objective(evaluator, x) == 51.0
+  @test MOI.eval_objective(evaluator_tree, x) == 51.0
+  @test MOI.eval_objective(evaluator_complete, x) == 51.0
 
   #same for the 3 evaluators
   non_empty_indices = MOI.jacobian_structure(evaluator)
@@ -84,30 +84,35 @@ end
   MOI.eval_constraint_jacobian(evaluator, sparse_jacobian, x)
   MOI.eval_constraint_jacobian(evaluator, sparse_jacobian_tree, x)
   MOI.eval_constraint_jacobian(evaluator, sparse_jacobian_complete, x)
-  
+
   @test sparse_jacobian_tree == sparse_jacobian
   @test sparse_jacobian_complete == sparse_jacobian
 
   grad = similar(x)
   MOI.eval_objective_gradient(evaluator, grad, x)
-  expr1 = :(5*x[3] + 3*x[1] + 4*x[4]^2 + 3)
-  expr2 = :(2*x[1] + 3*x[1]^3 + 4*x[2]^2 -2)
-  @test grad == [sparse_jacobian[1] + sparse_jacobian[4], sparse_jacobian[5], sparse_jacobian[2], sparse_jacobian[3]]
+  expr1 = :(5 * x[3] + 3 * x[1] + 4 * x[4]^2 + 3)
+  expr2 = :(2 * x[1] + 3 * x[1]^3 + 4 * x[2]^2 - 2)
+  @test grad == [
+    sparse_jacobian[1] + sparse_jacobian[4],
+    sparse_jacobian[5],
+    sparse_jacobian[2],
+    sparse_jacobian[3],
+  ]
 end
 
 @testset "normalize_indices! tests" begin
-  expr = :(5*x[3] + 3*x[1] + 4*x[4]^2 + 3)
+  expr = :(5 * x[3] + 3 * x[1] + 4 * x[4]^2 + 3)
   expr_tree = transform_to_expr_tree(expr)
   completed_tree = complete_tree(expr_tree)
 
   elt_var = get_elemental_variables(expr)
   sort!(elt_var)
-  normalize_indices!(expr, elt_var; initial_index=2)
-  expr == :(5 * x[4] + 3 * x[3] + 4 * x[5] ^ 2 + 3)
+  normalize_indices!(expr, elt_var; initial_index = 2)
+  expr == :(5 * x[4] + 3 * x[3] + 4 * x[5]^2 + 3)
 
-  normalize_indices!(expr_tree, elt_var; initial_index=2)
+  normalize_indices!(expr_tree, elt_var; initial_index = 2)
   expr_tree == transform_to_expr_tree(expr)
 
-  normalize_indices!(completed_tree, elt_var; initial_index=2)
+  normalize_indices!(completed_tree, elt_var; initial_index = 2)
   completed_tree == complete_tree(expr_tree)
-end
+end