tspan -> timespan.

Author: benedict-96

README.md

@@ -28,7 +28,7 @@ include("scripts/pendulum.jl")
 
 type = Float32 # Float16 etc.
 # get data 
-qp_data = GeometricMachineLearning.apply_toNT(a -> CuArray(type.(a)), pendulum_data((q=[0.], p=[1.]); tspan=(0.,100.)))
+qp_data = GeometricMachineLearning.apply_toNT(a -> CuArray(type.(a)), pendulum_data((q=[0.], p=[1.]); timespan=(0.,100.)))
 # call the DataLoader
 dl = DataLoader(qp_data)
 

docs/src/tutorials/adjusting_the_loss_function.md

@@ -20,7 +20,7 @@ using GeometricProblems.HarmonicOscillator: hodeproblem
 import Random # hide
 Random.seed!(123) # hide
 
-sol = integrate(hodeproblem(; tspan = 100), ImplicitMidpoint()) 
+sol = integrate(hodeproblem(; timespan = 100), ImplicitMidpoint()) 
 data = DataLoader(sol; suppress_info = true)
 
 nn = NeuralNetwork(GSympNet(2))

docs/src/tutorials/symplectic_autoencoder.md

@@ -79,7 +79,7 @@ using GeometricIntegrators: integrate, ImplicitMidpoint
 using GeometricMachineLearning 
 import Random # hide
 
-pr = tl.hodeproblem(; tspan = (0.0, 800.))
+pr = tl.hodeproblem(; timespan = (0.0, 800.))
 sol = integrate(pr, ImplicitMidpoint())
 nothing # hide
 ```

docs/src/tutorials/sympnet_tutorial.md

@@ -27,7 +27,7 @@ import Random # hide
 Random.seed!(1234) # hide
 
 # the problem is the ODE of the harmonic oscillator
-ho_problem = ho.hodeproblem(; tspan = 500)
+ho_problem = ho.hodeproblem(; timespan = 500)
 
 # integrate the system
 solution = integrate(ho_problem, ImplicitMidpoint())

docs/src/tutorials/volume_preserving_transformer_rigid_body.md

@@ -27,7 +27,7 @@ We now generate the data by integrating with:
 
 ```@example rigid_body
 const timestep = .2
-const tspan = (0., 20.)
+const timespan = (0., 20.)
 nothing # hide
 ```
 
@@ -38,7 +38,7 @@ using GeometricMachineLearning # hide
 using GeometricIntegrators: integrate, ImplicitMidpoint
 using GeometricProblems.RigidBody: odeproblem, odeensemble, default_parameters
 
-ensemble_problem = odeensemble(ics; tspan = tspan, timestep = timestep, parameters = default_parameters)
+ensemble_problem = odeensemble(ics; timespan = timespan, timestep = timestep, parameters = default_parameters)
 ensemble_solution = integrate(ensemble_problem, ImplicitMidpoint())
 
 dl_cpu = DataLoader(ensemble_solution; suppress_info = true)
@@ -228,7 +228,7 @@ ics_val₂ = [0., sin(1.1), cos(1.1)]
 const t_validation = 120
 
 function produce_trajectory(ics_val)
-    problem = odeproblem(ics_val;   tspan = (0, t_validation), 
+    problem = odeproblem(ics_val;   timespan = (0, t_validation), 
                                     timestep = timestep, 
                                     parameters = default_parameters)
     solution = integrate(problem, ImplicitMidpoint())
@@ -314,7 +314,7 @@ We can see that the volume-preserving transformer performs much better than the
 We also compare the times it takes to integrate the system with (i) implicit midpoint, (ii) the volume-preserving transformer and (iii) the standard transformer:
 ```@example rigid_body
 function timing() # hide
-problem = odeproblem(ics_val₁; tspan = (0, t_validation), timestep = timestep, parameters = default_parameters) # hide
+problem = odeproblem(ics_val₁; timespan = (0, t_validation), timestep = timestep, parameters = default_parameters) # hide
 solution = integrate(problem, ImplicitMidpoint()) # hide
 @time "Implicit Midpoint" solution = integrate(problem, ImplicitMidpoint())
 trajectory = Float32.(DataLoader(solution; suppress_info = true).input)

scripts/Script_using_fully_GML/data_problem.jl

@@ -85,12 +85,12 @@ end
 ########################################################################################
 # get data of a problem for Sypmnet (results is (data = target =(q,p))) from Hamiltonian
 
-function get_phase_space_data(nameproblem, q₀, p₀, tspan = (0., 100.), timestep = 0.1)
+function get_phase_space_data(nameproblem, q₀, p₀, timespan = (0., 100.), timestep = 0.1)
 
     # get the Hamiltonien corresponding to name_problem   
     H_problem, n_dim = dict_problem_H[nameproblem] 
 
-    q,p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
+    q,p = compute_phase_space(H_problem, q₀, p₀, timespan, timestep)
 
     return (q, p)
 end
@@ -102,15 +102,15 @@ function get_phase_space_multiple_trajectoy(nameproblem; singlematrix = true, n_
     H_problem, n_dim = dict_problem_H[nameproblem] 
 
     #define timespan
-    tspan=(0.,n_points*timestep)
+    timespan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     trajectory_q = [zeros(n_points+1,n_dim) for _ in 1:n_trajectory]
     trajectory_p = [zeros(n_points+1,n_dim) for _ in 1:n_trajectory]
     for i in 1:n_trajectory
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        trajectory_q[i],trajectory_p[i] = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
+        trajectory_q[i],trajectory_p[i] = compute_phase_space(H_problem, q₀, p₀, timespan, timestep)
     end
 
     if singlematrix
@@ -125,7 +125,7 @@ end
 ###############################################################################
 # compute phase space from the Hamiltonian
 
-function compute_phase_space(H_problem, q₀, p₀, tspan = (0., 100.), timestep = 0.1)
+function compute_phase_space(H_problem, q₀, p₀, timespan = (0., 100.), timestep = 0.1)
 
     n_dim = length(q₀)
 
@@ -144,7 +144,7 @@ function compute_phase_space(H_problem, q₀, p₀, tspan = (0., 100.), timestep
     h(t, q, p, params) = H2(q,p)
 
     # simulate data with geometric Integrators
-    ode = HODEProblem(v, f, h, tspan, timestep, q₀, p₀)
+    ode = HODEProblem(v, f, h, timespan, timestep, q₀, p₀)
 
     #return sol = integrate(ode, SymplecticEulerA())
     return sol = integrate(ode, SymplecticTableau(TableauExplicitEuler()))
@@ -175,7 +175,7 @@ function get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_poin
     H_problem, n_dim = dict_problem_H[nameproblem] 
 
     #define timespan
-    tspan=(0.,n_points*timestep)
+    timespan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     pre_data = NamedTuple()
@@ -184,7 +184,7 @@ function get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_poin
 
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
+        q, p = compute_phase_space(H_problem, q₀, p₀, timespan, timestep)
 
         Data = [(q[n], p[n]) for n in 1:size(q,1)]
 
@@ -217,7 +217,7 @@ function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory
     dH(x) = symplectic_matrix * ∇H(x)
 
     #define timespan
-    tspan=(0.,n_points*timestep)
+    timespan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     pre_data = NamedTuple()
@@ -227,7 +227,7 @@ function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory
 
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
+        q, p = compute_phase_space(H_problem, q₀, p₀, timespan, timestep)
 
         Data = [(q[n], p[n]) for n in 1:size(q,1)]
         data_calc = [[q[n]..., p[n]...] for n in 1:size(q,1)]
@@ -265,7 +265,7 @@ function get_multiple_trajectory_structure_Lagrangian(nameproblem; n_trajectory
     H_problem, n_dim = dict_problem_L[nameproblem] 
 
     #define timespan
-    tspan=(0.,n_points*timestep)
+    timespan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     pre_data = []
@@ -278,7 +278,7 @@ function get_multiple_trajectory_structure_Lagrangian(nameproblem; n_trajectory
 
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
+        q, p = compute_phase_space(H_problem, q₀, p₀, timespan, timestep)
 
         Data = [q[n] for n in 1:size(q,1)]
 

scripts/ensemblesolution/harmonic_oscillator.jl

@@ -8,7 +8,7 @@ using GeometricProblems.HarmonicOscillator: hodeensemble, hamiltonian, default_p
 
 
 #create the object ensemble_solution
-ensemble_problem = hodeensemble(tspan = (0.0,4.0))
+ensemble_problem = hodeensemble(timespan = (0.0,4.0))
 ensemble_solution =  exact_solution(ensemble_problem ) 
 
 include("plots.jl")

scripts/pendulum.jl

@@ -32,14 +32,14 @@ end
 @doc raw"""
 Generates data for a pendulum in 2d with optional arguments:
 - `T`: the type of the data (`Float32`, `Float64`, `Float16`, etc.)
-- `tspan`: default is `(0., 100.)`
+- `timespan`: default is `(0., 100.)`
 - `timestep` default is `0.1`
 - `q0`: default is `randn(1)`
 - `p0`: default is `rand(1)`.
 """
-function pendulum_data(; T = Float64, tspan = (T(0.), T(100.)), timestep = T(0.1), q0 = T.(randn(1)), p0 = T.(randn(1)))
+function pendulum_data(; T = Float64, timespan = (T(0.), T(100.)), timestep = T(0.1), q0 = T.(randn(1)), p0 = T.(randn(1)))
     # simulate data with geometric Integrators
-    ode = HODEProblem(v, f, H, tspan, timestep, q0, p0)
+    ode = HODEProblem(v, f, H, timespan, timestep, q0, p0)
 
     # sol = integrate(ode, SymplecticEulerA())
     sol = integrate(ode, ImplicitMidpoint())
@@ -52,6 +52,6 @@ function pendulum_data(; T = Float64, tspan = (T(0.), T(100.)), timestep = T(0.1
     return (q=q, p=p)
 end
 
-function pendulum_data(ics::NamedTuple{(:q, :p), Tuple{AT, AT}}; tspan = (T(0.), T(100.)), timestep = T(0.1)) where {T, AT<:AbstractVector{T}}
-    pendulum_data(; T=T, tspan=tspan, timestep=timestep, q0=ics.q, p0=ics.p)
+function pendulum_data(ics::NamedTuple{(:q, :p), Tuple{AT, AT}}; timespan = (T(0.), T(100.)), timestep = T(0.1)) where {T, AT<:AbstractVector{T}}
+    pendulum_data(; T=T, timespan=timespan, timestep=timestep, q0=ics.q, p0=ics.p)
 end

scripts/symplectic_autoencoders/integration.jl

@@ -19,11 +19,11 @@ p_zero = false
 μ_right = T(4/6)
 
 function perform_integration(params, n_time_steps)
-    tspan = (T(0),T(1))
-    timestep = T((tspan[2] - tspan[1])/(n_time_steps-1))
+    timespan = (T(0),T(1))
+    timestep = T((timespan[2] - timespan[1])/(n_time_steps-1))
     ics_offset = p_zero ? get_initial_condition2(params.μ, params.Ñ) : get_initial_condition(params.μ, params.Ñ)
     ics = (q=ics_offset.q.parent, p=ics_offset.p.parent)
-    ode = HODEProblem(v_f_hamiltonian(params)..., parameters=params, tspan, timestep, ics)
+    ode = HODEProblem(v_f_hamiltonian(params)..., parameters=params, timespan, timestep, ics)
     sol = integrate(ode, ImplicitMidpoint())
 end
 

scripts/symplectic_autoencoders/online_sympnet.jl

@@ -9,7 +9,7 @@ import Random
 backend = CUDABackend()
 
 params = [(α = α̃ ^ 2, N = 200) for α̃ in 0.8 : .1 : 0.8]
-pr = hodeensemble(; tspan = (0.0, 800.), parameters = params)
+pr = hodeensemble(; timespan = (0.0, 800.), parameters = params)
 sol = integrate(pr, ImplicitMidpoint())
 dl_cpu_64 = DataLoader(sol; autoencoder = true)
 dl = DataLoader(dl_cpu_64, backend, Float32)