The question is all in the title really. I am struggling to make a subsection on my macbook, using 2018 Maple software. The cmd + shift + . will only make sections, regardless of where i place my cursor.

Hi,

I am trying to solve a 2dof system numerically. What is the best way to find x1 and x2 by given initial conditions?

My first try to solve it is in the attached file.2DOFnumerical.mw

Thanks,

Baharm31

From the help pages for the Gram Schmidt command:

The number of Vectors returned is the dimension of the vector space spanned by V.  In particular, if the Vectors in V are not linearly independent, fewer Vectors than the number in V are returned.

That is not what happens when floating point numbers are involved, for example:

>restart;
>with(LinearAlgebra);
>a := Vector([1, 2, 3]); b := Vector([1, -2, 3]); c := Vector([3, 2, 1]); d := Vector([5, 1, -3]); e := Vector([0, 1.01, -3]);
>GramSchmidt([a, b, c, d, e]);

This returns 3 vectors as it should BUT
>GramSchmidt([b, c, d, e, a]) returns 5 vectors (one of which is essentially 0).  That is definitely a bug.
 

Hi everyone,

I just started using Maple which is part of a class I am taking. 

We are asked to write a procedure which returns two random values (think two dice).

What I would like to do is:

dice := proc()
    local a,b;
    a := rand(1..6);
    b := rand(1..6);
    
    return a,b;
end proc:

That doesn't work and I don't understand why. How does rand work? Also, how can I call rand in a loop, i.e. repeat rand n times and add the values?

I really hope you can help me here, really struggling.

I am trying to solve improper integrals using Maple. I need to choose at least one from attached and I am leaning towards number 26 but I am having trouble. I am new to Maple and have no idea where to even begin. Please provide the correct steps needed to get to the right answer.

Hi there:

i use Grid:-Map() to run some code on many cores. When I set

Grid:-Setup(numnodes=23);

everything runs fine. When I set (note I have 28 logical cores present):

Grid:-Setup(numnodes=24);

I get the "stack limit reached" message (see attached image below). I've explored setting stack limits to 'unlimited' at the OS level (ubuntu 18.04), as well as setting

kernelopts(stacklimit=infinity)

However, these do not help, and I still end up with the same message.

Any ideas what could be the problem? Also, I am assuming that kernelopts settings get passed to other, spawned kernels, but even if not, I experimented with setting this directly inside the function that gets passed to Grid:-Map()

thanks

Can be proved that Cos(ix) is bounded?

a:=sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*l3*m3+sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*l3*mi+sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*l3*m4+l1^2*m2*(diff(theta1(t), t, t))-sin(theta3(t))*(diff(theta3(t), t))^2*cos(theta1(t))*l1*lc3*m3+sin(theta4(t))*(diff(theta4(t), t))^2*cos(theta1(t))*l1*l4*mi+sin(theta4(t))*(diff(theta4(t), t))^2*cos(theta1(t))*l1*l4*m4-sin(theta4(t))*(diff(theta4(t), t))^2*cos(theta1(t))*l1*lc4*m4+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*ml+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*m3+l1^2*ml*(diff(theta1(t), t, t))+l1^2*mr*(diff(theta1(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*ml*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*mc*(diff(theta2(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*mi*(diff(theta5(t), t, t))-cos(theta3(t))*cos(theta1(t))*l1*l3*m4*(diff(theta3(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*mc*(diff(theta5(t), t, t))+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*mi+sin(theta6(t))*(diff(theta6(t), t))^2*cos(theta1(t))*h2*l1*m4-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*mi-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*m4-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*m3-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*mr-sin(theta5(t))*(diff(theta5(t), t))^2*cos(theta1(t))*h2*l1*mc-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*m3-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*lc2*m2-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*mr+sin(theta2(t))*sin(theta1(t))*l1*l2*ml*(diff(theta2(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*mi*(diff(theta5(t), t, t))+l1^2*m4*(diff(theta1(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*m3*(diff(theta5(t), t, t))+cos(theta3(t))*cos(theta1(t))*l1*lc3*m3*(diff(theta3(t), t, t))-sin(theta3(t))*sin(theta1(t))*l1*l3*m4*(diff(theta3(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*m4*(diff(theta6(t), t, t))-sin(theta4(t))*sin(theta1(t))*l1*l4*m4*(diff(theta4(t), t, t))-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*mi-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*mc-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*ml-sin(theta2(t))*(diff(theta2(t), t))^2*cos(theta1(t))*l1*l2*m4-sin(theta7(t))*(diff(theta7(t), t))^2*cos(theta1(t))*h3*l1*mc-cos(theta4(t))*cos(theta1(t))*l1*l4*mi*(diff(theta4(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*mr*(diff(theta2(t), t, t))-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*mi-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*m4+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*m3+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*mi+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*mc+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*mr+cos(q2(t))*sin(theta1(t))*l1*l2*mi*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*m4*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*lc2*m2*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*m3*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*mc*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*ml*(diff(theta2(t), t))*(diff(theta1(t), t))+cos(q2(t))*sin(theta1(t))*l1*l2*mr*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*mc*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*m4*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*mr*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*m3*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*mi*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*l2*ml*(diff(theta2(t), t))*(diff(theta1(t), t))-sin(q2(t))*cos(theta1(t))*l1*lc2*m2*(diff(theta2(t), t))*(diff(theta1(t), t))-cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*l3*mi+cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*lc3*m3-cos(theta4(t))*(diff(theta4(t), t))^2*sin(theta1(t))*l1*l4*m4-cos(theta4(t))*(diff(theta4(t), t))^2*sin(theta1(t))*l1*l4*mi+cos(theta4(t))*(diff(theta4(t), t))^2*sin(theta1(t))*l1*lc4*m4-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*ml-cos(theta6(t))*(diff(theta6(t), t))^2*sin(theta1(t))*h2*l1*m3-cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*l3*m4-cos(theta3(t))*(diff(theta3(t), t))^2*sin(theta1(t))*l1*l3*m3+l1^2*mc*(diff(theta1(t), t, t))-cos(theta4(t))*cos(theta1(t))*l1*l4*m4*(diff(theta4(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*mr*(diff(theta5(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*lc2*m2*(diff(theta2(t), t, t))+cos(theta1(t))*g*l1*mr+cos(theta1(t))*g*l1*m3+cos(theta1(t))*g*l1*m2+cos(theta1(t))*g*l1*m4+cos(theta1(t))*g*l1*ml+cos(theta1(t))*g*l1*mc+m1*g*lc1*cos(theta1(t))+cos(theta1(t))*g*l1*mi+cos(theta5(t))*cos(theta1(t))*h2*l1*m3*(diff(theta5(t), t, t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*m4*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*mc+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*mc*(diff(theta2(t), t))+cos(theta7(t))*(diff(theta7(t), t))^2*sin(theta1(t))*h3*l1*mc+l1^2*m3*(diff(theta1(t), t, t))+l1^2*mi*(diff(theta1(t), t, t))+cos(theta5(t))*(diff(theta5(t), t))^2*sin(theta1(t))*h2*l1*m4-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*m3*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*ml+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*ml*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*lc2*m2*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*mr+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*mr*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*m4+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*m4*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*mi+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*mi*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*mr*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*mi*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*l2*m3+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*l2*m3*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*mc*(diff(theta2(t), t))-cos(theta2(t))*sin(theta1(t))*(diff(theta1(t), t))*l1*l2*ml*(diff(theta2(t), t))+cos(theta2(t))*(diff(theta2(t), t))^2*sin(theta1(t))*l1*lc2*m2+sin(theta2(t))*cos(theta1(t))*(diff(theta1(t), t))*l1*lc2*m2*(diff(theta2(t), t))+sin(theta2(t))*sin(theta1(t))*l1*l2*m3*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*m3*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*mi*(diff(theta2(t), t, t))+cos(theta5(t))*cos(theta1(t))*h2*l1*m4*(diff(theta5(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*mr*(diff(theta2(t), t, t))+m1*lc1^2*(diff(theta1(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*m4*(diff(theta6(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*mr*(diff(theta5(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*mc*(diff(theta5(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*mi*(diff(theta6(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*mi*(diff(theta6(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*m3*(diff(theta6(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*m3*(diff(theta6(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*lc2*m2*(diff(theta2(t), t, t))+cos(theta2(t))*cos(theta1(t))*l1*l2*m4*(diff(theta2(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*mc*(diff(theta2(t), t, t))+sin(theta3(t))*sin(theta1(t))*l1*lc3*m3*(diff(theta3(t), t, t))-cos(theta3(t))*cos(theta1(t))*l1*l3*mi*(diff(theta3(t), t, t))-sin(theta3(t))*sin(theta1(t))*l1*l3*mi*(diff(theta3(t), t, t))-cos(theta3(t))*cos(theta1(t))*l1*l3*m3*(diff(theta3(t), t, t))-sin(theta3(t))*sin(theta1(t))*l1*l3*m3*(diff(theta3(t), t, t))+cos(theta7(t))*cos(theta1(t))*h3*l1*mc*(diff(theta7(t), t, t))-cos(theta6(t))*cos(theta1(t))*h2*l1*ml*(diff(theta6(t), t, t))+sin(theta7(t))*sin(theta1(t))*h3*l1*mc*(diff(theta7(t), t, t))-sin(theta6(t))*sin(theta1(t))*h2*l1*ml*(diff(theta6(t), t, t))+sin(theta4(t))*sin(theta1(t))*l1*lc4*m4*(diff(theta4(t), t, t))+cos(theta4(t))*cos(theta1(t))*l1*lc4*m4*(diff(theta4(t), t, t))-sin(theta4(t))*sin(theta1(t))*l1*l4*mi*(diff(theta4(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*m4*(diff(theta2(t), t, t))+sin(theta2(t))*sin(theta1(t))*l1*l2*mi*(diff(theta2(t), t, t))+sin(theta5(t))*sin(theta1(t))*h2*l1*m4*(diff(theta5(t), t, t))

I want to manipulate polynomials in two non-commuting variables, over the field of rational numbers.  I read some of the help concerning Ore algebras, and also some of the help concerning the Physics package (where there are non-commuting variables), but unfortunately I could not understand much of what I read!  For someone who is not a Maple virtuoso, is there a simple way to work with non-commutative polynomials?  

Hi all,

I wanted to know if there's a tool in Maple for solving (globally) non convex optimization problems?

specifically, I need to solve the following problem:

min||Ax-b||_1 s.t. ||x||_2=1

where A is a given matrix of size nxd

b is a given vector of size nx1

x is an unkown vector of size dx1 that should be a unit vector (hence the contraint ||x||_2=1).

The closest function I found in Maple is LSSolve but this function is intended for convex problems.

I'm able to solve the problem using Yalmip in matlab.

Here's an example code in matlab+yalmip that finds the unit vector x that globally minimizes ||Ax-b||_1.

clear;
close all;
clc;

n = 10;
d = 3;

A = rand(n,d);
b = rand(n,1);
x = sdpvar(d,1);

Objective = norm(A*x-b,1);
cons = x'*x==1;
options = sdpsettings('solver','bmibnb');
sol= optimize(cons,Objective, options);

x_sol = value(x)

Is there a way to write a similar code in Maple?

Thanks

I'm a student and I've recently been introduced to Maple. I've been given the task to create a polynomial in Maple that goes through the following points: 

[2, 2], [12, 6], [37, 42], [49, 21], [73, 49], [91, 2]

Once the polynomial has been created, I would like to know the formula. 

What do I need to do to solve this task?

I'm looking for the specific commands etc.

Thanks.

Hello

If 0 occurs in the first element, I want to remove the list containing zero and the associated number.

example

p := [[[0, 5], [3, 10], [1, 20], [0, 50]], [[2, 5], [0, 10], [2, 20], [0, 50]]]

after processing:

[[[3, 10], [1, 20]], [[2, 5], [2, 20]]]

I tried in vain...

select(i -> (subs(p,p[1,i,1])>0), [$1..nops(p)]);
 

[[1,2],[5,7]]intersect [[1,2]]

return [1,2]

there is error when run this.

search start from a, b, c, ... for each sequence if input a,b,c,d,e,f,g,h,i,j,k

is there a function like accumulate in haskell in maple instead of using for loop?

would like to search something if found, then return the length of it searched from the starting position

when start from a search a from b to g whether is a,  if find , return the length from c to the found position,

when start from b search b from c to h whether is b,  if find , return the length from c to the found position

....

then save the length into a list

a b c d e f g

   b c d e f g h

      c d e f g h i

         d e f g h i j

            ef g h i j k