For instance, here is a list of valid "rules" (given as equations): 

(* restart; *)
rules := [g = d, e = a, a = b, f = d, c = g, b = b, d = c, c = f, a = e]:

But these rules can be represented more compactly as a list of "cycles": 

cycles := [[g, d, c], [e, a], [f, d, c], [b]]:

Is there a efficient way to convert into ? 

Hey guys

I have a question using the piecewise function:

fa := unapply(piecewise(0 < x and x < a, k1, a < x and x < b, k2), x);

simplify(fa(x)) assuming 0 < a, 0 < x and x < a;

It should return k1, but it doesn't. Does anyone have a solution?

Sincerely,

Oliveira

Suppose I have a polynomial:

poly := x^6 - 3*x + 3

And I know one of its roots and its galois group:

firstroot := [solve](poly, x)[1]:
G := GaloisGroup(poly, x):

Since G act transitively on the all roots. How do I get all the other roots of this polynomial just by the firstroot and G, but not by solving the equation.

I would like to set a axis lable as  A (kg/m³)

where A is in italic style, (kg/m³) is in normal style

Is there documentation that tells about what the dollar sign means and how to manage it. It just appears in recent releases and it didn't used to in older releases. It is distracting and seems to appear randomly.

Thanks

I've been using Maple Flow for awhile and generally pleased with its performance...until today.

Going through my normal workflow, the sheet stopped evaluating and a little troubleshooting later it seems that the issue is that once I use a keyboard shortcut to include units, the sheet will not evaluate anything going forward. 

Once

I have to maximize my non linear objective function TBCI (given in attached worksheet) with 4 inequality constraints. The decision variables are i and q.The range of i is 0 to 1 and of q is 0 to 76.

When i tru to solve it using NLP solve it is showing error-"Error, (in Optimization:-NLPSolve) constraints must be specified as a set or list of equalities and inequalities".

Please help me to solve it. please find attached the maple file

For instance, Hypergeometric0F1Regularized^(1,0)[1,1.] = -0.113894... as given in Mathematica. I was wondering how this type of regularized hypergeometric function is defined in Maple. 

Download QR_method.mw

I incidently^(*) discovered that using MatrixPower to find the square root matrix of a relatively small matrix, returns wrong results, even for symetric positive definite matrices.

Trying to understand how MatrixPower proceeds using showstat is not that easy, but something I'm almost sure is that it doesn't ise an Eigenvectors decomposition.

Here is an example where I'm seeking for a matrix M such that C = M^2 and C is symetric definite positive of dimension 40.
(I didn't check if problems already occurs for smaller sizes)

^(*)  I was very bored by the prohibitive execution time of MatrixPower and looked for an alternative.

The matrix M that MatrixPower generates is far from verifying C = M^2 (using the option 'shape'='symmetric' doesn't improve anything).
The naive alternative based on an Eigenvectors decomposition works perfectly well while being 200 times faster.

Download MatrixPower_bug.mw

Could someone please exlain this behaviour:

indets('combinat:-binomial(i,j)', 'specfunc(combinat:-binomial)');
indets('combinat:-binomial(i,j)', specfunc('combinat:-binomial'));
indets('combinat:-binomial(i,j)', specfunc(combinat:-binomial));
indets(combinat:-binomial(i,j), specfunc(combinat:-binomial));

indets('combinat:-binomial(i,j)', 'specfunc(binomial)');
indets('combinat:-binomial(i,j)', specfunc('binomial'));
indets('combinat:-binomial(i,j)', specfunc(binomial));
indets(combinat:-binomial(i,j), specfunc(binomial));

indets('binomial(i,j)', 'specfunc(binomial)');
indets('binomial(i,j)', specfunc('binomial'));
indets('binomial(i,j)', specfunc(binomial));
indets(binomial(i,j), specfunc(binomial));

indets('binomial(i,j)', 'specfunc(combinat:-binomial)');
indets('binomial(i,j)', specfunc('combinat:-binomial'));
indets('binomial(i,j)', specfunc(combinat:-binomial));
indets(binomial(i,j), specfunc(combinat:-binomial));
 

I was looking for rewriting some expression in simpler forms and ened up getting wrong values from maple

Is something wrong on how I'm using it or is this a bug ?

This is the code with the output:

> NumericStatus(invalid_operation=false):
> simplify(sum(
>         (A-B)
>         *(-1+combinat:-binomial(N-2,i))
>         *(A)^(i)
>         *(B)^(N-2-i)
>     ,i=0..N-2));
                                                    (N - 1)    (N - 1)
                                                   B        - A



> NumericStatus(invalid_operation);
                                                          false

This is the wrong answer, is missing the part with the binomial, somehow its set to zero but the NumericStatus is still telling that everythig is fine.
It has not issues when one replaces the N-2 with N,

> simplify(sum(
>         (A-B)
>         *(-1+combinat:-binomial(N,i))
>         *(A)^(i)
>         *(B)^(N-i)
>     ,i=0..N));
                                          (N + 1)    (N + 1)                  N
                                         B        - A        + (A - B) (A + B)

> NumericStatus(invalid_operation);
                                                          false

If I drop the (-1) in front I get the right contribution from the binomial regardless of using N or N-2

> simplify(sum(
>         (A-B)
>         *(combinat:-binomial(N-2,i))
>         *(A)^(i)
>         *(B)^(N-2-i)
>     ,i=0..N-2));
                                                   /A + B\N          N
                                                   |-----|  (A - B) B
                                                   \  B  /
                                                   -------------------
                                                               2
                                                        (A + B)

> NumericStatus(invalid_operation);
                                                          false

which is equal to (A+B)^(N-2)*(A-B)

If I use assume(N>2) it still gives the same result but this time is flagged ad an invalid operation (which is not supposed to).
Interesting enough also if I set assume(N>0) in the second example gives me invalid_operation=true but return the correct result.