dear friends,
here is the full code that is creating the problem!!! while running
with ifort, the configuration is created as wished, but not in
gfortran....

!===========================================
! This is the main driver routine
! of the reverse monte carlo program
program rmonte
!===========================================

One reason that I keep silverfrost's f95 suite around is that if I can get
a program to compile, I can step through it with a debugger that I invoke
on one of the pull-downs. I'd like to emulate this capability with gcc's
gdb.

I googled for "gfortran debugger" and found a lot of information that was
often more relevant to the linux crowd. I *did* find this from a previous
exchange with FX:

OK then, a brief summary: gfortran is the GNU Fortran compiler, part of
GCC (the GNU Compiler Collection). GCC happens to be the system compiler
on Linux and most other free software operating systems, which means it's
widely used on these OS. gdb is the GNU debugger, also the default
debugger on Linux and other free software OS.

But that doesn't mean it's restricted to Linux. Both GCC (and gfortran)
and gdb are known to work on (free|net|open)bsd, Solaris, MacOS X,
Windows, AIX, Irix, HP-UX, Tru64 and probably others.

!end excerpt

I am currently running IBM's XLFortran 8.1 from a terminal shell on
MacOSX 10.4 (Tiger) without any issues (even though IBM has
discontinued it and never supported it on Tiger). I would like to
upgrade my system to MacOSX 10.5 (Leopard) and would like to know
ahead of time that XLF can be made to work from a terminal shell
(don't care about Xcode or even debugger support). Has anybody been
down this path already?

Al Greynolds
www.ruda.com

Today I tried a very simple speed test using fl32 and df command
(compaq visual fortran 6.6)

program speed
integer :: i, j, k, n
real :: a, b, c
call cpu_time(a)
do i=1,1000
do j=1,100
do k=1,100
c=(sin(real(i))**2.0+cos(real(j))**2.0)+log(real(i))*log(real(j))
+real(k)
! write(*,*) c
end do
end do
end do
call cpu_time(b)
b=b-a
write(*,*) b,c
end program

Today I tried a very simple speed test using fl32 and df command
(compaq visual fortran 6.6)

program speed
integer :: i, j, k, n
real :: a, b, c
call cpu_time(a)
do i=1,1000
do j=1,100
do k=1,100
c=(sin(real(i))**2.0+cos(real(j))**2.0)+log(real(i))*log(real(j))
+real(k)
!write(*,*) c
end do
end do
end do
call cpu_time(b)
b=b-a
write(*,*) b,c
end program

Today I tried a very simple speed test using fl32 and df command
(compaq visual fortran 6.6)

program speed
integer :: i, j, k, n
real :: a, b, c
call cpu_time(a)
do i=1,1000
do j=1,100
do k=1,100
c=(sin(real(i))**2.0+cos(real(j))**2.0)+log(real(i))*log(real(j))
+real(k)
!write(*,*) c
end do
end do
end do
call cpu_time(b)
b=b-a
write(*,*) b,c
end program

This is a follow on from an earlier post of mine regarding sorting.

I've never used pointers before and I'm finding the lingo a bit heavy.

Here's my problem.

I have a potentially very large matrix that looks like

1 2 3 4 5 6
2 3 4 5 6 7
3 4 5 6 7 8
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

For my largest problem the matrix will have 11 columns and about
10,000,000 rows.

I'm only interested in the section that is nonzero but am not aware of
how to change the matrix size quickly and efficiently as more rows are
needed. I was told that pointers maybe the way to go. The example I
was shown was to declare a single column vector which represents my
first column i.e.