mndaxpy.cxx

Go to the documentation of this file.

// @(#)root/minuit2:$Id$
// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei   2003-2005
 
/**********************************************************************
 *                                                                    *
 * Copyright (c) 2005 LCG ROOT Math team,  CERN/PH-SFT                *
 *                                                                    *
 **********************************************************************/
 
/* daxpy.f -- translated by f2c (version 20010320).
   You must link the resulting object file with the libraries:
      -lf2c -lm   (in that order)
*/
 
namespace ROOT {
 
namespace Minuit2 {
 
int Mndaxpy(unsigned int n, double da, const double *dx, int incx, double *dy, int incy)
{
   /* System generated locals */
   int i__1;
 
   /* Local variables */
   int i__, m, ix, iy, mp1;
 
   /*     constant times a vector plus a vector. */
   /*     uses unrolled loops for increments equal to one. */
   /*     jack dongarra, linpack, 3/11/78. */
   /*     modified 12/3/93, array(1) declarations changed to array(*) */
 
   /* Parameter adjustments */
   --dy;
   --dx;
 
   /* Function Body */
   if (n <= 0) {
      return 0;
   }
   if (da == 0.) {
      return 0;
   }
   if (incx == 1 && incy == 1) {
      goto L20;
   }
 
   /*        code for unequal increments or equal increments */
   /*          not equal to 1 */
 
   ix = 1;
   iy = 1;
   if (incx < 0) {
      ix = (-static_cast<int>(n) + 1) * incx + 1;
   }
   if (incy < 0) {
      iy = (-static_cast<int>(n) + 1) * incy + 1;
   }
   i__1 = n;
   for (i__ = 1; i__ <= i__1; ++i__) {
      dy[iy] += da * dx[ix];
      ix += incx;
      iy += incy;
      /* L10: */
   }
   return 0;
 
   /*        code for both increments equal to 1 */
 
   /*        clean-up loop */
 
L20:
   m = n % 4;
   if (m == 0) {
      goto L40;
   }
   i__1 = m;
   for (i__ = 1; i__ <= i__1; ++i__) {
      dy[i__] += da * dx[i__];
      /* L30: */
   }
   if (n < 4) {
      return 0;
   }
L40:
   mp1 = m + 1;
   i__1 = n;
   for (i__ = mp1; i__ <= i__1; i__ += 4) {
      dy[i__] += da * dx[i__];
      dy[i__ + 1] += da * dx[i__ + 1];
      dy[i__ + 2] += da * dx[i__ + 2];
      dy[i__ + 3] += da * dx[i__ + 3];
      /* L50: */
   }
   return 0;
} /* daxpy_ */
 
} // namespace Minuit2
 
} // namespace ROOT