C++ DoubleMatrix::size方法代码示例

void TimeWarp::createCombinedMatrix(DoubleMatrix myChromaMatrix, DoubleVector energyVector, DoubleMatrix* chromaEnergyMatrix){
	chromaEnergyMatrix->clear();
	int sizeRatio = energyVector.size() / myChromaMatrix.size();//
	printf("COMBINE: size of my chroma is %i\n", (int) myChromaMatrix.size());// energyVector.size() / myChromaMatrix.size();
	printf("COMBINED: size ratio of energy to chroma is %i \n", sizeRatio);
	int chromaSize = myChromaMatrix.size();	
//	printf("index is %i\n", index);
	
	for (int i = 0;i < energyVector.size();i++){
		DoubleVector d;
		int index = min(chromaSize-1, (int) floor(i/sizeRatio));

		for (int y = 0;y < 12;y++){
			d.push_back(myChromaMatrix[index][y]);//
		}

		
		d.push_back(energyVector[i]);
					(*chromaEnergyMatrix).push_back(d);
	}
	printf("COMBINED: size of chroma energy is %i\n", (int)(*chromaEnergyMatrix).size());

//	int x = (int)(*chromaEnergyMatrix).size()/3;
//	printf("energy[%i] %f \n", x, energyVector[x]);
/*
 for (int y = 0;y < 13;y++){
		printf("chroma[%i][%i] %f \n", x, y, myChromaMatrix[x/sizeRatio][y]);
		printf("c[%i][%i] %f \n", x, y, (*chromaEnergyMatrix)[x][y]);
	}
		printf("\n");
*/	

}

/*!
 * \brief assertSizeEqual Asserts that the two matrices
 * given as parameters are of equal size.
 * Throws an invalid argument exception if that is not the case.
 * \param A First matrix.
 * \param B Second matrix.
 */
void assertSizeEqual(const DoubleMatrix &A, const DoubleMatrix &B)
{
    if(A.size() != B.size())
    {
        throw std::invalid_argument("Matrices are not of equal size!");
    }
}

void EXPECT_MATRIX_DOUBLE_EQ(DoubleMatrix A, DoubleMatrix B, string message = ""){
	EXPECT_EQ(A.size(), B.size()) << "Number of lines is different. " << message;
	EXPECT_EQ(A[0].size(), B[0].size()) << "Number of columns is different. " << message;
	unsigned int N = A.size();
	unsigned int M = A[0].size();
	for (unsigned int i = 0; i < N; i++){
		for (unsigned int j = 0; j < M; j++)
			EXPECT_FLOAT_EQ(A[i][j], B[i][j]) << message;
	}
}

void StopRule::multiple (DoubleMatrix &mat1, DoubleVector &vec2, DoubleVector &proVec) {
	int row_, col_;
	proVec.resize(mat1.size());

	for (row_ = 0; row_ < mat1.size (); row_ ++) {
		proVec[row_] = 0.0;
		for (col_ = 0; col_ < mat1[0].size(); col_ ++)
			proVec[row_] += mat1[row_][col_] * vec2[col_];
	}
}

MatlabEngine::DoubleMatrix
MatlabEngine::GetMatrix( const string& inExp )
{
    DoubleMatrix result;
    mxArray* ans = GetMxArray( inExp );
    if( ans )
    {
        int numDims = mxGetNumberOfDimensions( ans );
        const int* dims = mxGetDimensions( ans );
        if( numDims != 2 )
            bcierr << "Can only handle two dimensions" << endl;
        result.resize( dims[ 0 ], vector<double>( dims[ 1 ] ) );
        double* value = mxGetPr( ans );
        if( value )
        {
            int indices[] = { 0, 0 };
            for( size_t i = 0; i < result.size(); ++i )
            {
                indices[ 0 ] = i;
                for( size_t j = 0; j < result[ i ].size(); ++j )
                {
                    indices[ 1 ] = j;
                    result[ i ][ j ] = value[ mxCalcSingleSubscript( ans, 2, indices ) ];
                }
            }
        }
        mxDestroyArray( ans );
    }
    return result;
}

int TimeWarp::getMinimumIndexOfRowFromMatrix(int j, DoubleMatrix& matrix){
	int minimumIndex = 0;
	
	double minimumValue = 0;
	
	int width = matrix.size();
	if (j >= 0 && width > 0 && j < matrix[0].size()){//&& i < matrix.size()
		//int height = (*matrix)[i].size();
		
		int i = 0;
		minimumValue = matrix[i][j];
		while (i < width){
			if (matrix[i][j] < minimumValue){
				minimumIndex = i;
				minimumValue = matrix[i][j];
			}//end if new value
			i++;
		}
	}else{
		printf("ERROR FROM GETTING MINIMIM!!! - zero - out of bounds, received %i and size is %i\n", j, (int)matrix.size());
	}
	
//	printf("minimum row index is %i\n", minimumIndex);
	return minimumIndex;
}

int TimeWarp::findMinimumOfMatrixColumn(DoubleMatrix d, int column){
	int minimumIndex = 0;
	
	double minimumValue = d[column][0];
	for (int i = 0;i < d.size();i++){
		if (d[column][i] < minimumValue){
			minimumIndex = i;
			minimumValue = d[column][i];
		}
	}
	
	return minimumIndex;
}

void TimeWarp::calculateCausalChromaSimilarityMatrix(DoubleMatrix& firstChromaMatrix, DoubleMatrix& secondChromaMatrix, DoubleMatrix& simMatrix){
	//calculates the chroma only similarity matrix 
	//but we have already done some, so is extending it...
	
	int size = 0;
	if (simMatrix.size() > 0){
		size = simMatrix[0].size();
	}
	
	if (secondChromaMatrix.size() > size ){
	
	for (int x = 0;x < firstChromaMatrix.size();x++){
		
		if (x < simMatrix.size()){
			//i.e. entries already exist
				for (int y = (int)simMatrix[x].size();y < secondChromaMatrix.size();y++){
					double distance;
					if (useDotProduct)
					distance = getChromaSimilarity(x, y, &firstChromaMatrix, &secondChromaMatrix);
					else
					distance = getEuclideanDistance(x, y, &firstChromaMatrix, &secondChromaMatrix);
				
					printf("putting one back X %i Y %i dist %f \n", x, y, distance);
					simMatrix[x].push_back(distance);
				}
			}
		else {
			DoubleVector d;
			for (int y = 0;y < secondChromaMatrix.size();y++){
					double distance;
					if (useDotProduct)
					distance = getChromaSimilarity(x, y, &firstChromaMatrix, &secondChromaMatrix);
					else
					distance = getEuclideanDistance(x, y, &firstChromaMatrix, &secondChromaMatrix);
			
				printf("new row X %i Y %i dist %f\n", x, y, distance);
					d.push_back( distance);	
				}
				simMatrix.push_back(d);
			}
		}
	}
			if (size > 0)
				printf("Causial CHROMA ONLY SIM SIZE %i x %i; ", (int)simMatrix.size(), (int) simMatrix[0].size());
		printf("First matrix SIZE %i , SECOND size %i\n", (int)firstChromaMatrix.size(), (int) secondChromaMatrix.size());	

	
}

bool
MatlabEngine::PutMatrix( const string& inExp, const DoubleMatrix& inValue )
{
    int sizeDim2 = inValue.empty() ? 0 : inValue[ 0 ].size();
    mxArray* val = mxCreateNumericMatrix( inValue.size(), sizeDim2, mxDOUBLE_CLASS, mxREAL );
    double* data = mxGetPr( val );
    if( data )
    {
        int indices[] = { 0, 0 };
        for( size_t i = 0; i < inValue.size(); ++i )
        {
            indices[ 0 ] = i;
            for( size_t j = 0; j < inValue[ i ].size(); ++j )
            {
                indices[ 1 ] = j;
                data[ mxCalcSingleSubscript( val, 2, indices ) ] = inValue[ i ][ j ];
            }
        }
    }
    bool success = PutMxArray( inExp, val );
    mxDestroyArray( val );
    return success;
}

bool
MatlabEngine::PutMatrix( const string& inExp, const DoubleMatrix& inValue )
{
  mwSize sizeDim2 = static_cast<mwSize>( inValue.empty() ? 0 : inValue[ 0 ].size() );
  mxArray* val = mxCreateNumericMatrix_( static_cast<mwSize>( inValue.size() ), sizeDim2, mxDOUBLE_CLASS, mxREAL );
  double* data = mxGetPr_( val );
  if( data )
  {
    mwIndex indices[] = { 0, 0 };
    for( mwIndex i = 0; i < static_cast<mwIndex>( inValue.size() ); ++i )
    {
      indices[ 0 ] = i;
      for( mwIndex j = 0; j < static_cast<mwIndex>( inValue[ i ].size() ); ++j )
      {
        indices[ 1 ] = j;
        data[ mxCalcSingleSubscript_( val, 2, indices ) ] = inValue[ i ][ j ];
      }
    }
  }
  bool success = PutMxArray( inExp, val );
  mxDestroyArray_( val );
  return success;
}

void TimeWarp::calculateAlignmentMatrix(DoubleMatrix firstMatrix, DoubleMatrix secondMatrix, DoubleMatrix* alignmentMatrix){//, DoubleMatrix simMatrix
	printf("starting Alignment calculation\n");
	//initialise alignment
	alignmentMatrix->clear();

	DoubleVector d;
	d.push_back(getDistance(0,0));
	(*alignmentMatrix).push_back(d);
	
	bool chromaCalculated = false;
	bool secondCalculated = false;
	
	while (!chromaCalculated || !secondCalculated) {
		
		if (!chromaCalculated)
			chromaCalculated = extendAlignmentAlong((int) firstMatrix.size(), alignmentMatrix);
		
		if (!secondCalculated)
			secondCalculated = extendAlignmentUp((int) secondMatrix.size(), alignmentMatrix);
		
	}
	printf("Alignment matrix calculated, size %i\n", (int) (*alignmentMatrix).size());
}

DoubleMatrix mult(DoubleMatrix& m2, ComplexMatrix& m1)
{
    //  Check dimensions
    unsigned int m1_nRows = m1.numRows();
    unsigned int m2_nRows = m2.numRows();
    unsigned int m1_nColumns = m1.numCols();
    unsigned int m2_nColumns = m2.numCols();

    if (m1.size() == 0)
    {
        return real(m1);
    }

    if (m2.size() == 0)
    {
        return m2;
    }

    DoubleMatrix result(m1_nRows, m2_nColumns);
    if (m1_nColumns == m2_nRows)
    {
        for (unsigned int row = 0; row < result.numRows(); row++)
        {
            for (unsigned int col = 0; col < m2_nColumns; col++)
            {
                double sum = 0.0;
                for (unsigned int k = 0; k < m1_nColumns; k++)
                {
                    sum = sum + (real(m1[row][k]) * m2[k][col]);
                }
                result[row][col] = sum;
            }
        }
        return result;
    }

    if (m1_nRows == m2_nColumns)
    {
        return mult(m2, m1);
    }

    throw ("Incompatible matrix operands to multiply");
}

DoubleMatrix ParseMatrixFromText(const string& textMatrix)
{
	DoubleMatrix mat;

    //Parse the matrix
    vector<string> rows = splitString(textMatrix, "\n");
    for(int row = 0; row < rows.size(); row++)
    {
        vector<string> values = splitString(rows[row], " \t");
        for(int col = 0; col < values.size(); col++)
        {
        	if(!mat.size())
            {
                mat.resize(rows.size(), values.size());
            }

            mat(row, col) = toDouble(values[col]);
        }
    }
	return mat;
}

void TimeWarp::calculateRestrictedCausalChromaSimilarityMatrix(DoubleMatrix& firstChromaMatrix, DoubleMatrix& secondChromaMatrix, DoubleMatrix& simMatrix, const int& Xstart, const int& Ystart, const int& Xlimit, const int& yLimit){
//calculates the chroma only similarity matrix - used to reduce computation later when doing the joint energy and chroma matrix
	DoubleVector d;
	
	int size = 0;
	if (simMatrix.size() > 0){
		size = simMatrix[0].size();
	}
	
	if (secondChromaMatrix.size() > size ){
	//	printf("sim matrix size %i and second matrix size %i Xstart %i\n", simMatrix.size(), secondChromaMatrix.size(), Xstart);
		for (int x = 0;x < Xstart;x++){
			simMatrix[x].push_back(0);
		}
		
		int endX = min(Xlimit, (int)firstChromaMatrix.size());
		
		
		for (int x = Xstart;x < endX;x++){
	
			if (x < simMatrix.size()){
				//i.e. entries already exist
				for (int y = (int)simMatrix[x].size();y < secondChromaMatrix.size();y++){
					double distance;
					if (useDotProduct)
						distance = getChromaSimilarity(x, y, &firstChromaMatrix, &secondChromaMatrix);
					else
						distance = getEuclideanDistance(x, y, &firstChromaMatrix, &secondChromaMatrix);
					
					//	printf("X %i Y %i dist %f\n", x, y, distance);
					simMatrix[x].push_back(distance);
				}
			}
			else {
				DoubleVector d;
				for (int y = 0;y < secondChromaMatrix.size();y++){
					double distance;
					if (useDotProduct)
						distance = getChromaSimilarity(x, y, &firstChromaMatrix, &secondChromaMatrix);
					else
						distance = getEuclideanDistance(x, y, &firstChromaMatrix, &secondChromaMatrix);
					
					//	printf("new row X %i Y %i dist %f\n", x, y, distance);
					d.clear();
					d.push_back( distance);	
				}
				simMatrix.push_back(d);
			}
			
		}//end for good section
		
		for (int x = endX;x < firstChromaMatrix.size(); x++){
			if (x < simMatrix.size()){
				simMatrix[x].push_back(0);
			}else{
				d.clear();
				d.push_back(0);
				simMatrix.push_back(d);
			}
		}//end for x to end
		
	}
	//	if (size > 0)
	//		printf("Causial CHROMA ONLY SIM SIZE %i x %i; ", (int)simMatrix.size(), (int) simMatrix[0].size());
	//printf("First matrix SIZE %i , SECOND size %i\n", (int)firstChromaMatrix.size(), (int) secondChromaMatrix.size());	
	

}