Fixes and clean up throughout.

Author: michakraus

src/hamiltonian.jl

@@ -1,11 +1,10 @@
-#=
+"""
     symbolic_hamitonian is a functions that creates a symbolic hamiltonian from any hamiltonian.
     The output of the function is 
         - the symbolics parameters used to build the hamiltonian (i.e t, q, p),
         - the symbolic expression of the hamiltonian,
         - the function generated from the symbolic hamiltonian. 
-=#
-
+"""
 function symbolic_hamiltonian(H::Base.Callable, dim::Int, params::Union{Tuple, NamedTuple, AbstractArray})
 
     RuntimeGeneratedFunctions.init(@__MODULE__)
@@ -18,10 +17,10 @@ function symbolic_hamiltonian(H::Base.Callable, dim::Int, params::Union{Tuple, N
     sparams = symbolize(params; redundancy = false)[1]        # for the parameters
 
     # create the symbolic hamiltonian
-    sH = H(p, st, q, sparams)
+    sH = H(st, q, p, sparams)
 
     # create the related code  
-    code_H = build_function(sH, p, st, q, develop(sparams)...)
+    code_H = build_function(sH, st, q, p, develop(sparams)...)
 
     # rewrite the code to take directly paramters
     rewrite_code_H = rewrite_hamiltonian(code_H, (q, p, st), sparams)
@@ -31,8 +30,3 @@ function symbolic_hamiltonian(H::Base.Callable, dim::Int, params::Union{Tuple, N
 
     return st, q, p, sparams, sH, gH
 end
-
-
-
-
-

src/lagrangian.jl

@@ -1,11 +1,10 @@
-#=
+"""
     symbolic_lagrangian is a functions that creates a symbolic lagrangian from any lagrangian.
     The output of the function is 
         - the symbolics parameters used to build the hamiltonian (i.e t, x, v),
         - the symbolic expression of the lagrangian,
         - the function generated from the symbolic lagrangian. 
-=#
-
+"""
 function symbolic_lagrangian(L::Base.Callable, dim::Int, params::Union{Tuple, NamedTuple, AbstractArray})
 
     RuntimeGeneratedFunctions.init(@__MODULE__)
@@ -31,4 +30,3 @@ function symbolic_lagrangian(L::Base.Callable, dim::Int, params::Union{Tuple, Na
 
     return st, x, v, sparams, sL, gL
 end
-

src/utils/build_function.jl

@@ -15,7 +15,7 @@ function build_eval(f::Base.Callable, args...; params = params::Union{Tuple, Nam
 end
 
 
-function build_hamiltonien(H::Base.Callable, dim::Int, params::Union{Tuple, NamedTuple, AbstractArray})
+function build_hamiltonian(H::Base.Callable, dim::Int, params::Union{Tuple, NamedTuple, AbstractArray})
 
         #compute the symplectic matrix
         sympmatrix = symplecticMatrix(dim)

src/utils/rewrite_code.jl

@@ -3,38 +3,40 @@
 =#
 
 function rewrite_code(expr, sargs, sparams = nothing, fun_name = "")
-    expr = Meta.parse(replace(string(expr), "var" => ""))
-    expr = Meta.parse(replace(string(expr), r"\""=>""))
+    expr_str = string(expr)
+    expr_str = replace(expr_str, "var" => "")
+    expr_str = replace(expr_str, r"\"" => "")
     for arg in sargs
-        str_symbol = replace(string(arg), r"\[.*"=>"")
+        str_symbol = replace(string(arg), r"\[.*" => "")
         if str_symbol[1] == '(' && str_symbol[end] == ')'
             str_symbol = str_symbol[2:end-1]
         end
         track = get_track(sargs, arg, "args")[2]
-        expr = Meta.parse(replace(string(expr), str_symbol => track))
+        expr_str = replace(expr_str, str_symbol => track)
     end
     for p in develop(sparams)
-        sparams
-        p
-        str_symbol = replace(string(p), r"\[.*"=>"")
+        str_symbol = replace(string(p), r"\[.*" => "")
         track = get_track(sparams, p, "params")[2]
-        expr = Meta.parse(replace(string(expr), str_symbol => track))
+        expr_str = replace(expr_str, str_symbol => track)
     end
-    expr = Meta.parse(replace(string(expr), r"function.*" => "function "*fun_name*"(args, params)\n"))
+    expr_str = replace(expr_str, r"function.*" => "function " * fun_name * "(args, params)\n")
+    expr = Meta.parse(expr_str)
 end
 
 function rewrite_hamiltonian(expr, args, sparams = nothing, fun_name = "shamiltonian")
     expr = rewrite_code(expr, args, sparams, fun_name)
-    string_expr = replace(string(expr), "args[1]" => "q")
+    string_expr = string(expr)
+    string_expr = replace(string_expr, "args[1]" => "q")
     string_expr = replace(string_expr, "args[2]" => "p")
     string_expr = replace(string_expr, "args[3]" => "t")
-    string_expr = replace(string_expr, "args" => "p, t, q")
+    string_expr = replace(string_expr, "args" => "t, q, p")
     expr = Meta.parse(string_expr)
 end
 
 function rewrite_lagrangian(expr, args, sparams = nothing, fun_name = "slagrangian")
     expr = rewrite_code(expr, args, sparams, fun_name)
-    string_expr = replace(string(expr), "args[1]" => "x")
+    string_expr = string(expr)
+    string_expr = replace(string_expr, "args[1]" => "x")
     string_expr = replace(string_expr, "args[2]" => "v")
     string_expr = replace(string_expr, "args[3]" => "t")
     string_expr = replace(string_expr, "args" => "t, x, v")
@@ -43,7 +45,8 @@ end
 
 function rewrite_neuralnetwork(expr, args, sparams)
     expr = rewrite_code(expr, args, sparams)
-    string_expr = replace(string(expr), "args[1]" => "x")
+    string_expr = string(expr)
+    string_expr = replace(string_expr, "args[1]" => "x")
     string_expr = replace(string_expr, "args" => "x")
     expr = Meta.parse(string_expr)
 end

test/test_hamiltonian.jl

@@ -3,12 +3,11 @@ using Symbolics
 using Test
 
 parameters = (k=1, )
-function hamiltonian(p, t, q, params)
+
+function hamiltonian(t, q, p, params)
     p[1]^2 / 2 + params.k * q[1]^2 / 2
 end
 
-symbolize(parameters)
-
 st̃, sq̃, sp̃, sparams, shamiltonian, hamiltonian_function = symbolic_hamiltonian(hamiltonian, 2, parameters)
 
 @variables st
@@ -24,5 +23,5 @@ st̃, sq̃, sp̃, sparams, shamiltonian, hamiltonian_function = symbolic_hamilto
 @test isequal(shamiltonian, Num((1//2)*(p[1]^2) + (1//2)*k*(q[1]^2)))
 
 t, q, p = 2, 0.5, 0.7
-@test hamiltonian_function(p, t, q, parameters) == hamiltonian(p, t, q, parameters)
+@test hamiltonian_function(t, q, p, parameters) == hamiltonian(t, q, p, parameters)
 

test/test_lagrangian.jl

@@ -3,6 +3,7 @@ using Symbolics
 using Test
 
 parameters = (k=1, )
+
 function lagrangian(t, q, v, params)
     v[1]^2 / 2 - params.k * q[1]^2 / 2
 end

test/test_params.jl

@@ -11,4 +11,4 @@ sparams = symbolize(params)[1]
 
 verified_sparams = ( (W = W_1, b = b_1), (W = (W_2 , W_3), c = c_1), M_1, (X_1, X_2))
 
-@test sparams === verified_sparams
+@test sparams === verified_sparams

test/test_rewrite.jl

@@ -5,17 +5,15 @@ using Test
 @variables W1[1:2,1:2] W2[1:2,1:2] b1[1:2] b2[1:2]
 sparams = ((W =  W1, b = b1), (W = W2, b = b2))
 
-@variables SX, SY
-sargs = [SX, SY]
+@variables st
+@variables sargs(st)[1:2]
 
 output = sparams[2].W  * tanh.(sparams[1].W * sargs + sparams[1].b) + sparams[2].b
 
 code_output = build_function(output, sargs..., develop(sparams)...)[2]
-rewrite_ouput = eval(rewrite_code(code_output, Tuple(sargs), sparams, "OUTPUT"))
+rewrite_output = eval(rewrite_code(code_output, Tuple(sargs), sparams, "OUTPUT"))
 
 params = ((W = [1 3; 2 2], b = [1, 0]), (W = [1 1; 0 2], b = [1, 0]))
 args = [1, 0.2]
 
-@test_nowarn rewrite_ouput(args, params) 
-
-
+@test_nowarn rewrite_output(args, params)