For polynomials in C[x], the distinguishing of roots is done by the index option of RootOf. See help pages ?RootOf and ?RootOf,indexed. An ordering of the complex numbers based on argument and magnitude is used for this purpose. The ordering can be changed (this is described on ?RootOf,indexed). Since it looks like you're a new Maple user, I wouldn't recommend changing the ordering on your own just yet.

Here is an example:

Download IndexedRootOf.mw

This works:

thaw(PDEtools:-Solve(subs(Ys=~ (Fz:= freeze~(Ys)), sys), Fz));

The variable names that have session-dependent assumptions are the indices of the table `property/OrigName`. Thus the following supplies the information that you're looking for, although not exactly in the format that you showed:

about(indices(`property/OrigName`, 'nolist'));

You can learn where the information is stored by reading the code of about, which is fairly short and straightforward:

showstat(about);

@C_R The fact that map(t-> t*~2, eqs) "works" is just a red herring, and has nothing to do with the elementwise operator, since map(t-> t*2, eqs) also works, producing identical results. Indeed, applying any elementwise operator to an equation (or indeed to any structure other than a set, list, table, rtable, or expression sequence) will give identical results to the non-elementwise form of the operator.

The anomaly with `*` must be due to the lack of a final eval internally, the same thing that you noticed. I can't yet explain the anomaly with `^`, but it might be related to either or both of these:

• Of the 5 operators you tested, only `^` is non-associative.
• Of those 5, only `^` requires a specific number of arguments, namely 2.

I don't think that the behavior of the standard arithmetic operators on non-algebraic structures is documented, so I can't call what you discovered a bug; it's just an anomaly. You can change the behavior like this:

AdjustArithOps:= module()
export
    `*`:= eval@:-`*`,

    `^`:= proc(a,b,$)
        try :-`^`(a,b) 
        catch "non-algebraic base": 
            if a::atomic then error else map(thisproc, a, b) fi
        catch "non-algebraic exponent": 
            if b::atomic then error else map2(thisproc, a, b) fi
        end try
    end proc
;
end module
:
eqs:= [a=b, c=d]:
use AdjustArithOps in 
    #Now you can do what you tried in your Question, or you can 
    #simply use the elementwise forms:
    map(`^`, eqs, 2); eqs^~2; map(`*`, eqs, 2); eqs*~2
end use; 
                       [ 2    2   2    2]
                       [a  = b , c  = d ]

                       [ 2    2   2    2]
                       [a  = b , c  = d ]

                     [2 a = 2 b, 2 c = 2 d]

                     [2 a = 2 b, 2 c = 2 d]

Yes, your computations can be greatly simplified by using elementwise operations (see help page ?elementwise).

Download Elementwise.mw

The possibility of a programmatic or automatic solution to this has been mentioned, but no code actually given. This is easier to code than one may expect.

Download IntofSum.mw

I don't know why the prettyprintred integrals and sums didn't appear above, but you can see them in the worksheet.

You could replace the extra factor of tau with 1/tau in the above, but the result is trivial because the integrals diverge at tau=0 (unless the Bs and betas make all the integrands zero).

Using assign is usually a bad idea. It can usually be replaced by eval, as is the case here. Your code can be shortened to this:

L:= [3,4,x,x^2,x^3]:
((X,x::algebraic)-> local n, a;
    `if`(patmatch(X, x^n::'nonunit'(anything), a), eval(n,a), NULL)
)~(L,x);
                             [2, 3]

You wanted to make the procedure shorter, yet you seem to go out of your way to make your code unnecessarily verbose by using RETURN, map instead of ~, etc.

Even shorter is

op~(2, select(patmatch, L, x^n::'nonunit'(anything)));
 

Yes, the way to do it is to create the types in a ModuleLoad. Here is an example:

M:= module()
local
    AddType:= proc(T::name, H::{type, procedure})
    uses TT= TypeTools;
        if TT:-Exists(T) then TT:-RemoveType(T) fi;
        TT:-AddType(T,H)
    end proc,

    ModuleLoad:= proc()
        AddType(Point, (e, n::{2,3})-> type(e, [algebraic$n]));
        AddType(Line, (e, n::{2,3})-> type(e, [Point(n)$2]))
    end proc
;
export
    CreateLine:= overload([
        proc(Pts::Line(2), $) option overload; "2D line" end proc,
        proc(Pts::Line(3), $) option overload; "3D line" end proc,
        ()-> "Unrecognized input format"
    ])
;
    ModuleLoad()
end module
:
M:-CreateLine([[1,2,3],[4,5,6]]);
                           "3D line"

M:-CreateLine([[1,2,3],[4,5]]);
                  "Unrecognized input format"

You almost had it correct with your subs. To completely eliminate the integral, the diff(eq2, x) should also be a target of the substitution: 

restart
:
eq:= diff(y(x),x) = y(x) + exp(x)*exp(-3*x)/2 + int(exp(x+t)*y(t), t= 0..x):
IC:= y(0)=1: 

eq2:= g(x) = int(exp(x+t)*y(t), t= 0..x):
IC_2:= eval(eq2, x= 0):  #Generate 2nd IC automatically.

#Eliminate the integral:
sys:= subs((rhs=lhs)(eq2), {eq, diff(eq2,x), IC, IC_2});
        / d                               
sys := { --- g(x) = g(x) + exp(2 x) y(x), 
        \ dx                              

   d                1                                            
  --- y(x) = y(x) + - exp(x) exp(-3 x) + g(x), g(0) = 0, y(0) = 1
   dx               2                                            

  \ 
   }
  / 

Now sys can be solved symbolically with dsolve(sys) or numerically with dsolve(sys, numeric).

The idea of factoring out the exp(x) will also work, but the above is simpler: Just make a substitution for the entire original integral.

This code does essentially the same thing as @dharr 's but does it with the index-free and functional syntax that I prefer. The entire computation---the construction of the Array---is done by a single line of code. The remaining two lines are simply to put that Array into a neatly displayed Table.

Download PairwiseIntersection.mw

The Table didn't transfer to MaplePrimes, but you can see it in the worksheet. It's identical to @dharr's both in content and displayed form.

You ( @Christopher2222 ) are a Moderator, and thus you can read the deleted content. If you do this, you will see that the vast majority of Moderator-deleted (as opposed to author-deleted) content is spam.

You are wrong about lost knowledge: It is the failure to delete inappropriate content that will cause the greater loss of knowledge, because good writers will stop using MaplePrimes, and it will become irrelevant. Do you think periodicals shouldn't have editors and peer review?

The defined coordinate systems are stored in an unexported table of an  undocumented package, as given in the title. Here's a procedure to access it:

Coords:= proc(C::{name,function}, V::list(name))
uses PC= Plot:-CoordinateSystems;  #undocumented package
local
    opq:= kernelopts(opaquemodules= false),    
    r:= PC:-CoordinateSystemsTable[String(`if`(C::name, C, op(0,C)))](
        V[],`if`(C::name, [][], op(C))
    )
;
    kernelopts(opaquemodules= opq);
    r
end proc
:
Coords(spherical_physics, [r, theta, phi]);
      [r*cos(phi)*sin(theta), r*sin(theta)*sin(phi), r*cos(theta)]

Since the package is undocumented, don't rely too much on the syntax remaining exactly the same as the way I just accessed it in the procedure.

By using a Newton's method iteration with pure-integer builtin (i.e., GMP) arithmetic, I can find roots of integers significantly faster than with any method that uses evalf. While most of Maple's integer-arithmetic commands whose names begin with i are builtin, that isn't true of iroot: It's written in Maple, and it uses evalf.

My Newton procedure is the second procedure listed in the table methods in the worksheet below. The Newton iteration for finding the cube root r of n is simply

r-> (2*r^3 + n)/(3*r^2)

Download Iroot.mw

The votes awarded after deletion do apply to the author's reputation. It has always been true (at least for the 10 years or so that I've been using MaplePrimes) that votes awarded to an item which is subsequently deleted continue to apply to the author's reputation.

I totally agree with acer that items Deleted As Spam should not be retained. There are now several Posts where the majority of Replies have been deleted as spam yet remain as clutter.

The syntax of Maple's hypergeom always has exactly three arguments. The first two arguments are arbitrary-length lists of algebraic expressions, and the third is a single algebraic expression rather than a list. If it's a 2F1 function, then the first list has 2 elements, and the second has 1.

The biggest and ugliest (IMO) differences between Maple and Mathematica syntax are that Maple's lists are enclosed in square brackets ([...]) rather than curly braces ({...}) and that Maple's function arguments are always in parentheses ((...)) rather than square brackets. (I consider the Mathematica to be uglier.)

In another Answer, @janhardo shows the correct syntax of a simple Maple hypergeom function (of class 2F1): 

hypergeom([1,1], [2], -z)

Your example could be entered as

-r^2/3*((1-beta)/`γ`)^n*
    hypergeom(
        [n, n/(1-beta)], [(beta-1-n)/(beta-1)], -r^(3/n*(1-beta))*chi^2/`γ`
    )

I used `γ` instead of gamma because gamma is by default a pre-defined constant (similar to Pi). If you mean the constant, then just use gamma. If it's intended to be a variable or parameter, there are several workarounds, one of which is `γ`.