HI there, I have a quick question and I just want to confirm what I found. I was trying to do some Fourier Transform using the MTM package and I was successful in doing so for one dimensional problems when it's only f(x) but when I tried to do something more complicate like 2D fourier transform when the f is a function of x and y ie. f(x,y), Maple seems not able to do it. I checked with help menu and it seems it can support only 1D. is there anything other package that I'm not aware of that is capable of a such thing?

In my previous post, I tried to convince you that going parallel is necessary for high performance applications. In this post, I am going to show what makes parallel programming different, and why that makes it harder.

Here are some definitions used in this post:

• process: the operating system level representation of a running executable. Each process has memory that is protected from other processes.
• thread: within a single process each thread represents an independent, concurrent path of execution. Threads within a process share memory.

We think of a function as a series of discrete steps. Lets say a function f, is composed of steps f1, f2, f3... e.g.

I started six month ago with what I though at the time to be a simple question.

Why is the mean in the Black and Scholes model assumed to be (mu-(1/2)*sigma^2)*T ?

I had seen numerous attempts of deriving such an relationship on the Internet but every solution that I found always had some flaw in the step-by-step mathematical logic which meant that the solution was rendered useless.

A few years ago I wrote a tool, mgrep, for searching Maple repositories;  download mgrep.zip. The zip file includes the noweb source (mgrep.nw), however, it is missing some of the files needed to rebuild the documentation—I will add them later when I bring an old drive back online.  You should not, however, need to rebuild the documentation (mgrep.pdf) because it is included along with the shell-script (mgrep) and gawk file (mgrep.awk).  To use the tool you will need to install mgrep and mgrep.awk in a directory in your path.  The --help option prints a brief help page.

Here I use mgrep to partially explore a question that  acer poses, that, whether % may be usefully employed in a Maple procedure. A reasonable start is to see whether it is so used in the distributed Maple library.  First I go to the lib subdirectory of the Maple installation, then call mgrep to search maple.mla for all procedures that use % as a name

Computers with multiple processors have been around for a long time and people have been studying parallel programming techniques for just as along. However only in the last few years have multi-core processors and parallel programming become truly mainstream. What changed?

Here are some definitions for terms used in this post:

• core: the part of a processor responsible for executing a single series of instructions at a time.
• processor: the physical chip that plugs into a motherboard. A computer can have multiple processors, and each processor can have multiple cores
• process: a running instance of a program. A process's memory is usually protected from access by other processes.
• thread: a running instance of a process's code. A single process can have multiple threads, and multiple threads can be executing at the same on multiple cores
• parallel: the ability to utilize more than one processor at a time to solve problems more quickly, usually by being multi-threaded.

For years, processors designers had been able to increase the performance of processors by increasing their clock speeds. However a few years ago they ran into a few serious problems. RAM access speeds were not able to keep up with the increased speed of processors, causing processors to waste clock cycles waiting for data. The speed at which electrons can flow through wires is limited, leading to delays within the chip itself. Finally, increasing a processor's clock speed also increases its power requirements. Increased power requirements leads to the processor generating more heat (which is why overclockers come up with such ridiculous cooling solutions). All of these issues meant that is was getting harder and harder to continue to increase clock speeds.  The designers realized that instead of increasing the core's clock speed, they could keep the clock speed fairly constant, but put more cores on the chip. Thus was born the multi-core revolution.

My name is Darin Ohashi and I am a senior kernel developer at Maplesoft. For the last few years I have been focused on developing tools to enable parallel programming in Maple. My background is in Mathematics and Computer Science, with a focus on algorithm and data structure design and analysis. Much of my experience with parallel programming has been acquired while working at Maplesoft, and it has been a very interesting ride.

In Maple 13 we added the Task Programming Model, a high level parallel programming system. With the addition of this feature, and a few significant kernel optimizations, useful parallel programs can now be written in Maple. Although there are still limitations and lots more work to be done on our side, adventurous users may want to try writing parallel code for themselves.

To encourage those users, and to help make information about parallel programming more available, I have decided to write a series of blog posts here at Maple Primes. My hope is that I can help explain parallel programming in general terms, with a focus on the tools available in Maple 13. Along the way I may post links to sites, articles and blogs that discuss parallel programming issues, as well as related topics, such as GPU programming (CUDA, OpenCL, etc).

My next post, the first real one, I am going to explain why parallel programming has suddenly become such an important topic.

Not all objects can be saved to .m and retrieved sucessfully in a restarted or new session. This is the case not only for "escaped" locals, but also for some objects implemented as function calls of a module member.

> restart:

> t := ScientificConstants:-Constant('c'):

> type(t, specfunc(anything,ScientificConstants:-Constant));
                                     true
 
> ScientificConstants:-GetValue(t...

I've been using a combination of Fortran and gnuplots to do my plots. my research required an intensive amount of data plotting. I've been trying to use maple to do scatterplots and curve fitting for my data. here is the code: > K := readdata("/Users/xxx/Work/dt40s5l10.110/ALL/dt40s5l10.110.1.DFIR.AVE", 8) # the file contains 2972 lines and 8 columns of data > unassign('G', 'X'); > seq(assign(G[i], (K[i+1, 5]-K[i, 5])/(K[i+1, 1]-K[i, 1])), i = 1 .. 2970); # to calculate the derivative > seq(assign(X[i], K[i, 1]), i = 1 .. 2970); when I tried to plot X vs G using scatterplots

Good morning!

I am currently involved (though hopefully near the end) in a lengthy discusion regarding how to use the mapleprimes editor. I should say up front that I am grateful for any forum that provides me a place to ask questions and to help others. I've been around for a few years, but only lately have I decided to put substantial effort into learning Maple. And it is a substantial effort, despite the Maple ads about how easy Maple is to use.

I was just reminded of an aspect of Maple GUI Components, new to Maple 13, that has sometimes come in very useful to me. It is the ability to refresh a component programatically.

I should explain. The old (and current default) behaviour is for the GUI not to refresh any other components until the current component is finished (ie. returns control).

The relevant situation in which this matters is when a given component has action code whose

Try to typeset

normal(1/((omega^Omega/a-1/2)[a,sqrt(2)][1/2]-(zeta+iota)[-y][-1,1]+(xi+Xi)[alpha[1/2]]));

in your favourite version of Maple. What's the "best" way to typeset this in LaTeX so that it looks 'best'? The renderer here on primes gives:-1/(-(omega^Omega/a-1/2)[a,2^(1/2)][1/2]+(zeta+iota)[-y][-1,1]-(xi+Xi)[alpha[1/2]])

It's fairly ugly, but at least the baseline alignments seem to be ok, even though the fonts are way too small (and fuzzy too).

Is there a convenient way to express a 2nd or higher derivative, say in an eval statement, so that it is not confused with an expression containing an exponent?

I recently ran into an interesting twist on the infamous Maple anti-pattern:

# A very garbagey way to build a list
l := [];
for i from 1 to 10000 by 100 do
    l := [op(l), isqrt(abs(floor((5000-i)/2)))];
end do;

A lot of users fall prey to this method of building a list rather than using :

# generate a list without extraneous garbage
l := [seq(isqrt(abs(floor((5000-i)/2))),i=1..10000,100)];

We are pleased to announce that we have just released new versions of Maple and MapleSim!

Here are some highlights from the new releases:

Maple 13 includes completely new 3D plot facilities, which are faster and use less memory. Another nice benefit is you can now annotate 3-D plots just like you do 2-D plots, including proper math notation in titles and labels, tickmarks in multiples of pi, and arrows. You can also create fly-through animations, which zoom a virtual camera around your 3-D plots. We’ve put a few examples on our website…take a look.
 
Writing multithreaded applications is now a whole lot easier using a new task-based programming model. You no longer have to worry about synchronization tools – Maple handles that part.  For example, here’s an interactive Mandelbrot application that uses the task-based model to automatically distributes the calculations to all available processors.

And the in small-but-useful category, Maple 13 now includes an Export to PDF option.

For more information on these and many other features, see What’s New in Maple 13.

MapleSim 2 includes a really cool new 3D animation feature for multibody systems. You just define the model, and when you run the simulation, MapleSim automatically creates an animated version of your model so you can really see what is going on.  You can even attach your own STL shape files, so the animations look more realistic…take a look for yourselves!

MapleSim 2 also includes a results manager that lets you keep track of the results of different simulation runs. Previous results can be viewed without having to re-execute the simulation, and are accessible from one session to the next.

For details, see What’s New in MapleSim 2.

Click here to read the full press release.
Click here to see what Maplesoft President & CEO Jim Cooper had to say.
 

On some Linux distributions, the default font (Lucida Bright at size 12) for text mode in Maple's Standard GUI doesn't look as good as it might at the default magnification.

Here's a screenshot of Maple 12 and some text in a worksheet (on my very old Fedora Core 2).

Notice how some letters look odd. The "i" and "s" are mismatched, as are the "u" and "c", etc. The screenshot may not do full justice to its ugliness. That is with Maple's option for font antialiasing enabled (though it wasn't improved by disabling the antialiasing -- those letters' sizes were still mismatched).

This is with Lucida Bright, which as I gather is the "recommended" font for a Java application that is intended as cross-platform. That is used at size 12 as Maple's default style for text mode (on Linux).

So I installed the "Microsoft TrueType core fonts", by following the instructions here.

My old Linux FC2 X server can handle TrueType fonts, as I believe  most  modern  Linux distributions can.

Now I get the following look, first with and then without font antialiasing enabled. It is much improved.

I don't know how the default appearance on other, more modern Linux distributions looks. Perhaps the Lucida Bright 12pt font appears more pleasing on new distributions using the stock fonts. Feedback is welcome.