Carl Love

## 26628 Reputation

11 years, 222 days
Himself
Wayland, Massachusetts, United States
My name was formerly Carl Devore.

## combinat...

First, you do not need to check the type of x,y,z; they are definitely integer. To find a subset of L with the desired property, we use the combinat package to iterate through subsets of L of size 4. For each subset, we iterate through its subsets of size 3, using geom3d:-IsRightTriangle. The last value of P4 after executing the loop below is your desired group of 4 with no right triangles.

`C:= combinat:-firstcomb(nops(L), 4):while C <> combinat:-lastcomb(nops(L), 4) do     P4:= L[[C[]]]:     ct:= 0; #count non rt triangles for this group of 4 pts.     for P3 in combinat:-choose(P4,3) do          geom3d:-triangle(               ABC,                [seq](geom3d:-point(A||k, P3[k][]), k= 1..3)          );          if geom3d:-IsRightTriangle(ABC) then  break  end if;          ct:= ct+1     end do;     # 4 triangles can be made from 4 pts: C(4,3) = 4.     if ct = 4 then  break  end if;      C:= combinat:-nextcomb(C, nops(L))end do:P4;      [[-5, 0, 2], [-5, 0, 10], [-4, -2, 3], [-4, -2, 9]]`

## output= solutionmodule, Results...

In your Optimization command (e.g.Minimize, LPSolve) include the option output= solutionmodule:

SM:= Optimization:-Minimize(
-4*x-5*y,
{6 >= x+2*y, 20 >= 5*x+4*y, x >= 0, y >= 0},
output= solutionmodule
):

Now SM is a module, so its contents (aka members) can be accessed with the :- operator. There are two members, SM:-Settings and SM:-Results. What you want is

SM:-Results(iterations);

## convert(..., list)...

You should forget about the print command. It is the wrong paradigm. It is inhibiting your understanding. Good Maple code very rarely uses it. I say this having read all your previous questions. The better paradigm is to make the result that you want to see the same as the result of the most recently executed command.

The result that you want in the present case can be achieved thus (the linebreak issue is handled automatically by the GUI) :

`restart: a:= 2:  b:= .29:  d:= 1.85: eq1:= x*(-b*x^2-x+1):eq2:= y*((a*x*x)/(b*y^2)-d-h*y): h:= .5: for k while 1 >= h do      h:= h + .1;          S:= solve({eq1, eq2}, {x, y});     X[k],Y[k]:= eval([x,y], S[2])[]end do:convert(X, list); convert(Y,list);   [0.809816975292943, 0.809816975292943, 0.809816975292943,     0.809816975292943, 0.809816975292943, 0.809816975292943]    [1.30989205371406, 1.28289831180836, 1.25827763787148,       1.23567070473363, 1.21479304855971, 1.19541568678247]`

## Classic worksheet...

You may have an old worksheet. If you have the 32-bit version of Maple, then you have the Classic interface. Use that to open the worksheet. Then resave it. Then try again with Standard. If you have 64-bit, then post the worksheet, and I'll do it for you.

## A:= t->...

Two (of many) ways:

A:= t-> [a(t), b(t), c(t)]; #a list

A:= t->  < a(t), b(t), c(t) >; #a (column) vector

## evala(Normal(A-B)), identify...

To prove that two algebraic numbers A and B are equal, use

evala(Normal(A-B));

You will get 0 if and only if they are equal.

In your case, they are equal. In this case simplify(A-B) will also work; however, the evala technique is guaranteed to work whereas the simplify is not.

The question remains, How can the first form be simplified to something like the second form? One technique that works in this case is identify.

r:= evalf(A):
for d from Digits+1 to 2^13 while r::float do
r:= identify(evalf[d](A));
end do:
d-1, r;

This is only a guess (albeit a very sophisticated guess), and it still needs to be proven:

eval(Normal(A-r));

0

## Parallel processing version...

Here is a version that I've reworked to make use of parallel processing. I needed to increase the number of side vectors b to 2^12 in order to get a meaningful time measurement. If your number of side vectors is only about 100 (like you said), it will be extremely wasteful to use the code below. This is because the overhead involved in setting up the parallel processing will be far greater than the time to solve the problem on one processor.

 > restart:

The float[8] technique used in this worksheet is extremely fast and is limited to moduli less than 2^25. If you need a larger modulus, it is very easy to modify (let me know), and  just a little slower.

 > N:= 2^7:  #order of matrix A n:= 2^12:  #number of vectors b[i] p:= 127:  #prime modulus
 > isprime(p);

Generate a random example upper triangular nonsingular A.

 > A:= LinearAlgebra:-RandomMatrix(      N, shape= triangular[upper, unit], datatype= float[8] ):

Convert to shape= rectangular, which is required by LinearAlgebra:-Modular.

 > A:= Matrix(A, shape= rectangular):

Input A to the Modular system.

 > A:= LinearAlgebra:-Modular:-Mod(p, A, float[8]):

Generate a list of random side vectors b[k].

 > b:= [seq](      LinearAlgebra:-RandomVector(N, datatype= float[8]),      k= 1..n ):

Make a solving procedure that can be mapped into parallel processors. It returns the solution for a single side vector.

 > Solve:= proc(b::Vector, A::Matrix, p::posint)      uses LAM= LinearAlgebra:-Modular;      local B:= LAM:-Mod(p, b, float[8]);      LAM:-BackwardSubstitute(p, A, B);      B end proc:

For reasons that I don't understand, it seems necessary to make a single bogus call to LinearAlgebra:-Modular:-BackwardSubstitute and generate an error before the parallel version will work. This only seems to be necessary once after each restart.

 > LinearAlgebra:-Modular:-BackwardSubstitute(p);

Error, (in LinearAlgebra:-Modular:-BackwardSubstitute) incorrect number of arguments

Threads:-Map is a parallel processing version of map. All that you need to run the parallel code is...

 > # X:= Threads:-Map(Solve, b, A, p);

...the rest of the code in the command below is just there to measure the time.

 > CodeTools:-Usage(      proc() :-X:= Threads:-Map(Solve, b, A, p) end proc() ):

memory used=5.30MiB, alloc change=15.31MiB, cpu time=234.00ms, real time=36.00ms

It looks like the code parallelizes extremely well:

 > 36.*kernelopts(numcpus)/234.;

It's actually the best parallelization ratio that I've ever achieved in my own code.

But if you compare the time with the single-processor time for the same number of b's, you will see that there is no savings using the parallel code. You would have to use about 2^16  b's before there would be any savings.

Verify results (not really necessary):

 > for k to n do      if LinearAlgebra:-Norm(              LinearAlgebra:-Modular:-AddMultiple(                   p,                   p-1,                   LinearAlgebra:-Modular:-Multiply(p, A, X[k]),                   LinearAlgebra:-Modular:-Mod(p, b[k], float[8])              )         )         <> 0      then error "Bad solve"      end if end do; "All solutions check";

 >

## LinearAlgebra:-Modular:-BackwardSubstitu...

At the sizes that you are talking about, it is not worth using multiple parallel processors. The following solution command runs in time less than the smallest time that can be measured directly by Maple, which is 1/64 seconds. If you really want to run on multiple parallel processors, let me know. But I think that the overhead of initiating the processes would outweigh any time savings.

Here's an example.

 > restart:

The float[8] technique used in this worksheet is extremely fast and is limited to moduli less than 2^25. If you need a larger modulus, it is very easy to modify (let me know), and  just a little slower.

 > N:= 2^7:  #order of matrix A n:= 2^6:  #number of vectors b[i] p:= 127:  #prime modulus
 > isprime(p);

Generate a random example upper triangular nonsingular A.

 > A:= LinearAlgebra:-RandomMatrix(         N, shape= triangular[upper, unit], datatype= float[8]    ):

Convert to shape= rectangular, which is required by LinearAlgebra:-Modular.

 > A:= Matrix(A, shape= rectangular):

Input A to the Modular system.

 > A:= LinearAlgebra:-Modular:-Mod(p, A, float[8]):

Generate a list of random side vectors b[k].

 > b:= [seq](LinearAlgebra:-RandomVector(N, datatype= float[8]),         k= 1..n    ):

Combine all the vectors into one matrix.

 > B:= `<|>`(seq(b[k], k= 1..n)):

Input it to Modular.

 > B:= LinearAlgebra:-Modular:-Mod(p, B, float[8]):

LinearAlgebra:-Modular:-BackwardsSubstitute does not "return" the answer. Rather, it overwrites B with the answer. In order to save B, we need to copy it.

 > X:= LinearAlgebra:-Modular:-Copy(p, B):

Solve system AX=B.

 > LinearAlgebra:-Modular:-BackwardSubstitute(p, A, X);

Verify results (not really necessary):

 > for k to n do      if LinearAlgebra:-Norm(              LinearAlgebra:-Modular:-Multiply(p, A, X[.., k])              - B[.., k]         )         <> 0      then error "Bad solve"      end if end do; "All solutions check";

The kth solution vector can be extracted thus:

 > k:= 9:
 > X9:= X[.., k];

(Optional) Convert back to true integer form.

 > X9int:= map(trunc,X9);

 > X9int[37], X9[37];

 >

## Single plot command does it...

It can be done with a single plot command. No transform or display is needed.

`restart:V:= exp(-x)*y^3/eta^3:eta:= 1+k*x+sin(2*Pi*x):x:= 0.1:Ks:= [.1, .5, -.1]:plot(     [seq](eval([V, y, y= 0..eta], k= K), K= Ks),     labels= ["v", "y"],     color= [black, red, blue],     linestyle= [solid, dash, dot],     legend= [seq](k = K, K= Ks));`

## A tiny bit of help...

It is sad that you have not received more help.... I can give you a tiny bit of help, but I have very little knowledge of this subject area. I think that some of what you want can be done with the ?DynamicSystems package. In particular, there is ?DynamicSystems,BodePlot and ?DynamicSystems,TransferFunction .

I think that Joe Riel may know this package well. Maybe he will notice this namecheck and respond.

Also, could you please retype your expressions in normal characters? The Maple Math typesetting is horrible---nearly impossible to read.

## No embedded assignments allowed...

Since no-one has answered yet and I know at least part of the answer, I will try to give some help. But I don't know much about Maplets yet.

What I can tell you for certain: Unlike some other languages (such as C), Maple does not allow assignments (:=) to be embedded in expressions. By changing a comma (,) to a semicolon (;), your code above can be made syntactically correct:

BoxRow(...

GridLayout([

[CheckBox['CB1'](), "Box1"],

....for all 6 boxes...

])); #<-- Here's the change

lstW:=['CB1','CB2',...for all 6 boxes];

What I'm not sure about: While the above is syntactically correct, I don't know whether it does anything useful.

## Not a p.d.f....

A plot of the function that you call pdf clearly shows that it is not a p.d.f. Its horizontal asymptotes are at e, not 0. Thus CDF is meaningless.  Also note that the result returned by dsolve has the form f(x) = ..., so, if the concept were meaningful at all, you'd need to have rhs(pdf) where you currently just have pdf.

## Need the elements of the vectors...

Your X25 and X2 are Vectors of polynomials. Quotient does not take Vectors as arguments, but it will take polynomials. So you could do

Quotient(X25[2], X2[2]);

## interface(imaginaryunit= ...)...

Come up with some other name for the imaginary unit. Let's say you choose i (but it does not need to be a single letter). Then do

interface(imaginaryunit= i);

Then you're free to use I however you want.

In Maple 17, all you need to do is

local I;

and that will automatically change the imaginary unit to _I.

## dsolve(..., numeric) and plots:-odeplot...

The solution returned by dsolve is taking a long time to compute plot points because non-numeric dsolve computes symbolic solutions in exact arithmetic even when the input coefficients are floats. This can lead to some extremely large rational numbers in the solution. (You can override this default with dsolve(..., convert_to_exact= false).) In this case, the solution is of the form exp(Int(N/D^2)) where the integral is unevaluated, N is polynomial of degree 8, D is polynomial of degree 5, and the coefficients of each polynomial are integers each having several hundred digits. When you try to plot this solution, Maple attempts a numerical integration (quadrature) of the exponent for each plotted point. For most of those points, it gives up because it can not achieve the accuracy specified by your value of Digits (probably set at the default 10).

It may be possible to carefully adjust the digits (lowercase d) and epsilon options on the numeric integration (see ?evalf,Int ) so that a plot can be obtained in a reasonable time. But it is much easier and much more efficient to use dsolve(..., numeric) and odeplot, like this:

pdf := dsolve(motion union ic, numeric);

plots:-odeplot(pdf, x= -0.01..0.01);

When you see the plot, you'll know why I chose such a narrow range.

 First 352 353 354 355 356 357 358 Last Page 354 of 383
﻿