in maple 2017 I have enconterd a problem in showing of matrix elements. this error did not exist in maple 2016.

after some mathematical operations with(Linearalgebra)

I have obtained a matrix but maple shows it as below

`Vector(3, {(1) = \`+\`(\`*\`(0.19498673e10, \`*\`(\`^\`(x[1], 3))), \`-\`(\`*\`(0.36539123e10, \`*\`(\`^\`(x[1], 2), \`*\`(x[2])))), \`*\`(0.12514628e10, \`*\`(\`^\`(x[1], 2), \`*\`(x[3]))), \`-\`(\`*\`(7987.1506, \`*\`(\`^\`(x[1], 2)))), \`*\`(0.35170874e10, \`*\`(x[1], \`*\`(\`^\`(x[2], 2)))), \`-\`(\`*\`(0.41418339e10, \`*\`(x[1], \`*\`(x[2], \`*\`(x[3]))))), \`-\`(\`*\`(9187.8615, \`*\`(x[1], \`*\`(x[2])))), \`*\`(0.28788960e10, \`*\`(x[1], \`*\`(\`^\`(x[3], 2)))), \`*\`(2871.4325, \`*\`(x[1], \`*\`(x[3]))), \`-\`(\`*\`(0.95594712e9, \`*\`(\`^\`(x[2], 3)))), \`*\`(0.21616680e10, \`*\`(\`^\`(x[2], 2), \`*\`(x[3]))), \`-\`(\`*\`(16552.293, \`*\`(\`^\`(x[2], 2)))), \`-\`(\`*\`(0.20009067e10, \`*\`(x[2], \`*\`(\`^\`(x[3], 2))))), \`-\`(\`*\`(30447.582, \`*\`(x[2], \`*\`(x[3])))), \`*\`(0.42009564e9, \`*\`(\`^\`(x[3], 3))), \`-\`(\`*\`(42372.407, \`*\`(\`^\`(x[3], 2))))), (2) = \`+\`(\`-\`(\`*\`(0.14713991e11, \`*\`(\`^\`(x[1], 3)))), \`*\`(0.42489026e11, \`*\`(\`^\`(x[1], 2), \`*\`(x[2]))), \`-\`(\`*\`(0.25018214e11, \`*\`(\`^\`(x[1], 2), \`*\`(x[3])))), \`-\`(\`*\`(55498.093, \`*\`(\`^\`(x[1], 2)))), \`-\`(\`*\`(0.34645652e11, \`*\`(x[1], \`*\`(\`^\`(x[2], 2))))), \`*\`(0.52229109e11, \`*\`(x[1], \`*\`(x[2], \`*\`(x[3])))), \`-\`(\`*\`(399927.96, \`*\`(x[1], \`*\`(x[2])))), \`-\`(\`*\`(0.24172439e11, \`*\`(x[1], \`*\`(\`^\`(x[3], 2))))), \`-\`(\`*\`(367829.40, \`*\`(x[1], \`*\`(x[3])))), \`*\`(0.11603445e11, \`*\`(\`^\`(x[2], 3))), \`-\`(\`*\`(0.24618238e11, \`*\`(\`^\`(x[2], 2), \`*\`(x[3])))), \`*\`(163169.71, \`*\`(\`^\`(x[2], 2))), \`*\`(0.24814370e11, \`*\`(x[2], \`*\`(\`^\`(x[3], 2)))), \`-\`(\`*\`(711030.81, \`*\`(x[2], \`*\`(x[3])))), \`-\`(\`*\`(0.64758011e10, \`*\`(\`^\`(x[3], 3)))), \`*\`(427083.52, \`*\`(\`^\`(x[3], 2)))), (3) = \`+\`(\`*\`(0.13627334e11, \`*\`(\`^\`(x[1], 3))), \`-\`(\`*\`(0.67651416e11, \`*\`(\`^\`(x[1], 2), \`*\`(x[2])))), \`*\`(0.94045968e11, \`*\`(\`^\`(x[1], 2), \`*\`(x[3]))), \`*\`(46901.078, \`*\`(\`^\`(x[1], 2))), \`*\`(0.70616015e11, \`*\`(x[1], \`*\`(\`^\`(x[2], 2)))), \`-\`(\`*\`(0.13072873e12, \`*\`(x[1], \`*\`(x[2], \`*\`(x[3]))))), \`-\`(\`*\`(994642.52, \`*\`(x[1], \`*\`(x[2])))), \`*\`(0.41170263e11, \`*\`(x[1], \`*\`(\`^\`(x[3], 2)))), \`-\`(\`*\`(2768390.4, \`*\`(x[1], \`*\`(x[3])))), \`-\`(\`*\`(0.22189949e11, \`*\`(\`^\`(x[2], 3)))), \`*\`(0.67100205e11, \`*\`(\`^\`(x[2], 2), \`*\`(x[3]))), \`-\`(\`*\`(961344.42, \`*\`(\`^\`(x[2], 2)))), \`-\`(\`*\`(0.52533380e11, \`*\`(x[2], \`*\`(\`^\`(x[3], 2))))), \`*\`(2309741.6, \`*\`(x[2], \`*\`(x[3]))), \`*\`(0.23373385e11, \`*\`(\`^\`(x[3], 3))), \`-\`(\`*\`(2708629.4, \`*\`(\`^\`(x[3], 2)))))})`

however its elemets is shown correctly

for example the first element is shown as:

x(1) ^ 3 * 0.194986727121702600e10 + x(1) ^ 2 * x(2) * (-0.365391227687975264e10) + x(1) ^ 2 * x(3) * 0.125146284187383199e10 + x(1) ^ 2 * (-0.798715058230362229e4) + x(1) * x(2) ^ 2 * 0.351708738191481209e10 + x(1) * x(2) * x(3) * (-0.414183393126536083e10) + x(1) * x(2) * (-0.918786154503699254e4) + x(1) * x(3) ^ 2 * 0.287889598946906424e10 + x(1) * x(3) * 0.287143252997207219e4 + x(2) ^ 3 * (-0.955947121705965400e9) + x(2) ^ 2 * x(3) * 0.216166802966718006e10 + x(2) ^ 2 * (-0.165522927641286878e5) + x(2) * x(3) ^ 2 * 

Any any good programming language or design program the format and style of a document is important for sharing with others.  But for the life of me, I don't know if I'm just missing the painfully obvious, but seriously is there not a blogpost or document about the best writing practices for using maple?

It would be a great help to understand general practices for formatting with the document blocks and execution groups.

How do we print the determinant as a matrix with vertical bars instead of brackets?
Thanks!

mapleatha

Hello people in mapleprimes,

I have a problem about map.

restart;
map(`*`,op([1/x,y,z]));

The output of this code is not y*z/x, but  (x*y*z)^(-y*z).

I can't understand why this occurs.
Can't you teach me about this?

Thanks in advance.

Nov_3_2017_mapleprimes.mw

I write shell scripts that call Maple to automate frequent tasks. Because I prefer writing Maple code to shell code, I've created a Maple package, Bark, that generates a shell script from Maple source code. It provides a compact notation for defining both optional and positional command-line parameters, and a mechanism to print a help page, from the command-line, for the script. The optional parameters can be both traditional single letter Unix options, or the more expressive GNU-style long options.

As an example, here is the Maple code, using Bark, for a hello-world script.

hello := module()
export
    Parser := Bark:-ArgParser(NULL
                              , 'prologue' = ( "Print `Hello, World!'" )
                              , 'opts' = ['help' :: 'help' &c "Print this help page"]
                             );
export
    ModuleApply := proc(cmdline :: string := "")
        Bark:-ArgParser:-Parse(Parser, cmdline);
        Bark:-printf("Hello, World!\n");
        NULL;
    end proc;
end module:

The following command creates and installs the shell script in the user's bin directory.

Bark:-CreateScript("hello", hello
                   , 'add_libname' = Bark:-SaveLib(hello, 'mla' = "hello.mla")
                  ):

The hello script is executed from the command-line as

$ hello
Hello,  World!

Pass the -h (or --help) option to display the help.

$ hello -h
Usage: hello [-h|--help] [--]

Print `Hello, World!'

Optional parameters:
-h, --help Print this help page

CreateScript creates two files that are installed in the bin directory: the shell script and a Maple archive file that contains the Maple procedures. The shell script passes its argument in a call to the parser (a Maple procedure) saved in the archive file (.mla file). Here's the created shell script for the hello command:

#!/usr/bin/env sh
MAPLE='/home/joe/maplesoft/sandbox/main/bin/maple'
CMD_LINE=$(echo $0; for arg in "$@"; do printf '%s\n' "$arg"; done)
echo "hello(\"$CMD_LINE\");" | "$MAPLE" -q -w2 -B --historyfile=none -b '/home/joe/bin/hello.mla'

I've used Bark on Linux and Windows (with Cygwin tools). It should work on any unix-compatible OS with the Bash shell. If you use a different shell that does not work with it, let me know and I should be able to modify the CreateScript command to have options for specific shells.

Bark is available on the MapleCloud. To install it, open the MapleCloud palette in Maple, select packages in the drop-down menu and go to the New tab (or possibly the Popular tab). You will also need the TextTools package which is also on the MapleCloud. The intro page for Bark has a command that automatically installs TextTools. Alternatively, executing the following commands in Maple 2017 should install both TextTools and Bark.

PackageTools:-Install~([5741316844552192,6273820789833728],'overwrite'):
Bark:-InstallExamples('overwrite'):

The source for a few useful scripts are included in the examples directory of the installed Bark toolbox. Maple help pages are included with Bark, use "Bark" as the topic.

As my first project as a Junior Applications Developer, I set out to learn to code in the best way I know how, by doing.  I ended up picking what was probably one of the hardest options I could pick, namely to replicate the sliding puzzle game, 2048. (https://en.wikipedia.org/wiki/2048_(video_game) ) Of course I didn’t realize how hard it would be at the time, but after spending the first week alone working on the logic, I had already dug my hole.

2048, the sliding puzzle game, basically starts with a 4x4 grid filled with zeros. As you swipe the grid, values move toward one of the up, down, left or right sides. With every subsequent swipe, a randomly placed value of 2 or 4 is added to the grid. Any neighbouring matching values in the direction of the swipe are added to one another. This was done by swiping 2 tiles of equal value into each other, creating a new tile with double the value. Two 2 tiles became a 4, two 4’s an 8, and so on.

The goal? To create a 2048 tile.

Overall the logic was probably the most challenging part of my task, once the framework was set. . The logic consisted of many if statements that made the numbers “slide” properly, ie not combining with another number. This was probably the hardest part. Troubleshooting and allowing for all the possible conditions also proved difficult. However, the user interface was probably the toughest part, figuring out the labels, making everything display correctly, and programming all the buttons to not break. That was fun.

Anyway, it was a really fun project to work on, and I’m extremely happy for how it turned out, and I hope you enjoy playing it, as much as I did making it!

You can try it out here:

https://maple.cloud/#doc=5765606839156736

Hi,

How do i set up a Fourth order Runge-Kutta, RK4, routine to solve this nonlinear second order differential equation?:

• a=-2, b=1
• k=0.1
• x0=2
• from t=0..100

Do you have any good examples that is similar to this problem?

thanks

So I encountered a Chini differential equation which is solvable in terms of an implicit function

restart; assume(nu > 2, beta > 0, lambda > 0, delta > 0, y >= 0);
simplify(dsolve(beta+y+(D(h))(y) = nu*((lambda+beta+y)^2-delta*h(y))^(1/2)));

The answer is really too ugly to be pasted here, but I do get a
RootOf [ linear + log(linear) + delta* some integral + 2 * the very same integral]

It took me a quarter of an hour to deciphre that the integrals are the same and that I could get it all down to (delta+2)*integral. Because Maple did not simplify it. 

But if I copy what is inside the RootOf(), and paste it into a simplify() - then it does! So how to force it into doing that in the first place? 

Still novice, yes ... 

Hello guys, I have a problem using simplex, at linear exercises.

Example:

> Typesetting[delayDotProduct](with, simplex, true);
> minimize (4*x1+3*x2+5*x3,{x1-2*x2+3*x3>=-1,x1+x2-x3>=1},NONNEGATIVE);

And I got an error:

Error, Got internal error in Typesetting:-Parse : "'_Inert_DELAYLESSEQ' is not a valid inert form"

How can I solve this? I'm new in Maple software. I'm using Maple15.

Thank you, have a nice day!

restart;
unames();  # first call ok
unames();  # second call

Error, invalid input: Typeset:-Kernel expects an equation for keyword parameter numericformatting

Error, unexpected result from Typesetting

I have a polynomial of 4th order and I wanted to use allvalues on the RootOf expression. It then says:
 

Error, (in evala/Normal/preproc) reducible RootOf detected.  Substitutions are {RootOf(4678560000000000000000000000000000000000+(16573041*CO^2+70122975000000000000*CO-623180900000000000000000000000000)*_Z^4+(-19887649200*CO^2-82987335000000000000000*CO+745755960000000000000000000000000000)*_Z^3+(5966294760000*CO^2+23851989000000000000000000*CO-221858784000000000000000000000000000000)*_Z^2+(417684600000000000000000000*CO-757598400000000000000000000000000000000)*_Z) = 600, RootOf(4678560000000000000000000000000000000000+(16573041*CO^2+70122975000000000000*CO-623180900000000000000000000000000)*_Z^4+(-19887649200*CO^2-82987335000000000000000*CO+...
Error, (in allvalues) numeric exception: division by zero

So apparently the expression is reducible but how do I do that?

I'm working with Fourier Transform. I'd like to transform a noisy image to the frequency domain, create a grayscale version of the spectrum, mask the dots or lines, threshold it, multiply the binary mask image with the magnitude image and then transform back to the spatial domain. Is this possible using Maple?

Any help would be appreciated.

I have a procedure, se, that takes 2 real numbers as arguments and returns a list of 3 real numbers,
so, for example,
se(1.2,2.7)=[-5.85,3.24,3.9].
(The exact nature of that procedure should not be important for plotting purposes.) 

The command   >plot3d(se(x,y),x=0..2,y=-2..3);  returns a surface plot as hoped.   
(I had some doubt because the help page suggests one needs 3 functions or procedures [f,g,h] to get a 3 d plot rather than one procedure that generates a list of 3 values but Maple 2017.3 came through). 
I have another procedure , td,that takes 2 real numbers as arguments and returns a list of 3 real numbers,  ;
so, for example,
td(2.7, 3.4)=[3.4, .594943507924521, -.111391393034295].

(Again, the exact nature of that procedure should not be important for plotting purposes.) 
The command   > plot3d(td(x,t),x=0..2,t=0..3);  returns the error message: 

Error, (in dsolve/numeric/process_parameters) parameter values must evaluate to numeric, got a = x

For some reason, plot3d is going back to the body of the procedure, td, rather than just accepting the values it provides.

Knowing that quotes can sometimes solve this sort of problem I then tried:
plot3d('td(x, t)', x = 0 .. 2, t = 0 .. 3);
only to get

Warning, unable to evaluate the function to numeric values in the region; see the plotting command's help page to ensure the calling sequence is correct

I am not sure what plot3d is complaining about. The procedure I believe has all the information it needs in the form it needs it.
I then tried another workaround.

I set td1(x,t) :=td(x,t)[1], td2(x,t) :=td(x,t)[2], td3(x,t) :=td(x,t)[3] and tried :
plot3d([td1(x, t), td2(x, t), td3(x, t)], x = 0 .. 3, t = 0 .. 2);
to get
Error, (in dsolve/numeric/process_parameters) parameter values must evaluate to numeric, got a = x
Again, for some reason, plot3d is going back to the body of the procedure td.

Finally, I tried:
plot3d('[td1(x, t), td2(x, t), td3(x, t)]', x = 0 .. 3, t = 0 .. 2);
 
and I got the plot I wanted.

I am very happy to have a working file but I do not understand what worked and why. The nest time I have such a problem I will have to resort to the mysterious syntax manipulations again and hope that I hit on a combination that works.

For completeness I include the procedure bodies for  se and td below but I think that is irrelevant information.

se := proc (x, y) [x^2-y^2, x*y, x+y] end proc;

td := proc (x, tt)
local des, ff, fpfp; global ans;
ans(parameters = [a = x]);
des := ans(tt); ff := rhs(des[2]); fpfp := rhs(des[3]); [tt, ff, fpfp]
end proc;
 and
ans:=dsolve(ic,numeric,parameters=[a]):  where ic is an ode (I used several with the same result) with initial condition involving a.;

Can anybody explain what is happening?

How does one declare 3d vector in Maple, say p1, p3, and x, and integrate the following function from -Infinity to q, and q to + Infinity? Note that there is an iota in the exponential, and p1.x is the dot product of p1 and x. 

Integrate from -Infinity to q, q to infinity w.r.t. p1 and p3 

e^( - i p1 . x ) * 1/((p3 -p1)^2)

The integration should preferably be in spherical co-ordinates, but a demonstration in Cartesian co-ordinates would also be helpful. 

how may i encounter this problem,

Please help me on this ode solve (dsolve) wit
 

Download Grosan.mw

h bcs