/*
 *  Matrix.h
 *  
 *
 *  Created by tristan on Sat Aug 24 2002.
 *  Copyright (c) 2001 __MyCompanyName__. All rights reserved.
 *
 */
 


////////////////////////////////////////////////////////////////////////////////////////
// Utility Functions
////////////////////////////////////////////////////////////////////////////////////////

#define FLOAT_ALIGNMENT 0x00000003

// 23 bit mantisa on a float (we need error for checking if two nums are equal)
// for now use error of 1/2^18, this could be refined up to 1/2^22 if needed
#define FLOATING_POINT_ERROR (1.0f/262144.0f)

// check if two numbers are approximately equal, used when floating point errors
// occur.  Should NEVER check to see if two floats are identical

inline bool approxEqual(float a, float b)
{
    a -= b;
    a = (a < 0) ? -a: a;
    return (a < FLOATING_POINT_ERROR);
}

float determinant (const float * matrix , int side);
void subMatrix    (const float * src, int side, float * dst , int col_omit, int row_omit);



///////////////////////////////////////////////////////////////////////////////////////
// Matrix
//////////////////////////////////////////////////////////////////////////////////////

class Matrix
{
    protected:
        float * transpose_record;		// to use while transposing the record

    public:
        char * address;		// the start of the data
        jint stride;		// the distance between each record   
        jint 	 width, 	// the width of the matrix
                 height, 	// the height of the matrix
                 elements;	// the number of matricies
        jboolean transpose;	// whether this matrix is or will be transposed
       
        Matrix (jint a, jint s, jint e):
            address((char *)a), stride(s), elements(e) {}
        bool identicalDataSpaces   (Matrix & other);
        bool intersectingDataSpaces(Matrix & other);
        void transposeMatrix(float * src, float * dst, int src_width, int src_height);
        void transposeMatrix(float * mat, int src_width, int src_height);
};

///////////////////////////////////////////////////////////////////////////////////////
// Src Matrix
//////////////////////////////////////////////////////////////////////////////////////

class MatrixSrc: public Matrix
{
    private:
        char * record_offset;		// the offset of this record in memory
    
        float * record;			// temporary storage to store a fully aligned and transposed
                                        // copy of the record, if the one in memory is not so
        float * current_record_ptr;	// the address of the memory containing the record last
                                        // returned by the nextMatrix() function
        jint record_size;		// the total floats in each record

    public:
        MatrixSrc ( jint address, jint stride, jint width, jint height, jint elements, jboolean transpose);
        ~MatrixSrc();
        
        void rewind() {	record_offset = address; }
        float * nextMatrix();

};

///////////////////////////////////////////////////////////////////////////////////////
// Dst Matrix
//////////////////////////////////////////////////////////////////////////////////////

class MatrixDst: public Matrix
{
    private:
        char  * record_offset;	// the offset of the record in memory
    
        jboolean data_buffered;	// if all of the data has to be buffered
        char * buffer;		// a buffer used when data_buffered
        
        jboolean last_record_in_temp;
        jboolean record_buffered;	// if only a single record is buffered
        float * record;		// to store data if source is unaligned
        
        jint record_size;
        void createBuffer();

    public:
        MatrixDst (jint address, jint stride, jint width, jint height, jint elements, jboolean transpose);
        ~MatrixDst();
        void configureBuffer(MatrixSrc & a, MatrixSrc & b);        
        void configureBuffer(MatrixSrc & a);    
        
        float * nextMatrix();
        void writeComplete();

};