1HEADmaster

1 files changed, 1015 insertions, 0 deletions

diff --git a/common/quicktime_win32/vectorOps.h b/common/quicktime_win32/vectorOps.h
new file mode 100644
index 0000000..4b240d1
--- /dev/null
+++ b/common/quicktime_win32/vectorOps.h
@@ -0,0 +1,1015 @@
+/*
+     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__ */
+