Items tagged with matrix

Feed

I've read the spec online for LinearSolve but it's not clear on the function of inplace on nonsquare matrices. For example, consider the following:

A:=<0;1>;
B:=<0:2>;
LinearSolve(A,B,inplace=true)

This last line outputs <2;0>, which is also the value stored in B after the operation, whereas [2] would be the desired result. In the case of A being a row vector an error is encountered due to lack of storage. Does what happened above generalise for any matrix with more rows than columns: storing the result in B, but adding zeroes to the bottom unused parts of B, due to B being larger than the solution?

Also, does anyone have any advice on an efficient method for solving A.x=b, in the case where b is a vector, and A is a large but tall (varying size, but often 5x as many rows as columns, e.g. 10000x2000) integer matrix, where most of the entries in any particular column are zero (more than 90%)? I've found the option method='modular' helps quite a lot, but not enough, any ideas for quick fixes?

I'm sorry if this sounds like a noob question. I am trying to make a matrix from a table, something like Gauss-Jordan Elimination tutor.

For example

maplet1 := Maplet([BoxCell(Table([A, B], [[1, 2], [3, 4]]), 'as_needed'), Button("OK", Shutdown())]);

How do I turn it to 2x2 matrix?Any help appreciated

restart; with(LinearAlgebra); with(Student[LinearAlgebra]); 
Z := Matrix([[3, 1, 5, 4, 5], [0, 0, 0, 0, 0], [28, 6, 4, 5, 9], [98, 5, 82, 2, 4], [24, 55, 23, 22, 90]]); 
B := Matrix([[0], [0], [0], [0], [0]]); 
A := <Z|B>:
if Row(A, 2) = ZeroVector[row](6) then A; end if;

I used the code above but it didn't work...any help appreciated

I have four matrix equations

P1, P2, P3 are known 4x4 matrix.

A1 A2 A3 A4 are known 1x4 matrix.

x1 x2 x3 x4 are 1x1 known matrix.

U is 4x4 unknown matrix.

These equations are 

(A1T*U*P1*A1) +( (P2*A1)T*U*P1*A1) + ( (P3*A1)T*U*A1) + ( ( P3*A 2)T*U*P1*A1) + x1 =0;

(A2T*U*P1*A2) +( (P2*A2)T*U*P1*A2) + ( (P3*A2)T*U*A2) + ( ( P3*A2 )T*U*P1*A2) + x2 =0;

(A3T*U*P1*A3) +( (P2*A3)T*U*P1*A3) + ( (P3*A3)T*U*A3) + ( ( P3*A3 )T*U*P1*A3) + x3 =0;

(A4T*U*P1*A4) +( (P2*A4)T*U*P1*A4) + ( (P3*A4)T*U*A4) + ( ( P3*A4 )T*U*P1*A4) + x4 =0;

How can i find 4x4 matrix U by using these above four equations??

Thank you

First Question: How to define nx1 matrix Y:=(y1,y2,...,yn) ? (n is a Natural number while it is ungiven)

Second Question: How to derivative of matrix Y with respect to nx1 matrix X:=(x1,x2,...,xn) ?

 


My efforts for the first question:  (I know to define 6x1 matrix etc. , but I dont know to define nx1 matrix

restart: Matrix(1..6,1,symbol=y) 

 

My efforts for the second question:

restart; with(VectorCalculus);
Matrix([x^2, x*y, x*z]);
Jacobian([x^2, x*y, x*z], [x, y, z]);


Can you help me? 

I have a vector x of this type:

x :=Vector[column]([A__11*u__1+A__12*u__2+...+A__1m*u__m,

A__21*u__1+A__22*u__2+...+A__2m*u__m,

...,

A__n1*u__1+A__n2*u__2+...+A__nm*u__m]);

If I define u:=Vector[column]([u__1,u__2,...,u__m]), then it is clear that the equation has the form x=A*u.

I want to extract the matrix A, for the given vectors x and u.

IMPORTANT: I know I could create a loop (i=1 to m) and set u__i=1 and all other u__j=0 (for all j not equal i) and then reconstruct each column by this method, but it seems to be a overkill for such an easy problem.

I would be glad, if someone could show me a method how one can achive this in maple.

For exaqmple, the quadratic equation w^2 + uw + v = 0 corresponds to the deter minant


| -u  1  1  |

| v    0  1  |  = 0

|w^2 w w-1|

Is there any way to find a determinant corresponding to an equation, as above?

This is an issue in the preparation of a nomograph for the initial equation.  

It is generally solved by trial and error.

h1_y_h2.mw
 

(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949)*(.825+.387*(((-(9.8*.11^3*4190)*(4.216485*10^(-2)-7.097451*10^(-3)*(T__1(t)+T__1s(t))+2.63217825*10^(-5)*(T__1(t)+T__1s(t))^2-4.9518879*10^(-8)*(T__1(t)+T__1s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4))*((999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4)^2))*(T__1(t)-T__1s(t))/((0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__1(t)+T__1s(t))+(0.130419399687942e-5*(1/4))*(T__1(t)+T__1s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__1(t)+T__1s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__1(t)+T__1s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__1(t)+T__1s(t))^5)*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949)))^(1/6)/(1+((.492*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949))/(4190*(0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__1(t)+T__1s(t))+(0.130419399687942e-5*(1/4))*(T__1(t)+T__1s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__1(t)+T__1s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__1(t)+T__1s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__1(t)+T__1s(t))^5)))^(9/16))^(8/27))^2/(.11)

subs({T__1(t) = T__1, T__1s(t) = T__1s}, (-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949)*(.825+.387*(((-(9.8*.11^3*4190)*(4.216485*10^(-2)-7.097451*10^(-3)*(T__1(t)+T__1s(t))+2.63217825*10^(-5)*(T__1(t)+T__1s(t))^2-4.9518879*10^(-8)*(T__1(t)+T__1s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4))*((999.9399+2.1082425*10^(-2)*(T__1(t)+T__1s(t))-1.77436275*10^(-3)*(T__1(t)+T__1s(t))^2+.438696375*10^(-5)*(T__1(t)+T__1s(t))^3-.6189861563*10^(-8)*(T__1(t)+T__1s(t))^4)^2))*(T__1(t)-T__1s(t))/((0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__1(t)+T__1s(t))+(0.130419399687942e-5*(1/4))*(T__1(t)+T__1s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__1(t)+T__1s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__1(t)+T__1s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__1(t)+T__1s(t))^5)*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949)))^(1/6)/(1+((.492*(-9.481411*10^(-6)*(T__1(t)+T__1s(t))^2+2.1356735*10^(-3)*(T__1(t)+T__1s(t))+.5599920949))/(4190*(0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__1(t)+T__1s(t))+(0.130419399687942e-5*(1/4))*(T__1(t)+T__1s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__1(t)+T__1s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__1(t)+T__1s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__1(t)+T__1s(t))^5)))^(9/16))^(8/27))^2/(.11))

9.090909091*(-0.9481411000e-5*(T__1+T__1s)^2+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)*(.825+.387*(-54.6535220*(0.4216485000e-1-0.7097451000e-2*T__1-0.7097451000e-2*T__1s+0.2632178250e-4*(T__1+T__1s)^2-0.4951887900e-7*(T__1+T__1s)^3)*(999.9399+0.2108242500e-1*T__1+0.2108242500e-1*T__1s-0.1774362750e-2*(T__1+T__1s)^2+0.4386963750e-5*(T__1+T__1s)^3-0.6189861563e-8*(T__1+T__1s)^4)*(T__1-T__1s)/((0.178910466924394e-2-0.2968280104e-4*T__1-0.2968280104e-4*T__1s+0.3260484992e-6*(T__1+T__1s)^2-0.2240455202e-8*(T__1+T__1s)^3+0.8342448369e-11*(T__1+T__1s)^4-0.1262127629e-13*(T__1+T__1s)^5)*(-0.9481411000e-5*(T__1+T__1s)^2+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)))^(1/6)/(1+.6710121288*((-0.9481411000e-5*(T__1+T__1s)^2+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)/(7.496348563-.1243709364*T__1-.1243709364*T__1s+0.1366143212e-2*(T__1+T__1s)^2-0.9387507296e-5*(T__1+T__1s)^3+0.3495485867e-7*(T__1+T__1s)^4-0.5288314766e-10*(T__1+T__1s)^5))^(9/16))^(8/27))^2

(1)

h__1 := proc (T__1, T__1s) options operator, arrow; (-0.9481411000e-5*(T__1+T__1s)^2+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)*(.825+.387*((0.4216485000e-1-0.7097451000e-2*T__1-0.7097451000e-2*T__1s+0.2632178250e-4*(T__1+T__1s)^2-0.4951887900e-7*(T__1+T__1s)^3)*(999.9399+0.2108242500e-1*T__1+0.2108242500e-1*T__1s-0.1774362750e-2*(T__1+T__1s)^2+0.4386963750e-5*(T__1+T__1s)^3-0.6189861563e-8*(T__1+T__1s)^4)*(T__1-T__1s)*(-54.6535220)/((0.178910466924394e-2-0.2968280104e-4*T__1-0.2968280104e-4*T__1s+0.3260484992e-6*(T__1+T__1s)^2-0.2240455202e-8*(T__1+T__1s)^3+0.8342448369e-11*(T__1+T__1s)^4-0.1262127629e-13*(T__1+T__1s)^5)*(-0.9481411000e-5*(T__1+T__1s)^2+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)))^(1/6)/(1+.6710121288*((-0.9481411000e-5*(T__1+T__1s)^2+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)/(7.496348563-.1243709364*T__1-.1243709364*T__1s+0.1366143212e-2*(T__1+T__1s)^2-0.9387507296e-5*(T__1+T__1s)^3+0.3495485867e-7*(T__1+T__1s)^4-0.5288314766e-10*(T__1+T__1s)^5))^(9/16))^(8/27))^2*9.090909091 end proc

proc (T__1, T__1s) options operator, arrow; (-0.9481411000e-5*((T__1+T__1s)^2)+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)*(.825+.387*(((0.4216485000e-1-0.7097451000e-2*T__1-0.7097451000e-2*T__1s+0.2632178250e-4*((T__1+T__1s)^2)-0.4951887900e-7*((T__1+T__1s)^3))*(999.9399+0.2108242500e-1*T__1+0.2108242500e-1*T__1s-0.1774362750e-2*((T__1+T__1s)^2)+0.4386963750e-5*((T__1+T__1s)^3)-0.6189861563e-8*((T__1+T__1s)^4))*(T__1-T__1s)*(-1)*54.6535220/(((0.178910466924394e-2-0.2968280104e-4*T__1-0.2968280104e-4*T__1s+0.3260484992e-6*((T__1+T__1s)^2)-0.2240455202e-8*((T__1+T__1s)^3)+0.8342448369e-11*((T__1+T__1s)^4)-0.1262127629e-13*((T__1+T__1s)^5))*(-0.9481411000e-5*((T__1+T__1s)^2)+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949))))^(1/6))/(((1+.6710121288*(((-0.9481411000e-5*((T__1+T__1s)^2)+0.2135673500e-2*T__1+0.2135673500e-2*T__1s+.5599920949)/(7.496348563-.1243709364*T__1-.1243709364*T__1s+0.1366143212e-2*((T__1+T__1s)^2)-0.9387507296e-5*((T__1+T__1s)^3)+0.3495485867e-7*((T__1+T__1s)^4)-0.5288314766e-10*((T__1+T__1s)^5)))^(9/16)))^(8/27))))^2*9.090909091 end proc

(2)

(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949)*(.825+.387*(((-(9.8*.11^3*4190)*(4.216485*10^(-2)-7.097451*10^(-3)*(T__2(t)+T__2s(t))+2.63217825*10^(-5)*(T__2(t)+T__2s(t))^2-4.9518879*10^(-8)*(T__2(t)+T__2s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4))*((999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4)^2))*(T__2s(t)-T__2(t))/((0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__2(t)+T__2s(t))+(0.130419399687942e-5*(1/4))*(T__2(t)+T__2s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__2(t)+T__2s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__2(t)+T__2s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__2(t)+T__2s(t))^5)*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949)))^(1/6)/(1+((.492*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949))/(4190*(0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__2(t)+T__2s(t))+(0.130419399687942e-5*(1/4))*(T__2(t)+T__2s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__2(t)+T__2s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__2(t)+T__2s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__2(t)+T__2s(t))^5)))^(9/16))^(8/27))^2/(.11)

subs({T__2(t) = T__2, T__2s(t) = T__2s}, (-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949)*(.825+.387*(((-(9.8*.11^3*4190)*(4.216485*10^(-2)-7.097451*10^(-3)*(T__2(t)+T__2s(t))+2.63217825*10^(-5)*(T__2(t)+T__2s(t))^2-4.9518879*10^(-8)*(T__2(t)+T__2s(t))^3)/(999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4))*((999.9399+2.1082425*10^(-2)*(T__2(t)+T__2s(t))-1.77436275*10^(-3)*(T__2(t)+T__2s(t))^2+.438696375*10^(-5)*(T__2(t)+T__2s(t))^3-.6189861563*10^(-8)*(T__2(t)+T__2s(t))^4)^2))*(T__2s(t)-T__2(t))/((0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__2(t)+T__2s(t))+(0.130419399687942e-5*(1/4))*(T__2(t)+T__2s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__2(t)+T__2s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__2(t)+T__2s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__2(t)+T__2s(t))^5)*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949)))^(1/6)/(1+((.492*(-9.481411*10^(-6)*(T__2(t)+T__2s(t))^2+2.1356735*10^(-3)*(T__2(t)+T__2s(t))+.5599920949))/(4190*(0.178910466924394e-2-(0.593656020810955e-4*(1/2))*(T__2(t)+T__2s(t))+(0.130419399687942e-5*(1/4))*(T__2(t)+T__2s(t))^2-(1.79236416162215*(1/8))*10^(-8)*(T__2(t)+T__2s(t))^3+(1.33479173942873*(1/16))*10^(-10)*(T__2(t)+T__2s(t))^4-(4.03880841196434*(1/32))*10^(-13)*(T__2(t)+T__2s(t))^5)))^(9/16))^(8/27))^2/(.11))

9.090909091*(-0.9481411000e-5*(T__2+T__2s)^2+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)*(.825+.387*(-54.6535220*(0.4216485000e-1-0.7097451000e-2*T__2-0.7097451000e-2*T__2s+0.2632178250e-4*(T__2+T__2s)^2-0.4951887900e-7*(T__2+T__2s)^3)*(999.9399+0.2108242500e-1*T__2+0.2108242500e-1*T__2s-0.1774362750e-2*(T__2+T__2s)^2+0.4386963750e-5*(T__2+T__2s)^3-0.6189861563e-8*(T__2+T__2s)^4)*(T__2s-T__2)/((0.178910466924394e-2-0.2968280104e-4*T__2-0.2968280104e-4*T__2s+0.3260484992e-6*(T__2+T__2s)^2-0.2240455202e-8*(T__2+T__2s)^3+0.8342448369e-11*(T__2+T__2s)^4-0.1262127629e-13*(T__2+T__2s)^5)*(-0.9481411000e-5*(T__2+T__2s)^2+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)))^(1/6)/(1+.6710121288*((-0.9481411000e-5*(T__2+T__2s)^2+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)/(7.496348563-.1243709364*T__2-.1243709364*T__2s+0.1366143212e-2*(T__2+T__2s)^2-0.9387507296e-5*(T__2+T__2s)^3+0.3495485867e-7*(T__2+T__2s)^4-0.5288314766e-10*(T__2+T__2s)^5))^(9/16))^(8/27))^2

(3)

h__2 := proc (T__2, T__2s) options operator, arrow; (-0.9481411000e-5*(T__2+T__2s)^2+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)*(.825+.387*((0.4216485000e-1-0.7097451000e-2*T__2-0.7097451000e-2*T__2s+0.2632178250e-4*(T__2+T__2s)^2-0.4951887900e-7*(T__2+T__2s)^3)*(999.9399+0.2108242500e-1*T__2+0.2108242500e-1*T__2s-0.1774362750e-2*(T__2+T__2s)^2+0.4386963750e-5*(T__2+T__2s)^3-0.6189861563e-8*(T__2+T__2s)^4)*(T__2s-T__2)*(-54.6535220)/((0.178910466924394e-2-0.2968280104e-4*T__2-0.2968280104e-4*T__2s+0.3260484992e-6*(T__2+T__2s)^2-0.2240455202e-8*(T__2+T__2s)^3+0.8342448369e-11*(T__2+T__2s)^4-0.1262127629e-13*(T__2+T__2s)^5)*(-0.9481411000e-5*(T__2+T__2s)^2+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)))^(1/6)/(1+.6710121288*((-0.9481411000e-5*(T__2+T__2s)^2+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)/(7.496348563-.1243709364*T__2-.1243709364*T__2s+0.1366143212e-2*(T__2+T__2s)^2-0.9387507296e-5*(T__2+T__2s)^3+0.3495485867e-7*(T__2+T__2s)^4-0.5288314766e-10*(T__2+T__2s)^5))^(9/16))^(8/27))^2*9.090909091 end proc

proc (T__2, T__2s) options operator, arrow; (-0.9481411000e-5*((T__2+T__2s)^2)+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)*(.825+.387*(((0.4216485000e-1-0.7097451000e-2*T__2-0.7097451000e-2*T__2s+0.2632178250e-4*((T__2+T__2s)^2)-0.4951887900e-7*((T__2+T__2s)^3))*(999.9399+0.2108242500e-1*T__2+0.2108242500e-1*T__2s-0.1774362750e-2*((T__2+T__2s)^2)+0.4386963750e-5*((T__2+T__2s)^3)-0.6189861563e-8*((T__2+T__2s)^4))*(T__2s-T__2)*(-1)*54.6535220/(((0.178910466924394e-2-0.2968280104e-4*T__2-0.2968280104e-4*T__2s+0.3260484992e-6*((T__2+T__2s)^2)-0.2240455202e-8*((T__2+T__2s)^3)+0.8342448369e-11*((T__2+T__2s)^4)-0.1262127629e-13*((T__2+T__2s)^5))*(-0.9481411000e-5*((T__2+T__2s)^2)+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949))))^(1/6))/(((1+.6710121288*(((-0.9481411000e-5*((T__2+T__2s)^2)+0.2135673500e-2*T__2+0.2135673500e-2*T__2s+.5599920949)/(7.496348563-.1243709364*T__2-.1243709364*T__2s+0.1366143212e-2*((T__2+T__2s)^2)-0.9387507296e-5*((T__2+T__2s)^3)+0.3495485867e-7*((T__2+T__2s)^4)-0.5288314766e-10*((T__2+T__2s)^5)))^(9/16)))^(8/27))))^2*9.090909091 end proc

(4)

``

``

im trying to build a matrix starting from a function, so i can later use this matrix to get a more simple function using linearfit from the statistics package, like a kind of regression.

i want to get a matrix starting from h__1(T1,T__1s) so it has to be a 3 columns matrix (T__1,T__1s,h__1). so as you can see, i have got the functions h__1 and h__2, but i need to evaluate it at differents values for T__1 and T__1s and building a kind of value-table in matrix form.

for h__1, T__1 must be higher than T__1s, or you could get imaginary values, don't know if that important for building the matrix.

thank you very much for your help.

Download h1_y_h2.mw

 

Bear with me, while I've used Maple V, I've never done any actual programming in Maple as I've almost entirely used Matlab.  Right now I've got an issue with trying to fill a square matrix using a sinc function [(sin(Pi*x)/(Pi*x)].  Here's my procedure:


 

Note that the arguments for sin and for the denominator are written as they are so as to define the domain of  the sinc function as [-m/2,m/2] along a row and [-n/2,n/2] along a column of the matrix I want to fill and so that I the arguments can have decimal values.  Also note the conditional statements there because when the sine argument and the denominator yields Pi*0, the function equals 1 despite the zero in the denominator.

So I'm unsure how to fill a matrix of some size m x n using the procedure (or a function if that makes the programming easier).  Here's how I would write the code for Matlab:

Z=zeros(2001,2001);
X=(-5:.005:5)';
Y=(-5:.005:5)';

count1=1;

for j=-5:.005:5
    count2=1;
    for k=-5:.005:5
        Z(count1,count2)=sinc(k)^2*sinc(j)^2;
        count2=count2+1;
    end
    count1=count1+1;
end

Given my meager experience writing Maple code, I'm a bit flumoxed.

Thanks, and don't feel like you have to be gentle. No one ever accused me of writing elegant code.

Thanks

Hi, so I have few problems here. I need to;

Create a MxN Matrix/Lattice, where N and M can be any positive integer, that contains a random selection of -1/1s at each entry.

Need to sum every entry, then multiply by -1 to find “H”.

Need to multiply each neighbour to find its bond energy, so if it’s the same you get 1 else -1, but only its direct neighbours once, so if it was a 2x2 matrix there would be only 4 values and then sum them.

I don’t seem to be able to set up the code so that it does it for any size matrix, as I only know how to write it out basic for a 2x2. Also, not so important, but I wanted to know if could create a loop that would find every iteration of possible setups i.e. for a 2x1 you can have 1.1, -1.1, 1.-1, -1.-1. And then give the solutions outlined earlier for each of the the possibilities [There being 2MxN ]

Cheers in advance.

Am a post graduate student. am using maple as soft ware.. How can I create a 15 x 15 matrix in maple?

hi i have this code that doesnt work and I cant find the problem. I cant make the matrix include more than 2 rows. i want this to give me the whole nxn matrix, and then the solution to the wronskian. 

can you pls help?:) thanks! 

with*linalg;
funcs := [x, 3*x, x^2, 5*x];
n := nops(funcs);
print*n;
printlevel := n;
count := 1;
listM[count] := funcs;
for i from 2 to n do listN := diff(funcs, `$`(x, i-1));
count := count+1;
listM[count] := listN end do;
M := convert(listM, matrix);
det(M)

Hello guys, i have some matrix equations.

A^(T)*X+X*A+Q = 0 , where A,Q - matrixs, X - unknown matrix, i need to solve this.

i tried to solve this from http://www.mapleprimes.com/questions/200940-How-To-Solve-Matrix-Equation-Problem-In-Maple#answer203570 methods, but not successfully.

How can to solve this problem?

multMatrix.mw

thx.

When I use the Determinant function on a matrix with (single variable) polynomial entries with real coefficients I often get an incorrect answer. I know the answers are incorrect because they have a higher degree or a lower lowest degree than is possible given the matrix elements.

However, when I replace the coefficients in the polynomials with rational numbers or I put in the option method=minor, I get the correct answer.

The problem seems to be roundoff error. However, the important error is not simply small changes in the resulting polynomial. The important error is the presence of entirely incorrect powers of the variable and not with very small coefficients.

How does this happen and why does the help page for Determinant( ) not warn of this behavior? In particuiar, why does the help page not say that using Gaussian elimination (i.e., the default) will often give incorrect answers in such cases, but using method=minor will work? Is this behavior known? I cannot find any reference to it on the internet.

2 3 4 5 6 7 8 Last Page 4 of 41