The question of how to do matrix operations over a finite field with p^k elements k>1 was raised in this forum in April 27 2010. I wonder if there has been any progress since then for recent versions of Maple.

I am expecially interested in finding the rank of a matrix over a field of order p^k, k > 1.

Hello all, 

During my last attempt to solve ODE system (autonomous system which includes 3 first order diff. equations) with initial conditions, Maple had performed the solution which includes d_z1 parameter as follows below (I present the solution of one of the equations):

S(t)=S(0)∫(QN_z1+A)d_z1, where integral ∫ is defined integral from 0 to t, S(0) is the initial value of S, Q, N and A are the parameters. I would like to ask, what does it mean _z1 and d_z1? Why if the ODE system is only time dependent, I received the integral with other differential, that is d_z1? Does it mean that the integral can't be evaluated or maybe something else?

Thanks in advance,

Dmitry

Hello,

I am trying to find all the roots of this equation and to solve it:

exp(x)*cos(x)+1=0

but doing fsolve(exp(x)*cos(x)+1,x=0..10) it gives me only one solution, while I know that there is more than one solution. How can I do in order to solve this equation and have all the roots in the range 0..10?

I really can't figure it out!

Thank you

Giulia

I am creating a plot in Maple17 which will include many line segments and polygons.  I want the axes to be equally scaled, so that line segments that are perpendicular actually look perpendicular.  When I view what I have created so far, line segments that are perpendicular do not appear to be so in a plot, even though I used the "scaling=constrained" option several times.  I created a stripped-down file that isolates the problem.  Here it is:

Download perp.mw

An angle that should be a right angle looks obtuse in the plot.  I used "scaling=constrained" in both the "display" command and the "segp" procedure.  I am using "polygonplot" to plot line segments (degenerate polygons) because the final plot will contain genuine polygons and this seemed like the easiest way to do it.  If this is a bad idea for some reason I can change it.

GS

so would anybody know how to write a function that checks whether two line segments intersect?  each line segment is given a list [[a,b],[x,y]] , of 2 lists with 2 numbers in each.   

it should return  "True" if ∃s,t ∈ [0,t] : sa+(1-s)b =tx+(1-t)y ,  else"False"

 I haven't a clue so any help would be appreciated,

thanks in advance.

I can't seem to find what's wrong with this function:

F:= x-> (-c-ax)/b;
G:=x-> (-d-ex)/f;
If -a/b = -e/f then print (false) else print (true); end if;

Hello,

For a control systems project I'am working on I need to minimize the actuator effort required to control an input voltage to certain output voltage. As a first experiment I chose a sinusoidal input ug and a sinusoidal output ul. The function to minimize is the funtion Uint. We know that when both the input voltage and output voltage share the frequency, phase and amplitude, that the control effort is zero. Running the animation (see Maple input below) shows that if the input and output voltage frequencies approach eachother the function Uint goes to zero. However, if the frequencies exactly match and I evaluate the function Uint I get a devision by zero notification (this could already be seen from the function of Uint). How can I solve this?

Download 20131109_Division_by.mw

Thanks

I have just started using Maple 17 for general relativity, and I have managed to set up coordinates and enter a somewhat complicated spacetime metric, and to find the Killing vectors for the metric.

I can't seem to do something much more basic, though, initialize the components of a vector field as functions of the coordinates.

For example, how would I set up a 4-vector field A such that the contravariant component A^3 = cosh(x2), where x2 is one of my coordinates?

Thanks.

restart;
with(plots):
with(Optimization):
with(LinearAlgebra):
with(Statistics):
with(DEtools):
x11 := <0.208408965651696e-3, -0.157194487523421e-2, -0.294739401402979e-2, 0.788206708183853e-2, 0.499394753201753e-2, 0.191468321959759e-3, 0.504980449104750e-2, 0.222150494088535e-2, 0.132091821964287e-2, 0.161118434883258e-2, -0.281236534046873e-2, -0.398055875132037e-2, -0.111753680372819e-1, 0.588868146012489e-2, -0.354191562612469e-2, 0.984082837373291e-3, -0.116041186868374e-1, 0.603027845850267e-3, -0.448778128168742e-2, -0.127561485214862e-1, -0.412027655195339e-2, 0.379387381798949e-2, -0.602550446997765e-2, -0.605986284736216e-2, -0.751396992404410e-2, 0.633613424008655e-2, -0.677581832613623e-2>;
y11 := <-21321.9719565717, 231.709204951251, 1527.92905167191, -32.8508507060675, 54.9408176234139, -99.4222178124229, -675.771433486265, 42.0838668074923, -12559.3183308951, 5.21412214166344*10^5, 1110.50031772203, 3.67149699000155, -108.543878970269, -8.48861069398811, -521.810552387313, 26.4792411876883, -8.32240296737599, -1085.40982521906, -44.1390030597906, -203.891397612798, -56.3746416571417, -218.205643256096, -178.991498697065, -42.2468018350386, .328546922634921, -1883.18308996621, 111.747881085748>;
z11 := <1549.88755331800, -329.861725802688, 8.54200301129155, -283.381775745327, -54.5469129127573, 1875.94875597129, -16.2230517860850, 6084.82381954832, 1146.15489803104, -456.460512914647, 104.533252701641, 16.3998365630734, 11.5710907832054, -175.370276462696, 33.8045539958636, 2029.50029336951, 1387.92643570857, 9.54717543291120, -1999.09590358328, 29.7628085078953, 2.58210333216737*10^6, 57.7969622731082, -6.42551196941394, -8549.23677077892, -49.0081775323244, -72.5156360537114, 183.539911458475>;
ICS:=[x1(0)=x11[1],y1(0)=y11[1],z1(0)=z11[1]];
N := Dimension(x11)-1:
sys1 := [Diff(x1(t),t) = k1*x1(t)+ k2*y1(t)+ k3*z1(t), Diff(y1(t),t) = k5*x1(t)+ k6*y1(t)+ k7*z1(t), Diff(z1(t),t) = k9*x1(t)+ k10*y1(t)+ k11*z1(t)];
SS := proc(k1,k2,k3,k5,k6,k7,k9,k10,k11)
local F, V;
if not type([k1,k2,k3,k5,k6,k7,k9,k10,k11],[numeric,numeric,numeric,numeric,numeric,numeric,numeric,numeric,numeric]) then return 'SS'(k1,k2,k3,k5,k6,k7,k9,k10,k11);
elif k1<0 or k2<0 or k3<0 or k5<0 or k6<0 or k7<0 or k9<0 or k10<0 or k11<0 then return 1e100;
end if;
F := dsolve(eval({Diff(x1(t),t) = k1*x1(t)+ k2*y1(t)+ k3*z1(t), Diff(y1(t),t) = k5*x1(t)+ k6*y1(t)+ k7*z1(t), Diff(z1(t),t) = k9*x1(t)+ k10*y1(t)+ k11*z1(t),x1(0)=x11[1],y1(0)=y11[1],z1(0)=z11[1]},{:-k1=k1,:-k2=k2,:-k3=k3,:-k5=k5,:-k6=k6,:-k7=k7,:-k9=k9,:-k10=k10,:-k11=k11}), [x1(t),y1(t),z1(t)], numeric, output=Array([seq(k,k=0..N)]));
V := convert(Column(F[2,1],2),Vector);
Norm(V-x11,2);
Norm(V-y11,2);
Norm(V-z11,2);
end proc:
params := NLPSolve(SS(k1,k2,k3,k5,k6,k7,k9,k10,k11), method=nonlinearsimplex, initialpoint=[k1=.1, k2=.1, k3=.1, k5=.1, k6=.1, k7=.1, k9=.1, k10=.1, k11=.1],evaluationlimit=200):

Warning, limiting number of function evaluations reached

reference from 

http://www.maplesoft.com/applications/view.aspx?SID=1667

when debug

k1=.1; k2=.1; k3=.1; k5=.1; k6=.1; k7=.1; k9=.1; k10=.1; k11=.1;
F := dsolve({Diff(x1(t),t) = k1*x1(t)+ k2*y1(t)+ k3*z1(t), Diff(y1(t),t) = k5*x1(t)+ k6*y1(t)+ k7*z1(t), Diff(z1(t),t) = k9*x1(t)+ k10*y1(t)+ k11*z1(t),x1(0)=x11[1],y1(0)=y11[1],z1(0)=z11[1]}, [x1(t),y1(t),z1(t)], numeric, output=Array([seq(k,k=0..N)]));

Warning, The use of global variables in numerical ODE problems is deprecated, and will be removed in a future release. Use the 'parameters' argument instead (see ?dsolve,numeric,parameters)
Error, (in dsolve/numeric) Array/array solutions cannot be obtained for ODE containing unassigned global variables {k1, k10, k11, k2, k3, k5, k6, k7, k9}

x11 := Vector([0.208408965651696e-3, -0.157194487523421e-2, -0.294739401402979e-2, 0.788206708183853e-2, 0.499394753201753e-2, 0.191468321959759e-3, 0.504980449104750e-2, 0.222150494088535e-2, 0.132091821964287e-2, 0.161118434883258e-2, -0.281236534046873e-2, -0.398055875132037e-2, -0.111753680372819e-1, 0.588868146012489e-2, -0.354191562612469e-2, 0.984082837373291e-3, -0.116041186868374e-1, 0.603027845850267e-3, -0.448778128168742e-2, -0.127561485214862e-1, -0.412027655195339e-2, 0.379387381798949e-2, -0.602550446997765e-2, -0.605986284736216e-2, -0.751396992404410e-2, 0.633613424008655e-2, -0.677581832613623e-2]):
y11 := Vector([ -21321.9719565717, 231.709204951251, 1527.92905167191, -32.8508507060675, 54.9408176234139, -99.4222178124229, -675.771433486265, 42.0838668074923, -12559.3183308951, 5.21412214166344*10^5, 1110.50031772203, 3.67149699000155, -108.543878970269, -8.48861069398811, -521.810552387313, 26.4792411876883, -8.32240296737599, -1085.40982521906, -44.1390030597906, -203.891397612798, -56.3746416571417, -218.205643256096, -178.991498697065, -42.2468018350386, .328546922634921, -1883.18308996621, 111.747881085748]):
z11 := Vector([ 1549.88755331800, -329.861725802688, 8.54200301129155, -283.381775745327, -54.5469129127573, 1875.94875597129, -16.2230517860850, 6084.82381954832, 1146.15489803104, -456.460512914647, 104.533252701641, 16.3998365630734, 11.5710907832054, -175.370276462696, 33.8045539958636, 2029.50029336951, 1387.92643570857, 9.54717543291120, -1999.09590358328, 29.7628085078953, 2.58210333216737*10^6, 57.7969622731082, -6.42551196941394, -8549.23677077892, -49.0081775323244, -72.5156360537114, 183.539911458475]):

a1 := Diff(x1(t),t) = k1*x1(t)+ k2*y1(t)+ k3*z1(t) + k4*u(t);
b1 := Diff(y1(t),t) = k5*x1(t)+ k6*y1(t)+ k7*z1(t) + k8*u(t);
c1 := Diff(z1(t),t) = k9*x1(t)+ k10*y1(t)+ k11*z1(t) + k12*u(t);
d1 := Diff(u(t), t) = 0;
ICS:=x1(0)=x11[1],y1(0)=y11[1],z1(0)=z11[1];
solL:=dsolve({a1,b1,c1,d1,ICS}, numeric, method=rkf45, parameters=[k1,k2,k3,k4,k5,k6,k7,k8,k9,k10,k11,k12]);
ans:=proc(p1,p2,p3) solL(parameters=[a1=p1,b1=p2,c1=p3]); end proc:
FitParams:=Statistics:-NonlinearFit(ans, x11, y11, z11, x1, y1, z1);

Error, (in Statistics:-NonlinearFit) unexpected parameters: Vector(27, {(1) = 1549.88755331800, (2) = -329.861725802688, (3) = 8.54200301129155, (4) = -283.381775745327, (5) = -54.5469129127573, (6) = 1875.94875597129, (7) = -16.2230517860850, (8) = 6084.82381954832, (9) = 1146.15489803104, (10) = -456.460512914647, (11) = 104.533252701641, (12) = 16.3998365630734, (13) = 11.5710907832054, (14) = -175.370276462696, (15) = 33.8045539958636, (16) = 2029.50029336951, (17) = 1387.92643570857, (18) = 9.54717543291120, (19) = -1999.09590358328, (20) = 29.7628085078953, (21) = 2582103.332, (22) = 57.7969622731082, (23) = -6.42551196941394, (24) = -...

So I am working on doing some trajectory simulations in Maple using standard Newton's Laws, some force expressions, and initial conditions.

Anyway, the numerical solution works fine if I let the initial conditions I specified (for z=-1) be actually for z=-0.9. To illustrate, when I give an initial condition like this:

x(-1) = x_0, D(x)(-1) = xd_0, Vz(-1) = v_0

the results don't make any sense. However, when using the same x_0, xd_0, and v_0 and I give initial conditions like this:

x(-.9) = x_0, D(x)(-.9) = xd_0, Vz(-0.9) = v_0,

the solutions at least make a bit of sense.

What's weird is that, when I let z -> 0.93 or so, the solution changes discontinuously. And this shouldn't happen. The initial conditions were calculated for and should work for z = -1. I don't understand why they aren't.

Here is my Maple document. ics1 are the problem.

dsolve_field_traject.mw

Do you guys have any idea what could be going on?

the question is as follow:

The partition does not always have to be equal intervals. Consider evaluating f(x)=x³ between 3 and 5, but splitting up the interval into a partition in which the end points of the subintervals are in a geometric progression. The common ratio r has to be chosen so that 3 is the first term and 5 is the last. Also the subintervals must be capable of getting smaller as n the number of subintervals increases. Check that the geometric series

a, ar, ar², ar³,.....arⁱ, .....arⁿ =b

with r=  and suitable choices for a and b satisfies these criteria. Treating the difference between arⁱ and ar^(i-1) as the width of the subinterval and using the right hand endpoint of the subinterval, evaluate the Riemann sum to n terms for f(x)=x³. Find the limit as n tends to infinity to show that the partition does not affect the result.

here is what i have got so far, can anyone check if im doing it right? thanks

>a:=3:

>b:=a*r^10:

>r:=(5/3)^1/10:

>for i from 0 to 5 do a*r^i end do; -> a list of number appear in sequence ie:3, 3.157...,3.323...3.497...etc

>restart;

>a:=3:

>b:=a*r^100:

>r:=(5/3)^1/100:

>dxj:=a*r^i-a*r^i-1

>xj:=i*dxj+a

>f:=x->x^3

>evalf(sum(f(xj^*)dxj,i=1..100)) -> my value is sth like 162.4788870...

I tried to find the limit, but maple 16 freezed so i think i must have done sth seriously wrong?

<math xmlns='http://www.w3.org/1998/Math/MathML'><mrow><mi>b</mi><mo>&coloneq;</mo><mi>a</mi><mo>&sdot;</mo><msup><mi>r</mi><mrow><mn>10</mn></mrow></msup><mo>&#x3b;</mo><mo>&nbsp;</mo></mrow></math>

Is there any way to write a function that determines the area of any n-sided polygon determined by a sequence of points? ie [[x_1, y_1]. [x_2, y_2], ... [x_n, y_n]] while returning 0 if any of the 2 segments intersect, otherwise print the area. Thanks for any help

Hello,

would you please help me how can i introduce a probability distribution function to maple in document mode?

I want to calculate integral of x f(x)dx, while I want maple to know f(x) is a probability distribution function.

I do not have any assumption about f(x)(for example normal or exponential distriburion)

Thanks

I really very much like this package since it works just perfectly converting units and also supports CGS for people doing calculations in theoretical physics. I have just a suggestion concerning the formattig: As is explained in many physics books and also at the units standard website http://physics.nist.gov/, units shouldn't be placed in square brackets since these brackets are defined such that [m] = kg means: unit of m is kg. To write is m = 3 [kg] is a very common and unharmful mistake, also used very often when labelling axes in figures, e.g. m [kg] instead of the correct m/kg or m (kg). Another issue is that units shouldn't be printed italic but upright and any physics journal requests its authors to consider this rule. Again, this is not a "mistake" but on the other hand the Maple pretty-print output is already so nice that considering such rules would even make it perfect.

I am fully aware that omitting the brackets could be considered harmful if someone has an algebraic expression in front of the unit where symbols and units could be mixed. On the other hand having the usual interspace between unit and expression, the unit being upright and maybe even coloured (analogously to e.g. operators in the physics package) units and symbols could be easily held apart.