Ejemplo n.º 1
0
// gaussian elimination - main function
int WINAPI GaussianElimination(double ** ppMatrix, int iRows, int iColumns, GAUSSIAN_ELIMINATION_OUTPUT * pOutputBuffer)
{

	if(ppMatrix == NULL) {
		return -1;
	}

	if(pOutputBuffer->ppSMatrix != NULL) {
		iColumns += iRows;
	}
	SetMatrixDimensions(iRows, iColumns);
	double ** ppWorkMatrix;
	if(pOutputBuffer->ppSMatrix == NULL) {
		ppWorkMatrix = pOutputBuffer->ppReducedEcholonForm;
	} else {
		ppWorkMatrix = AllocateMatrixMemory(iColumns + iRows, iRows);
	}
	if(!ppWorkMatrix) {
		return -1;
	}

	if(pOutputBuffer->ppSMatrix != NULL) {
		for(int i = (iColumns - iRows); i < iColumns; i++) {
			for(int g = 0; g < iRows; g++) {
				if(g == i - iColumns + iRows) {
					ppWorkMatrix[i][g] = 1.0f;
				} else {
					ppWorkMatrix[i][g] = 0.0f;
				}
			}
		}
		CopyMatrix(ppWorkMatrix, ppMatrix, iRows, iColumns - iRows);
	} else {
		CopyMatrix(ppWorkMatrix, ppMatrix, iRows, iColumns);
	}

	POSITION posPivot = StepOne(ppWorkMatrix);
	//printf("%lf, %lf", ppWorkMatrix[0][0], ppWorkMatrix[0][1]);
	StepTwo(ppWorkMatrix, &posPivot);
	//printf("%lf, %lf", ppWorkMatrix[0][0], ppWorkMatrix[0][1]);
	if(StepThree(ppWorkMatrix, posPivot) != 0) {
		return -1;
	}
	//printf("%lf, %lf", ppWorkMatrix[0][0], ppWorkMatrix[0][1]);
	StepFour(ppWorkMatrix, posPivot);
	//printf("%lf, %lf", ppWorkMatrix[0][0], ppWorkMatrix[0][1]);
	POSITION_ARRAY pivots = StepFive(ppWorkMatrix, posPivot);
	//printf("%lf, %lf", ppWorkMatrix[0][0], ppWorkMatrix[0][1]);
	AddPosition(&pivots, posPivot);
	StepSix(ppWorkMatrix, pivots);
	//printf("%lf, %lf", ppWorkMatrix[0][0], ppWorkMatrix[0][1]);

	if(pOutputBuffer->ppSMatrix) {
		DivideOutputAndSMatrix(ppWorkMatrix, pOutputBuffer);
	} else {
		CopyMatrix(pOutputBuffer->ppReducedEcholonForm, ppWorkMatrix, iRows, iColumns);
	}

	return 0;
}
Ejemplo n.º 2
0
int main(int argc, char* argv[])
{
	double** A;
	A = AllocateMatrixMemory(5, 3);
	A[0][1] = 2.0;
	A[2][4] = 4.0;

	FreeMatrixMemory(5, A);

	return 0;
}
AbstractContinuumMechanicsSolver<DIM>::AbstractContinuumMechanicsSolver(AbstractTetrahedralMesh<DIM, DIM>& rQuadMesh,
        ContinuumMechanicsProblemDefinition<DIM>& rProblemDefinition,
        std::string outputDirectory,
        CompressibilityType compressibilityType)
    : mrQuadMesh(rQuadMesh),
      mrProblemDefinition(rProblemDefinition),
      mOutputDirectory(outputDirectory),
      mpOutputFileHandler(NULL),
      mpQuadratureRule(NULL),
      mpBoundaryQuadratureRule(NULL),
      mCompressibilityType(compressibilityType),
      mResidualVector(NULL),
      mSystemLhsMatrix(NULL),
      mPreconditionMatrix(NULL)
{
    assert(DIM==2 || DIM==3);

    //Check that the mesh is Quadratic
    QuadraticMesh<DIM>* p_quad_mesh = dynamic_cast<QuadraticMesh<DIM>* >(&rQuadMesh);
    DistributedQuadraticMesh<DIM>* p_distributed_quad_mesh = dynamic_cast<DistributedQuadraticMesh<DIM>* >(&rQuadMesh);

    if(p_quad_mesh == NULL && p_distributed_quad_mesh == NULL)
    {
        EXCEPTION("Continuum mechanics solvers require a quadratic mesh");
    }


    mVerbose = (mrProblemDefinition.GetVerboseDuringSolve() ||
                CommandLineArguments::Instance()->OptionExists("-mech_verbose") ||
                CommandLineArguments::Instance()->OptionExists("-mech_very_verbose") );

    mWriteOutput = (mOutputDirectory != "");
    if (mWriteOutput)
    {
        mpOutputFileHandler = new OutputFileHandler(mOutputDirectory);
    }

    // see dox for mProblemDimension
    mProblemDimension = mCompressibilityType==COMPRESSIBLE ? DIM : DIM+1;
    mNumDofs = mProblemDimension*mrQuadMesh.GetNumNodes();

    AllocateMatrixMemory();

    // In general the Jacobian for a mechanics problem is non-polynomial.
    // We therefore use the highest order integration rule available.
    mpQuadratureRule = new GaussianQuadratureRule<DIM>(3);
    // The boundary forcing terms (or tractions) are also non-polynomial in general.
    // Again, we use the highest order integration rule available.
    mpBoundaryQuadratureRule = new GaussianQuadratureRule<DIM-1>(3);

    mCurrentSolution.resize(mNumDofs, 0.0);
}
Ejemplo n.º 4
0
int main(int argc, char **argv)
{
	int *dim_A = new int [2];
	dim_A[0] = 5; dim_A[1] = 3;
	double** A = AllocateMatrixMemory(dim_A[0], dim_A[1]);
	PopulateMatrixValues(A, dim_A[0], dim_A[1]);

	int *dim_B = new int [2];
	dim_B[0] = 3; dim_B[1] = 2;
	double** B = AllocateMatrixMemory(dim_B[0], dim_B[1]);
	PopulateMatrixValues(B, dim_B[0], dim_B[1]);

	PrintMatrix(A, dim_A[0], dim_A[1]);
	std::cout << "\n";
	PrintMatrix(B, dim_B[0], dim_B[1]);
	std::cout << "\n";

	double** AB = Multiply(A, B, dim_A, dim_B);
	PrintMatrix(AB, dim_A[0], dim_B[1]);
	
	return 0;
}
int main(int argc, char * argv[])
{
    if(argc !=2 ) { Usage(argv[0]); return 1; } //has the user provided the data filename in the command line?
    std::ifstream read_file(argv[1]);  //...then open it for reading
    assert(read_file.is_open());
    double ** A;
    int rows,cols;
    read_file >> rows >> cols;  //the format of the file is that first the size is given...
    std::cout << "Dynamically allocating memory for a matrix "<<rows<<"x"<<cols<<"\n";
    A = AllocateMatrixMemory(rows, cols);
    for(int r=0;r<rows; r++)  //... and then the elements are in the file
    {
        for(int c=0;c<cols;c++)
          read_file >> A[r][c];
    }
    read_file.close();    //do not forget to close the file
    std::cout << "Lets see if we read correct,by printing the matrix on the console:\n";
    for(int r=0;r<rows; r++) {
        for(int c=0;c<cols;c++) { std::cout << A[r][c]<< "  ";}
        std::cout << "\n";
    }
    FreeMatrixMemory(rows, A);  //do not forget to release the memory allocated from new
}
Ejemplo n.º 6
0
static POSITION_ARRAY StepFive(double ** ppMatrix, POSITION posPivot)
{
	POSITION_ARRAY pivots = {NULL, 0};
	int iRowsSave = iRows;
	int iColumnsSave = iColumns;

	if(iRows - 1 == 0) {
		return pivots; // Fertig
	}

	if(iColumns - posPivot.iColumn == 0) {
		return pivots; // Fertig
	}
	
	double ** ppSmallerMatrix = AllocateMatrixMemory(iColumns - posPivot.iColumn - 1, iRows - 1);

	for(int i = posPivot.iColumn + 1; i < iColumns; i++) {
		for(int g = 1; g < iRows; g++) {
			ppSmallerMatrix[i - posPivot.iColumn - 1][g - 1] = ppMatrix[i][g];
		}
	}

	iRows--; 
	iRowsOffset++;
	iColumns -= posPivot.iColumn + 1;
	iColumnsOffset += posPivot.iColumn + 1;

	POSITION posNewPivot = StepOne(ppSmallerMatrix);
	if(posNewPivot.iColumn == -1) {
		// Rücksetzen
		iRowsOffset -= (iRowsSave - iRows);
		iRows = iRowsSave;
		iRowsOffset -= (iColumnsSave - iColumns);
		iColumns = iColumnsSave;
		return pivots; // Fertig
	}
	
	StepTwo(ppSmallerMatrix, &posNewPivot);
	StepThree(ppSmallerMatrix, posNewPivot);
	StepFour(ppSmallerMatrix, posNewPivot);
	pivots = StepFive(ppSmallerMatrix, posNewPivot);

	AddPosition(&pivots, posNewPivot);

	for(int i = 0; i < pivots.iCount; i++) {
		pivots.pPositions[i].iColumn += posPivot.iColumn + 1; // Auf neue Grösse anpassen
		pivots.pPositions[i].iRow += 1;
	}

	// Rücksetzen
	iRowsOffset -= (iRowsSave - iRows);
	iRows = iRowsSave;
	iColumnsOffset -= (iColumnsSave - iColumns);
	iColumns = iColumnsSave;

	// Eingruppieren der neuen Matrix
	for(int i = posPivot.iColumn + 1; i < iColumns; i++) {
		for(int g = 1; g < iRows; g++) {
			ppMatrix[i][g] = ppSmallerMatrix[i - posPivot.iColumn - 1][g - 1];
		}
	}

	// Freigeben des Speichers
	FreeMatrixMemory(ppSmallerMatrix, iColumns - posPivot.iColumn - 1);

	return pivots;
}