Items tagged with jacobian jacobian Tagged Items Feed

in Maple of a function with respect to a vector that contains product of variables?

I appologize before hand from my abuse of notation. 

Suppose I have a function

f:= x*y*z + 3*x^2*y*z;

and a vector defined as 

v:= <x*z | x^2*z>; #Column vector

and I would like to comput df/dv

So that the result from the Jacobian would be

J=<y , 3*y>; #Row vector

This is a simple example that can be solved by looking, but I would like to know if there is a way in maple to solve something like this. Some of the problems that I find are
1) The variables x*y*z commute i.e. x*y*z=z*x*y=y*z*x=x*z*y
2) And if I apply partial derivatives like  df/(dx*dz) = y+6*x*y and df/(dx*dx*dz) = 6 which is not the result that I desire, because what I want is the partial derivatives with respect to the functions x*z and x^2*z not to the variables x and z.

My application is far bigger than this example that I am posting, this is why I would like to find a way to produce this type of Jacobian. Any suggestion will be highly appreciate it.

For example, given a 3d point p(x,y,z), with (x,y,z) as its coordinates. Then it is transformed by rotation and translation, as 

p'=R(p)*p+t(p), where R(p) is a 3x3 rotation matrix that is a matrix of functions of p, and t(p) is a 3x1 vector function of p. 

My question is how to derive dp'/d(as a 3x3 matrix) using maple? 

To make it clear,I want to do it in a way that dp'/dp = ∂p'/∂p + ∂p'/∂R*∂R/∂p +  ∂p'/∂t*∂t/∂p

And I'd like to know each intermediate quantity, such as p'/∂R, R/∂p.


Anyone can help?

Thanks a lot. 

Determine using determinants the range of values of a (if any) such that
f(x,y,z)=4x^2+y^2+2z^2+2axy-4xz+2yz
has a minimum at (0,0,0).

From the theory, I understand that if the matrix corresponding to the coefficients of the function is positive definite, the function has a local min at the point. But, how do I get the range of values of a such that f is a min? Is this equivalent to finding a such that det(A) > 0?

 

2.

Now modify the function to also involve a parameter b: g(x,y,z)=bx^2+2axy+by^2+4xz-2a^2yz+2bz^2. We determine conditions on a and b such that g has a minimum at (0,0,0).
By plotting each determinant (using implicitplot perhaps, we can identify the region in the (a,b) plane where g has a local minimum.

Which region corresponds to a local minimum?

Now determine region(s) in the (a,b) plane where g has a local maximum.

I don't understand this part at all..


Hi there,
I have a set of differential equations whose solution, Jacobian matrix and its eigenvalues, direction field, phase portrait and nullclines, need to be computed.

Each of the equations has a varying parameter.

I know how to get the above for a single parameter value, but when I set a range of values for the parameters, Maple is not able to handle all cases as I would expect: solving the differential equation system:

eq1 := x*(1.6*(1-(1/100)*x)-phi*y)
eq2 := (x/(15+x)-0.3e-1*x-.4)*y+.6+theta
desys := [eq1, eq2];
vars := [x, y];
steadyStates := map2(eval, vars, [solve(desys)])

already yields an error:
Error, (in unknown) invalid input: Utilities:-SetEquations expects its 2nd argument, equations, to be of type set({boolean, algebraic, relation}), but received {-600*y+(Array(1..2, {(1) = 8400, (2) = 15900})), Array(1..5, {(1) = 0, (2) = 0, (3) = 0, (4) = 0, (5) = 0})}


The equations are the following:
de1 := diff(x(t), t) = x(t)*(1.6*(1-(1/100)*x(t))-phi*y(t));
de2 := diff(y(t), t) = (x(t)/(15+x(t))-0.3e-1*x(t)-.4)*y(t)+.6+theta

the parameters being:
phi:=[0 0.5 1 1.5 2]
theta:=[5. 10.]

How can I handle the situation so that Maple computes each of the above for each combination of the parameters?

I would like to avoid using two for loops and having to store all results in increasingly bigger and complicated arrays.

The worksheet at issue is this: MaplePrimes_Tumour_model_phi_theta_variation.mw


Thanks,
jon

Hi there,

I would like to have the Jacobian matrix of an ODE system evaluated, and their eigenvalues computed, at the steady states of the system.

I know how to get the Jacobian matrix evaluated and the eigenvalues computed on an individual basis, setting manually each steady state as the argument of the matrix.

However, I would like to have it in a loop, so that the loop manages all steady states, that is:

steadyStates:= solve(mySystem); # would yield a set of pairs/lists

for each steadyState

m:=Jacobian(steadyStateN); # evaluate the Jacobian matrix

ev:= eigenvals(m); # compute the eigenvalues and save them to another variable/array and print them

end for:

First, I am not to find a way to loop over my steadyStates.

Attached is an example where the Jacobian matrix and eigenvalues are computed individually, where the steady states have been hard-coded once they have been computed: MaplePrimes_Predator_prey_model_Jacobian.mw

 

Any ideas on how to do this?

Thanks,

jon

 

 

I have generated an 8x8 Jacobian, containing a few variables and several zeros as elements. I would like to translate this to LaTeX code. How can I first simplify what I have, to make it tractable?

Here is the Maple code:

eq_1 := Lambda-mu*S-(beta*(H+C+C1+C2)*S+tau*(T+C)*S)/(S+T+H+C+C1+C2+C1M+C2M);
eq_2 := (-beta*(H+C+C1+C2)*T+tau*(T+C)*S)/(S+T+H+C+C1+C2+C1M+C2M)-(mu+mu[T])*T;
eq_3 := (beta*(H+C+C1+C2)*S-tau*(T+C)*H)/(S+T+H+C+C1+C2+C1M+C2M)-(mu+mu[A])*H;
eq_4 := (beta*(H+C+C1+C2)*T+tau*(T+C)*H)/(S+T+H+C+C1+C2+C1M+C2M)-(mu+mu[T]+mu[A]+lambda[T])*C;
eq_5 := lambda[T]*C-(mu+mu[A]+rho[1]+eta[1])*C1;
eq_6 := rho[1]*C1-(mu+mu[A]+rho[2]+eta[2])*C2;
eq_7 := eta[1]*C1-(mu+rho[1]+gamma)*C1M;
eq_8 := eta[2]*C2+rho[1]*C1M-(mu+rho[2]+gamma*rho[1]/(rho[1]+rho[2]))*C2M;
J := VectorCalculus:-Jacobian([eq_1, eq_2, eq_3, eq_4, eq_5, eq_6, eq_7, eq_8], [S, T, H, C, C1, C2, C1M, C2M]);

JQDFE := eval(J, [S = Lambda/(beta-mu[A]), T = 0, H = Lambda*(beta/(mu+mu[A])-1)/(beta-mu[A]), C = 0, C1 = 0, C2 = 0, C1M = 0, C2M = 0]);

Thanks.

got an error when try to jacobian this

with(VectorCalculus):
f1 := -2*x1-x2; f2 := -x1-4*x2; g1 := 2*x1+3*x2-6; g2 := -x1; g3 := -x2;
penalty := lambda1*max(f1-M,0) + lambda2*max(f2-M,0) + (M^2)*(max(g1,0) + max(g2,0) + max(g3,0)):
obj := eval(penalty,[lambda1=3,lambda2=0.645,M=1]);
Hf := Jacobian(Jacobian(obj, [x1, x2, x3]), [x1, x2, x3]);

Error, invalid input: VectorCalculus:-Jacobian expects its 1st argument, f,
to be of type {Vector(algebraic), list(algebraic)}, but received 3*max(0, -2*x1-x2-1)+.645*max(0, -x1-4*x2-1)+max(0, 2*x1+3*x2-6)+max(0, -x1)+max(0, -x2)

 

Greetings,

       I am new to Maple and this forum. I would like to obtain a Jacobian of a system of 12 ODEs. What have I done wrongly with my code?

eq_1 := -B*a+A-V*(c+d+t+s+h)*a/(a+b+c+d+e+f+g+h+s+t+u+v)-W*(b+d)*a/(a+b+c+d+e+f+g+h+s+t+u+v);
eq_2 := W*(b+d)*a/(a+b+c+d+e+f+g+h+s+t+u+v)-V*(c+d+t+s+h)*b/(a+b+c+d+e+f+g+h+s+t+u+v)-(F*G+B+D)*b;
eq_3 := V*(c+d+t+s+h)*a/(a+b+c+d+e+f+g+h+s+t+u+v)-W*(b+d)*c/(a+b+c+d+e+f+g+h+s+t+u+v)-(B+E+C)*c;
eq_4 := V*(c+d+t+s+h)*b/(a+b+c+d+e+f+g+h+s+t+u+v)+W*(b+d)*c/(a+b+c+d+e+f+g+h+s+t+u+v)-(B+C+D+F)*d;
eq_5 := G*F*b-V*(c+d+t+s+h)*e/(a+b+c+d+e+f+g+h+s+t+u+v)-(B+H)*e;
eq_6 := H*e-V*(c+d+t+s+h)*f/(a+b+c+d+e+f+g+h+s+t+u+v)-(B+S)*f;
eq_7 := S*f-V*(c+d+t+s+h)*g/(a+b+c+d+e+f+g+h+s+t+u+v)-B*g;
eq_8 := V*(c+d+t+s+h)*g/(a+b+c+d+e+f+g+h+s+t+u+v)+S*s-(B+E+C)*h;
eq_9 := F*d+V*(c+d+t+s+h)*e/(a+b+c+d+e+f+g+h+s+t+u+v)-(B+C+H+T)*t;
eq_10 := H*t+V*(c+d+t+s+h)*f/(a+b+c+d+e+f+g+h+s+t+u+v)-(U+B+C+S+S)*s;
eq_11 := T*t+W*(b+d)*x/(a+b+c+d+e+f+g+h+s+t+u+v)-(B+H+Y)*u;
eq_12 := U*s-(B+S)*v+H*u-Y*H*v/(H+S);
with(linalg);
J := Jacobian([eq_1, eq_2, eq_3, eq_4, eq_5, eq_6, eq_7, eq_8, eq_9, eq_10, eq_11, eq_12], [a, b, c, d, e, f, g, h, s, t, u, v]);

I am getting the message: 

 Vector(4, {(1) = ` 12 x 12 `*Matrix, (2) = `Data Type: `*anything, (3) = `Storage: `*rectangular, (4) = `Order: `*Fortran_order})

Thanks!!

I have 2 problem with my jacobian matrix:

first: i can not evaluate 11*11 jacobian matrix. at last i can evaluate 10*10 matrix. can i solve this?
second: i want to export my matrix for matlab but i see this error : {export matrix"cannot convert matrix element to float[8] data type"}
so how i can use this matrix in my matlab code?
 my jacobian matrix:


with(VectorCalculus); Jacobian([VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`*`(2.68, ex), VectorCalculus:-`-`(VectorCalculus:-`*`(2, vx))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(3.500000001, e^VectorCalculus:-`*`(1.666666667, sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))), VectorCalculus:-`+`(VectorCalculus:-`*`(rx, 1/sqrt(VectorCalculus:-`+`(rx^2, ry^2))), VectorCalculus:-`*`(1/2, VectorCalculus:-`*`(VectorCalculus:-`+`(VectorCalculus:-`*`(2, rx), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb(ex)))), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))))), ln(e)), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(50.00000000, e^VectorCalculus:-`-`(VectorCalculus:-`*`(5.000000000, sqrt(VectorCalculus:-`+`(Rx^2, Ry^2))))), Rx), ln(e)), 1/sqrt(VectorCalculus:-`+`(Rx^2, Ry^2)))), VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`+`(VectorCalculus:-`*`(2.68, ey), VectorCalculus:-`-`(VectorCalculus:-`*`(2, vy))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(3.500000001, e^VectorCalculus:-`*`(1.666666667, sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))), VectorCalculus:-`+`(VectorCalculus:-`*`(ry, 1/sqrt(VectorCalculus:-`+`(rx^2, ry^2))), VectorCalculus:-`*`(1/2, VectorCalculus:-`*`(VectorCalculus:-`+`(VectorCalculus:-`*`(2, ry), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb(ey)))), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))))), ln(e)), 1/sqrt(VectorCalculus:-`+`(VectorCalculus:-`-`(VectorCalculus:-`+`(sqrt(VectorCalculus:-`+`(rx^2, ry^2)), sqrt(VectorCalculus:-`+`(VectorCalculus:-`+`(rx, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ex))))^2, VectorCalculus:-`+`(ry, VectorCalculus:-`-`(VectorCalculus:-`*`(2, vb(ey))))^2)))^2), VectorCalculus:-`-`(VectorCalculus:-`*`(4, vb^2)))))), VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(VectorCalculus:-`*`(50.00000000, e^VectorCalculus:-`-`(VectorCalculus:-`*`(5.000000000, sqrt(VectorCalculus:-`+`(Rx^2, Ry^2))))), Ry), ln(e)), 1/sqrt(VectorCalculus:-`+`(Rx^2, Ry^2)))), 1, 1, 1, 1, 1, 1, 1, 1, 1], [vx, vy, ex, ey, rx, ry, Ex, Ey, vb, Rx, Ry])

Hi all,

For research purposes, I have symbolic matrices of dimentions up to 100 x 50 (and above) with certain number of parameters. Then giving random value to those paramters, I want the numerical rank of the matrices.

 

Maple 17 does not seem to work well with symbolic ranks, where expentials are involved.

And more to it, both

Student[MultivariateCalculus][Jacobian]

and

VectorCalculus[Jacobian]

does not seem to work. ...

MAPLE Users,

Suppose I have a set of points in some N-dimensional space.  I would like to obtain a simple polynomial that

best fits the data.  I do not know in advance the form of the function, but a simple function that does not overfit

the data would probably be OK.  By "simple" I mean the smallest degree with or without cross-terms that gives a

decent fit.  My data set will typically be an external comma or tab separated text file.

I have a 2D ode system. Let the interior equilibrium points be x1 & y1. It is easy to get the Jacobian matrix with the code

> with(linalg);
> with(DEtools);
> J := jacobian([H, K], [x, y]);
 
where H & K are the RHS of odes. But I need the higher order terms by transforming x=x1+u, 
y=y1+v in matrix notation. Please give me the code. 

restart:

with(LinearAlgebra):
with(ArrayTools):


k:=4;
pA:=<seq(p[a,i],i=2..(k+1))>;
pB:=<seq(p[b,i],i=2..(k+1))>;
pA+pB;

with(VectorCalculus):

pA:=<seq(p[a,i],i=2..(k+1))>;
pB:=<seq(p[b,i],i=2..(k+1))>;
pA+pB;

 

Hi all,

 

After I loaded the package with(VectorCalculus), the output of vectors changed to a different one.

Is there any real "difference" when...

Here is the Rossler system, one of the simplest examples of 3 dimensional deterministic chaos (under certain conditions according to "params"). Thanks to Doug and Joe for various assists. Comments and critiques most welcome !

restart;
interface(displayprecision=10):
ross_x:=diff(x(t),t)=-y(t)-z(t):
ross_y:=diff(y(t),t)=x(t)+a*y(t):
ross_z:=diff(z(t),t)=b+x(t)*z(t)-c*z(t):
rossler_sys:=ross_x,ross_y,ross_z;

#Find fixed points:
sol:=solve({rhs(ross_x...

Page 1 of 1