agent_compositor_test/references/igraph-1.0.1/vendor/lapack/dger.c

/*  -- translated by f2c (version 20240504).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"

/* > \brief \b DGER   

    =========== DOCUMENTATION ===========   

   Online html documentation available at   
              http://www.netlib.org/lapack/explore-html/   

    Definition:   
    ===========   

         SUBROUTINE DGER(M,N,ALPHA,X,INCX,Y,INCY,A,LDA)   

         DOUBLE PRECISION ALPHA   
         INTEGER INCX,INCY,LDA,M,N   
         DOUBLE PRECISION A(LDA,*),X(*),Y(*)   


   > \par Purpose:   
    =============   
   >   
   > \verbatim   
   >   
   > DGER   performs the rank 1 operation   
   >   
   >    A := alpha*x*y**T + A,   
   >   
   > where alpha is a scalar, x is an m element vector, y is an n element   
   > vector and A is an m by n matrix.   
   > \endverbatim   

    Arguments:   
    ==========   

   > \param[in] M   
   > \verbatim   
   >          M is INTEGER   
   >           On entry, M specifies the number of rows of the matrix A.   
   >           M must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] N   
   > \verbatim   
   >          N is INTEGER   
   >           On entry, N specifies the number of columns of the matrix A.   
   >           N must be at least zero.   
   > \endverbatim   
   >   
   > \param[in] ALPHA   
   > \verbatim   
   >          ALPHA is DOUBLE PRECISION.   
   >           On entry, ALPHA specifies the scalar alpha.   
   > \endverbatim   
   >   
   > \param[in] X   
   > \verbatim   
   >          X is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( m - 1 )*abs( INCX ) ).   
   >           Before entry, the incremented array X must contain the m   
   >           element vector x.   
   > \endverbatim   
   >   
   > \param[in] INCX   
   > \verbatim   
   >          INCX is INTEGER   
   >           On entry, INCX specifies the increment for the elements of   
   >           X. INCX must not be zero.   
   > \endverbatim   
   >   
   > \param[in] Y   
   > \verbatim   
   >          Y is DOUBLE PRECISION array, dimension at least   
   >           ( 1 + ( n - 1 )*abs( INCY ) ).   
   >           Before entry, the incremented array Y must contain the n   
   >           element vector y.   
   > \endverbatim   
   >   
   > \param[in] INCY   
   > \verbatim   
   >          INCY is INTEGER   
   >           On entry, INCY specifies the increment for the elements of   
   >           Y. INCY must not be zero.   
   > \endverbatim   
   >   
   > \param[in,out] A   
   > \verbatim   
   >          A is DOUBLE PRECISION array, dimension ( LDA, N )   
   >           Before entry, the leading m by n part of the array A must   
   >           contain the matrix of coefficients. On exit, A is   
   >           overwritten by the updated matrix.   
   > \endverbatim   
   >   
   > \param[in] LDA   
   > \verbatim   
   >          LDA is INTEGER   
   >           On entry, LDA specifies the first dimension of A as declared   
   >           in the calling (sub) program. LDA must be at least   
   >           max( 1, m ).   
   > \endverbatim   

    Authors:   
    ========   

   > \author Univ. of Tennessee   
   > \author Univ. of California Berkeley   
   > \author Univ. of Colorado Denver   
   > \author NAG Ltd.   

   > \ingroup ger   

   > \par Further Details:   
    =====================   
   >   
   > \verbatim   
   >   
   >  Level 2 Blas routine.   
   >   
   >  -- Written on 22-October-1986.   
   >     Jack Dongarra, Argonne National Lab.   
   >     Jeremy Du Croz, Nag Central Office.   
   >     Sven Hammarling, Nag Central Office.   
   >     Richard Hanson, Sandia National Labs.   
   > \endverbatim   
   >   
    =====================================================================   
   Subroutine */ int igraphdger_(integer *m, integer *n, doublereal *alpha, 
	doublereal *x, integer *incx, doublereal *y, integer *incy, 
	doublereal *a, integer *lda)
{
    /* System generated locals */
    integer a_dim1, a_offset, i__1, i__2;

    /* Local variables */
    integer i__, j, ix, jy, kx, info;
    doublereal temp;
    extern /* Subroutine */ int igraphxerbla_(char *, integer *, ftnlen);


/*  -- Reference BLAS level2 routine --   
    -- Reference BLAS is a software package provided by Univ. of Tennessee,    --   
    -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--   


    =====================================================================   


       Test the input parameters.   

       Parameter adjustments */
    --x;
    --y;
    a_dim1 = *lda;
    a_offset = 1 + a_dim1;
    a -= a_offset;

    /* Function Body */
    info = 0;
    if (*m < 0) {
	info = 1;
    } else if (*n < 0) {
	info = 2;
    } else if (*incx == 0) {
	info = 5;
    } else if (*incy == 0) {
	info = 7;
    } else if (*lda < max(1,*m)) {
	info = 9;
    }
    if (info != 0) {
	igraphxerbla_("DGER  ", &info, (ftnlen)6);
	return 0;
    }

/*     Quick return if possible. */

    if (*m == 0 || *n == 0 || *alpha == 0.) {
	return 0;
    }

/*     Start the operations. In this version the elements of A are   
       accessed sequentially with one pass through A. */

    if (*incy > 0) {
	jy = 1;
    } else {
	jy = 1 - (*n - 1) * *incy;
    }
    if (*incx == 1) {
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    if (y[jy] != 0.) {
		temp = *alpha * y[jy];
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    a[i__ + j * a_dim1] += x[i__] * temp;
/* L10: */
		}
	    }
	    jy += *incy;
/* L20: */
	}
    } else {
	if (*incx > 0) {
	    kx = 1;
	} else {
	    kx = 1 - (*m - 1) * *incx;
	}
	i__1 = *n;
	for (j = 1; j <= i__1; ++j) {
	    if (y[jy] != 0.) {
		temp = *alpha * y[jy];
		ix = kx;
		i__2 = *m;
		for (i__ = 1; i__ <= i__2; ++i__) {
		    a[i__ + j * a_dim1] += x[ix] * temp;
		    ix += *incx;
/* L30: */
		}
	    }
	    jy += *incy;
/* L40: */
	}
    }

    return 0;

/*     End of DGER */

} /* igraphdger_ */