It seems as if that they shouldn't be used as user defined binary operations then.

That contradicts to 2 of my usual suggestions - use & for binary operations and don't use indexed function names :)

I guess that a lot of my code with &* and &^ is broken in Maple 12 (or did it happen earlier?) - what about backward compatibility?

Alec

surd is a replacement for ^(1/5), so get rid of that. Use h in the form I wrote it.

Alec

surd is a replacement for ^(1/5), so get rid of that. Use h in the form I wrote it.

Alec

A great explanation!

The thing that puzzled me, was that it seemed to be specifically * problem - seems to be OK with + and . .

Just checked few more combinations.  - and / seem to be OK, but &^ has the same problem as &*.

Alec

The first definition has erroneous backticks. It should be

`&*` := proc () -> G:-output(G:-`*`(map(G:-input, [args])[]));

The second one should work. The error message says that G is not a module - that means that it hasn't been assigned to GF(2,8). It should be assigned for that to work,

G := GF(2, 8);

Also, it can be written more simple as

inverse:=G:-output@G:-inverse@G:-input;

Alec

The first definition has erroneous backticks. It should be

`&*` := proc () -> G:-output(G:-`*`(map(G:-input, [args])[]));

The second one should work. The error message says that G is not a module - that means that it hasn't been assigned to GF(2,8). It should be assigned for that to work,

G := GF(2, 8);

Also, it can be written more simple as

inverse:=G:-output@G:-inverse@G:-input;

Alec

The proper way would be using G:-output,

decAdd := (a, b)-> G:-output(G:-`+`(G:-input(a), G:-input(b)));

Actually, I would write it in a different form, something like

`&+`:=()->G:-output(G:-`+`(map(G:-input,[args])[])):

Then you could use it as, for example,

3 &+ 5 &+ 7;
                                  1

as well as

`&+`(3,5,7);
                                  1

Alec

The proper way would be using G:-output,

decAdd := (a, b)-> G:-output(G:-`+`(G:-input(a), G:-input(b)));

Actually, I would write it in a different form, something like

`&+`:=()->G:-output(G:-`+`(map(G:-input,[args])[])):

Then you could use it as, for example,

3 &+ 5 &+ 7;
                                  1

as well as

`&+`(3,5,7);
                                  1

Alec

Just ask any lawyer - obviously, you are not one.

If it is for self education - read UCITA, for example.

The first precedent (won by a customer) was in 1961.

Alec

Roman,

as far as I understand, it is just a part of usual anti-Microsoft FUD propaganda. There are many people that hate Windows. Some others play with MSFT stocks - are trying to make them low so that they could buy more of them etc.

In reality - Vista is pretty good, I use it, and XP wouldn't even, probably run on my hardware and it was not designed for multiple cores.

Since I use Windows Vista and don't use Maple - they are two completely different things to me having nothing in common. Personally, I didn't see any bugs in Windows Vista. I am not saying that they don't exist - just it is not that easy to find them. I couldn't.

In Maple, it is hard to find something that is not buggy. Again - I am not saying that bug-free parts of Maple don't exist - just it is not that easy to find them. Again, I couldn't.

About building from scratch - there are many features in Vista which didn't exist in any previous version of Windows. They were built from scratch. Some other parts, such as networking, printing, Windows shell etc. existed - but in a very different form. As far as I can tell - they originally (well - in 2004) started from the Windows server 2003 codebase, but then were significantly rewritten.

Alec

PS Roman, I am moving my blog posts from here to the wiki, in particular, the Eratosthenes Sieve. At the end, I added a thank you note for you and StephenForrest. Your suggestion about making array indexes a single variable instead of an expression, was very helpful. -Alec

Most math applications, unfortunately, are written for Linux or Mac and don't run very well in Windows.

There are some using .NET though - Group Explorer, for example. There is a Python implementation for .NET - IronPython . VSLab is interesting. Just found a link to math projects on CodePlex .

It would, certainly, make a lot of sense for everything written in Java, be written for .NET Framework instead. It is as easy to write as in Java, but looks nice and works nice.

OpenMaple can, probably, be used from .Net applications through C++, but I personally didn't try that.

Alec

I agree with the programmers in the comments - the article's author, obviosly, does not exactly understand the situation - we write for .NET - not for a particular platform. It can be run everywhere where .NET framework is available - in XP, Vista, Linux, or Mac.

For native code - also, the difference is not between Vista and XP - it is much more between 32-bit and 64-bit, using SSE3 or not, multiple cores - hardware issues, not software.

It is hard even to understand what he meant by "writing for Vista" - if he meant writing applications that will run on Vista, but won't run on XP - of course there are not that many people wanting to do that. Most people are trying to write software so that it will run both in XP and Vista.

Alec

As far as I understand, Alias - without copying, Reshape - with copying (or, more precisely, creating a new Array.)

The only problem with Alias is that it works not for all Matrices, but only for those with a rectangular storage, so in other cases an additional operation is needed, converting a Matrix to a Matrix with a rectangular storage.

Reshape produces an Array with a rectangular storage, and works for Arrays not necessarily with a rectangular storage, converting them first to Arrays with rectangular storage, if necessary.

Alec

As far as I understand, Alias - without copying, Reshape - with copying (or, more precisely, creating a new Array.)

The only problem with Alias is that it works not for all Matrices, but only for those with a rectangular storage, so in other cases an additional operation is needed, converting a Matrix to a Matrix with a rectangular storage.

Reshape produces an Array with a rectangular storage, and works for Arrays not necessarily with a rectangular storage, converting them first to Arrays with rectangular storage, if necessary.

Alec

KroneckerProduct is in LinearAlgebra package, and also you could search this site for it.

Various forms of vec are presented in Dave Linder's post above.

For vech, one can use something like <seq(seq(A[i,j], i=1..j),j=1..n)> where n is the number of columns of A (assuming that A is square).

Alec