DRA Systems: OR-Objects 1.2.4: Class BLAS1

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: INNER | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

drasys.or.linear.blas
Class BLAS1

java.lang.Object
  |
  +--drasys.or.linear.blas.BLAS1

public class BLAS1
extends java.lang.Object
implements BLAS1I

Serial implementation of the BLAS1. See BLAS1I for more details.

Constructor Summary

BLAS1()


Method Summary

void caxpy(int n, ComplexI alpha, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.

void ccopy(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Copies vector x to vector y: y = x.

Complex cdotc(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.

Complex cdotu(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.

void cscal(int n, ComplexI alpha, float[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.

void csscal(int n, float alpha, float[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.

void cswap(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Interchange two vectors: x <-> y.

double dasum(int n, double[] x, int begx, int incx)
          Computes the sum of the absolute values.

void daxpy(int n, double alpha, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.

void dcopy(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Copies vector x to vector y: y = x.

double ddot(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.

double dnrm2(int n, double[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))

void drot(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, double cos, double sin)
          Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x

void drotg(Real a, Real b, Real cos, Real sin)
          Generates the parmseters cos and sin for a plane rotation.

void dscal(int n, double alpha, double[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.

double dsdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.

void dswap(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Interchange two vectors: x <-> y.

double dzasum(int n, double[] x, int begx, int incx)
          Computes the sum of the absolute values.

double dznrm2(int n, double[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))

int icamax(int n, float[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.

int idamax(int n, double[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.

int isamax(int n, float[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.

int izamax(int n, double[] x, int begx, int incx)
          Finds the index of the element with the maximum absolute value.

float sasum(int n, float[] x, int begx, int incx)
          Computes the sum of the absolute values.

void saxpy(int n, float alpha, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.

float scasum(int n, float[] x, int begx, int incx)
          Computes the sum of the absolute values.

float scnrm2(int n, float[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))

void scopy(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Copies vector x to vector y: y = x.

float sdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.

float sdsdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Computes the dot product of two vectors: alpha = x (.) y.

float snrm2(int n, float[] x, int begx, int incx)
          Computes the euclidean norm of the vector: sqrt(sum(xi^2))

void srot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, float cos, float sin)
          Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x

void srotg(Real a, Real b, Real cos, Real sin)
          Generates the parmseters cos and sin for a plane rotation.

void sscal(int n, float alpha, float[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.

void sswap(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)
          Interchange two vectors: x <-> y.

void zaxpy(int n, ComplexI alpha, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Constant times a vector plus a vector: y = y + alpha * x.

void zcopy(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Copies vector x to vector y: y = x.

Complex zdotc(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.

Complex zdotu(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, Complex results)
          Computes the dot product of two vectors: alpha = x (.) y.

void zdscal(int n, double alpha, double[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.

void zscal(int n, ComplexI alpha, double[] x, int begx, int incx)
          Scale a vector by a constant: x = alpha * x.

void zswap(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)
          Interchange two vectors: x <-> y.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BLAS1

public BLAS1()

Method Detail

dasum

public double dasum(int n,
                    double[] x,
                    int begx,
                    int incx)
             throws BlasException

Computes the sum of the absolute values.

Specified by:: dasum in interface BLAS1I

Parameters:: n - number of vector element; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

daxpy

public void daxpy(int n,
                  double alpha,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException

Constant times a vector plus a vector: y = y + alpha * x.

Specified by:: daxpy in interface BLAS1I

Parameters:: n - number of vector elements; alpha - constant multiplier of 'x'.; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

dcopy

public void dcopy(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException

Copies vector x to vector y: y = x.

Specified by:: dcopy in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

ddot

public double ddot(int n,
                   double[] x,
                   int begx,
                   int incx,
                   double[] y,
                   int begy,
                   int incy)
            throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: ddot in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

drot

public void drot(int n,
                 double[] x,
                 int begx,
                 int incx,
                 double[] y,
                 int begy,
                 int incy,
                 double cos,
                 double sin)
          throws BlasException

Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x

Specified by:: drot in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements; alpha - constant; beta - constant

dscal

public void dscal(int n,
                  double alpha,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException

Scale a vector by a constant: x = alpha * x.

Specified by:: dscal in interface BLAS1I

Parameters:: n - number of vector elements; alpha - scale factor; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

dswap

public void dswap(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException

Interchange two vectors: x <-> y.

Specified by:: dswap in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

dnrm2

public double dnrm2(int n,
                    double[] x,
                    int begx,
                    int incx)
             throws BlasException

Computes the euclidean norm of the vector: sqrt(sum(xi^2))

Specified by:: dnrm2 in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

idamax

public int idamax(int n,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException

Finds the index of the element with the maximum absolute value.

Specified by:: idamax in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

sasum

public float sasum(int n,
                   float[] x,
                   int begx,
                   int incx)
            throws BlasException

Computes the sum of the absolute values.

Specified by:: sasum in interface BLAS1I

Parameters:: n - number of vector element; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

saxpy

public void saxpy(int n,
                  float alpha,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Constant times a vector plus a vector: y = y + alpha * x.

Specified by:: saxpy in interface BLAS1I

Parameters:: n - number of vector elements; alpha - constant multiplier of 'x'.; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

scopy

public void scopy(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Copies vector x to vector y: y = x.

Specified by:: scopy in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

sdot

public float sdot(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: sdot in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

srot

public void srot(int n,
                 float[] x,
                 int begx,
                 int incx,
                 float[] y,
                 int begy,
                 int incy,
                 float cos,
                 float sin)
          throws BlasException

Applies a plane rotation: x = cos*x + sin*y & y = cos*y + sin*x

Specified by:: srot in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements; alpha - constant; beta - constant

sscal

public void sscal(int n,
                  float alpha,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException

Scale a vector by a constant: x = alpha * x.

Specified by:: sscal in interface BLAS1I

Parameters:: n - number of vector elements; alpha - scale factor; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

sswap

public void sswap(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Interchange two vectors: x <-> y.

Specified by:: sswap in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

snrm2

public float snrm2(int n,
                   float[] x,
                   int begx,
                   int incx)
            throws BlasException

Computes the euclidean norm of the vector: sqrt(sum(xi^2))

Specified by:: snrm2 in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

isamax

public int isamax(int n,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException

Finds the index of the element with the maximum absolute value.

Specified by:: isamax in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

dzasum

public double dzasum(int n,
                     double[] x,
                     int begx,
                     int incx)
              throws BlasException

Computes the sum of the absolute values.

Specified by:: dzasum in interface BLAS1I

Parameters:: n - number of vector element; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

zaxpy

public void zaxpy(int n,
                  ComplexI alpha,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException

Constant times a vector plus a vector: y = y + alpha * x.

Specified by:: zaxpy in interface BLAS1I

Parameters:: n - number of vector elements; alpha - constant multiplier of 'x'.; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

zcopy

public void zcopy(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException

Copies vector x to vector y: y = x.

Specified by:: zcopy in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

zdotu

public Complex zdotu(int n,
                     double[] x,
                     int begx,
                     int incx,
                     double[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: zdotu in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

zdotc

public Complex zdotc(int n,
                     double[] x,
                     int begx,
                     int incx,
                     double[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: zdotc in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

zscal

public void zscal(int n,
                  ComplexI alpha,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException

Scale a vector by a constant: x = alpha * x.

Specified by:: zscal in interface BLAS1I

Parameters:: n - number of vector elements; alpha - scale factor; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

zswap

public void zswap(int n,
                  double[] x,
                  int begx,
                  int incx,
                  double[] y,
                  int begy,
                  int incy)
           throws BlasException

Interchange two vectors: x <-> y.

Specified by:: zswap in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

scasum

public float scasum(int n,
                    float[] x,
                    int begx,
                    int incx)
             throws BlasException

Computes the sum of the absolute values.

Specified by:: scasum in interface BLAS1I

Parameters:: n - number of vector element; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

caxpy

public void caxpy(int n,
                  ComplexI alpha,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Constant times a vector plus a vector: y = y + alpha * x.

Specified by:: caxpy in interface BLAS1I

Parameters:: n - number of vector elements; alpha - constant multiplier of 'x'.; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

ccopy

public void ccopy(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Copies vector x to vector y: y = x.

Specified by:: ccopy in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

cdotu

public Complex cdotu(int n,
                     float[] x,
                     int begx,
                     int incx,
                     float[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: cdotu in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

cdotc

public Complex cdotc(int n,
                     float[] x,
                     int begx,
                     int incx,
                     float[] y,
                     int begy,
                     int incy,
                     Complex results)
              throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: cdotc in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

cscal

public void cscal(int n,
                  ComplexI alpha,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException

Scale a vector by a constant: x = alpha * x.

Specified by:: cscal in interface BLAS1I

Parameters:: n - number of vector elements; alpha - scale factor; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

cswap

public void cswap(int n,
                  float[] x,
                  int begx,
                  int incx,
                  float[] y,
                  int begy,
                  int incy)
           throws BlasException

Interchange two vectors: x <-> y.

Specified by:: cswap in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

dsdot

public double dsdot(int n,
                    float[] x,
                    int begx,
                    int incx,
                    float[] y,
                    int begy,
                    int incy)
             throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: dsdot in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

sdsdot

public float sdsdot(int n,
                    float[] x,
                    int begx,
                    int incx,
                    float[] y,
                    int begy,
                    int incy)
             throws BlasException

Computes the dot product of two vectors: alpha = x (.) y.

Specified by:: sdsdot in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the 'x' vector elements; begx - offset of the first 'x' vector element; incx - the distance between 'x' vector elements; y - array containing the 'y' vector elements; begy - offset of the first 'y' vector element; incy - the distance between 'y' vector elements

izamax

public int izamax(int n,
                  double[] x,
                  int begx,
                  int incx)
           throws BlasException

Finds the index of the element with the maximum absolute value.

Specified by:: izamax in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

icamax

public int icamax(int n,
                  float[] x,
                  int begx,
                  int incx)
           throws BlasException

Finds the index of the element with the maximum absolute value.

Specified by:: icamax in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

dznrm2

public double dznrm2(int n,
                     double[] x,
                     int begx,
                     int incx)
              throws BlasException

Computes the euclidean norm of the vector: sqrt(sum(xi^2))

Specified by:: dznrm2 in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

scnrm2

public float scnrm2(int n,
                    float[] x,
                    int begx,
                    int incx)
             throws BlasException

Computes the euclidean norm of the vector: sqrt(sum(xi^2))

Specified by:: scnrm2 in interface BLAS1I

Parameters:: n - number of vector elements; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

drotg

public void drotg(Real a,
                  Real b,
                  Real cos,
                  Real sin)
           throws BlasException

Generates the parmseters cos and sin for a plane rotation.

Specified by:: drotg in interface BLAS1I

Parameters:: da -; db -; cos - cosine return value; sin - sine return value

srotg

public void srotg(Real a,
                  Real b,
                  Real cos,
                  Real sin)
           throws BlasException

Generates the parmseters cos and sin for a plane rotation.

Specified by:: srotg in interface BLAS1I

Parameters:: da -; db -; cos - cosine return value; sin - sine return value

zdscal

public void zdscal(int n,
                   double alpha,
                   double[] x,
                   int begx,
                   int incx)
            throws BlasException

Scale a vector by a constant: x = alpha * x.

Specified by:: zdscal in interface BLAS1I

Parameters:: n - number of vector elements; alpha - scale factor; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

csscal

public void csscal(int n,
                   float alpha,
                   float[] x,
                   int begx,
                   int incx)
            throws BlasException

Scale a vector by a constant: x = alpha * x.

Specified by:: csscal in interface BLAS1I

Parameters:: n - number of vector elements; alpha - scale factor; x - array containing the vector elements; begx - offset of the first vector element; incx - the distance between vector elements

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: INNER | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

Method Summary
`void`	`caxpy(int n, ComplexI alpha, float[] x, int begx, int incx, float[] y, int begy, int incy)` Constant times a vector plus a vector: y = y + alpha * x.
`void`	`ccopy(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Copies vector x to vector y: y = x.
`Complex`	`cdotc(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, Complex results)` Computes the dot product of two vectors: alpha = x (.) y.
`Complex`	`cdotu(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, Complex results)` Computes the dot product of two vectors: alpha = x (.) y.
`void`	`cscal(int n, ComplexI alpha, float[] x, int begx, int incx)` Scale a vector by a constant: x = alpha * x.
`void`	`csscal(int n, float alpha, float[] x, int begx, int incx)` Scale a vector by a constant: x = alpha * x.
`void`	`cswap(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Interchange two vectors: x <-> y.
`double`	`dasum(int n, double[] x, int begx, int incx)` Computes the sum of the absolute values.
`void`	`daxpy(int n, double alpha, double[] x, int begx, int incx, double[] y, int begy, int incy)` Constant times a vector plus a vector: y = y + alpha * x.
`void`	`dcopy(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)` Copies vector x to vector y: y = x.
`double`	`ddot(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)` Computes the dot product of two vectors: alpha = x (.) y.
`double`	`dnrm2(int n, double[] x, int begx, int incx)` Computes the euclidean norm of the vector: sqrt(sum(xi^2))
`void`	`drot(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, double cos, double sin)` Applies a plane rotation: x = cosx + siny & y = cosy + sinx
`void`	`drotg(Real a, Real b, Real cos, Real sin)` Generates the parmseters cos and sin for a plane rotation.
`void`	`dscal(int n, double alpha, double[] x, int begx, int incx)` Scale a vector by a constant: x = alpha * x.
`double`	`dsdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Computes the dot product of two vectors: alpha = x (.) y.
`void`	`dswap(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)` Interchange two vectors: x <-> y.
`double`	`dzasum(int n, double[] x, int begx, int incx)` Computes the sum of the absolute values.
`double`	`dznrm2(int n, double[] x, int begx, int incx)` Computes the euclidean norm of the vector: sqrt(sum(xi^2))
`int`	`icamax(int n, float[] x, int begx, int incx)` Finds the index of the element with the maximum absolute value.
`int`	`idamax(int n, double[] x, int begx, int incx)` Finds the index of the element with the maximum absolute value.
`int`	`isamax(int n, float[] x, int begx, int incx)` Finds the index of the element with the maximum absolute value.
`int`	`izamax(int n, double[] x, int begx, int incx)` Finds the index of the element with the maximum absolute value.
`float`	`sasum(int n, float[] x, int begx, int incx)` Computes the sum of the absolute values.
`void`	`saxpy(int n, float alpha, float[] x, int begx, int incx, float[] y, int begy, int incy)` Constant times a vector plus a vector: y = y + alpha * x.
`float`	`scasum(int n, float[] x, int begx, int incx)` Computes the sum of the absolute values.
`float`	`scnrm2(int n, float[] x, int begx, int incx)` Computes the euclidean norm of the vector: sqrt(sum(xi^2))
`void`	`scopy(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Copies vector x to vector y: y = x.
`float`	`sdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Computes the dot product of two vectors: alpha = x (.) y.
`float`	`sdsdot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Computes the dot product of two vectors: alpha = x (.) y.
`float`	`snrm2(int n, float[] x, int begx, int incx)` Computes the euclidean norm of the vector: sqrt(sum(xi^2))
`void`	`srot(int n, float[] x, int begx, int incx, float[] y, int begy, int incy, float cos, float sin)` Applies a plane rotation: x = cosx + siny & y = cosy + sinx
`void`	`srotg(Real a, Real b, Real cos, Real sin)` Generates the parmseters cos and sin for a plane rotation.
`void`	`sscal(int n, float alpha, float[] x, int begx, int incx)` Scale a vector by a constant: x = alpha * x.
`void`	`sswap(int n, float[] x, int begx, int incx, float[] y, int begy, int incy)` Interchange two vectors: x <-> y.
`void`	`zaxpy(int n, ComplexI alpha, double[] x, int begx, int incx, double[] y, int begy, int incy)` Constant times a vector plus a vector: y = y + alpha * x.
`void`	`zcopy(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)` Copies vector x to vector y: y = x.
`Complex`	`zdotc(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, Complex results)` Computes the dot product of two vectors: alpha = x (.) y.
`Complex`	`zdotu(int n, double[] x, int begx, int incx, double[] y, int begy, int incy, Complex results)` Computes the dot product of two vectors: alpha = x (.) y.
`void`	`zdscal(int n, double alpha, double[] x, int begx, int incx)` Scale a vector by a constant: x = alpha * x.
`void`	`zscal(int n, ComplexI alpha, double[] x, int begx, int incx)` Scale a vector by a constant: x = alpha * x.
`void`	`zswap(int n, double[] x, int begx, int incx, double[] y, int begy, int incy)` Interchange two vectors: x <-> y.

drasys.or.linear.blas Class BLAS1

BLAS1

dasum

daxpy

dcopy

ddot

drot

dscal

dswap

dnrm2

idamax

sasum

saxpy

scopy

sdot

srot

sscal

sswap

snrm2

isamax

dzasum

zaxpy

zcopy

zdotu

zdotc

zscal

zswap

scasum

caxpy

ccopy

cdotu

cdotc

cscal

cswap

dsdot

sdsdot

izamax

icamax

dznrm2

scnrm2

drotg

srotg

zdscal

csscal

drasys.or.linear.blas
Class BLAS1