@yaseen Which elements, and how do you wish to pair them in order to take products?

@yaseen Which elements, and how do you wish to pair them in order to take products?

@Mac Dude I certainly did not advocate suppressing the warning. I showed how to suppress the warning, and then I advocated dealing with it via explicit declaration instead of suppressing the warning. I suggested that dealing with it via explicit declaration was better; I gave an example of the supression potentially leading to problems.

The act of showing how to do something does not make any suggestion that it's a good idea.

@Mac Dude I certainly did not advocate suppressing the warning. I showed how to suppress the warning, and then I advocated dealing with it via explicit declaration instead of suppressing the warning. I suggested that dealing with it via explicit declaration was better; I gave an example of the supression potentially leading to problems.

The act of showing how to do something does not make any suggestion that it's a good idea.

Also possible is to use %a in the format string, rather than %e.

That should avoid any reliance on Digits or the length of the float.

acer

Also possible is to use %a in the format string, rather than %e.

That should avoid any reliance on Digits or the length of the float.

acer

@Carl Love Using method=ftocms I see, in Maple 17.01,

restart:                                                                

ee:=sin(x)/cos(x)/(1+sin(x)^3)^(1/2):
                                  
J:=Int(ee,x=0..Pi/4):                                                   

evalf(J);                                                               
                                 0.3224464890

K:=IntegrationTools:-Change(J, t= sin(x)):                              

W:=value(subsindets(K,specfunc(anything,Int),z->Int(op(z),method=ftocms))):

has(K,Int), has(W,Int);                                                    

                                  true, false
evalf(W);
                                                    -9
                      0.3224464894 - 0.6772297809 10   I

@Carl Love Using method=ftocms I see, in Maple 17.01,

restart:                                                                

ee:=sin(x)/cos(x)/(1+sin(x)^3)^(1/2):
                                  
J:=Int(ee,x=0..Pi/4):                                                   

evalf(J);                                                               
                                 0.3224464890

K:=IntegrationTools:-Change(J, t= sin(x)):                              

W:=value(subsindets(K,specfunc(anything,Int),z->Int(op(z),method=ftocms))):

has(K,Int), has(W,Int);                                                    

                                  true, false
evalf(W);
                                                    -9
                      0.3224464894 - 0.6772297809 10   I

@Sabeen I did not notice that your question was for Maple 12 specifically, sorry.

The `orientation` option was not an important part of my answer, as was just to make the plots display in a fixed way of my choice. You can simply remove that option from the calls, or use only two values instead of the three I used.

Here is a version revised for Maple 12.02.

inter3dM12.mw

It's not clear to me whether you really need a piecewise assembly of bivariate interpolating polynomials for your larger data sets, or whether you can make do with an (black box) interpolating function like the `f` that I have demonstrated. Note that with such an `f` you can compute at individual (x,y) points, eg. f(3.4,0.005) as well as make 3D plots.

(I don't mean to sound obtuse, but I'm not even 100% sure from your wording whether you are starting off with just arrays of numeric data, or whether you are somehow starting off with a plot structure from which you have extracted the given data. Sorry, if it should be obvious. I figured that you were starting off with a discrete regular grid of x-y points and their corresponding z-height-values, and wished to interpolate from that, eg. so as to produce a smoother 3D surface.)

If you only need to produce a more refined surface plot, and you have a very large set of numeric data (on a regular grid in the independent x-y plane) then the most efficient way to proceed in Maple 12 would likely be A) just used `surfdata` as in my sheet's first example, or B) refined to a finer mesh by manually calling ArrayInterpolation and specify the interpolatory scheme of your choice and then pass the finer mesh to `surfdata`.  Those should both be somewhat quick, depending on your GUI's rendering speed. But the second example in my attached sheet, which uses an interpolatory procedure `f` to compute values point-by-point, would be considerably slower that A) or B) for large data sets. In other words, if all you want to do is interpolate to a finer mesh, for plotting, then it's more efficient to compute the entire finer mesh in a single call to ArrayInterpolation.

See also this Example worksheet, perhaps, which has a download link at its end. Or see the ArrayInterpolation help-page.

@Sabeen I did not notice that your question was for Maple 12 specifically, sorry.

The `orientation` option was not an important part of my answer, as was just to make the plots display in a fixed way of my choice. You can simply remove that option from the calls, or use only two values instead of the three I used.

Here is a version revised for Maple 12.02.

inter3dM12.mw

It's not clear to me whether you really need a piecewise assembly of bivariate interpolating polynomials for your larger data sets, or whether you can make do with an (black box) interpolating function like the `f` that I have demonstrated. Note that with such an `f` you can compute at individual (x,y) points, eg. f(3.4,0.005) as well as make 3D plots.

(I don't mean to sound obtuse, but I'm not even 100% sure from your wording whether you are starting off with just arrays of numeric data, or whether you are somehow starting off with a plot structure from which you have extracted the given data. Sorry, if it should be obvious. I figured that you were starting off with a discrete regular grid of x-y points and their corresponding z-height-values, and wished to interpolate from that, eg. so as to produce a smoother 3D surface.)

If you only need to produce a more refined surface plot, and you have a very large set of numeric data (on a regular grid in the independent x-y plane) then the most efficient way to proceed in Maple 12 would likely be A) just used `surfdata` as in my sheet's first example, or B) refined to a finer mesh by manually calling ArrayInterpolation and specify the interpolatory scheme of your choice and then pass the finer mesh to `surfdata`.  Those should both be somewhat quick, depending on your GUI's rendering speed. But the second example in my attached sheet, which uses an interpolatory procedure `f` to compute values point-by-point, would be considerably slower that A) or B) for large data sets. In other words, if all you want to do is interpolate to a finer mesh, for plotting, then it's more efficient to compute the entire finer mesh in a single call to ArrayInterpolation.

See also this Example worksheet, perhaps, which has a download link at its end. Or see the ArrayInterpolation help-page.

@erik10 There is some introductory material on data structures in the Portal, here. It would be useful to see even more details there.

A side-by-side chart by which one could easily compare various features (mutability, uniqueness of entries, fixed or variable size, etc) of the structures might be useful for the new user.

Clear references (help links) from the list Help page to such Portal pages would be beneficial, and by that I mean more than just a "See Also" link.

A sentence indicating why a given reference is relevant can be crucial. Eg. there is a link to selection in the "See Also" section of list , and there is a brief sentence near the Examples, "To extract the contents of a list or set, use the empty selection operator [ ]." But these are too far separated. Why isn't there a help link within or adjacent to that explanatory sentence?

There should be help links to the select Help page (which includes details on `remove` and `selectremove`) on both the list Help page and that Portal page.

Using `remove` with a predicate is a common operation on lists. I don't see why that ought become a new command in the ListTools package, as long as it is more adequately referenced and illustrated by example in the Help pages of the data structures to which it applies.

1)

restart;
U := [7, 9, 14]:
A := [-2, 7, 8, 12, 9, -78, 0]:

remove(member,A,U);

                      [-2, 8, 12, -78, 0]

Someone asked about a week ago on math.stackexchange.com about your item 1) and in the answer I gave there I used something equivalent to remove(member,A,{op(U)}) because that would be more efficient in cases such as when list `U` had many entries and/or duplicates. (See also Carl's explanation below.)

acer

@PatrickT After reading your followup I'm not sure why your purposes might not be covered just by, say,

alias(gamma=__anameiwillnototherwiseuse):

@PatrickT After reading your followup I'm not sure why your purposes might not be covered just by, say,

alias(gamma=__anameiwillnototherwiseuse):

@Carl Love To me that looks like it might be an oversight in the implementation, or perhaps something difficult to get just right on the first version. It's the kind of thing that I meant when I wrote that I expect that there are wrinkles to be ironed out. I hope that this can be remedied, since it is a useful thing to want to do.

I hope that it gets fixed in the kernel. I am not trying to skirt the issue when I mention that in the Standard GUI there may be situations in which there is some minor relief in Maple 17 with the following:

restart:
local gamma;
gamma:=`γ`:
evalf(gamma); # output is prettyprinted as the lowercase Greek letter
evalf(:-gamma);

Of course, in the above the local name gamma is not unassigned. And the unevaluated instance would still evalf to the usual float value.

evalf('gamma');

                          0.5772156649

But an alias might serve a bit better.

restart:
local gamma;
alias(gamma=`γ`):
evalf(gamma); # prettyprints as the lowercase Greek letter
evalf('gamma'); # prettyprints as the lowercase Greek letter

But if using an alias is adequate for some set of purposes then why bother with the local declaration at all...