|
|
/*
File: vectorOps.h Contains: vector and matrix functions for AltiVec Version: QuickTime 7.3 Copyright: (c) 2007 (c) 1999-2001 by Apple Computer, Inc., all rights reserved. Bugs?: For bug reports, consult the following page on the World Wide Web: http://developer.apple.com/bugreporter/
*/#ifndef __VECTOROPS__
#define __VECTOROPS__
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
#if PRAGMA_ONCE
#pragma once
#endif
#ifdef __cplusplus
extern "C" {#endif
#if PRAGMA_IMPORT
#pragma import on
#endif
/*
------------------------------------------------------------------------------------- This section is a collection of Basic Linear Algebra Subprograms (BLAS), which use AltiVec technology for their implementations. The functions are grouped into three categories (called levels), as follows: 1) Vector-scalar linear algebra subprograms 2) Matrix-vector linear algebra subprograms 3) Matrix operations Following is a list of subprograms and a short description of each one. -------------------------------------------------------------------------------------*/#ifdef __VEC__
/*
------------------------------------------------------------------------------------- Level 1-------------------------------------------------------------------------------------*//**************************************************
vIsamax finds the position of the first vector element having the largest magnitude. count length of vector x (count is a multiple of 4) x array of floats **************************************************//*
* vIsamax() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( long )vIsamax( long count, const vector float x[]);
/**************************************************
vIsamin finds the position of the first vector element having minimum absolute value. count length of vector x (count is a multiple of 4) x array of floats **************************************************//*
* vIsamin() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( long )vIsamin( long count, const vector float x[]);
/**************************************************
vIsmax finds the position of the first vector element having maximum value. count length of vector x (count is a multiple of 4) x array of floats **************************************************//*
* vIsmax() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( long )vIsmax( long count, const vector float x[]);
/**************************************************
vIsmin finds the position of the first vector element having minimum value. count length of vector x (count is a multiple of 4) x array of floats **************************************************//*
* vIsmin() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( long )vIsmin( long count, const vector float x[]);
/**************************************************
vSasum finds the sum of the magnitudes of the elements in a vector. count length of vector x (count is a multiple of 4) x array of floats **************************************************//*
* vSasum() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( float )vSasum( long count, const vector float x[]);
/**************************************************
vSsum is the vector version of sasum but without the absolute value. It takes the value of each element of the array and adds them together. multiple of 4) x array of floats **************************************************//*
* vSsum() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( float )vSsum( long count, const vector float x[]);
/**************************************************
vSaxpy multiplies a vector x, by a scalar and adds it to a vector y and stores the result in y n number of floats in x (n is a multiple of 4) alpha scalar number is single-precision floating-point x array of vector floats y array of vector floats, where the the result is stored **************************************************//*
* vSaxpy() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSaxpy( long n, float alpha, const vector float x[], vector float y[]);
/*************************************************************
vScopy copies a vector x, into another vector y. n mumber of floats in x and y (n is a multiple of 4) x array of vector floats y array of vector floats *************************************************************//*
* vScopy() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vScopy( long n, const vector float x[], vector float y[]);
/*************************************************************
vSdot finds the dot product of two vectors. n mumber of floats in x and y (n is a multiple of 4) x array of vector floats y array of vector floats *************************************************************//*
* vSdot() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( float )vSdot( long n, const vector float x[], const vector float y[]);
/*************************************************************
vSnaxpy computes saxpy "n" times. n number of saxpyV computations to be performed and the number of elements in vector A (n is a multiple of 4) m number of floats in each vector x(i) or y(i) a array of vector floats containing scalars a(i) x matrix containing arrays of vector- floats x(i) y matrix containing vectors y(i) *************************************************************//*
* vSnaxpy() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSnaxpy( long n, long m, const vector float a[], const vector float x[], vector float y[]);
/*************************************************************
vSndot computes the dot products "n" times. n number of dot product computations to be performed and the number of elements in vector S m number of elements in vectors x(i) and y(i) for each dot product computation (m is a multiple of 4) s array of floats. Depending on the value of "isw" different computations/ are performed and the results are stored in the array S isw indicates the type of computation to perform. if isw=1, S(i) <-- x(i) y(i) if isw=2, S(i) <-- - x(i) y(i) if isw=3, S(i) <-- S(i) + x(i) y(i)/ if isw=4, S(i) <-- S(i) - x(i) y(i)/ x matrix containing arrays x(i) y matrix containing arrays y(i) *************************************************************//*
* vSndot() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSndot( long n, long m, float s[], long isw, const vector float x[], const vector float y[]);
/*************************************************************
vSnrm2 finds the Euclidean length of a vector with scaling of input to avoid destructive underflow and overflow. count length of vector (multiple of 4) x array of vector floats *************************************************************//*
* vSnrm2() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( float )vSnrm2( long count, const vector float x[]);
/*************************************************************
vSnorm2 finds the Euclidean length of a vector with no scaling of input. count length of vector (multiple of 4) x array of vector floats *************************************************************//*
* vSnorm2() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( float )vSnorm2( long count, const vector float x[]);
/*************************************************************
vSrot applies a plane rotation. n number of points to be rotated, also number of elements in x and y (n is a multiple of 4) x array of vector floats. It is a vector of length n, containing x(i) coordinates of points to be rotated y array of vector floats. It is a vector of length n, containing y(i) coordinates of points to be rotated c cosine of angle of rotation s sine of angle of rotation *************************************************************//*
* vSrot() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSrot( long n, vector float x[], vector float y[], float c, float s);
/*************************************************************
vSscal multiplies a vector x, by a scalar and stores the result in the vector x. n number of floats in x (n is a multiple of 4) alpha scalar number is single-precision floating-point x array of vector floats *************************************************************//*
* vSscal() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSscal( long n, float alpha, vector float x[]);
/*************************************************************
vSswap interchanges the elements of vectors x and y n number of floats in x and y (n is a multiple of 4) x array of vector floats y array of vector floats *************************************************************//*
* vSswap() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSswap( long n, vector float x[], vector float y[]);
/*************************************************************
vSyax multiplies a vector x, by a scalar and stores the result in a vector y. n number of floats in x (n is a multiple of 4) alpha scalar number is single-precision floating-point x array of vector floats y array of vector floats *************************************************************//*
* vSyax() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSyax( long n, float alpha, const vector float x[], vector float y[]);
/*************************************************************
vSzaxpy multiplies a vector x, by a scalar and adds it to a vector y and stores the result in vector Z. n number of floats in x (n is a multiple of 4) alpha scalar number is single-precision floating-point x array of vector floats y array of vector floats Z array of vector floats, where the is stored *************************************************************//*
* vSzaxpy() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSzaxpy( long n, float alpha, const vector float x[], const vector float yY[], vector float z[]);
/*
------------------------------------------------------------------------------------- Level 2-------------------------------------------------------------------------------------*//*************************************************************
vSgemv multiplies an array of vector floats y by a scalar beta, and takes the result and adds it to the product of a scalar alpha multiplied by a matrix A multiplied by a vector x. The above result is stored in array y. Futhermore, the same function also performs the above calculation/ with the transpose of matrix A, instead of matrix A. In this function argument "forma" distinguishes between the above two cases. forma indicates the form of matrix A to use in the computation, where: If forma = "n", Matrix A is used If forma = "T", Transpose of Matrix A is used m number of rows in matrix A and depending on value of forma if forma = "n", it is the length of vector y if forma = "T", it is the length of vector x. m is a multiple of 4 n number of columns in matrix A and depending on value of forma if forma = "n", it is the length of vector x if forma = "T", it is the length of vector y. m is a multiple of 4 alpha is a scaling constant A is an m by n matrix. Its elements are vector floats x is an array of vector floats beta is a scaling constant y is an array of vector floats *************************************************************//*
* vSgemv() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgemv( char forma, long m, long n, float alpha, const vector float a[], const vector float x[], float beta, vector float y[]);
/*************************************************************
vSgemx adds an array of vector floats y to the product of an scalar alpha by a mtrix A multiplied by an array of vector floats x. It then stores the result in the vector y. m number of rows in matrix A and the length of vector y. m is a multiple of 4 n number of columns in matrix A and the length of vector x. m is a multiple of 4 alpha is a scaling constant a is an m by n matrix. Its elements are vector floats x is an array of vector floats y is an array of vector floats *************************************************************//*
* vSgemx() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgemx( long m, long n, float alpha, const vector float a[], const vector float x[], vector float y[]);
/*************************************************************
vSgemtx takes the transpose of a mtrix A and multiplies it by an array x. It then multiplies the result by a scalar alpha. Finally adds the above result to an array y and stores the result in array y. m number of rows in matrix A and the length of vector x. m is a multiple of 4 n number of columns in matrix A and the length of vector y. m is a multiple of 4 alpha is a scaling constant a is an m by n matrix. Its elements are vector floats x is an array of vector floats y is an array of vector floats *************************************************************//*
* vSgemtx() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgemtx( long m, long n, float alpha, const vector float a[], const vector float x[], vector float y[]);
/*
------------------------------------------------------------------------------------- Level 3-------------------------------------------------------------------------------------*/
/*************************************************************
vSgeadd performs matrix addition for general matrices or their transposes. height height of the matrix (it is multiple of 4) width width of the matrix (it is multiple of 4) A matrix A, and depending on forma: if forma='n', A is used in the computation, and A has m rows and n columns if forma='T', A(T) is used in the computation, and A has n rows and m columns forma indicates the form of matrix A to use in the computation, where: if forma='n', A is used in the computation if forma='T', A(T) is used in the computation b matrix b, and depending on formb: if formb='n', b is used in the computation, and b has m rows and n columns if formb='T', b(T) is used in the computation, and b has n rows and m columns formb indicates the form of matrix b to use in the computation, where: if forma='n', b is used in the computation if forma='T', b(T) is used in the computation c is an m by n matrix c, containing the reults of the computation *************************************************************//*
* vSgeadd() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgeadd( long height, long width, const vector float a[], char forma, const vector float b[], char formb, vector float c[]);
/*************************************************************
vSgesub performs matrix subtraction for general matrices or their transposes. height height of the matrix (it is multiple of 4) width width of the matrix (it is multiple of 4) A matrix A, and depending on forma: if forma='n', A is used in the computation, and A has m rows and n columns if forma='T', A(T) is used in the computation, and A has n rows and m columns forma indicates the form of matrix A to use in the computation, where: if forma='n', A is used in the computation if forma='T', A(T) is used in the computation b matrix b, and depending on formb: if formb='n', b is used in the computation, and b has m rows and n columns if formb='T', b(T) is used in the computation, and b has n rows and m columns formb indicates the form of matrix b to use in the computation, where: if forma='n', b is used in the computation if forma='T', b(T) is used in the computation c is an m by n matrix c, containing the reults of the computation *************************************************************//*
* vSgesub() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgesub( long height, long width, const vector float a[], char forma, const vector float b[], char formb, vector float c[]);
/*************************************************************
vSgemul performs matrix multiplication for general matrices or their transposes. l height of the matrix A (it is multiple of 4) m width of matrix A (it is multiple of 4) n width of matrix b (it is multiple of 4) A matrix A, and depending on forma: if forma='n', A is used in the computation, and A has l rows and m columns if forma='T', A(T) is used in the computation, and A has m rows and l columns forma indicates the form of matrix A to use in the computation, where: if forma='n', A is used in the computation if forma='T', A(T) is used in the computation b matrix b, and depending on formb: if formb='n', b is used in the computation, and b has m rows and n columns if formb='T', b(T) is used in the computation, and b has n rows and m columns formb indicates the form of matrix b to use in the computation, where: if forma='n', b is used in the computation if forma='T', b(T) is used in the computation matrix is the matrix containing the results of the computation *************************************************************//*
* vSgemul() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgemul( long l, long m, long n, const vector float a[], char forma, const vector float b[], char formb, vector float matrix[]);
/*************************************************************
vSgemm performs combined matrix multiplication and addition for general matrices or their transposes. l number of rows in matrix c (it is multiple of 4) m has the following meaning: if forma='n', it is the number of columns in matrix A if forma='T', it is the number of rows in matrix A. In addition if formb='n', it is the number of rows in matrix b if formb='T', it is the number of columns in matrix b n columns in matrix c A matrix A, and depending on forma: if forma='n', A is used in the computation, and A has l rows and m columns if forma='T', A(T) is used in the computation, and A has m rows and l columns forma indicates the form of matrix A to use in the computation, where: if forma='n', A is used in the computation if forma='T', A(T) is used in the computation b matrix b, and depending on formb: if formb='n', b is used in the computation, and b has m rows and n columns if formb='T', b(T) is used in the computation, and b has n rows and m columns formb indicates the form of matrix b to use in the computation, where: if forma='n', b is used in the computation if forma='T', b(T) is used in the computation alpha is a scalar beta is a scalar matrix is the l by n matrix *************************************************************//*
* vSgemm() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgemm( long l, long m, long n, const vector float a[], char forma, const vector float b[], char formb, vector float c[], float alpha, float beta, vector float matrix[]);
/*************************************************************
vSgetmi performs general matrix transpose (in place). size is the number of rows and columns in matrix x *************************************************************//*
* vSgetmi() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgetmi( long size, vector float x[]);
/*************************************************************
vSgetmo performs general matrix transpose (out-of-place). height is the height of the matrix width is the width of the matrix x array of vector floats y array of vector floats *************************************************************//*
* vSgetmo() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgetmo( long height, long width, const vector float x[], vector float y[]);
/*************************************************************
vSgevv is a new function. It takes matrix A and multiplies it by matrix b and puts the result in matrix m. l is the height of the matrix n is the width of the matrix A array of vector floats of at least l * m in length b array of vector floats of at least m * n in length m array of vector floats, containing the results of multiplication. It is m * n in size *************************************************************//*
* vSgevv() * * Availability: * Non-Carbon CFM: in vecLib 1.0 and later * CarbonLib: not in Carbon, but vecLib is compatible with CarbonLib * Mac OS X: in version 10.0 and later */EXTERN_API_C( void )vSgevv( long l, long n, const vector float a[], const vector float b[], vector float m[]);
#endif /* defined(__VEC__) */
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
#ifdef __cplusplus
}#endif
#endif /* __VECTOROPS__ */
|
