The question wheather closures are functions or objects came to my mind when reading several proposals concerning on closures. It looks like most authors regard them as both - functions and objects but giving not a real and concrete distinction in what case a closure is a function - or functional object - and an object.

For example in Neil Gafters vision for closures, closures seem to be both functions or an anonymous function or method and objects - or even classes beecause its possible to extend a class or template from a closure.

I think, if we follow the traditional closure syntax and usage - like in lisp or Perl where closures are regarded as procedures or sub routines. I have difficulties to imagíne a case where it makes sense or its practical to have the ability to extend a template or class from a closure as follows:

class MyClass
extends 
{ int x, int y => int }

or any such nomenclature. If a closure is nothing more than an anonymous function why do we need extend them to real object types? Is it just enough to have a short hand for anonymous methods in which the BGGA Syntax would just be enough?

I even have diffiuclty to see what a class or object like:

{int x, int y => int }

in the above example would describe or what power closures provide to describe real world entitities. To me closures are to abstract to describe real world entities i would only allow them as a short hand for anonymous functions or methods as used in Lisp or Perl.

Also it would make sense to allow closures as parameters for normal methods i.g:

int myClosureMethod(int x, {int y, int z = > int }){
 //something
}

but dont apply them on classes or templates because templates are already a very powerful feature to describe real world entities.

The next release of LinAlg API will provide methods to compute Eigenvalues and the triple scalar product.

Eigenvalues and the triple scalar product are common and helpful mathematical features that are useful for solving a lot of common math problems.

The Eigenvalues are computed by solving the linear equation det(A-lambda*In) where A is a Matrix, lambda a free parameter and In the identity matrix. We can simplify this by simply determening the det(a) of the Matrix with a parameter and omitting the multplication with the identity matrix since a value multplied by 1 results in the same value.

And the multiplication by the identity matrix just means: multiply all diagonal components of the matrix by 1 that is m11, m22, m33 and m44 if you have a 4x4 matrix.

In my last Blog i did make some suggestions to get rid of the redundand => syntax of closures. I suggested to use := and to invent a keyword i.g. block or function to highlight the fact that closures are functional objects - basicall Neil Gafter regards them as equivalent to anonymous methods however i think there is no strict distinction in Gafters proposal wheather a closure is a pure function or an object

According to Neil Gafter, a closure object needs to be invoked by calling the invoke() method for a particular closure. The invoke method can have parameters i.g.:

{ int x => x + 1 } //closure definition
{ int x = > x + 1 }invoke(10); //call closure with 10 as parameter

So if a closure is a function in this case - besides the fact that its also an object - a closure object - then i think it would make sense to declare this whole block of statemens as a function:

function { int x => x+ 1}(int);

In my last Blog i said that the => symbol is redundant and suggested to use := as a variation of =. With this variation the closure would be written as:

function{
 int x := x+ 1;
}(int);
//call closure with 10 as argument
function{ int x:=x+1 }(10);

This syntax could also be used to simply define getters that return values:

function {int x:=10;}(); //always returns 10

int s = function sum{int x, int y := x+y }(3, 5); //call sum with 3 and 5 as parameters

Local variables

function{
int j = 0;
int i=3;
 switch(i){
   //some switch statements
  case 1: j++;
  case 2: j--;
  }
}();

Thus using a function keyword makes clear that a closure is both a function and an object that can be invoked. The invocation is executed by adding the () parantheses to the statement.

Basically, when i read all the proposals, comments and pros and cons on closures in Java the first thing i would get rid of is the obviously redundant => declaration.

So in case of block statements the following would be allowed:

{
 int x = 0;
 int y = 3;
 int sum:= x+ y;
}

As i understood it right, => has at least two meanings. It means return for functions and := or = in the other case.

Replace => by := for assignments

I would use := for assignments rather than => simply because := is more naturial to mathematicians and logicians and is usually used to describe an assignment in math and logics. This could be used as outlined above:

{
 int x = 4;
 int y = 3;
 int z = 3;
 int sum:=x+y+z; //assignment
}

Use a function keyword instead of {int, int => int} syntax

For the function declaration, i would suggest to use a keyword rather than a symbol. Why not invent a function keyword that has a similar meaning like => i.g.:

public int function add(int x, int y){
return x + y;
}

In the other case, i would use := instad of => because the arrow direction implies to read it left to right rather than right to left and there is no <= to represant the invert direction.

Use a block keyword to declare block statements

Rather than just simply type closures i would invent a block keyword that defines a block of anonymous statements:

//only valid for anonymous block statements, not be used in loops 
//itereations

block{
 int x = 3;
 int y = 4;

}

So with these language features you could write a simple to read Java code that is clear and understandable by everyone:

class MyClass{
 //declare a function type
 public int function add(int x, int y){
    return x + y;
 }
 public int function sub(int x, int y){
  return x - y;
 }
 public void function(List intList){
    for(int i = 0; i < 10; i++){
        intList.add(i);
     }
  }
 public static void main(String[] args){
   
  //declare a closures block
   block{
     int x = 4;
     int y = 3;
    System.out.println("x + y" + (x+y));
    }
  }
 }

}

There is a first source files upload avaiable for LinAlg API in CVS trunk. To check out the sources simply use your favorite CVS access programm and type the following commands:

cvs -d :pserver:username@cvs.dev.java.net:/cvs login
:pserver:username@cvs.dev.java.net:/cvs checkout linalg

If you are using NetBeans you just need to configure the CVSRoot path and the set the checkout options. There seems to be a problem with NetBeans CVS under Windows but if you have a Linux CVS client that should work well.

We will provide further CVS sources for different OS and Java platforms in the future. So far you need to become a member of LinAlg API project and download the sources and .jar files from the document/files section.

The twentieth member has joined the LinAlg API community. Members background ranges from computer sciences and software engineers with up to 5 years of experience in Java programming and with industry background.

In particular in the last two month many people joined LinAlg API and asked for help in developing or porting LinAlg API to other platforms.

Thats a great news and i hope and will look forward to get more fellows that want to contribute and help improving LinAlg API. We are on a good way.

In my last Blog i said that LinAlg API is finished. This is still true yet i did add some more features to it and revealed two new ports for mobile and 64 bit platforms as a special christmas release :).

Features

With this release LinAlg API now offers core features for the following mathematical types and a bit more:

• 2D and 3D Vectors
• Matrices
• complex numbers
• Quaternions
• Algorithms
• Geomtools

To download release 2.0 of LinAlg API go to the LinAlg API project page at linalg.dev.java.net.

Thanks to the contributors

This 2.0 release of LinAlg API would not have been possible without the help of the many contributors that joined LinAlg API and helped testing it or porting it to other systems. Special thanks goes to Morton Gulbrandtsen - working on a Solaris and Debian port -, David Clavel and Steven Martin who first joind LinAlg API and gave a good feedback.

Merry Christmas and a Happy new Year...

... to the Java community and the rest of the world from the LinAlg API team.

Yes. Finally, i got it done. LinAlg API now offers all the things i wanted to see it have. Sure, there are some things to do here and there but basically all features from my todo list are now implemented and exist at an almost complete level. The Quaternion class needs to be finished yet this is something i will do in the next couple of weeks however the Quaternion class already provides some basic operations for Quaternions you can work with with.

LinAlg API: Scope and Features

From the very beginning i wanted to write an almost complete linear algebra API that offers basic features to do linear algebra with Java. Now, lets have a short look at what features LinAlg API provides with this stable release:

• 2D and 3D Vector arithmetics
• Matrix operations - both array based and non array-based
• Complex Number operations
• Quaternions - still something on the todo list
• Algorithms - yes, there is a general Gaussian algorithm now
• Demos, Docs, Tutorials

Sure, there are some things you wont find in LinAlg API that some people may find useful yet the Todo list has not been closed :). Another important thing - that has nothing todo with its implementation - is the growing number of interesting people and developers that join the project. Some of them give feedback others not but its a good feeling to see that there are people that like the project and want to help make it better.

Sure, i am still looking for volunteers, testers and developers to test and help improve LinAlg API so if you are interested feel free to joint the project.

Demos, Docs, Tutorials

There are a few demos available that demonstrate the core features of LinAlg API, a tutorial for beginners and a whitepaper for those interested in background information. I will start writing a JCP for those interested in using LinAlg API for their own implementations. Basically using LinAlg API is rather simple - no matter if you use it for developing apps or to develop your own linear algebra API. I will provide more tutorials and information on implementation issues in the near future.

Since the beginning of OpenJDK i followed the discussion about the mercurial move. Since the main job of porting over the sources from subversion CVS to Mercurial - that is the Mercurial transition - is done i wanted to test Mercurial myself at home.

As a Windows user i was looking for a Windows download and found one at the Mercurial download page. Having installed Mercurial on my machine i did run the hg test command and got a list of help commands for the other mercurial commands.

After experimenting with other commands i found that for each command it is required to add the hg command which i find a bit of "repeat yourself." and thought i got myself writing a few batch files to do the job.

Having a few batch files to create and update repositories i found that having a GUI application for Mercurial that displays the repositories and their files would be even better. I am not aware about how good Java would do the job here but i think it should be possible to have an application that goes over all files in the directories of the repositories and shows the files connected to them.

LinALg API now provides 4D Math operations using Quaternions. For those that are not familiar with Quaternions i will provide a short introduction.

What are Quaternions?

A Quaternion is a 4 dimensional number consisting of a real part and three imaginary parts thus a Quaternion can be written as:

xo + x1 * i + x2 * j + x3 * k;

In this case, the constants i, j and k and their factors represent the imaginary part of a Quaternion. If you are familiar with complex numbers you now that the square root of i^2 = -1. This equation is also valid for the three other imaginary parts of quaternion that is i^2 = j^2 = k^2 = -1. There are some other rules that apply to the imaginary parts of Quaternions i.g. i * j = k and j * i = -k yet these are not important for this Blog but for the understanding of Quaternion theory.

Basic operations

As with complex numbers there are basic operations for +,-*,/, complex conjugate and scalar multiplication for Quaternions. Again, as with complex numbers or Vectors, the sum, difference and product of Quaternions are per component operations that is you add or subtract over each component of a Quaternion.

When are Quaternions useful?

Quaternions are used in 3D Math to describe a rotation of an object in 3D space using a simple scalar and a 3D Vector so a Quaternion can be written as follows: [s, v] where s is a normal scalar and v is a Vector with components x,y,z.

You can do the same using matrices to describe a rotation or translation but with Quaternions you need less memory for the operations so Quaternions are used to safe memory and gain speed.

A Java Implementation for Quaternions

A Java Implementation for Quaternions should represent the fact that a Quaternion is a 4D space number with four elements - that is the scalar and the three imaginary parts - and provide basic operations on Quaternions. So a basic Java Quaternion type might look like this:

public class Quaternion{

 private double s, x, y, z; //scalar, x, y and z coordinates

 public Quaternion(double s, double x, double y, double z){
    //basic construction
   }
 //creates an identity quaternion with s = 1
 public Quaternion identity(){
    this.s = 1;
    this.x = 0;
    this.y = 0;
    this.z = 0;
 }
 public Quaternion add(Quaternion q){};
 public Quaternion sub(Quaternion q){};
 public Quaternion mul(Quaternion q){};
 public Quaternion conjugate(){};
}

The Quaternion used in LinAlg API already provides basic methods for +, conjugation, -, negation and construction. Whats missing is * and the possibility to create Quaternions from Euler angles and to create a rotation matrix for Quaternions.

In one of my last Blogs i have already announced that there is a mobile port of the LinAlg API available. I also plan to port my statistics API to 64 Bit and mobile platforms.

This includes also porting demo apps and samples to these platforms. I dont know how many such APIs are available in the mobile world though i think there are not that much out there and also i believe that having such APIs or applications for the mobile world would be great.

I have started adding some graphics tools to LinAlg API using Java2D. As a result i have a simple 2D coordinate system that is scalable and can be customized to your personal needs.

I would love to show a picture of it if i knew how to load images to this Blog - may be someone can help me here. The graphics tools basically consists of a few methods that enable you display coordinate systems and Vectors in 2D graphics and to scale these coordinate systems by any unit you like. This feature is not yet implemented but its easy to do it. Just need to provide further methods with corresponding parameters.

A new statisitcs API

Another thing i am currently planning to work on is a new statistics API with some demo apps providing common statistic algorithms like mean, standard deviation,binomial and faculty algorithms, statistic distributions etc. To distinguish myself from other libraries i will also provide graphics tools for this API to display statistic data or to animate certain distributions like the poisson distribution.

A simple tutorial on how to use LinAlg API and its various classes can be found in the documents/file section at linalg.dev.java.net.

This is a simple tutorial that convers the basics and does not show all capabilities of LinAlg API.

When i started developing LinAlg API it was just personal interest and a sort of experiment. Is it possible to write a simple-to-use API for Vector and Matrix operations? Well, the answer seems to be: Yes. Then, i decided to add Complex number functionality and to keep scope of LinAlg API features to a minimum. There are of course other such APIs for vector and matrix calculus yet i had my very own idea how to implement such an API. I wanted to make it easy-to-use and comfortable. Thats why it is implemented as it is.

The way to java.net

As development moved on i decided to host it on java.net in order to find fellow developers to join this project. It took a bit of Blogging to gain some interest and now i have fellow developers all over the world from the USA over China to India. One thing thats a bit hard is to get information about project members once they joined the project and to keep track of development of these developrs. Until you have setup some sort of mailing list or a developer forum it seems to be impossible to keep uptodate with the development of other people. So here is a proposal for java.net to add a feature for this to share information on users contact information and background - because sometimes its interesting to have an idea of the people you are working with.

Moving on

Now, since Linalg has made its way over the world its time to move on. I have added a few ports to 64 Bit systems and other Java platforms like the wireless API. I am still looking for interested developers that could porting LinAlg API to other 64 Bit systems and to the mobile platform. The End.

To begin with my thesis i would like to provide a definition of opensoucre software since some people might have a different concept of it. Under OpenSource software i understand any software that is either released under the GPL and / or GPL equivalent license.

According to this definition most projects at this page and most of the Apache projects are opensource software.

I am not aware about how many Java opensoucre projects exist - i do develop one of my own at linalg.dev.java.net - but i think its not a small number compared to non opensoucre projects.

Thesis: OpenSource software is low-quality

A common opinion of many people is or seems to be that opensource software - as understood above - is bad or not you get what you pay for. I dont know how many of these people develop web applications but in the Java web domain there are many good or even great opensource libraries available that are easy to use and provide good productivity.

Also - if you visit some of the websites of apache projects - you will discover that opensource developers do care about information on releases, milestones, updates, bugs etc. Sometims it seems that people stating the opposite did never use a good opensource software. Sure there ís opensource software that does not provide these information but you can say the same for many high price software products.

I think most people stating this thesis have used some sort of GNU software - i dont say GNU software is bad - but using GNU software can really be a silly adventure. Yet i do believe that most opensource developers do have an idea of professional software development and since there is a growing competition among opensource software open source software developers too have to distinguish themselves from other products. So you wont "sell" your opensource software until you care about your customers needs and provide a little bit of basic information etc. that make possible users convince your product will help them in their daily work.

Anti-thesis: High price software is good

Now lets get back to the antithesis which runs: "High-Price software is good". Ok. How many people use Microsoft software and how many people would sign the thesis that all Microsoft software is worth the price paying for it? On the other hand. Compare the price of a Mac and what you get for it - oh ok, dont get me on the current Mac / Java story - but basically consider all the features and software you get for the price of a Mac - compared to MS Windows and their tools. Excellent.

And how many people would say that Microsoft user support is great! So, personally, i think that today it does not matter if a product is opensource software or not. The quality of a software does not necesseraliy depend on its license but it does mor and more depend on the people who develop it and on how they treat their users / customers needs.