Assign Same Value to Multiple Array Items - How?

Good evening, everyone,

I want to achieve something like this in a 2D-array:

1 0 0 0 0
0 0 1 0 0
0 0 0 1 0
0 1 0 0 0
0 0 0 0 1

What I have now is a nested DO LOOP with an awful amount of IFs and ELSEIFs like:

DO icoun=1,ncols
    DO jcoun=1,nrows
        IF((icoun==3.AND.jcoun==1) &
           & .OR.(icoun==4.AND.jcoun==2)...) THEN

            ...

        END IF
    END DO
END DO

Is there an easier way to achieve this?

Use data initialization instead of the 'hard coded' setting.

But, this is only really useful if you wish the array to appear the same way, every time. For the example you have given, a simple way to initialize would look like:

      DATA ((MY_ARRAY(I,J),I=1,5),J=1,5)/ &
     1,0,0,0,0, &
     0,0,1,0,0, &
     0,0,0,1,0, &
     0,1,0,0,0, &
     0,0,0,0,1/

'Something like this' is quite vague, and discourages answering.

If, however, what you intend to have is a permutation matrix, you can store it as a permutation vector (i.e., a 1-D array), with values [1, 4, 2, 3, 5], where the entries are the row numbers of the one (and only one) element with value = 1 in each column, with zeros in the rest of the column.

Such permutation vectors are routinely used in Lapack for routines that do Gaussian elimination with pivoting.

If you want something else, you need to describe that in more detail.

Thanks for the replies.

mecej4, basically, what I want is exactly like this, the differences being, that it's actually a 14x7 matrix and instead of only '1' it looks like this:

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

If what you wish to do is to work with only the non-zero entries in a sparse matrix, you can choose a sparse matrix representation that suits your needs.

The simplest is the so called COO representation. See, for example, http://www.culatools.com/blog/2011/09/08/sparse-101-matrix-formats/ .In this representation, the sparse matrix is stored as an NNZ X 3 matrix, where NNZ is the number of non-zero elements. Each row of the compact matrix contains the (R, C, V) triplet for a non-zero element of the original matrix. R and C are the coordinates (row and column) and V is the value of the matrix element in that position. Except in a few special cases, there are no entries in the COO representation with V = 0.

Viroxa, your phrase 'what I want is exactly like this' reminded me of a poster that I saw decades ago, which said:

Engineers Do Precision Guesswork

mecej4's pivot array, and his sparse matrix representation are both great ideas, but if the initialisation is done once per run of the program, the DATA statement (with all the values including zeroes) takes a lot of beating. 14x7 is 98 elements, and as the values are 0, 1 ... etc but never very big, even INTEGER4 takes up less than 400 bytes, so it is difficult to see that there is a lot of benefit. Traditionally, a lot of such initialisations could be done in a BLOCK DATA subprogram. You could use INTEGER2.

I've never been very fond of BLOCK DATA, probably because many compilers I've used don't support it rather than it being disapproved of in modern Fortran.

If the array needs to be reinitialised after it has been changed, DATA and BLOCK DATA won't do the job unless you keep a set of arrays in pristine form and simply copy them into your working arrays each time reinitialisation is called for.

Something similar happens with a Multiple Document Interface (MDI) Windows program, because each 'document' (i.e. problem running separately) may need its own initialisations. In such a case, where the program space requirements do not stress the available memory capacity, I find it better to spawn a new complete copy of the program rather than having child windows. That also solves problems of having unique datasets for each 'document'.

Eddie

Thanks for the suggestions. mecej4's suggestion seems like a good idea.

The array is recalculated 3*nelem times with nelem = number of elements, and thereby assembled into a new [14,7,3]-array. This new array is then again recalculated 3 times with different input values.

All in all there are 33nelem calculations.

Quoted from LitusSaxonicum ... if the initialisation is done once per run of the program, the DATA statement (with all the values including zeroes) takes a lot of beating

If the program is intended to be applied to more than one problem, fixed arrays initialised with DATA statements are not suitable. Read the problem data from a file, calculate the array sizes based on that data, allocate the arrays, and then read problem data into the arrays (or, if possible, populate the arrays using an algorithm). This is far better than writing an inflexible program to solve only one problem size, and then attempting to adapt the program to each new problem size that comes up.

Read the problem data from a file, calculate the array sizes based on that data, allocate the arrays, and then read problem data into the arrays (or, if possible, populate the arrays using an algorithm)

That's the way I did it.

One more question regarding sparse matrices: Are there intrinsic routines for sparse matrix operations or could you recommend a library to use?

Read the problem data from a file, calculate the array sizes based on that data, allocate the arrays, and then read problem data into the arrays (or, if possible, populate the arrays using an algorithm)

That's the way I did it.

One more question regarding sparse matrices: Are there intrinsic routines for sparse matrix operations or could you recommend a library to use?

Don't expect intrinsics for sparse matrices for a decade or two. Several libraries are available in source form.

Prof. Yousef Saad is an authority on sparse matrices. See his Web page at http://www-users.cs.umn.edu/~saad/ .

It would be useful for you to be specific about which operations you need to perform with sparse matrices.

• MATMUL
• SUM -TRANSPOSE

Quoted from mecej4 Prof. Yousef Saad is an authority on sparse matrices. See his Web page at http://www-users.cs.umn.edu/~saad/ .

Mecej4, have you try his methods in comparison with ones of INTEL and LAIPE we tried earlier this year? Both Intel and LAIPE sparse solvers were slower then dense INTEL solver for the same sparse matrices.

Dan, most of the sparse matrix packages are intended for application to matrices other than banded matrices. It can certainly be the case that, for a banded matrix, a specialized band matrix solver will be a better choice than packages such as UMFPack, SuperLU, MUMPS and WSMP. The packages that I listed are of real help with other matrix sparse patterns, such as those that come from piping networks, product manufacturing and distribution, airline reservations, etc.

Laipe2 may well be better for some types of matrices, but I did not like the Fortran 77 tricks that Jenn-Ching Luo uses in his compact matrix representation. Nobody else uses those tricks and they will give you trouble with modern Fortran. For many users, it can be a big hurdle to have to convert from one of the standard compact storage conventions to the Laipe2 scheme.

The only software from Saad's site that I actually used was for converting from one sparse format to another, e.g., RUA to CSR.