topic Re: Cardino Code in Intel® Fortran Compiler

Cardino Code

JohnNichols — Mon, 23 May 2022 16:36:19 GMT

There is an interesting discussion on Cardino code evolving on the Fortran Discourse site. FDs does not allow for zip files to be uploaded and I am loath to start a github point and waste days. Plus most people are on both sites, and the important one is definitely.

Here is the Intel Solution ( so far for Cardino).

I also include the MNIST program from Milan C. Interesting code, worth a look.

Re: Cardino Code

JohnNichols — Mon, 23 May 2022 20:56:02 GMT

As @mecej4 pointed out I had a mistake in Cardino.

I had assumed incorrectly that the function ** in complex numbers would return the correct answer for the one third root, it appears not to and one needs the work around

if((R%RE-SD%RE) .lt. 0.0D0) then T = -((abs(R-SD))**THIRDROOT) else T = (R - SD)**THIRDROOT end if

Where you check that the real part is negative - here the imaginary is zero and then the solution is trivially the 0ne third root of the positive number and then change the sign.

Please note I was just having some fun, there are a lot more checks to put in the code, I was just showing you could get it to work.

Re: Cardino Code

JohnNichols — Mon, 23 May 2022 22:17:35 GMT

In order for MNIST to work in Intel Fortran properly as intended, we need to add RANDOM_SEED to teh published code, otherwise you are just repeating the same numbers over and over. Intel Fortran Random_number appears to take a constant from the computer if you do not use random_seed.

The manual tells us: the processor sets the seed for RANDOM_NUMBER to a processor-dependent value

Any ideas what this processor dependent CONSTANT is?

Thanks

Re: Cardino Code

Steve_Lionel — Mon, 23 May 2022 23:00:59 GMT

What you really want to call is RANDOM_INIT (.FALSE.,.FALSE.) This is the standard way of initializing RANDOM_NUMBER to have nonrepeatable sequences. (The second argument controls the behavior of RANDOM_NUMBER across coarray images.)

What the specific constant value is isn't particularly important.

Re: Cardino Code

JohnNichols — Tue, 24 May 2022 15:00:21 GMT

I used RANDOM SEED and that has stopped the endless repition of the same numbers. I will change to your method.

it is not important, merely asking why is a good scientific method.

!if (this_image() == 1) & print '(a,i2,a,f5.2,a,/)', ' Epoch ', n, ' completed. Accuracy of the analysis is : ', accuracy(net, validation_images, label_digits(validation_labels),2) * 100, ' %' end do epochs print '(//" End of the analysis. "//)' print '(80("-"))' contains real function accuracy(net, x, y, PR) type(network), intent(in out) :: net real, intent(in) :: x(:,:), y(:,:) INTEGER, INTENT(IN) :: PR INTEGER, ALLOCATABLE :: k(:) INTEGER, ALLOCATABLE :: m(:) REAL, ALLOCATABLE :: P(:) REAL, ALLOCATABLE :: Q(:) integer :: i, good, n good = 0 n = size(x, dim=2) do i = 1, n k = maxloc(y(:,i)) p = y(k,i) m = maxloc(net % output(x(:,i))) Q = x(m,i) if (all(maxloc(net % output(x(:,i))) == maxloc(y(:,i)))) then good = good + 1 else if(PR .eq. 2) then if(i .lt. 9900) then write(*,*)i,k-1 end if end if end if end do accuracy = real(good) / size(x, dim=2) end function accuracy end program Zeus

The code works ok without the print statement, but the line 34 causes this crash - I am lost?

line 90 is in the program unit in Zeus, previously attached. The function loops through 10000 numbers in two arrays to count same numbers.

Re: Cardino Code

Steve_Lionel — Tue, 24 May 2022 15:25:09 GMT

You call the function from a PRINT statement, and then have a PRINT statement in the function. Fortran doesn't allow you to start an I/O operation on a unit when one is already in progress on that unit. If you wanted to add this as a debugging statement, perhaps change it to a WRITE to unit 0 (STDERR).

Re: Cardino Code

JohnNichols — Wed, 25 May 2022 16:26:47 GMT

Thanks for the answer. I was intrigued that original developer used some interesting techniques from Fortran that are legal, but take a while to wrap your head around.

Re: Cardino Code

JohnNichols — Wed, 25 May 2022 16:33:38 GMT

T = (R - SD)**THIRDROOT

If T, R and SD are complex, and the real components of R and SD are not zero, but the complex are zero, and R-SD < 0 on the number line, then the answer to this problem is purely real, so if R-SD = -125 than the answer is -5, but Intel Fortran does not give this answer, it gives a complex number, with a non zero imaginary part.. This comes from the Cardino problem.

Re: Cardino Code

JohnNichols — Wed, 25 May 2022 21:56:49 GMT

@Steve_Lionel , the problem of solving cubic equations was brought up on the Fortran discourse page. It is interesting to play with the code as I work on real stuff.

The support in Intel Fortran for complex functions, on the face of it appears a bit terse. So for example the sign function is not defined as a function in Intel for complex. The interesting challenge is the variations in the definitions, although it would appear to have four defined pairs if you look at the logic of the problem. Wikipedia and Wolfram offer opinions.

Am I missing something?

Re: Cardino Code

Steve_Lionel — Wed, 25 May 2022 21:59:29 GMT

The Fortran standard does not define SIGN on complex. As you note, it is not well-defined.

Re: Cardino Code

mecej4 — Thu, 26 May 2022 02:10:22 GMT

There is a signum function defined for complex variables in mathematics.

It is defined as z/|z| for z not equal to 0, and as 0 for z = 0, z being a complex number.

What do you expect the signum of i to be? The signum of -i ?

I wish you would spell Cardano's name the usual way.

Re: Cardino Code

Arjen_Markus — Thu, 26 May 2022 07:49:37 GMT

The way you would express the cubic root of a number x in Fortran or most other programming languages is by x**(1.0/3.0) (or pow(x, 1.0/3.0) or...). Note that the power is NOT 1/3, as it would be in mathematics, but a close approximation. And that is one of the problems: while with y = -5, y**3 gives -125, with x = 125 (positive, to avoid other problems), you cannot exactly get 5 via x**(1.0/3.0) - or if due to rounding it does happen to come out as 5 exactly, other values would lead to slight deviations from the mathematically correct value.

The solution for a programming language is not to allow negative values for a power of fractional value. An alternative might be to define a power of 1/n as we have a power of n as well as of x (n integer, x real). But even that poses problems: (-1.0)**(1/4) is a complex number, whereas (-1.0)**(1/3) is -1.0.