Comments (7)
Krastanov
commented on June 12, 2024
1
I suspect your use of TimeDependentSum is incorrect. Currently in H2 you create a new TimeDependentSum object (which allocates new operators, etc). Rather, you want to create a single TimeDependentSum object and just update the scalar weight in it.
Check out https://docs.qojulia.org/timeevolution/timedependent-problems/
In particular, it seems the constructor should be
H2 = TimeDependentSum([t -> 1.0 .+ 0.1*sin.(t), t -> 1.0 .+ 0.1*sin.(t)], [σge, σeg])
Notice that H2 is NOT a function anymore, so it will not be creating a new TimeDependentSum instance. Rather the solver will be appropriately updating (in-place modifying) the single instance you give it.
from quantumoptics.jl.
amilsted
commented on June 12, 2024
1
There are a couple of (related) things going on:
- The QO evolution functions will store the state at every element of
tspan, so allocations are needed for that. - The integrator will stop at every element of
tspan, so has to do at least that many timesteps. - You are using a two-element
tspanfor DiffEq and a 10000-element one for QO.
julia> tspan = [0.0:0.01:100.0;];
julia> @time timeevolution.schroedinger_dynamic(tspan, ψ0, H5; alg=Tsit5());
0.008411 seconds (20.11 k allocations: 2.017 MiB)
julia> fout = (x...)->nothing
#23 (generic function with 1 method)
julia> @time timeevolution.schroedinger_dynamic(tspan, ψ0, H5; alg=Tsit5(), fout=fout);
0.001917 seconds (111 allocations: 489.125 KiB)
julia> tspan = (0.0, 100.0);
julia> @time timeevolution.schroedinger_dynamic(tspan, ψ0, H5; alg=Tsit5(), fout=fout);
0.000661 seconds (100 allocations: 6.508 KiB)Now we're much closer to DiffEq. The other thing is that you're effectively hardcoding a sparse representation of the operators in the DiffEq case, this probably accounts for the rest.
Btw, there's no need for . broadcasting syntax in defining the time-dependent operator. This
H5_ = TimeDependentSum([t -> 1.0 + 0.1*sin(t), t -> 1.0 + 0.1*sin(t)], (σge, σeg)) is marginally faster.
from quantumoptics.jl.
amilsted
commented on June 12, 2024
1
Ah, yeah - that's a point. We try to do in-place updates of the statevector and that won't work with static arrays.
from quantumoptics.jl.
mgoloshchapov
commented on June 12, 2024
@Krastanov, thank you for your answer. I tried examples from https://docs.qojulia.org/timeevolution/timedependent-problems/ and different constructor for H2 that you suggested. They work slightly better than my initial versions, but still far from realisations with DifferentialEquations.jl(
H5 = TimeDependentSum([t -> 1.0 .+ 0.1*sin.(t), t -> 1.0 .+ 0.1*sin.(t)], [σge, σeg]);
@btime timeevolution.schroedinger_dynamic(tspan, ψ0, H5; alg=Tsit5());
2.544 ms (20105 allocations: 2.02 MiB)const H6 = LazySum(ComplexF64[0.0, 0.0],[σge, σeg]);
function H_pump(t, psi)
H6.factors[1] = 1.0 + 0.1*sin(t);
H6.factors[2] = 1.0 + 0.1*sin(t);
return H6
end;@btime timeevolution.schroedinger_dynamic(tspan, ψ0, H_pump; alg=Tsit5());
2.714 ms (26511 allocations: 2.16 MiB)const coeff_funcs = [t->1.0 + 0.1*sin(t),t->1.0 + 0.1*sin(t)];
const H7 = LazySum([c(tspan[1]) for c∈coeff_funcs],[σge,σeg])
# Dynamic function
function Ht(t,psi)
for i=1:length(H7.factors)
H7.factors[i] = coeff_funcs[i](t)
end
return H7
end@btime timeevolution.schroedinger_dynamic(tspan, ψ0, Ht; alg=Tsit5());
2.937 ms (32929 allocations: 2.21 MiB)I also tried example from tutorial with larger tspan:
# Generic Gaussian pulse
pulse(t,t0,Ω) = @. Ω*exp(-(t-t0)^2)
# Operators
b1 = SpinBasis(1//2)
sx1 = tensor(sigmax(b1), one(b1))
sx2 = tensor(one(b1), sigmax(b1))
# Define coefficients and Hamiltonian
tspan = [0.0:0.01:100.0;]
const coeff_funcs = [t->pulse(t,1,0.5),t->(pulse(t,5,1))]
const H = LazySum([c(tspan[1]) for c∈coeff_funcs],[sx1,sx2])
# Dynamic function
function Ht(t,psi)
for i=1:length(H.factors)
H.factors[i] = coeff_funcs[i](t)
end
return H
end
psi0 = tensor(spindown(b1), spindown(b1));@btime timeevolution.schroedinger_dynamic(tspan, psi0, Ht);
1.913 ms (21072 allocations: 2.80 MiB)Do you have the same performance on your computer?
from quantumoptics.jl.
Krastanov
commented on June 12, 2024
Indeed, I confirm that I see the same large number of allocations on QuantumOptics v1.0.14 and julia 1.9.3
@amilsted , I think you are most familiar with this portion of the code. Any ideas?
from quantumoptics.jl.
amilsted
commented on June 12, 2024
By the way, you should find you can use static arrays in the QO case too. Operator(my_basis, some_static_array) and Ket(my_basis, static_vector) should work.
from quantumoptics.jl.
mgoloshchapov
commented on June 12, 2024
Thank you so much!
I changed tspan and operator definition both in example and my project, everything works fast now.
It seems like static arrays don't help here:
Without SA:
tspan = (0.0, 100.0);
ψ0 = nlevelstate(basis, 1);
H5 = TimeDependentSum([t -> 1.0 + 0.1*sin(t), t -> 1.0 + 0.1*sin(t)], [σge, σeg]);
@btime timeevolution.schroedinger_dynamic(tspan, ψ0, H5; alg=Tsit5());
641.848 μs (96 allocations: 6.53 KiB)With SA:
σge_static = Operator(basis,
SA[0.0+0.0im 1.0+0.0im
0.0+0.0im 0.0+0.0im]);
σeg_static = Operator(basis,
SA[0.0+0.0im 0.0+0.0im
1.0+0.0im 0.0+0.0im]);
ψ0_static = Ket(basis, SA[1.0+0.0im,0.0+0.0im]);
H8 = TimeDependentSum([t -> 1.0 + 0.1*sin(t), t -> 1.0 + 0.1*sin(t)], [σge_static, σeg_static]);
@btime timeevolution.schroedinger_dynamic(tspan, ψ0, H8; alg=Tsit5());611.492 μs (12924 allocations: 758.17 KiB)One thing I don't really understand is why there is an error when I pass ψ0_static with H8:
@btime timeevolution.schroedinger_dynamic(tspan, ψ0_static, H8; alg=Tsit5());Initial condition incompatible with functional form.
Detected an in-place function with an initial condition of type Number or SArray.
This is incompatible because Numbers cannot be mutated, i.e.
`x = 2.0; y = 2.0; x .= y` will error.
If using a immutable initial condition type, please use the out-of-place form.
I.e. define the function `du=f(u,p,t)` instead of attempting to "mutate" the immutable `du`.
If your differential equation function was defined with multiple dispatches and one is
in-place, then the automatic detection will choose in-place. In this case, override the
choice in the problem constructor, i.e. `ODEProblem{false}(f,u0,tspan,p,kwargs...)`.
For a longer discussion on mutability vs immutability and in-place vs out-of-place, see:
https://diffeq.sciml.ai/stable/tutorials/faster_ode_example/#Example-Accelerating-a-Non-Stiff-Equation:-The-Lorenz-Equation
Some of the types have been truncated in the stacktrace for improved reading. To emit complete information
in the stack trace, evaluate `TruncatedStacktraces.VERBOSE[] = true` and re-run the code.
Stacktrace:
[1] get_concrete_u0(prob::ODEProblem{SVector{2, ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, ODEFunction{true, SciMLBase.AutoSpecialize, QuantumOptics.timeevolution.var"#df_#3"{QuantumOptics.timeevolution.var"#dschroedinger_#52"{QuantumOptics.timeevolution.var"#_tdop_schroedinger_wrapper#9"{TimeDependentSum{NLevelBasis{Int64}, NLevelBasis{Int64}, Tuple{var"#15#17", var"#16#18"}, LazySum{NLevelBasis{Int64}, NLevelBasis{Int64}, Vector{Float64}, Tuple{Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}, Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}}}, Float64}}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, isadapt::Bool, t0::Float64, kwargs::Base.Pairs{Symbol, Any, NTuple{8, Symbol}, NamedTuple{(:u0, :p, :reltol, :abstol, :save_everystep, :save_start, :save_end, :callback), Tuple{SVector{2, ComplexF64}, SciMLBase.NullParameters, Float64, Float64, Bool, Bool, Bool, CallbackSet{Tuple{}, Tuple{DiscreteCallback{DiffEqCallbacks.var"#30#31", DiffEqCallbacks.SavingAffect{QuantumOptics.timeevolution.var"#fout_#4"{Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, QuantumOptics.timeevolution.var"#fout#7"}, Float64, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, DataStructures.BinaryMinHeap{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.saving_initialize), typeof(SciMLBase.FINALIZE_DEFAULT)}}}}}})
@ DiffEqBase ~/.julia/packages/DiffEqBase/MFgVe/src/solve.jl:1237
[2] get_concrete_problem(prob::ODEProblem{SVector{2, ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, ODEFunction{true, SciMLBase.AutoSpecialize, QuantumOptics.timeevolution.var"#df_#3"{QuantumOptics.timeevolution.var"#dschroedinger_#52"{QuantumOptics.timeevolution.var"#_tdop_schroedinger_wrapper#9"{TimeDependentSum{NLevelBasis{Int64}, NLevelBasis{Int64}, Tuple{var"#15#17", var"#16#18"}, LazySum{NLevelBasis{Int64}, NLevelBasis{Int64}, Vector{Float64}, Tuple{Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}, Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}}}, Float64}}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, isadapt::Bool; kwargs::Base.Pairs{Symbol, Any, NTuple{8, Symbol}, NamedTuple{(:u0, :p, :reltol, :abstol, :save_everystep, :save_start, :save_end, :callback), Tuple{SVector{2, ComplexF64}, SciMLBase.NullParameters, Float64, Float64, Bool, Bool, Bool, CallbackSet{Tuple{}, Tuple{DiscreteCallback{DiffEqCallbacks.var"#30#31", DiffEqCallbacks.SavingAffect{QuantumOptics.timeevolution.var"#fout_#4"{Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, QuantumOptics.timeevolution.var"#fout#7"}, Float64, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, DataStructures.BinaryMinHeap{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.saving_initialize), typeof(SciMLBase.FINALIZE_DEFAULT)}}}}}})
@ DiffEqBase ~/.julia/packages/DiffEqBase/MFgVe/src/solve.jl:1093
[3] solve_up(prob::ODEProblem{SVector{2, ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, ODEFunction{true, SciMLBase.AutoSpecialize, QuantumOptics.timeevolution.var"#df_#3"{QuantumOptics.timeevolution.var"#dschroedinger_#52"{QuantumOptics.timeevolution.var"#_tdop_schroedinger_wrapper#9"{TimeDependentSum{NLevelBasis{Int64}, NLevelBasis{Int64}, Tuple{var"#15#17", var"#16#18"}, LazySum{NLevelBasis{Int64}, NLevelBasis{Int64}, Vector{Float64}, Tuple{Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}, Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}}}, Float64}}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, sensealg::Nothing, u0::SVector{2, ComplexF64}, p::SciMLBase.NullParameters, args::Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; kwargs::Base.Pairs{Symbol, Any, NTuple{6, Symbol}, NamedTuple{(:reltol, :abstol, :save_everystep, :save_start, :save_end, :callback), Tuple{Float64, Float64, Bool, Bool, Bool, CallbackSet{Tuple{}, Tuple{DiscreteCallback{DiffEqCallbacks.var"#30#31", DiffEqCallbacks.SavingAffect{QuantumOptics.timeevolution.var"#fout_#4"{Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, QuantumOptics.timeevolution.var"#fout#7"}, Float64, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, DataStructures.BinaryMinHeap{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.saving_initialize), typeof(SciMLBase.FINALIZE_DEFAULT)}}}}}})
@ DiffEqBase ~/.julia/packages/DiffEqBase/MFgVe/src/solve.jl:1000
[4] solve(prob::ODEProblem{SVector{2, ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, ODEFunction{true, SciMLBase.AutoSpecialize, QuantumOptics.timeevolution.var"#df_#3"{QuantumOptics.timeevolution.var"#dschroedinger_#52"{QuantumOptics.timeevolution.var"#_tdop_schroedinger_wrapper#9"{TimeDependentSum{NLevelBasis{Int64}, NLevelBasis{Int64}, Tuple{var"#15#17", var"#16#18"}, LazySum{NLevelBasis{Int64}, NLevelBasis{Int64}, Vector{Float64}, Tuple{Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}, Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}}}, Float64}}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, args::Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; sensealg::Nothing, u0::Nothing, p::Nothing, wrap::Val{true}, kwargs::Base.Pairs{Symbol, Any, NTuple{6, Symbol}, NamedTuple{(:reltol, :abstol, :save_everystep, :save_start, :save_end, :callback), Tuple{Float64, Float64, Bool, Bool, Bool, CallbackSet{Tuple{}, Tuple{DiscreteCallback{DiffEqCallbacks.var"#30#31", DiffEqCallbacks.SavingAffect{QuantumOptics.timeevolution.var"#fout_#4"{Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, QuantumOptics.timeevolution.var"#fout#7"}, Float64, Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, DataStructures.BinaryMinHeap{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.saving_initialize), typeof(SciMLBase.FINALIZE_DEFAULT)}}}}}})
@ DiffEqBase ~/.julia/packages/DiffEqBase/MFgVe/src/solve.jl:929
[5] integrate(tspan::Tuple{Float64, Float64}, df::QuantumOptics.timeevolution.var"#dschroedinger_#52"{QuantumOptics.timeevolution.var"#_tdop_schroedinger_wrapper#9"{TimeDependentSum{NLevelBasis{Int64}, NLevelBasis{Int64}, Tuple{var"#15#17", var"#16#18"}, LazySum{NLevelBasis{Int64}, NLevelBasis{Int64}, Vector{Float64}, Tuple{Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}, Operator{NLevelBasis{Int64}, NLevelBasis{Int64}, SMatrix{2, 2, ComplexF64, 4}}}}, Float64}}}, x0::SVector{2, ComplexF64}, state::Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, dstate::Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, fout::QuantumOptics.timeevolution.var"#fout#7"; alg::Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, steady_state::Bool, tol::Float64, save_everystep::Bool, saveat::Tuple{Float64, Float64}, callback::Nothing, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
@ QuantumOptics.timeevolution ~/.julia/packages/QuantumOptics/6utec/src/timeevolution_base.jl:59
[6] #integrate#6
@ ~/.julia/packages/QuantumOptics/6utec/src/timeevolution_base.jl:75 [inlined]
[7] schroedinger_dynamic(tspan::Tuple{Float64, Float64}, psi0::Ket{NLevelBasis{Int64}, SVector{2, ComplexF64}}, f::Function; fout::Nothing, kwargs::Base.Pairs{Symbol, Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Tuple{Symbol}, NamedTuple{(:alg,), Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}}}})
@ QuantumOptics.timeevolution ~/.julia/packages/QuantumOptics/6utec/src/schroedinger.jl:54
[8] schroedinger_dynamic
@ ~/.julia/packages/QuantumOptics/6utec/src/schroedinger.jl:46 [inlined]
[9] #schroedinger_dynamic#53
@ ~/.julia/packages/QuantumOptics/6utec/src/schroedinger.jl:59 [inlined]
[10] var"##core#1153"()
@ Main ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:489
[11] var"##sample#1154"(::Tuple{}, __params::BenchmarkTools.Parameters)
@ Main ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:495
[12] _run(b::BenchmarkTools.Benchmark, p::BenchmarkTools.Parameters; verbose::Bool, pad::String, kwargs::Base.Pairs{Symbol, Integer, NTuple{4, Symbol}, NamedTuple{(:samples, :evals, :gctrial, :gcsample), Tuple{Int64, Int64, Bool, Bool}}})
@ BenchmarkTools ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:99
[13] #invokelatest#2
@ ./essentials.jl:821 [inlined]
[14] invokelatest
@ ./essentials.jl:816 [inlined]
[15] #run_result#45
@ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:34 [inlined]
[16] run_result
@ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:34 [inlined]
[17] run(b::BenchmarkTools.Benchmark, p::BenchmarkTools.Parameters; progressid::Nothing, nleaves::Float64, ndone::Float64, kwargs::Base.Pairs{Symbol, Integer, NTuple{5, Symbol}, NamedTuple{(:verbose, :samples, :evals, :gctrial, :gcsample), Tuple{Bool, Int64, Int64, Bool, Bool}}})
@ BenchmarkTools ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:117
[18] run (repeats 2 times)
@ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:117 [inlined]
[19] #warmup#54
@ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:169 [inlined]
[20] warmup(item::BenchmarkTools.Benchmark)
@ BenchmarkTools ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:168
[21] top-level scope
@ ~/.julia/packages/BenchmarkTools/0owsb/src/execution.jl:575from quantumoptics.jl.
Related Issues (20)
- ``potentialoperator()`` could use better documentation HOT 7
- LazySum of LazyTensor of sparse result in high alloc in integration HOT 2
- Addition of LazyTensor and LazySum HOT 1
- Return noise in stochastic solvers HOT 1
- Adding ForwardDiff support for all solvers HOT 1
- Precompiling fails on Julia 1.8.5 HOT 5
- Create an animation / more intuitive example for 2D time dependent schrodinger equation
- krylov methods HOT 5
- Time-dep operators used with non-dynamic evolution HOT 1
- docs do not seem to show methods implemented in QuantumOpticsBase HOT 7
- ForwardDiff fails on (schroedinger_dynamic with) TimeDependentOperator HOT 6
- Different behavior of schroedinger() and master() for sum basis. HOT 3
- Sparse state matrices given to the various solvers lead to poor performance - we should either provide a warning or automatically call `dense` HOT 3
- Possible hard wall boundary condition for particle? HOT 2
- Can't see occupations for composite many-body basis
- Different Fockbasis implementation HOT 1
- usability/documentation improvement: MethodError typehints when picking the wrong master equation function and better `see also` sections in the documentation HOT 4
- better error message when the Hamiltonian or Lindblad function are not of the necessary output type (currently we just get an confusing assert error) HOT 1
- update CI actions to newest versions and set up dependabot (as is already done for QuantumOpticsBase.jl) HOT 1
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from quantumoptics.jl.