On Friday, January 7, 2022 at 5:30:42 PM UTC-6, Thomas Koenig wrote:
> Niklas Holsti <niklas...@tidorum.invalid> schrieb:
> > On 2022-01-07 23:31, Thomas Koenig wrote:
> >> Thomas Koenig <tko...@netcologne.de> schrieb:
> > The challenge may have been intended specifically for C,
> Definitely.
> > but as the
> > thread has talked about several languages, here is an Ada equivalent.
> Just for the record, I was aware that Ada can do this :-)
> > For simplicity I nested the Foo procedure into the main procedure, but
> > it could of course be in a separate module (a package) with trivial
> > syntax changes.
> Actually, I made the Fortran program not use the more advanced
> features of passing an assumed-shape array (not that the callee
> makes assumptions about the array, but that the shape is assumed
> from the caller - I always find that bit of terminolgy a little
> confusing), but this sort of feature would definitely not follow
> the "small language" philosophy of C.
> >
> > A difference to the Fortran solution is that when the array F is passed
> > to Foo, the parameter must be written "F.all" instead of plain "F", as
> > Foo is declared to take a Matrix, while F is a pointer (access) to a
> > Matrix. I could have avoided that by making Foo take an "access Matrix"
> > parameter, but then I could not have declared that parameter to be only
> > an output (result) parameter.
> >
> >
> > with Ada.Text_IO, Ada.Integer_Text_IO;
> > procedure Big_Matrix is
> > use Ada.Text_IO, Ada.Integer_Text_IO;
> > type Matrix is array (Positive range <>, Positive range <>)
> > of Integer;
> >
> > procedure Foo (X : out Matrix) is
> > begin
> > for I in X'Range(1) loop
> > for J in X'Range(2) loop
> > X(I,J) := abs (I - J);
> > end loop;
> > end loop;
> > end Foo;
> The equivalent of that in Fortran would be
>
> subroutine foo(x)
> integer, dimension(:,:), intent(out) :: x
> integer :: i,j
> do i=1,size(x,1)
> do j=1,size(x,2)
> x(i,j) = abs(i-j)
> end do
> end do
> end subroutine foo
<
is Ada row-major order--like Fortran ?
<
> Someday, somebody maybe write up the history of which language
> infuenced which. I believe Fortran modules were strongly influenced
> by Ada packages, and the separation between public and private
> specifications was only introduced in Fortran with the 2008 standard
> with submodules.

On 2022-01-08 2:55, MitchAlsup wrote:
> On Friday, January 7, 2022 at 5:30:42 PM UTC-6, Thomas Koenig wrote:
>> Niklas Holsti <niklas...@tidorum.invalid> schrieb:
>>> On 2022-01-07 23:31, Thomas Koenig wrote:
>>>> Thomas Koenig <tko...@netcologne.de> schrieb:
>>> The challenge may have been intended specifically for C,
>> Definitely.
>>> but as the
>>> thread has talked about several languages, here is an Ada equivalent.
>> Just for the record, I was aware that Ada can do this :-)
>>> For simplicity I nested the Foo procedure into the main procedure, but
>>> it could of course be in a separate module (a package) with trivial
>>> syntax changes.
>> Actually, I made the Fortran program not use the more advanced
>> features of passing an assumed-shape array (not that the callee
>> makes assumptions about the array, but that the shape is assumed
>> from the caller - I always find that bit of terminolgy a little
>> confusing), but this sort of feature would definitely not follow
>> the "small language" philosophy of C.
>>>
>>> A difference to the Fortran solution is that when the array F is passed
>>> to Foo, the parameter must be written "F.all" instead of plain "F", as
>>> Foo is declared to take a Matrix, while F is a pointer (access) to a
>>> Matrix. I could have avoided that by making Foo take an "access Matrix"
>>> parameter, but then I could not have declared that parameter to be only
>>> an output (result) parameter.
>>>
>>>
>>> with Ada.Text_IO, Ada.Integer_Text_IO;
>>> procedure Big_Matrix is
>>> use Ada.Text_IO, Ada.Integer_Text_IO;
>>> type Matrix is array (Positive range <>, Positive range <>)
>>> of Integer;
>>>
>>> procedure Foo (X : out Matrix) is
>>> begin
>>> for I in X'Range(1) loop
>>> for J in X'Range(2) loop
>>> X(I,J) := abs (I - J);
>>> end loop;
>>> end loop;
>>> end Foo;
>> The equivalent of that in Fortran would be
>>
>> subroutine foo(x)
>> integer, dimension(:,:), intent(out) :: x
>> integer :: i,j
>> do i=1,size(x,1)
>> do j=1,size(x,2)
>> x(i,j) = abs(i-j)
>> end do
>> end do
>> end subroutine foo
> <
> is Ada row-major order--like Fortran ?

Fortran is column-major order, at least as that term is used in the Ada
standard :-)

The Ada standard suggests (but does not require) that row-major order
should be the default, but column-major is used if the array type
declaration includes the aspect Convention => Fortran.

Thomas Koenig <tkoenig@netcologne.de> writes:

> [...] please provide a short example program which reads an
> integer n, generates an n*n integer array and passes it to a
> function which fills it with the absolute difference between the
> indices, and then the calling function prints out the array. In
> order to be useful, the program should work with moderate n (let's
> say n=10000) on a Linux system with default stack size, which is 8
> MB.

#include <stdio.h>
#include <stdlib.h>

static void initialize_matrix( unsigned N, int m[N][N] );

int
main( int argc, char *argv[] ){
unsigned long const N = argc > 1 ? strtoul( argv[1], 0, 0 ) : 10000;
int (*const m)[N] = malloc( N * sizeof *m );
unsigned i, j;

if( N > -1U || !m ) return EXIT_FAILURE;

initialize_matrix( N, m );
for( i = 0; i < N; i++ ){
for( j = 0; j < N; j++ ){
printf( " %4d", m[i][j] );
}
printf( "\n" );
}
free( m );

return 0;
}

void
initialize_matrix( unsigned const N, int m[N][N] ){
unsigned i, j;
for( i = 0; i < N; i++ ){
for( j = 0; j < N; j++ ){
m[i][j] = i<j ? j-i : i-j;
}
}
}

(And here is a function for doing general matrix multiplication.)

typedef unsigned long Index, Extent;

void
matrix_multiply(
Extent const L, Extent const M, Extent const N,
const double a[L][M], const double b[M][N],
double c[L][N]
){
Index i, j, k;
for( i = 0; i < L; i++ ){
for( j = 0; j < N; j++ ){
double r = 0;
for( k = 0; k < M; k++ ){
r += a[i][k] * b[k][j];
}
c[i][j] = r;
}
}
}

Tim Rentsch <tr.17687@z991.linuxsc.com> schrieb:
> Thomas Koenig <tkoenig@netcologne.de> writes:
>
>> [...] please provide a short example program which reads an
>> integer n, generates an n*n integer array and passes it to a
>> function which fills it with the absolute difference between the
>> indices, and then the calling function prints out the array. In
>> order to be useful, the program should work with moderate n (let's
>> say n=10000) on a Linux system with default stack size, which is 8
>> MB.
>
>#include <stdio.h>
>#include <stdlib.h>
>
> static void initialize_matrix( unsigned N, int m[N][N] );
>
> int
> main( int argc, char *argv[] ){
> unsigned long const N = argc > 1 ? strtoul( argv[1], 0, 0 ) : 10000;
> int (*const m)[N] = malloc( N * sizeof *m );

Looks like a VLA, which is optional in C11, and is (AFAIK)
not implemented by Microsoft.

> Relied on 1970s FORTRAN compiler for subscript optimization.
> Much clearer to write a lengthy subscript expressions than optimize it
> yourself via pointer obfuscation.

Not too lengthy - wasn’t it limited to const * index + offset?
Don’t have my McCracken Guide any more.

On Saturday, January 15, 2022 at 9:57:42 AM UTC-6, mac wrote:
> > Relied on 1970s FORTRAN compiler for subscript optimization.
> > Much clearer to write a lengthy subscript expressions than optimize it
> > yourself via pointer obfuscation.
>
> Not too lengthy - wasn’t it limited to const * index + offset?
> Don’t have my McCracken Guide any more.
<
Even WATFIV had arbitrary integer expressions as subscripts (circa 1970)

According to MitchAlsup <MitchAlsup@aol.com>:
>On Saturday, January 15, 2022 at 9:57:42 AM UTC-6, mac wrote:
>> > Relied on 1970s FORTRAN compiler for subscript optimization.
>> > Much clearer to write a lengthy subscript expressions than optimize it
>> > yourself via pointer obfuscation.
>>
>> Not too lengthy - wasn’t it limited to const * index + offset?
>> Don’t have my McCracken Guide any more.
><
>Even WATFIV had arbitrary integer expressions as subscripts (circa 1970)

The alternative is to store the complicated expression in a variable and expect
the compiler to deal with it, e.g. if you can't write

... A(I*(J*K(l))) ...

you write

ITEMP = I*(J*K(l))
... A(ITEMP) ...

--
Regards,
John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
Please consider the environment before reading this e-mail. https://jl.ly

On Saturday, January 15, 2022 at 12:14:31 PM UTC-6, John Levine wrote:
> According to MitchAlsup <Mitch...@aol.com>:
> >On Saturday, January 15, 2022 at 9:57:42 AM UTC-6, mac wrote:
> >> > Relied on 1970s FORTRAN compiler for subscript optimization.
> >> > Much clearer to write a lengthy subscript expressions than optimize it
> >> > yourself via pointer obfuscation.
> >>
> >> Not too lengthy - wasn’t it limited to const * index + offset?
> >> Don’t have my McCracken Guide any more.
> ><
> >Even WATFIV had arbitrary integer expressions as subscripts (circa 1970)
> The alternative is to store the complicated expression in a variable and expect
> the compiler to deal with it, e.g. if you can't write
>
> ... A(I*(J*K(l))) ...
>
> you write
>
> ITEMP = I*(J*K(l))
> ... A(ITEMP) ...
>
I often advocate the later if only that it makes single stepping in a debugger easier
to grasp "what is happening".
>
> --
> Regards,
> John Levine, jo...@taugh.com, Primary Perpetrator of "The Internet for Dummies",
> Please consider the environment before reading this e-mail. https://jl.ly

Thomas Koenig <tkoenig@netcologne.de> writes:

> Tim Rentsch <tr.17687@z991.linuxsc.com> schrieb:
>
>> Thomas Koenig <tkoenig@netcologne.de> writes:
>>
>>> [...] please provide a short example program which reads an
>>> integer n, generates an n*n integer array and passes it to a
>>> function which fills it with the absolute difference between the
>>> indices, and then the calling function prints out the array. In
>>> order to be useful, the program should work with moderate n (let's
>>> say n=10000) on a Linux system with default stack size, which is 8
>>> MB.
>>
>> #include <stdio.h>
>> #include <stdlib.h>
>>
>> static void initialize_matrix( unsigned N, int m[N][N] );
>>
>> int
>> main( int argc, char *argv[] ){
>> unsigned long const N = argc > 1 ? strtoul( argv[1], 0, 0 ) : 10000;
>> int (*const m)[N] = malloc( N * sizeof *m );
>
> Looks like a VLA, which is optional in C11, and is (AFAIK)
> not implemented by Microsoft.

There are no variable length arrays in the above code.

And anyone who relies on Microsoft toolsets deserves what they get.

On Sunday, March 6, 2022 at 7:43:22 AM UTC-6, Tim Rentsch wrote:
> Thomas Koenig <tko...@netcologne.de> writes:
>
> > Tim Rentsch <tr.1...@z991.linuxsc.com> schrieb:
> >
> >> Thomas Koenig <tko...@netcologne.de> writes:
> >>
> >>> [...] please provide a short example program which reads an
> >>> integer n, generates an n*n integer array and passes it to a
> >>> function which fills it with the absolute difference between the
> >>> indices, and then the calling function prints out the array. In
> >>> order to be useful, the program should work with moderate n (let's
> >>> say n=10000) on a Linux system with default stack size, which is 8
> >>> MB.
> >>
> >> #include <stdio.h>
> >> #include <stdlib.h>
> >>
> >> static void initialize_matrix( unsigned N, int m[N][N] );
> >>
> >> int
> >> main( int argc, char *argv[] ){
> >> unsigned long const N = argc > 1 ? strtoul( argv[1], 0, 0 ) : 10000;
> >> int (*const m)[N] = malloc( N * sizeof *m );
> >
> > Looks like a VLA, which is optional in C11, and is (AFAIK)
> > not implemented by Microsoft.
> There are no variable length arrays in the above code.
<
They are not variable length, they are of dynamic length:
different "runs" can use arrays of different sizes.
>
> And anyone who relies on Microsoft toolsets deserves what they get.

MitchAlsup <MitchAlsup@aol.com> writes:

> On Sunday, March 6, 2022 at 7:43:22 AM UTC-6, Tim Rentsch wrote:
>
>> Thomas Koenig <tko...@netcologne.de> writes:
>>
>>> Tim Rentsch <tr.1...@z991.linuxsc.com> schrieb:
>>>
>>>> Thomas Koenig <tko...@netcologne.de> writes:
>>>>
>>>>> [...] please provide a short example program which reads an
>>>>> integer n, generates an n*n integer array and passes it to a
>>>>> function which fills it with the absolute difference between the
>>>>> indices, and then the calling function prints out the array. In
>>>>> order to be useful, the program should work with moderate n (let's
>>>>> say n=10000) on a Linux system with default stack size, which is 8
>>>>> MB.
>>>>
>>>> #include <stdio.h>
>>>> #include <stdlib.h>
>>>>
>>>> static void initialize_matrix( unsigned N, int m[N][N] );
>>>>
>>>> int
>>>> main( int argc, char *argv[] ){
>>>> unsigned long const N = argc > 1 ? strtoul( argv[1], 0, 0 ) : 10000;
>>>> int (*const m)[N] = malloc( N * sizeof *m );
>>>
>>> Looks like a VLA, which is optional in C11, and is (AFAIK)
>>> not implemented by Microsoft.
>>
>> There are no variable length arrays in the above code.
>
> They are not variable length, they are of dynamic length:
> different "runs" can use arrays of different sizes.

I was using the term "variable length array" in the sense that it
is defined in the ISO C standard.