From 6e0ffd144d990ca1299ce2e56a37305802742d8e Mon Sep 17 00:00:00 2001 From: Brian Matzon Date: Sat, 5 Jul 2003 23:59:44 +0000 Subject: [PATCH] removing parts of Math --- src/native/common/MatrixOpCommon.cpp | 346 --------------------------- src/native/common/MatrixOpCommon.h | 116 --------- 2 files changed, 462 deletions(-) delete mode 100644 src/native/common/MatrixOpCommon.cpp delete mode 100755 src/native/common/MatrixOpCommon.h diff --git a/src/native/common/MatrixOpCommon.cpp b/src/native/common/MatrixOpCommon.cpp deleted file mode 100644 index 347ca765..00000000 --- a/src/native/common/MatrixOpCommon.cpp +++ /dev/null @@ -1,346 +0,0 @@ - -//#include -#include -#include -#include "MatrixOpCommon.h" - -bool Matrix::identicalDataSpaces(Matrix & other) -{ - if (address != other.address) - return JNI_FALSE; - if (stride != other.stride) - return JNI_FALSE; - if ((width * height) != (other.width * other.height)) - return JNI_FALSE; - return JNI_TRUE; -} - -bool Matrix::intersectingDataSpaces(Matrix & other) -{ - char * my_max_address = &address[ stride * elements ]; - char * other_max_address = &other.address[ other.stride * other.elements]; - - if (address >= other.address || address <= other_max_address) return JNI_TRUE; - if (other.address >= address || other.address <= my_max_address) return JNI_TRUE; - return JNI_FALSE; -} - -void Matrix::transposeMatrix(float * src, float * dst, int src_width, int src_height) -{ - // square matrix transpose - if (src_width == src_height) - { - for (int i = 0; i < src_width; i++) - for (int j = 0; j < src_width; j++) - dst[i + src_width * j] = src[j + i * src_width]; - } - // non square matrix transpose - else - { - for (int i = 0; i < src_width; i ++) - for (int j = 0; j < src_height; j++) - dst[i + src_height * j] = src[j + i * src_height]; - } -} - -void Matrix::transposeMatrix(float * mat, int src_width, int src_height) -{ - float temp; - - // square matrix transpose - if (src_width == src_height) - { - for (int col = 0; col < src_width; col++) - { - for (int row = col+1; row < src_height; row++) - { - // swap the two elements - temp = mat [col * src_height + row]; - mat[col * src_height + row] = mat[row * src_width + col]; - mat[row * src_width + col] = temp; - } - } - } - // non square matrix transpose - else - { - transposeMatrix(mat, transpose_record, src_width, src_height); - memcpy(mat, transpose_record, src_width * src_height * sizeof(float)); - } - -} - - -MatrixSrc::MatrixSrc ( jint addr, jint s, - jint w, jint h, - jint e, jboolean t): - Matrix(addr, s, e), - record_offset((char *) addr), - record_size (w*h) -{ - if (t) { - width = h; - height = w; - } - else { - width = w; - height = h; - } - - elements = e; - record = new float[width * height]; - - // vectors do not need to be transposed - transpose = (t == JNI_TRUE) && (w != 1) && (h != 1); - - if (transpose && (width != height)) - // only need temp storage for transpose if the matrix is not square - transpose_record = new float[width*height]; - else - transpose_record = 0; - - if (elements == 1) - { - // fool the nextMatrix function into returning a value - elements = 2; - nextMatrix(); - elements = 1; - } -} - -MatrixSrc::~MatrixSrc() -{ - //cout << "MatrixSrc destructor \n"; - - delete [] record; - - if (transpose_record != 0) - delete [] transpose_record; -} - -float * MatrixSrc::nextMatrix() -{ - if (elements > 1) - { - //cout << "Elements: " << elements << "\n"; - //cout << "Address: " << (unsigned int) (record_offset) << "\n"; - - // the record is not properly aligned - if ((unsigned int) (record_offset) & FLOAT_ALIGNMENT) - { - // copy the floats into a buffer so that they are aligned - // on 4 byte margins (not necessary on intel, but a good thing) - - memcpy (record, record_offset, record_size * sizeof(float)); - - if (transpose) - transposeMatrix (record, height, width); - - record_offset = &record_offset[stride]; - current_record_ptr = record; - } - // the record is aligned but it has to be transposed - else if (transpose) - { - transposeMatrix ((float *) (record_offset), record, height, width); - record_offset = &record_offset[stride]; - current_record_ptr = record; - } - // nothing has to be done to the record - else - { - // the floats are aligned in memory - current_record_ptr = (float *) record_offset; - record_offset = &record_offset[stride]; - } - } - - return current_record_ptr; -} - -MatrixDst::MatrixDst (jint addr, jint s, jint w, jint h, jint e, jboolean t): - Matrix(addr, s, e) -{ - width = w; - height = h; - record_size = width * height; - record = new float[record_size]; - - // vectors do not need to be transposed - transpose = (t) && (w != 1) && (h != 1); - - if (transpose) - transpose_record = new float[width*height]; - else - transpose_record = 0; - - data_buffered = JNI_FALSE; - record_buffered = JNI_FALSE; - - record_offset = address - stride; -} - -MatrixDst::~MatrixDst() -{ - //cout << "MatrixDst destructor \n"; - - delete [] record; - if (transpose_record != 0) - delete [] transpose_record; - - // copy back any buffered data - if (data_buffered) - { - char * src = buffer; - char * dest = address; - - for (int i = 0; i < elements; i++) - { - memcpy(dest, src, record_size * sizeof(float)); - src += stride; - dest += stride; - } - - delete [] buffer; - } -} - -void MatrixDst::configureBuffer(MatrixSrc & a, MatrixSrc & b) -{ - - - if (!a.intersectingDataSpaces(b)) - { - // as long as the output only overlays 1 of the sources, and the other - // source only has 1 matrix in it, only a record_buffer is required - if (a.elements == 1 && identicalDataSpaces(b)) - record_buffered = JNI_TRUE; - else if (b.elements == 1 && identicalDataSpaces(a)) - record_buffered = JNI_TRUE; - else - // otherwise all of the output has to be buffered - createBuffer(); - } - else - createBuffer(); -} - -void MatrixDst::configureBuffer(MatrixSrc & a) -{ - if (identicalDataSpaces(a)) - record_buffered = JNI_TRUE; - else if (intersectingDataSpaces(a)) - createBuffer(); -} - -void MatrixDst::createBuffer() -{ - data_buffered = JNI_TRUE; - buffer = new char[ elements * stride ]; - record_offset = buffer - stride; -} - -float * MatrixDst::nextMatrix() -{ - record_offset = &record_offset[stride]; - int alignment = ((unsigned int)(record_offset)) & FLOAT_ALIGNMENT; - - if (transpose || record_buffered || alignment) - { - last_record_in_temp = JNI_TRUE; - return record; - } - else - { - last_record_in_temp = JNI_FALSE; - return (float *) record_offset; - } -} - - -void MatrixDst::writeComplete() -{ - if (last_record_in_temp) - { - // 3 reasons why the record would be in temp - // - // 1. The record is not aligned - // 2. The result will need to be transposed - // 3. Direct Mode where result would overlay an operand - - if (((unsigned int)(record_offset)) & FLOAT_ALIGNMENT) - { - if (transpose) - transposeMatrix(record, width, height); - memcpy (record, record_offset, record_size * sizeof(jfloat)); - } - else if (transpose) - { - transposeMatrix(record, (float *) &record_offset[0], width, height); - } - else - memcpy (record_offset, record, record_size * sizeof(jfloat)); - } -} - -/////////////////////////////////////////////////////////////////////////// - -void subMatrix (const float * src, int side, float * dst , int col_omit, int row_omit) -{ - int index = 0; - int src_index = 0; - - for (int c = 0; c < side; c++) - { - if (c == col_omit) - { src_index += side; - continue; - } - for (int r = 0; r < side; r++) - { - if (r == row_omit) - { src_index++; - continue; - } - dst[index++] = src[src_index++]; - } - } -} - -float determinant (const float * matrix , int side) -{ - - - // we are assuming for this case that the data is in column major format - - float det = 0; - - if (side == 2) - // your basic cross product aka 2x2 determinant - det = matrix[0] * matrix[3] - matrix[2] * matrix[1]; - else - { - // create room to store the sub matrix - int temp_side = side - 1; // the dimensions of the sub matrix - float * temp_matrix = new float[temp_side * temp_side]; - - // keep the sign (this way we avoid an additional branch in the inner loop) - float sign = 1; - - for (int row = 0; row < side; row++) - { - // get a sub matrix by eliminating the 0th col and the specified row - subMatrix(matrix, side, temp_matrix, 0, row); - - // add to the determinant sign * [a]i0 * [M]i0 - det += sign * matrix[row] * determinant (temp_matrix, temp_side); - - // alternate the sign - sign *= -1; - } - - delete [] temp_matrix; - } - - return det; -} diff --git a/src/native/common/MatrixOpCommon.h b/src/native/common/MatrixOpCommon.h deleted file mode 100755 index 181058ec..00000000 --- a/src/native/common/MatrixOpCommon.h +++ /dev/null @@ -1,116 +0,0 @@ -/* - * 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(); - -}; - -