Welcome to !
First thanks, because I thaught I wouldn't get out of it !
I am following python because I am a very bad programmer but I like it !
In french, we haven't yet lot of Julia's users or I haven't met them. My
aim now is to try to make the portrait phase accompanying this example
from python.
What I live most in Julia is the easy symbolic variable writing w\_o,
which makes exactly like the maths command.
Surely I prefer your nativ ODE but it seems for me still harder at the
time !
I have found lot of beautifull examples in julia but they are so
condensed that I don't find anything I can remenber ! It's like chinese
language ?
I know mostly european language but I can't learn chinese because it's
so well modeled !
Bu with time I hope I can progress... And thanks to all the list for
helping and not feeling alone... It's a hobby for me, very important to
cary on and may be translate things in french.
Le 21/06/2016 00:16, Gabriel Gellner a écrit :
Welcome by the way! I used to use Python a lot myself. Julia is great,
but it does require a fair amount of extra learning due to its youth.
I hope you get past the rocky start :)
```
using PyPlot
using PyCall
@pyimport scipy.integrate as integrate
function f(y, t)
if t < 25
return [y[2], -8*y[1] + 0.1*y[2]]
elseif 25 < t < 45
return [y[2], -8*y[1]]
else
return [y[2], -8*y[1] - 0.1*y[2]]
end
end
t = linspace(0, 35, 1000)
y = [0.01, 0]
y1 = integrate.odeint(f, y, t)
plot(t, y1)
xlim(0, 35)
ylim(-0.2, 0.2)
```
This is what I would do to make your code work. Some of the issues was
that you were using 0-based indexing (C like, python etc) so I just
changed all the lines that had things like y[0] -> y[1] and y[1] -> y[2].
Also you should be careful about following python idioms to closely in
Julia. Doing things like
plt = PyPlot
is likely not the correct idea. I have shown what I consider idiomatic
use of PyPlot would look like in this case.
Final question. Are you using the python integrators because you want
the LSODE codes specifically? You could of course use the pure Julia
package ODE.jl if you can deal with using a Runge-Kutta algorithm
instead (Adams methods are coming soon!)
Here is your code using that package instead just for comparison (with
some naming changes to be more awesome in my mind ;)
using ODE
```
using ODE
function f(t, y)
if t < 25
return [y[2], -8*y[1] + 0.1*y[2]]
elseif 25 < t < 45
return [y[2], -8*y[1]]
else
return [y[2], -8*y[1] - 0.1*y[2]]
end
end
tspan = linspace(0, 35, 1000)
y0 = [0.01, 0]
t, y = ode45(f, y0, tspan)
plot(t, y)
xlim(0, 35)
ylim(-0.2, 0.2)
```
Good luck!
On Monday, June 20, 2016 at 1:41:41 PM UTC-7, Henri Girard wrote:
y1 (odeint arrays has nothing inside) that's why there is an error
but from what ?
Le lundi 20 juin 2016 17:32:07 UTC+2, Henri Girard a écrit :
I am trying to convert from python to julia, but I don't know
how to use
y1=integrate.odeint(f,t), apparently I should have add a
derivativ ?
--python----------------------
from scipy.integrate import odeint
def f(y,t):
if t<25:
return [y[1],-8*y[0]+0.1*y[1]]
elif 25<t<45:
return [y[1],-8*y[0]]
else:
return [y[1],-8*y[0]-0.1*y[1]]
t=np.linspace(0,35,1000)
# start from y=0.01, y’=0
y1=odeint(f,[0.01,0],t)
plt.plot(t,y1[:,0])
plt.title("Evolution temporelle")
plt.xlabel("Temps t (s)")
plt.ylabel("Intensite i (A)")
plt.plot(0,0.01,"ro")
#plt.savefig("RLC-demarrage.eps")
plt.show()
----------ijulia----------------
@pyimport scipy.integrate as odeint
function f(y,t)
if t<25
return [y[1],-8*y[0]+0.1*y[1]]
elseif 25<t<45
return [y[1],-8*y[0]]
else
return [y[1],-8*y[0]-0.1*y[1]]
end
end;
t=linspace(0,35,1000)
y=linspace(0.01,0)
y1=integrate.odeint(f,y,t)
