I don't know what's going wrong. It doesn't give a 2D Plot. Thanks in advance.

Download temperature24hr.mw

BE312-1920-CW2-Amended-Maple-Codemw-46469mw-46557_(1).mw

How do you run this code in Maple 2019 to Maple 18 because I can't see the output?

Thank you

I thought the easiest way to show the world map, a projected flat map into 3d was to use the builtin one and just transform it.  You can zoom into it and rotate it no problem but unforunately it's not as clean as I thought.  Is it possible to have cleaner shading manipulating the Builtin map to 3d?

with(plots):
with(plottools):
with(DataSets):
with(Builtin):
m := WorldMap():
m1 := Display(m)
                                

to3d := transform((x, y) -> [x, y, 0]):
m2 := to3d(m1)
                               

display(m2)

If a maple command or function are not available on the target language  of the code generation of maple, is it possible to set myself the expected output for such cases so that the Csharp(...)  recognizes the cases and generates the expect code?

for example 

h := proc(x::Array(1 .. 3, 1 .. 3), y::Array(1 .. 3, 1 .. 3)) local z; z := evalm(x &* y); return z[1, 1] + z[2, 2]; end proc;
CSharp(h);

The function names {`&*`, evalm} can not be recognized in the target language

but for the &* it shoud be easy to add a template with the desired C# output. 

Is it possible to add templates in existing languages but not new language definitions?

I am trying to solve a set of equations

Why are the results not the same as the following results?

Is there any other way to get the correct answer?

Download

Hi all, assume data::list, I want check data is not empty, which one is faster ?

Greetings,

I need to numerically solve a set of about 95 simultaneous algebraic transcendental equations, with each having about 25 terms that are expressions of three independent variables and other parameters of the problem (some 2500 total terms).  I've had much difficulty solving this set on Engineering Equations Solver (EES, from fchart software), and I'm now suspecting bugs in that program.

I'm not able to find a spec sheet or user's manual that explains Maple's capabilities.  I haven't found a place to read about such things as, "maximum number of algebraic equations," or "maximum number of characters in an equation", or other kinds of guides that would give me a direct indication on the software's capabilities.

Is there a stand-alone desk top version than can crunch numbers without resource to the cloud?

Can anyone please direct me to a complete manual for the user explaining such details?  

Thanks,

Tom

I had expected that applying the power rule for exponents would lead to an answer of zero. Maple refuses to give the desired answer, but using a procedure it works as expected.

Did I miss something?
 

Download mapleprimes.mw

Hi, 

Here is an example where evalf ( Int(....) ) fails to compute an in integral.
The function to integrate is very smooth and, except method=_Gquad, all the others seem to fail (even method=_MonteCarlo fails, which is probably the most surprising thing!)

Is it a weakness of evalf+Int or a misusse of my own ?

Download evalf_Int.mw

I'm using variable names that have subscripts, not as a table index but literal i.e. R__1 as a unique variable name.  It seems whenever I make assumptions on variables that have subscripts, when I use them the variables that have subscripts are printed twice:

Can anyone explain why this happens and how to get around it?

Thanks in advance.

Dear Friends

I want to know that how can I plot a 2D curve in 3D? 

I need to plot the curve for example z=y^2, in a 3D space and exactly in the plane x=0. The ranges are -1<y<1, -1<x<1, 0<z<1

(I want to copy and paste this curve in another 3D figure.) 

Thanks a lot

alternatingseries.mw
I have a double about this alternating series.
According to maple this series converges:

evalf(sum((-1)^(n+1)*(ln(n)/n+1),n=1..infinity))
                          0.3401310963

However limit ln(n)/n + 1 does not equal to zero, it equals 1. Therefore the series should diverge.

Also while I am on the subject of series and limits, why is limit (-1)^n  as n goes to infinity a range between -1-I and 1 + I.

limit((-1)^(n), n=infinity)
                        -1 - I .. 1 + I

Hello, I am having a bit of difficulty simplifying some calculations in Maple 2019. In short, in order to verify that the tensors that I am trying to use are indeed inverses of each other, I am simply trying to multiply component wise, for example the tensor component e[2,~2] with the tensor component f[~2,2], since they are essentially inverses of each other, i.e. the matrix defining f is actually the inverse of the matrix e, i.e. f=e^(-1), should give back 1 as an answer. Nonetheless, when I attempt to take this simple multiplication Maple does not reduce it, but rather just gives multiplies the terms with no simplification. Is there anything I can do so that Maple may simplify its calculations? I have already tried the "eval" calling sequence but that didn't do the trick, and I fear that when escalating the calculations I will get a bunch of long expressions rather than concise solutions. Thank you for your help in advance,
 

Christoffel_symbols_of_de_Sitter_metric_research.mw

When discussing Maple programming, we often refer to for-loops, while-loops, until-loops, and do-loops (the latter being an infinite loop). But under the hood, Maple has only two kinds of loop, albeit very flexible and powerful ones that can combine the capabilities of any or all of the above, making it possible to write very concise code in a natural way.

Before looking at some actual examples, here is the formal definition of the loops' syntax, expressed in Wirth Syntax Notation, where "|" denotes alternatives, "[...]" denotes an optional part, "(...)" denotes grouping, and Maple keywords are in boldface:

[ for  ] [ from  ] [ by  ] [ to  ]
    [ while  ]
do
    
( end do | until  )

[ for  [ , variable ] ] in 
    [ while  ]
do
    
( end do | until  )

In the first form, every part of the loop syntax is optional, except the do keyword before the body of the loop, and either end do or an until clause after the body. (For those who prefer it, end do can also be written as od.) In the second form, only the in clause is required.

The simplest loop is just:

do
    
end do

This will repeat the forever, unless a break or return statement is executed, or an error occurs.

One or two loop termination conditions can be added:

• A while clause can be written before the do, specifying a condition that is tested before each iteration begins. If the condition evaluates to false, the loop ends.
• An until clause can be written instead of the end do, specifying a condition that is tested after each iteration finishes. If the condition evaluates to true, the loop ends.

A so-called for-loop is just a loop to which iteration clauses have been added. These can take one of two forms:

• Any combination of for (with a single variable), from, by, and to clauses. The last three can appear in any order.
• A for clause with one or two variables, followed by an in clause.

The following for-loop executes 10 times:

for  from 1 to 10 do
    
end do

However, if the doesn't depend on the value of , both the for and from clauses can be omitted:

to 10 do
    
end do

In this case, Maple supplies an implicit for clause (with an inaccessible internal variable), as well as an implicit "from 1" clause. In fact, all of the clauses are optional, and the infinite loop shown earlier is understood by Maple in exactly the same way as:

for  from 1 by 1 to infinity while true do
    
until false

When looping over the contents of a container, such as a one-dimensional array A, there are several possible approaches. The one closest to how it would be done in most other programming languages is (this example and those that follow can be copied and pasted into a Maple session):

 := Array([,"foo",42]);
for  from lowerbound() to upperbound() do
    print([],[])
end do;

If only the entries in the container are of interest, it is not necessary to loop over the indices. Instead, one can write:

 := Array([,"foo",42]);
for  in  do
    print()
end do;

If both the indices and values are needed, one can write:

 := Array([,"foo",42]);
for ,  in  do
    print([],)
end do;

For a numerically indexed container such as an Array, this is equivalent to the for-from-to example. However, this method also works with arbitrarily indexed containers such as a Matrix or table:

 := LinearAlgebra:-RandomMatrix(2,3);
for ,  in  do
    print([],)
end do;

 := table({1="one","hello"="world",=42});
for ,  in eval() do
    print([],)
end do;

(The second example requires the call to eval due to last-name evaluation of tables in Maple, a topic for another post.)

As with a simple do-loop, a while and/or until clause can be added. For example, the following finds the first negative entry, if any, in a Matrix (traversing the Matrix in storage order):

 := LinearAlgebra:-RandomMatrix(2,3);
for ,  in  do
    # nothing to do here
until  < 0;
if  < 0 then
    print([],)
end if;

Notice that the test, < 0, is written twice, since it is possible that the Matrix has no negative entry. Another way to write the same loop but only perform the test once is as follows:

 := LinearAlgebra:-RandomMatrix(2,3);
for ,  in  do
    if  < 0 then
	print([],);
	break
    end if;
end do;

Here, we perform the test within the loop, perform the desired processing on the found value (just printing in this case), and use a break statement to terminate the loop.

Sometimes, it is useful to abort the current iteration of the loop and move on to the next one. The next statement does exactly that. The following loop prints all the indices but only the positive values in a Matrix:

 := LinearAlgebra:-RandomMatrix(2,3);
for ,  in  do
    print(=[]);
    if  < 0 then
	next
    end if;
    print(=);
end do;

(Note that a simple example like this would be better written by enclosing the printing of the value in an if-statement instead of using next. The latter is generally only used if the former is not possible.)

Maple's loop statements are very flexible and powerful, making it possible to write loops with complex combinations of termination conditions in a concise yet readable way. The ability to use while and/or until in conjunction with for means that break statements are often unnecessary, further improving clarity.

Lets say you have this simple list here 

L := [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

Which command would you use to partion into intervals? 

L_g := [1..2,3..4,5..6,7..8,9..10]