MaplePrimes Posts

MaplePrimes Posts are for sharing your experiences, techniques and opinions about Maple, MapleSim and related products, as well as general interests in math and computing.

Latest Post
  • Latest Posts Feed

  •  

    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:

    pde__1 := diff(u(x, t), t)-(diff(u(x, t), x, x)) = 1+x*cos(t)
    iv__1 := (D[1](u))(0, t) = sin(t), (D[1](u))(1, t) = sin(t), u(x, 0) = 1+cos(2*Pi*x)

    pdsolve([pde__1, iv__1])

    u(x, t) = 1+cos(2*Pi*x)*exp(-4*Pi^2*t)+t+x*sin(t)

    (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:

    pde__2 := diff(u(x, t), t) = 13*(diff(u(x, t), x, x))
    iv__2 := (D[1](u))(0, t) = 0, (D[1](u))(1, t) = 1, u(x, 0) = (1/2)*x^2+x

    pdsolve([pde__2, iv__2])

    u(x, t) = 1/2+Sum(2*(-1+(-1)^n)*cos(n*Pi*x)*exp(-13*Pi^2*n^2*t)/(Pi^2*n^2), n = 1 .. infinity)+13*t+(1/2)*x^2

    (12)

    How we solve the problem, step by step:

       

     

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

    pde__3 := (diff(u(x, t), x, x))*a^2+1 = diff(u(x, t), t, t)
    iv__3 := u(0, t) = 0, u(L, t) = 0, u(x, 0) = f(x), (D[2](u))(x, 0) = g(x)

    `assuming`([pdsolve([pde__3, iv__3])], [L > 0])

    u(x, t) = (1/2)*(2*(Sum(sin(n*Pi*x/L)*(2*L*sin(a*Pi*t*n/L)*(Int(sin(n*Pi*x/L)*g(x), x = 0 .. L))*a-Pi*cos(a*Pi*t*n/L)*(Int(sin(n*Pi*x/L)*(-2*f(x)*a^2+L*x-x^2), x = 0 .. L))*n)/(Pi*n*a^2*L), n = 1 .. infinity))*a^2+L*x-x^2)/a^2

    (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:

    pde__4 := diff(u(x, t), t)-(diff(u(x, t), x, x)) = g(x, t)
    iv__4 := (D[1](u))(0, t) = 0, (D[1](u))(1, t) = 0, u(x, 0) = f(x)

    pdsolve([pde__4, iv__4], u(x, t))

    u(x, t) = Int(f(tau1), tau1 = 0 .. 1)+Sum(2*(Int(f(tau1)*cos(n*Pi*tau1), tau1 = 0 .. 1))*cos(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)+Int(Int(g(x, tau1), x = 0 .. 1)+Sum(2*(Int(g(x, tau1)*cos(n1*Pi*x), x = 0 .. 1))*cos(n1*Pi*x)*exp(-Pi^2*n1^2*(t-tau1)), n1 = 1 .. infinity), tau1 = 0 .. t)

    (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:

    f := proc (x) options operator, arrow; 3*cos(42*x*Pi) end proc
    g := proc (x, t) options operator, arrow; exp(3*t)*cos(17*x*Pi) end proc

     

    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):

    value(simplify(evalindets(u(x, t) = Int(f(tau1), tau1 = 0 .. 1)+Sum(2*(Int(f(tau1)*cos(n*Pi*tau1), tau1 = 0 .. 1))*cos(n*Pi*x)*exp(-Pi^2*n^2*t), n = 1 .. infinity)+Int(Int(g(x, tau1), x = 0 .. 1)+Sum(2*(Int(g(x, tau1)*cos(n1*Pi*x), x = 0 .. 1))*cos(n1*Pi*x)*exp(-Pi^2*n1^2*(t-tau1)), n1 = 1 .. infinity), tau1 = 0 .. t), specfunc(Int), proc (u) options operator, arrow; `PDEtools/int`(op(u), AllSolutions) end proc)))

    u(x, t) = 3*cos(42*Pi*x)*exp(-1764*Pi^2*t)+cos(Pi*x)*(65536*cos(Pi*x)^16-278528*cos(Pi*x)^14+487424*cos(Pi*x)^12-452608*cos(Pi*x)^10+239360*cos(Pi*x)^8-71808*cos(Pi*x)^6+11424*cos(Pi*x)^4-816*cos(Pi*x)^2+17)*(exp(289*Pi^2*t+3*t)-1)*exp(-289*Pi^2*t)/(289*Pi^2+3)

    (31)

     

    Here is pdsolve's solution to the specific problem:

    pdsolve([pde__4, iv__4], u(x, t))

    u(x, t) = ((-65536*cos(Pi*x)^17+278528*cos(Pi*x)^15-487424*cos(Pi*x)^13+452608*cos(Pi*x)^11-239360*cos(Pi*x)^9+71808*cos(Pi*x)^7-11424*cos(Pi*x)^5+816*cos(Pi*x)^3-17*cos(Pi*x))*exp(-289*Pi^2*t)+(867*Pi^2+9)*cos(42*Pi*x)*exp(-1764*Pi^2*t)+65536*exp(3*t)*(cos(Pi*x)^16-(17/4)*cos(Pi*x)^14+(119/16)*cos(Pi*x)^12-(221/32)*cos(Pi*x)^10+(935/256)*cos(Pi*x)^8-(561/512)*cos(Pi*x)^6+(357/2048)*cos(Pi*x)^4-(51/4096)*cos(Pi*x)^2+17/65536)*cos(Pi*x))/(289*Pi^2+3)

    (32)

     

    And the two solutions are equal:

    simplify((u(x, t) = 3*cos(42*x*Pi)*exp(-1764*Pi^2*t)+cos(x*Pi)*(65536*cos(x*Pi)^16-278528*cos(x*Pi)^14+487424*cos(x*Pi)^12-452608*cos(x*Pi)^10+239360*cos(x*Pi)^8-71808*cos(x*Pi)^6+11424*cos(x*Pi)^4-816*cos(x*Pi)^2+17)*(exp(289*Pi^2*t+3*t)-1)*exp(-289*Pi^2*t)/(289*Pi^2+3))-(u(x, t) = ((-65536*cos(x*Pi)^17+278528*cos(x*Pi)^15-487424*cos(x*Pi)^13+452608*cos(x*Pi)^11-239360*cos(x*Pi)^9+71808*cos(x*Pi)^7-11424*cos(x*Pi)^5+816*cos(x*Pi)^3-17*cos(x*Pi))*exp(-289*Pi^2*t)+(867*Pi^2+9)*cos(42*x*Pi)*exp(-1764*Pi^2*t)+65536*exp(3*t)*(cos(x*Pi)^16-(17/4)*cos(x*Pi)^14+(119/16)*cos(x*Pi)^12-(221/32)*cos(x*Pi)^10+(935/256)*cos(x*Pi)^8-(561/512)*cos(x*Pi)^6+(357/2048)*cos(x*Pi)^4-(51/4096)*cos(x*Pi)^2+17/65536)*cos(x*Pi))/(289*Pi^2+3)))

    0 = 0

    (33)

    f := 'f'; g := 'g'

     

    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.

    pde__5 := diff(u(x, t), t)-(diff(u(x, t), x, x)) = t*cos(2001*x)
    iv__5 := (D[1](u))(0, t) = 0, (D[1](u))(Pi, t) = 0, u(x, 0) = Pi*cos(2*x)

    pdsolve([pde__5, iv__5])

    u(x, t) = (1/16032024008001)*(4004001*t+exp(-4004001*t)-1)*cos(2001*x)+Pi*cos(2*x)*exp(-4*t)

    (34)

    pdetest(%, [pde__5, iv__5])

    [0, 0, 0, 0]

    (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.

    pde__6 := diff(u(x, t), t)-(diff(u(x, t), x, x)) = exp(-t)*sin(3*x)
    iv__6 := u(0, t) = 0, u(Pi, t) = 1, u(x, 0) = phi(x)

    pdsolve([pde__6, iv__6], u(x, t))

    u(x, t) = (1/8)*(8*(Sum(2*(Int(-(-phi(x)*Pi+x)*sin(n*x), x = 0 .. Pi))*sin(n*x)*exp(-n^2*t)/Pi^2, n = 1 .. infinity))*Pi-Pi*(exp(-9*t)-exp(-t))*sin(3*x)+8*x)/Pi

    (36)

    pdetest(%, [pde__6, iv__6])

    [0, 0, 0, (-phi(x)*Pi^2+Pi*x+2*(Sum((Int(-(-phi(x)*Pi+x)*sin(n*x), x = 0 .. Pi))*sin(n*x), n = 1 .. infinity)))/Pi^2]

    (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 n = 0 .. infinity instead of n = 1 .. infinity as it should be:

    pde__7 := diff(v(x, t), t, t)-(diff(v(x, t), x, x))

    iv__7 := v(0, t) = 0, v(x, 0) = -(exp(2)*x-exp(x+1)-x+exp(1-x))/(exp(2)-1), (D[2](v))(x, 0) = 1+(exp(2)*x-exp(x+1)-x+exp(1-x))/(exp(2)-1), v(1, t) = 0

    pdsolve([pde__7, iv__7])

    v(x, t) = Sum(-2*sin(n*Pi*x)*((Pi^2*(-1)^n*n^2-Pi^2*n^2+2*(-1)^n-1)*sin(Pi*t*n)-(-1)^n*cos(Pi*t*n)*Pi*n)/(Pi^2*n^2*(Pi^2*n^2+1)), n = 1 .. infinity)

    (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:

    pde__8 := diff(u(x, t), t) = k*(diff(u(x, t), x, x))+cos(w*t)
    iv__8 := (D[1](u))(L, t) = 0, (D[1](u))(0, t) = 0, u(x, 0) = x

    `assuming`([pdsolve([pde__8, iv__8], u(x, t))], [L > 0])

    u(x, t) = piecewise(w = 0, (1/2)*L+Sum(2*L*(-1+(-1)^n)*cos(n*Pi*x/L)*exp(-k*Pi^2*n^2*t/L^2)/(n^2*Pi^2), n = 1 .. infinity)+t, (1/2)*(L*w+2*(Sum(2*L*(-1+(-1)^n)*cos(n*Pi*x/L)*exp(-k*Pi^2*n^2*t/L^2)/(n^2*Pi^2), n = 1 .. infinity))*w+2*sin(w*t))/w)

    (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:

    pde__9 := diff(f(t, x), t) = diff(f(t, x), x, x)
    iv__9 := f(t, 0) = 0, f(t, 1) = 1, f(0, x) = piecewise(x = 0, 1, 0)

    pdsolve([pde__9, iv__9])

    f(t, x) = Sum(2*(-1)^n*sin(n*Pi*x)*exp(-Pi^2*n^2*t)/(n*Pi), n = 1 .. infinity)+x

    (40)

     

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

    pde__10 := -(diff(u(x, t), t, t))-(diff(u(x, t), x, x))+u(x, t) = 2*exp(-t)*(x-(1/2)*x^2+(1/2)*t-1)

    iv__10 := u(x, 0) = x^2-2*x, u(x, 1) = u(x, 1/2)+((1/2)*x^2-x)*exp(-1)-((3/4)*x^2-(3/2)*x)*exp(-1/2), u(0, t) = 0, eval(diff(u(x, t), x), {x = 1}) = 0

    pdsolve([pde__10, iv__10], u(x, t))

    u(x, t) = -(1/2)*exp(-t)*x*(x-2)*(t-2)

    (41)

     

    References:

     

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


     

    Download What_is_New_after_Maple_2018.mw

    Katherina von Bülow

    In an attempt to explore the field of image processing, Samir and I created an application (download here) that demonstrates the removal of twot types of noises from an image through frequency and spatial filtering.

    Periodic noises and salt & pepper noises are two common types of image noises, usually caused by errors during the image capturing or data transmission process. Periodic noises result in repetitive patterns being added onto the original image, while salt & pepper noises are the irregular appearance of dark pixels in the bright area and bright pixels in the dark area of the image. In this application, we artificially generate these noises and pollute a clean picture in order to demonstrate the removal techniques.

    (Fig 1: Picture of Waterloo Office taken by Sophie Tan            Fig 2: Converted to greyscale for processing, added two noises)

    In order to remove periodic noises from the image, we apply a 2D Fourier Transform to convert the image from spatial domain to frequency domain, where periodic noises can be visually detected as separate, discrete spikes and therefore easily removed.

    (Fig 3 Frequency domain of the magnitude of the image)

    One way to remove salt and pepper noises is to apply a median filter to the image. In this application, we run a 3 by 3 kernel across the image matrix that sorts and places the median among the 9 elements as the new matrix entry, thus resulting in the whole image being median-filtered.

    Comparison of the image before and after noise removal:

    Please refer to the application for more details on the implementation of the two removal techniques.

     

    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.

    Hello, everyone! My name’s Sophie and I’m an intern at Maplesoft. Samir 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=[1]), u in cols[3..])]:

    where cols is a list of column labels and shape[1] 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[2], steps = 256, num_epochs = 3, shuffle = true):

    where we

    1. Give the training data (train_data[3..32]) and the corresponding labels (train_data[2]) 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[2], 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)[1] 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 [0] 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.

     

    Mukhametshina Liya

    Games with pseudo-fractals
     

    Homothety_Fractals.mw

     

      

      

    Aleksandrov Denis,
    7th grade
    secondary school #57 of Kazan

    _ANIMATED_PICTURE_ON_THE_COORDINATE_PLANE_Aleksandrov_D..mw

     

    We have just released a new version of MapleSim.  The MapleSim 2018 family of products offers new tools for developing digital twins, greater connectivity with other modeling tools, and expanded modeling scope. Improvements include:

    • New tools for creating motion profiles
    • FMI  import for FMI 2.0 Fixed-Step Co-Simulation
    • Optimized handling of large models
    • Inclusion of temperature effects in the MapleSim Hydraulics Library from Modelon and MapleSim Pneumatics Library from Modelon
    • Heat transfer through air and water with the MapleSim Heat Transfer Library from CYBERNET

    See What’s New in MapleSim 2018 for more information about these and other improvements.

    Who should be considered an 'expert'? How does one achieve expert status? In this guest MaplePrimes blog post, 'Understanding Maple' author Ian Thompson discusses his view of what makes an expert, his journey of becoming an expert in Maple, and the process of putting together and perfecting this resource for Maple users.

     

    In days of 8-bit computers, one would sometimes encounter individuals who knew everything about a particular device or piece of software. Single programmers wrote entire applications or games, and some could debug their work by looking directly at a core dump (a printout of the numbers stored in the computer’s memory). Some even managed to take computers beyond their specifications by exploiting design loopholes that the manufacturers hadn’t foreseen or intended. It would be fair to classify such individuals as ‘experts’.

    Fast forward twenty five years, and the picture is far less clear. The complexity of computers and software has grown to such an extent that even relatively small smartphone applications are created by teams of developers, and nobody understands every aspect of a CPU chip, much less an entire PC or tablet. Who now should be classified as an expert? One possibility is that an expert is a person who may sometimes need to look up the details of a rarely used command or feature, but who is never confused or frustrated by the behavior of the system or software in question (except where there is a bug), and never needs help from anyone, except perhaps on rare occasions from its creators.

    This rather stringent definition makes me an expert in only two areas of computing: the Fortran programming language, and the mathematical computation system Maple. An argument could be made for the typesetting system LATEX, but whilst this has a large number of expert users, there is also a much smaller group of more exalted experts, who maintain the system and develop new packages and extensions. It would be fair to say that I fall into the first category, but not the second.*

    How does one achieve expert status? Some software actively prevents this, by hiding its workings to such an extent that fully understanding its behavior is impossible. Where it is possible to gain expert status, I have experienced two very different routes, both starting during my time as a research student, when it became clear that Fortran and Maple would be useful in my work. There were several parallels. I knew a little about both, having used them for basic tasks as an undergraduate. However, working out why things went wrong and how to fix them was time-consuming and unrewarding, since it often relied on magic recipes obtained from unreliable sources, and in many cases I didn’t really understand why these worked, any more than I understood why my own attempts had not. I realized then that knowing a little was at the root of these problems. Partial knowledge, supplemented by contradictory, outdated and even downright bad advice from websites and well-meaning individuals (some of whom invariably labor under false pretences of their own expert status) is not an efficient way to approach scientific computing. In fact it’s just a recipe for frustration. In the case of Fortran, fixing this turned out to be easy, because there are lots of good books on the subject. Reading one of these eliminated all of my problems with the language at a stroke. I can’t claim that I remembered every command and its syntax, nor do I know them all now. This is hardly surprising — the Fortran Language Standard (a very terse document that sets out everything the language provides) now extends to more than 600 pages. Instead, the book provided a general picture of how things work in Fortran, and showed the right way to go about tackling a problem. This investment in time has since paid itself back hundreds of times over.

    The route to expert status in Maple was far more challenging. Its own help pages give a very comprehensive description of individual commands, but they are intended as a reference guide, and if it’s possible to become an expert using these alone, then I never discovered the correct order in which to read them. I found a number of books on Maple in the university library, but most were too basic to be useful, and others focused on particular applications. None seemed likely to give me the general picture — the feel for how things work — that would make Maple into the time-saving resource it was intended to be.

    The picture became clearer after I taught Maple to students in three different courses. Nothing encourages learning better than the necessity to teach someone else! Investigating the problems that students experienced gave me new opportunities to properly understand Maple, and eventually the few remaining gaps were filled in by the Programming Guide. This is a complex document, similar in length to the Fortran Language Standard, but with more examples. Personally I would only recommend it to readers with experience of programming language specifications. Students now started to ask how I came to know so much about Maple, and whether there was a book that would teach them the same. Since no such book existed, I decided to write one myself. As the old adage goes, if you want something doing properly, do it yourself. The project soon began to evolve as I tried to set down everything that the majority of Maple users need to know. I’ve always hated books that skirt around important but difficult topics, so where before I might have used a dirty trick to circumnavigate a problem, now I felt compelled to research exactly what was going on, and to try to explain it in a simple, concise way. When the first draft was complete, I approached Cambridge University Press (CUP). The editor arranged for reviews by four anonymous referees**, and by Maplesoft’s own programming team. This led to several major improvements. My colleague, Dr Martyn Hughes, also deserves a mention for his efforts in reading and commenting on four different drafts. Meanwhile, Maplesoft continued to release new editions of their software, and the drafts had to be revised to keep up with these. The cover was created by one of CUP’s designers, with instructions that it should not look too ‘treeish’ — one might be surprised by the number of books that have been written about Maple syrup, and it would be a shame for Understanding Maple to be mixed up with these by potential readers browsing the internet. Then there were the minor details: how wide should the pages be? What font should be used? Should disk be spelled with a ‘c’ or a ‘k’? Could quotes from other sources be used without the threat of legal action over copyright infringement? One rights holder laughably tried to charge $200 for a fragment of text from one of their books. Needless to say, no greenbacks were forthcoming.

    The resulting book is concise, with all the key concepts needed to gain an understanding of Maple, alongside numerous examples, packed into a mere 228 pages. It gives new users a solid introduction, and doesn’t avoid difficult topics. It isn’t perfect (in fact I have already started to list revisions that will be made if a second edition is published in the future) but I’ve seen very few problems that can’t be solved with the material it contains. Only time will tell if Understanding Maple will it create new experts. At the very least, I would certainly like to think it will make Maple far easier to grasp, and help new users to avoid some of the traps that caught me out many years ago.

     

    Learn more about Understanding Maple, which is published by Cambridge University Press.

    There are many questions that complain about Latex conversion in Maple.

    I'd like to again request that Maplesoft improves Latex output of its expressions. If Maple can just fix how it generates fractions, that will good enough for now.

    I am willing to send Maplesoft a personal check of the amount of one month salary for one of your developers to do this fix if you are willing to do it. It should not take more than one month to do this simple fix in your code. It might even take one day if someone knows the code.

    The problem comes when there is a fraction in the expression. the Latex output instead of using proper latex code using "\frac{}{}", it instead uses "/" which makes the output terrible.

    Another case, where Maple generate (expression)^{-1} instead of \frac{1}{expression}.

    It can't be that hard to fix these 2 issues, which can go a long way towards making the latex generated by Maple much better. Here is an example

    eq:=-(1/2)*1/y = (1/3)*x^3+z:
    sol:=solve(eq,y);

    latex(sol);
    -3/2\, \left( {x}^{3}+3\,z \right) ^{-1}

    Which renders as

    Which is terrible. The screen output is much better.

    Compare this to Mathematica

    eq = -(1/2)*(1/y) == (1/3)*x^3 + z;
    sol = y /. First@Solve[eq, y];
    TeXForm[sol]
    
       -\frac{3}{2 \left(x^3+3 z\right)}

    Which renders in Latex as

    If Maplesoft does not think Latex is improtant, then they are completely wrong. CAS support in Latex is very important. Ignoring Latex means you will lose customers who want good Latex support of the math output of Maple. After all, Math and Latex go togother. And Maple is supposed to be all about Mathematics.

    Any chance of Maplesoft taking some time to fix these issues in Latex? Maple has not had any improvement in Latex for years and years. I keep buying Maple each year, and nothing changes in its Latex export.

    thank you

    vv if you could please help adjust your code.  I've adjusted the start of the eurocup code to match the world cup however I haven't decoded your coding and probably won't be able to have time before the world cup starts.  I've got as far as adding the teams, flags and ratings of each team.

    Let me just say while copying and pasting the flag bytes to the code, Maple became a bitch to work worth (pardon my language) but I became so frustated because my laptop locked up twice.  The more I worked with Maple the slower it got, until it froze right up.  Copying and pasting large data in maple is almost to near IMPOSSIBLE.  .. perhaps this could be a side conversation.

    Here's the world cup file so far.

    2018_World_Cup.mw

    **edit added**
    Fixed flag sizes, couple of other fixes in other stats and added some additional stats
    2018_World_Cup7.mw

     

    ANIMATED image of cascade of opening matryoshkas

    E.R. Ibragimova

     

     

    ИбрагимоваЭ.Р_03_Казань_Матрёшки.mws

    Murtazin Shamil, 6th grade

    Simulation of the animated image "Flask with bubbles"

     

    FLASC_Murtazin_S.A..mw

    In as much as the embedded component suite is a brilliant tool for the custom design of online educational programs, student tests, etc, my purposes are orientated around encouraging and assisting of self directed investigation, with the utilization of the packages of maple, but in a manner that allows the user to neglect the requirement to have any knowledge of maple code itself, allowing them to focus entirely on their discipline of choice. 

    So because the content the user will enter into the interface I am designing is naturally going to be quite variant from individual to individual, one of the  necessary properties that does not exist is for the math containers to have the option of being resizeable at the discretion of the user.

    At the moment, I have added buttons that allow the user to resize the window by pressing one of four buttons entitled "increase height". "decrease height", "increase width" and "decrease height". This will suffice for my first working prototype but i just feel that it would be much neater if it were possible to resize the math component directly, and some option of the neighbouring embedded components to either shift their position accordingly, or maintain rectilinear alignment with the greater proportion of other components by all embedded components shifting accordingly when one math container is resized.

     

    I just feel that if at least one person less experienced than me reads this it will be a worth while post, because it will help them avoid things that eluded me when I was younger.


     

    The omitted function definitions are not relevant to the reason for which I decided to post about this. I would like the maple user to simply observe how many variables are involved in the relation's (R) three equalities in the consideration of the output.

     

    The reason I believe this is important, is that it is sometimes very easy to believe induction is sufficient proof of the truth value of a relation over the superset of a subset that has been enumerated, much like the example of the coefficients of the
    "105^(th) cyclotomic polynomial if one were to inductively reason statements about the coeffiecents of the previous 104 polynomials."

     

     

    A[n, k, M] = abs(C[0](n, k, M))/abs(C[1](n, k, M)); B[n, k, M] = abs(C[0](n, k, M))/abs(C[2](n, k, M)); E[n, k, M] = abs(C[1](n, k, M))/abs(C[2](n, k, M))

    R

    "`𝓃`(A[n,k,M])=`𝓃`(B[n,k,M]), `𝓃`(E[n,k,M])=`𝒹`(A[n,k,M]),`𝒹`(B[n,k,M])=`𝒹`(E[n,k,M])]"

    for t to 7 do R(t, 2, 30) end do

    [1 = 1, 1 = 1, 1 = 1]

     

    [1 = 1, 1 = 1, 1 = 1]

     

    [1 = 1, 1 = 1, 1 = 1]

     

    [1 = 1, 1 = 1, 1 = 1]

     

    [1 = 1, 1 = 1, 1 = 1]

     

    [1 = 1, 1 = 1, 1 = 1]

     

    [1 = 11^(1/2)*7^(1/2), 11^(1/2)*7^(1/2) = 1, 7 = 7]

    (1)


     

    Download INDUCTION_IS_NOT_YOUR_FREN.mw

    Up to swMATH   Maple is referenced in 4183 articles   in zbMATH   and

    up to swMATH Mathematica is referenced in 4654 articles  in zbMATH.

    These numbers are sure unexpected to me. I think the ratio of the prices of academic editions MMA/Maple (which approximately equals 2 ) truly reflects their capabilities.

    1 2 3 4 5 6 7 Last Page 1 of 260