## How to get phase portrait sketch for homogeneous ...

Dear sir, I hereby request you to suggest an appropriate method to plot phase portrait sketches for the above cited subject

in 2D and 3D for the problem With thanks and regards.

Mr M ANAND

Associate Profesoor in Mathematics.

## evalf/xxx, printlevel, typesetting...

This question is related to an answer I gave here:
So, please look at a simple worksheet containing only a few lines; the resuts are in the # comments.

restart;
evalf(frac(Pi^20));

#                              23.
restart;
printlevel:=40:
evalf(frac(Pi^20));

###  prinlevel stuff
#                              0.

And now the questions.
1. Why the first evalf(frac(Pi^20))  does not  call  `evalf/frac`?
(the second does, trace(`evalf/frac`)  shows this  if inserted).
Note that  `evalf/frac`(Pi^20)    returns  0.
2. Why evalf(frac(Pi^20))    depends on printlevel?
Note that  if  printlevel is changed to 20 (say)  the result is again 23.
3. Why if we set interface(typesetting=standard)  in a fresh session
the results are both 23?

## Problem with a while do loop...

I can't get a While do loop to work as expected.

For i from 2 while M[i,1]<>M[1,1] and i<25 do..   It doesn't catch row 15 where M[15,1] =M[1,1] but it does stop at i = 24 ok.    (1)  (2) ## Improvements in solving PDE & BC in Maple 2018.1

Maple 2018

For Maple 2018.1, there are improvements in pdsolve's ability to solve PDE with boundary and initial conditions. This is work done together with E.S. Cheb-Terrab. The improvements include an extended ability to solve problems involving non-homogeneous PDE and/or non-homogeneous boundary and initial conditions, as well as improved simplification of solutions and better handling of functions such as piecewise in the arguments and in the processing of solutions. This is also an ongoing project, with updates being distributed regularly within the Physics Updates.

Solving more problems involving non-homogeneous PDE and/or non-homogeneous boundary and initial conditions

Example 1: Pinchover and Rubinstein's exercise 6.17: we have a non-homogenous PDE and boundary and initial conditions that are also non-homogeneous:

 >  >  (1)
 How we solve the problem, step by step:

Example 2: the PDE is homogeneous but the boundary conditions are not. We solve the problem through the same process, which means we end up solving a nonhomogeneous pde with homogeneous BC as an intermediate step:

 >  >  (12)
 How we solve the problem, step by step:

Example 3: a wave PDE with a source that does not depend on time:

 >  >  (23)
 How we solve the problem, step by step:

Example 4: Pinchover and Rubinstein's exercise 6.23 - we have a non-homogenous PDE and initial condition:

 >  >  (30)

If we now make the functions f and g into specific mappings, we can compare pdsolve's solutions to the general and specific problems:

 >  Here is what pdsolve's solution to the general problem looks like when taking into account the new values of f(x) and g(x,t):

 >  (31)

Here is pdsolve's solution to the specific problem:

 >  (32)

And the two solutions are equal:

 >  (33)
 > Improved simplification in integrals, piecewise functions, and sums in the solutions returned by pdsolve

Example 1: exercise 6.21 from Pinchover and Rubinstein is a non-homogeneous heat problem. Its solution used to include unevaluated integrals and sums, but is now returned in a significantly simpler format.

 >  >  (34)
 >  (35)

Example 2: example 6.46 from Pinchover and Rubinstein is a non-homogeneous heat equation with non-homogeneous boundary and initial conditions. Its solution used to involve two separate sums with unevaluated integrals, but is now returned with only one sum and unevaluated integral.

 >  >  (36)
 >  (37)

More accuracy when returning series solutions that have exceptions for certain values of the summation index or a parameter

Example 1: the answer to this problem was previously given with instead of as it should be:

 >  >  (38)

Example 2: the answer to exercise 6.25 from Pinchover and Rubinstein is now given in a much simpler format, with the special limit case for w = 0 calculated separately:

 >  >  (39)

Improved handling of piecewise, eval/diff in the given problem

Example 1: this problem, which contains a piecewise function in the initial condition, can now be solved:

 >  >  (40)

Example 2: this problem, which contains a derivative written using eval/diff, can now be solved:

 >  >  (41)

References:

Pinchover, Y. and Rubinstein, J.. An Introduction to Partial Differential Equations. Cambridge UP, 2005.

Katherina von Bülow

## Likelihood function and finding some constants...

Hello Friends

I have a critical problem that I wish to solve it with maple

suppose we have a list like following: y_obs=(2,4,8,7,9,52,35,478,52) and corresponding variance σy=(.2,.3,.5,.87,.1.2,.22,.78,.99,1.5)
we know y as the function of x described such as y_theoric=x+p and minimizing X is

X=Sigma [(y_theoric-y_obs)^2]/σy which includes the sum of nine numbers...

the question is:

How we can find p from likelihood function and plot general behavior of y versus of x through two above series?

for example this solution used in article under the names Hubble parameter data constraints on dark energy by Yun Chen and Bhatra Ratra (Physics Letters B)

Thank you

## What does this plot look like?...

I mean

```restart;
plots:-implicitplot(sqrt(b)*sqrt(1-4*p/b)-2*arctan(sqrt((9*p/b-22201/10000)/(9/4-9*p/b))) = 0, b = 0 .. 5,
p = 0 .. 5, gridrefine = 2, rational);``` I find the above result unsatisfactory.

## How to fix for-loop slowdown...

Hello,

I have a very large expression I'm tring to average (by doing limit(1/L*int(<expr>,t=-L..L),L=infinty) ). However, given that this expression is so large (sum of 11k terms), I'm was looking for ways to speed up the calculation and use less RAM.

I found that applying the lim@int seperately to each term of the sum helps. Also, since my integrand has various functions of other variables (eg. f(x), g(y), etc), Maple seems to go faster if I freeze those functions using frontend.

However, the problem I'm running into is that, as I'm running through my for-loop to apply lim@int to each term, Maple starts running slower and slower, as well as taking more and more RAM. Additionally, it doesn't go to completion because it runs out of stack space.

Is there an optimization trick to avoid this problem? I've tried garbage collecting after each iteration; that helps the RAM problem (at a cost of speed), but it still slows down over time.

I've attached my code: MWE.maple. Fair warning: on a non-server computer, it is liable to run very slow.

## convert Ei1 to Ei...

Is it possible to convert E1(x) to Ei(x) explicitly?

In particular I have this expression which is real, but imaginary numbers appear due to the definition of Ei1 for negative arguments.

(-exp(j*z)*Ei(1, j*z)+I*Pi*exp(-j*z)+exp(-j*z)*Ei(1, -j*z))/(2*j)

j>0,z>0

Thank you

## A strange interface bug...

The procedure F computes the smallest prime factor of  ithprime(n)-2

`F := n -> ifactors((ithprime(n)-2)):`

F(11);
29
Strangely, print(F)  must be interrupted!
print(F);
Warning,  computation interrupted

Also,

`F := n -> ifactors((ithprime(n)-2));`

Warning,  computation interrupted
Warning,  computation interrupted

(F is defined, only the display fails).
This happens only for interface(typesetting=extended).
In Maple 2017 it was OK.

## Error, numeric exception: division by zero...

how I can remove this error.

Error, numeric exception: division by zero

code2.mw

## Possible bug with pdsolve and assuming?...

Hello,

I was trying to apply some assumptions to a pdsolve command and noticed a strange error. Here's a minimal working example.

```restart():

pdsolve(diff(f(t,x),t) = 0, {f(t,x)}, ivars = {x, t}) assuming x::real:```

returns

`Error, (in simpl/relopsum) invalid terms in sum: diff(f(t,x),t) = 0`

Is this indeed a bug, or is it expected behavior?

## Maple 2018.1 update

by: Maple 2018

We have released an update to Maple, Maple 2018.1. This release provides enhancements to the mathematical computation engine, including physics and DEs.  It also provides substantial improvements to the command line version, easier access to group management tools in the MapleCloud, and a few other interface improvements.

This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2018.1 download page, where you can also find more details.

## physics package - bug in tensor products of kets...

btw, what i'm really trying to do is represent spin 1/2 states, along with the usual spin operators, and be able to take tensor products of the spin states. any hints on how to do that would be greatly appreciated.

btw, the physics package is amazing!

thanks,

larry

bug.mw

## how to make break point to a local proc inside mod...

One of the frustrating things I am finding in using Maple debugger is that I can't set breakpoint using stopat() at some line number in some inner module, if the inner module is local module. It has to be an exported module.

Here is an example

```restart;
foo:=module()
export main_entry;
local foo1; #inner module. But if local, Can't set breakpoint from outside

foo1:=module()
export main_entry;
local foo2;

foo2:=proc() #or breakpoint in first line here
local s,x;
s:=1;     #suppose I want to set break point here
s:=s+sin(x);
end proc;

main_entry:=proc()
foo2();
end proc;
end module;

main_entry :=proc()
foo1:-main_entry(); #call inner module's proc
end proc;

end module;
```

Since there is inner module, local to outside module, I can't set break into the inner module procs anywhere.

stopat(foo:-foo1::foo2);
Error, module does not export `foo1`

A workaround for now is to change "local" to "export" on the inner modules declarations I want to debug, so I can setbreak points inside them, then when done, make them local again. So changed "local foo1" to "export foo1" above, and now

stopat(foo:-foo1::foo2,2);

works.

This was also a little strange to me, since foo2() is a LOCAL proc to module foo1, yet Maple did not complain like it did when module foo1 was a LOCAL module to foo. I would have expected Maple to complain again for same reason.

So I am using the above workaround for now. But it is just a little annoying becuase I have to keep changing module from LOCAL to EXPORT in order to set breakpoints, then remember to make them local again.

Is there a better workaround?

A product suggestion: make stopat() ignore the local module setting and treat it as export for the purpose of setting a break point. This way one does not have to change the code just to set a breakpoint. Or if not to change current behavior, add a new option, as in

stopat(........, option= ignore_local_setting)

So the default remain the same as now, but with the new option, it will set breakpoint anywhere, even in local modules.

Thank you

## A Beginner’s guide to using the DNN Classifier...

by: Maple 2018

Hello, everyone! My name’s Sophie and I’m an intern at Maplesoft. @Samir Khan asked me to develop a couple of demonstration applications using the DeepLearning package - my work is featured on the Application Center

I thought I’d describe two critical commands used in the applications – DNNClassifier() and DNNRegressor().

The DNNClassifier calls tf.estimator.DNNClassifier from the Tensorflow Python API. This command builds a feedforward multilayer neural network that is trained with a set of labeled data in order to perform classification on similar, unlabeled data.

Dataset used for training and validating the classifier has the type DataFrame in Maple. In the Prediction of malignant/benign of breast mass example, the training set is a DataFrame with 32 columns in total, with column labels: “ID Number”, “Diagnosis”, “radius”, “texture”, etc. Note that labeling the columns of the dataset is mandatory, as later the neural network needs to identify which feature column corresponds to which list of values.

Feature columns are what come between the raw input data and the classifier model; they are required by Tensorflow to specify how the input data should be transformed before given to the model. Maple now supports three types of Feature Columns, including:

• NumericColumn that represents real, numerical figure,
• CategoricalColumn that denotes categorical(ordinal) data
• BucketizedColumn that organizes continuous data into a discrete number buckets with specified boundaries.

In this application, the input data consists of 30 real, numeric values that represents physical traits of a cell nucleus computed from a digitized image of the breast mass. We create a list of NumericColumns by calling

```with(DeepLearning):
fc := [seq(NumericColumn(u,shape=), u in cols[3..])]:```

where cols is a list of column labels and shape indicates that each data input is just a single numeric value.

When we create a DNNClassifier, we need to specify the feature columns (input layer), the architecture of the neural network (hidden layers) and the number of classes (output layer). Recall that the DNNClassifier builds a feedforward multilayer neural network, hence when we call the function, we need to indicate how many hidden layers we want and how many nodes there should be on each of the layer. This is done by passing a list of non-negative integers as the parameter hidden_units when we call the function. In the example, we did:

`classifier := DNNClassifier(fc, hidden_units=[20,40,20],num_classes=2):`

where we set 3 hidden layer each with 20, 40, 20 nodes respectively. In addition, there are 30 input nodes (i.e. the number of feature columns) and 1 output node (i.e. binary classification). The diagram below illustrates a simpler example with an input layer with 3 nodes, 2 hidden layers with 7, 5 nodes and an output layer with 1 node. (Created using NN-SVG by https://github.com/zfrenchee/NN-SVG)

After we built the model, we can train it by calling

`classifier:-Train(train_data[3..32], train_data, steps = 256, num_epochs = 3, shuffle = true):`

where we

1. Give the training data (`train_data[3..32]`) and the corresponding labels (`train_data`) to the model.
2. Specified that the entire dataset will be passed to the model for three times and each iteration has 256 steps.
3. Specified that data batches for training will be created by randomly shuffling the tensors.

Now the training process is complete, we can use the validation set to evaluate the effectiveness of our model.

`classifier:-Evaluate(test_data[3..32],test_data, steps = 32);`

The output indicates an accuracy of ~92.11% in this case. There are more indices like accuracy_basline, auc, average_loss that help us decide if we need to modify the architecture for better performance.

We then build a predictor function that takes an arbitrary set of measurements as a DataSeries and returns a prediction generated by the trained DNN classifier.

`predictor := proc (ds) classifier:-Predict(Transpose(DataFrame(ds)), num_epochs = 1, shuffle = false) end proc;`

Now we can pass a DataSeries with 30 labeled rows to the predictor: (Recall the cols is a list of the column names)

```ds := DataSeries([11.49, 14.59, 73.99, 404.9, 0.1046, 8.23E-02, 5.31E-02, 1.97E-02, 0.1779, 6.57E-02, 0.2034, 1.166, 1.567, 14.34, 4.96E-03, 2.11E-02, 4.16E-02, 8.04E-03, 1.84E-02, 3.61E-03, 12.4, 21.9, 82.04, 467.6, 0.1352, 0.201, 0.2596, 7.43E-02, 0.2941, 9.18E-02], labels = cols[3..]);
predictor(ds);
```

The output indicates that the probability of this data being a class _id  is ~90.79%. In other words, according to our model, the probability of this breast mass cell being benign is ~90.79%.

The use of the DNNRegressor is very similar (almost identical) to that of the Classifier, the only significant difference is that while the Classifier predicts discrete labels as classes, the Regressor predicts a continuous qualitative result with the provided data (Note that CategoricalColumn is still applicable). For more details about the basic usage of the DNNRegressor, please refer to Predicting the burnt area of a forest fires with DNN Regressor.

﻿