The easiest way to debug Fortran and Basic is to put in many little print statements, and then to take them out when they are no longer needed. In Java™, System.out.println statements are far from little. The quick way to solve the problem is by building a macro-expanding preprocessor. I took advantage of the split method of Java 1.4 and later and the deepToString method of Java 1.5 and later to write something very short. I needed a name for my work, so I looked in Google and did not find PrintMacroJ anywhere, so that is the name that I use.

Having written a preprocessor, I added a few more macros for other things besides printing. I put in a macro to help with regular expressions, a macro to delete underscores in numerical fields as in Ruby, a swap macro, a macro for milliseconds, a few macros to make methods look more like functions, and some macros for overloading operators.

I respectfully invite everybody to add new macros to PrintMacroJ by merely adding new else if paragraphs to the manage method of the Print class. It is the only class in the Print.java file. Please note that the Print.manage method is called from three files: Print.java, AllPri2Java.pri, and Update.pri .
To top

The print macro

print   eye   x

Java 5 and later makes it easy to build such a thing oneself. I have written a macro-expander, whose source file is Print.java, having a macro named print to make use of the java.util.Arrays.deepToString static method. That is, the print macro writes a call to that method into the output file.

PrintMacroJ contains other macros besides print. The macro-expander splits each line of the input file on blanks and tabs into tokens having no white-space in them. If the left-most token of the line is recognized as the name of a macro, that macro is used. Otherwise, the line is passed through unchanged.
To top

An example

This file is expanded to a file named CheckSort.java which can then be compiled by javac and executed by java. The reader who looks at CheckSort.java will notice how monstrous and unreadable the print macros have grown.

Here is what the program printed when it was run:

eye, 0, x, [0.29298615, 0.72581846, 0.06552495, 0.20124246]
eye, 0, x, [0.06552495, 0.20124246, 0.29298615, 0.72581846]

eye, 1, x, [0.17495424, 0.23389111, 0.96421194, 0.59524924]
eye, 1, x, [0.17495424, 0.23389111, 0.59524924, 0.96421194]

eye, 2, x, [0.6218451, 0.81528014, 0.9022297, 0.20639604]
eye, 2, x, [0.20639604, 0.6218451, 0.81528014, 0.9022297]

eye, 3, x, [0.06735267, 0.06981697, 0.3623766, 0.65278155]
eye, 3, x, [0.06735267, 0.06981697, 0.3623766, 0.65278155]

eye, 4, x, [0.4803864, 0.9918647, 0.97115314, 0.78323096]
eye, 4, x, [0.4803864, 0.78323096, 0.97115314, 0.9918647]

eye, 5, x, [0.40152532, 0.057389356, 0.98135525, 0.7244261]
eye, 5, x, [0.057389356, 0.40152532, 0.7244261, 0.98135525]

eye, 6, x, [0.9820171, 0.0944072, 0.45101392, 0.6934208]
eye, 6, x, [0.0944072, 0.45101392, 0.6934208, 0.9820171]

All these quoted and unquoted arguments are connected with commas between them. Then curly braces are put on the left and right. Then this formula is used to initialize a new Object[]. Then this Object[] is handed to the deepToString method, as I have said. Then the resulting left-most and right-most square brackets are removed by a regular expression. Then System.out.println is used to actually do the printing. Another look at CheckSort.java may make this clearer.

The CheckSort.pri and CheckSort.java files have exactly the same number of lines, because Print.java always outputs exactly one line for every line it inputs. This is necessary for understanding javac’s diagnostics.
To top

How I wrote and ran CheckSort

set left=CheckSort

pri

I have in June 2007 changed the pri.bat file to use the -server modifier on the last line. This is meant to increase run-time speed, but sometimes it makes the program go slower.
To top

Putting javac into the path

findJavac

C:\Program Files\Java\jdk1.6.0\bin\javac.exe
C:\Program Files\Java\jdk1.7.0\bin\javac.exe

findJavac > path6.bat

C:\Program Files\Java\jdk1.6.0\bin\javac.exe
C:\Program Files\Java\jdk1.7.0\bin\javac.exe

"C:\Program Files\Java\jdk1.6.0\bin\"

set path="C:\Program Files\Java\jdk1.6.0\bin\";%path%

path6

path6

Also, deepToString is not found on Javas earlier than Java 5.
To top

The pri and pr and prin macros

pri   eye   x

To print the values without the commas, use instead

pr   eye   x

To print the names eye and x but no values or commas, use instead

prin   eye   x

deleteUnderscores long n=4_687_968_574_463_210_974L;

long n=4687968574463210974L;

doubleBackslashes String yearPattern="\d\d\d\d";

String yearPattern="\\d\\d\\d\\d";

milliseconds   a

long a=System.currentTimeMillis();

swap   a   b  temporary

{ temporary=a; a=b; b=temporary; }

For example, consider the file Midpoint.pri. It contains a method called midpoint for doing numerical approximations to definite integrals. The midpoint method returns a double. Its parameters are an Integrand called i, a double called a, another double called b, and an int called n. The doubles and ints are familiar. Integrand is an inner interface of the Midpoint class. The Integrand interface contains a double method called f, which has a double parameter called x. The Integrand interface is constructed by the myInterface macro:

myInterface   Integrand   double f(double x)

An example of using the Integrand interface is the line

function   Integrand   multsin   return mult*sin(x);

The function call is all on one line. Some method bodies take up too much space for one line, so there are two other macros to work them. They are beginFunction and endFunction. In the Midpoint.pri file they go around the fibonacci’s body. The beginFunction macro has only two arguments: the name of the abstract class to be extended, and the name of the variable to hold the object. The endFunction macro has no arguments.
To top

The stack

yourInterface  Midpoint.Integrand   double f(double x)

function   Midpoint.Integrand   sinc   return Math.sin(x)/x;

myInterface   Real2Real   double f(double x)

Imagine that two different programmers were assigned to write different methods. The first programmer was to write a method to approximate the maximum of a function defined on a rectangle by picking points at random and taking maximum. The second programmer was to write a method to approximate the minimum of a function defined on a rectangle by picking points at random and taking minimum. In the real world, they would write different files and e-mail them in. However, to spare the reader’s nerves, I have put all their work in the same file. Also I have put in that same file a main method to call both methods. The file is called Max2.pri.

The reader sees at once that each programmer used a different interface, but the two interfaces have the same signature. (The signature to use was told to the programmers before they started.) That means that it is possible to implement both interfaces at the same time. We do this on each beginFunction and function line by putting the names of both interfaces in the same token with a comma between the names. The result of expansion of the macros is of course in the file Max2.java.

The reason that this works is that the functions were used only as parameters to the methods, but the methods did not return functions. The Java compiler will always catch a blunder of this kind, so the programmer need not worry about it. Just program what is desired, and if it is not permitted then javac will say so.

If there were three files instead of one, then the file with the main method would have to use yourInterface macros, and all the interface names in that file would have to have both top-level class and inner interface with a dot between, as I said above. Similarly, the method names would have to be prefixed with their top-level class names and a dot, as above.
To top

Two other files using functions

The second file is HalfStep.pri. It contains a method called halfStep for solving systems of ordinary differential equations with initial conditions by the half-step algorithm. The inner interface containing the signature is called Derivative, and each Derivative function receives a double array of values, and computes from it a double array of derivatives at those values. I leave it to the user or to her students to write the Runge-Kutta algorithm in the same style. The signature need not change. It suffices to write a new method to compete against halfStep.
To top

Using a throws clause

myInterface   TableWorthy   double f( double x ) throws Exception

The main method defines a function h which is the standard univariate normal without its normalizing denominator. The function p makes a symmetric proposal using the centered uniform distribution. The function r increments some totals and, once in every million times, prints average and variance. If everything goes well, the average will approach zero and the variance will approach unity.

The file is copied from the ideas of Nicholas Metropolis, but he is not responsible for any errors I may have made. I have made no provision for tuning the algorithm or burning it in, but it seems to work anyway.
To top

The Metropolis algorithm: statistics

The LogMetro.pri file purports to work Darwin’s experiment on crossed and self of Zea mays by a Bayesian method, not by the frequentist method of Fisher. See pages 16ff of http://darwin-online.org.uk/content/frameset?itemID=F1249&viewtype=text&pageseq=414&keywords=zea%20mays for Darwin’s numbers and Galton’s comments. The x array in the main method contains the differences of the two plants in the same pot, following Fisher, not following Galton. The density model I use in the new method logDensity is exp( -abs(x-center)/scale )/(scale*2), which is not Gauss’s normal density. As Galton remarks, quoted by Darwin, the “law of error” seems not to apply here. Instead of making scale a parameter, I make the logarithm of scale a parameter. (This is a common practice.) The prior probability is uniform for the two parameters: center and logarithm of scale. The logHeight function merely adds up the logarithms of the heights for the x’s.

The propose function is much like that in the previous section, but now it works in two dimensions. The report function counts how many times the center was negative, and every million times around the big loop it prints the total number of times, the number of negatives, and their ratio: leftProb. When I ran the program, leftProb appeared to approach a number slightly smaller than .0014 . That is, if the algorithm and model and prior are appropriate to this problem, (and if I understood and programmed all this correctly,) then the probability that self makes bigger plants than crossed is slightly smaller than .0014, and the probability that crossed makes bigger plants than self is slightly larger than .9986 .

Users of the Metropolis algorithm are as always reminded that (1) the algorithm need not converge, (2) it might converge to a wrong value, and (3) even if it does converge to the right value, there is no way of knowing that this has happened.
To top

The ShadedContours program

It appears that there are two kinds of contour-plotting programs. One kind plots functions, and the other kind plots matrices of numbers. ShadedContours.pri is the first kind. There is a main method at the bottom of its file to make a plot of the contours of Math.tan(x*y). The title of the plot is Tangent of Product. The function which calculates Math.tan(x*y) is named tangent. The x values lie between -5 and 5, and the y values lie between -5 and 5. The number of shadings between contours is 6.

When the program is started by means of the pri.bat file, a “decorated” window will open showing white pixels for very positive function values, nearly black pixels for very negative values, and shades of gray in between. Where white touches nearly black there is a discontinuity. The contours are the boundaries between the shadings, so they are not separately drawn. The window can be dragged and resized, and its contents can be copied to the clipboard by holding down the Alt key and pressing the Print Scr button. Then the clipboard can be pasted down into Microsoft Word, or some other high-quality program, to be printed. (The reader can guess that I use Microsoft Windows on my computer.) WordPad is not high quality for images.

Why is the window decorated? So that it can be dragged and resized and hidden and closed. Unfortunately, the decoration gets in the way of some of the contours. What we want is a way of removing the decoration. The way of removing it is to click the window with the mouse to make sure it has the focus, and then to push the Esc key on the keyboard. Then the decoration will be removed. (Pushing Esc again will decorate the window, and so on.) The Alt and Print Scr keys can be used either with or without the decoration, but without looks better. To end the program, just put the decoration on, if it is not on, and click on the “X” of the decoration to close the window.

Of course, the ShadedContours class will usually be instantiated from another file. An example is UseShadedContours.pri. This file plots two different windows, one for Math.sin(x*y) and one for Math.log(x*y). The latter window has 12 shades instead of only 6. There is a yourInterface declaration, and the inner interface ShadedContours.Altitude gets its full name. The two windows open with the same location and same size, so one must drag and resize to see both at the same time. Then they may be undecorated by the Esc key as before. The “X” close icon on the decoration of a window will close only that window, so two clicks are needed to end the program, one click on each decoration.

At first the contours for Math.sin(x*y) may look like those for Math.tan(x*y); the boundaries are from the same family of hyperbolas. However, the shading is different, and white and nearly black on the sine window can never touch each other. This is because the sine function is continuous. The contours for Math.log(x*y) are new. The second and fourth quadrants are dead black, even blacker than the nearly black mentioned above. This is to signify NaN, because logarithms of negative numbers are not real.

Now to explain how the ShadedContours program works. All the trickery is in the paint method. The double for loop for the variables eye and j looks at each pixel position in the window. The x is calculated from j and the y from eye. Then the altitude function is used on x and y to get z. If k is 1, then the z’s are collected in the alts array and a count kept of the NaN’s. Then the array is sorted, and when k is 2 the rank of z is found by binary search. The rank determines the shade of gray. That is to say, no calculus is used at all, and singularities and discontinuities are easily handled. (However, the z difference between the first and second contours is usually not the same as the z difference between the second and third contours, and so on.) Of course, this algorithm could not be used until computers came to their present speed and size. The problem of plotting contours is not solved; it is overpowered. The reader is respectfully invited to compare the present algorithm against its old-style calculus-using competitors, especially in the case of Math.tan(x*y) .
To top

The unclass.bat file

In fact, I do not provide a Print.class file, or any .class file, in the zip. Print.class is compiled the first time pri.bat is used.
To top

The AllPriUnJava.pri file

set left=AllPriUnJava
pri

The old name of this file was UnJava.pri, but then I saw that the old name was unclear in its meaning, so I changed it.
To top

The AllPri2Java.pri file

set left=AllPri2Java
pri

set left=PriUpdateJava
pri

What is needed is a macro. I have written it and named it let to remind me of Basic. One may write, say,

let x = yy + zzz * wwww ^ vvvvv

x=add(yy,multiply(zzz,power(wwww,vvvvv)));

I have been assuming that the static methods are in the same class as the line containing the let call. If they are in a different class, say, RatioStatics, then we use

staticsClass RatioStatics
let x = yy + zzz * wwww ^ vvvvv

x=RatioStatics.add(yy,RatioStatics.multiply(zzz,RatioStatics.power(wwww,vvvvv)));

Three other operators known to the let macro are ** and new and fresh. The ** operator is an exact synonym of the ^ operator, but it imitates Fortran instead of Basic. The new operator has the same meaning as in ordinary Java. The fresh operator means use a constructor. Here is an example of its use:

constructorsClass RatioStatics
let x = fresh 5,6

x=new RatioStatics(5,6);

constructorsClass RatioStatics
let RatioStatics x = fresh 5,6

RatioStatics x=new RatioStatics(5,6);

Parentheses are permitted in the let call, and they have their usual meaning. Commas are permitted too, and they are useful for static method calls:

let int eye = RatioStatics.compareTo ( x / y , u - v )

Let me say a word about subscripts. The let macro does not know anything about subscripts. Nevertheless, they may be used, provided that they are written solid with no blanks. Here is an example, with extra-wide spacing:

let   x[i][j]   =   y[i]   +   z[j]

x[i][j]=add(y[i],z[j]);

The let macro can do not only the binary + and - operators but also the singulary + and - operators. The singulary operators are changed to plus and minus, respectively, but the binary operators are changed to add and subtract, respectively.

Also, the let macro can do the ternary operator and relational operators and boolean operators. A contrived example is

let DemoTernary x = ( y < z ) ? y + z : y * z

The let macro is meant for primitives and for immutable objects. It cannot do anything to mutable objects except instantiate them.
To top

RatioStatics

The DoubleStatics.java file has methods for doubles but not any for ints. This means that ints will be promoted to doubles. Here is an example:

public class Junk
{

	public static void main(String[] args)
	{
	staticsClass DoubleStatics
	let double x = 2 / 3
	print x
	}

}

The package is merely a subdirectory. It is not a Java archive (.jar file,) so please do not change the classpath. The package does not yet contain a .class file, but when the user compiles a file referring to the package, say by typing pri at the Dos prompt, javac will write the .class file for the package without saying anything.

A user who wishes to change compPivMat\CompPivMat.pri should keep in mind that everything must be done from the parent directory, not in the package. For example, one might type at the Dos prompt

set left=compPivMat\CompPivMat
notepad %left%.pri

priOnly

I nearly forgot to say what DemoCompPivMat.pri does. It uses least squares to fit a polynomial of degree k-1 to some xData,yData points.
To top

Let and Dac

The web has few examples of mutable complex-value arithmetic, but there are some, and they are unexpectedly speedy. I will say later in this file how speedy. Here is what a call of the mutate macro may look like:

mutate x := y + z * w

{ multiply(temporary0ComplexMutate,z,w); add(temporary1ComplexMutate,y,temporary0ComplexMutate); copy(x,temporary1ComplexMutate); }

makeTemps 10

Each method of a .pri file needs its own makeTemps calls, and they must come before the mutate calls which need them.
To top

ComplexMutate

A demo program is DemoComplexMutate.pri which becomes DemoComplexMutate.java. I have made a point of not using fresh inside the loop, because that would construct and destruct objects inside the loop, exactly what we wish to avoid. I do need many named variables to move the freshes out of the loop.

Now here is something new, not like the “demo” programs. It is SincosComplexMutate.pri and of course its .java file SincosComplexMutate.java. This is a particularly crude form of Euler’s algorithm to solve the sine and cosine ordinary differential equations starting from zero for the sine and one for the cosine and going around the loop a billion times. (American billion.) On my computer this Java program takes 15 seconds to run. For comparison, the corresponding program in Gnu C++, using the built-in _Complex double, and using the command-line modifiers for greatest speed, takes 14 seconds. A famous proprietary freeware C++ takes 15 seconds, the same as our Java program. Other freeware C++es seem to be slower.

The Euler algorithm was chosen to make the ComplexMutate class look speedy. Unfortunately, most useful programs in numerical analysis have subscripts, and Java programs having subscripts are slow. I have timed the matrix multiplication of complex-valued matrices, and a Java program using ComplexMutate is about 2.5 times as slow as the corresponding program in Gnu C++. (Thirty-two seconds for Java and thirteen seconds for Gnu C++, edge size 200, 100 repetitions.)
To top

Mutate and Dac

Now we come to the fun part. The macro-expander checks to make sure that the controlled variable of the for is the variable of the matching next. This is a feature of Basic that other computer languages don’t have, and I find it helps in reading a file with big nests of loops.

I emphasize that the starting and stopping values of the controlled variable and the value of the step must each be a single token having no blanks inside. As usual, the values and keywords and = sign must be separated by blanks. Failure to keep to these rules will prevent the macro-expander from seeing that these statements are the Basic for, and javac will say something unkind.

Now the bad news. The macro-expander cannot check that the step value is an integer. If it has a fractional part, the loop will work wrong. The javac compiler will know that a mistake has been made, but it won’t tell.

The macro system uses its stack to check that the for and its next are using the same controlled variable, and that different for loops nested one inside another are using different controlled variables. The latter check is found also in the better class of Basics and in Fortran’s do loops.
To top

The firstly and lastly macros

This may make more sense if the reader will be kind enough to click on HyperbolaTable.pri. I do something similar to the main method and to a multi-line if statement. The token “firstly” is erased from its line, but the rest of the tokens on that line remain. The token “lastly” and all the other tokens on its line are erased, so the line becomes empty. To see this, the reader is respectfully invited to click on HyperbolaTable.java.

If the tokens following a “firstly” do not match the tokens following its “lastly,” then there will be a diagnostic, and the macro-expansion will stop.

The firstly and lastly use the same macro-time stack that was mentioned above.
To top

Lonely curly braces and lonelyCurly

enforce bigX!=0 bigY!=0

The opposite of enforce is forbid. If the boolean expression in a forbid is true, then the forbid throws a new Error. Both the enforce and the forbid give complete details when they throw. That is, the “second expression” of the “assert” is not necessary (or possible) with enforce and forbid.
To top

The define and unDefine macros

		for( int j=0;j<n;j++ )
		{
		multiply Temp C H
		add S S Temp
		multiply Temp S H
		subtract C C Temp
		}

The unDefine macro erases the definition made by the define. For example,

unDefine subtract

The setq is special. It changes to a Java assignment statement with equal-sign and semicolon. For example,

( setq s ( add s ( multiply c h ) ) )

s=add(s,multiply(c,h));

Also the dotimes is special. It becomes a Java for loop. The tokens must be a left paren, the word dotimes, another left paren, a token for the controlled variable of the loop, another token for the number of iterations, and a right paren. You are correct: the parens do not balance. For example,

( dotimes ( j n )

for(int j=0;j<n;j++){

A right round parenthesis all alone on a line is changed to a right curly brace. That is, the end of the dotimes loop is changed to the end of the for loop. This change occurs only if a dotimes loop starting on a previous line is still unrequited by its final right parenthesis. Nested dotimes loops are permitted. However, these joke macros do not make use of the macro-time stack mentioned above.

The other operators, here add and multiply, are assumed to be names of static methods. An example file is SincosSetq.pri. It is changed to SincosSetq.java. The reader is respectfully reminded that the white-space separating the parentheses and other tokens is obligatory here.

The resulting Java program runs at full Java speed, perhaps because the JIT compiler moves the static methods inline. The Java program is more than fifteen times as speedy as my corresponding Lisp program, sincosSetq.txt, using the speediest Lisp system that I know about, Steel Bank Common Lisp. (Yes, I know the suffix ought to be lisp instead of txt, but most browsers don’t know what to do with a lisp file.) However, I am no Lisp programmer, so it may be that my Lisp program is poorly written, or that I have used Steel Bank incorrectly, or that there is a speedier Lisp. I respectfully invite correction from people who know better than I.
To top

Changes

set left=Update
pri
unclass

       at        dot
smtw2gh  toadmail   com

For many more links for languages connected with Java, click on http://www.robert-tolksdorf.de/vmlanguages.html.

To top