Files
solver/OndselSolver/MatrixSolver.cpp
John Dupuy 87ed8700e2 modify code to suppress or fix warnings in gcc and clang (#41)
* first fix to start branch PR

* explicit conversion from sizet to int

* Array.h and DiagonalMatrix.h

* many sizet to int conversions

* removed some unused variables and added expl overrides

* removed many unused parameters

* more typing

* even more

* last of the easy changes
2023-12-08 10:00:00 -07:00

82 lines
2.5 KiB
C++

/***************************************************************************
* Copyright (c) 2023 Ondsel, Inc. *
* *
* This file is part of OndselSolver. *
* *
* See LICENSE file for details about copyright. *
***************************************************************************/
#include <iostream>
#include <limits>
#include <memory>
#include <chrono>
#include "MatrixSolver.h"
#include "SparseMatrix.h"
#include "FullMatrix.h"
#include "SingularMatrixError.h"
using namespace MbD;
void MatrixSolver::initialize()
{
Solver::initialize();
singularPivotTolerance = 4 * std::numeric_limits<double>::epsilon();
}
void MatrixSolver::setSystem(Solver*)
{
}
FColDsptr MatrixSolver::solvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCol, bool saveOriginal)
{
this->timedSolvewithsaveOriginal(spMat, fullCol, saveOriginal);
return answerX;
}
FColDsptr MatrixSolver::solvewithsaveOriginal(FMatDsptr fullMat, FColDsptr fullCol, bool saveOriginal)
{
this->timedSolvewithsaveOriginal(fullMat, fullCol, saveOriginal);
return answerX;
}
FColDsptr MatrixSolver::timedSolvewithsaveOriginal(SpMatDsptr spMat, FColDsptr fullCol, bool saveOriginal)
{
auto start = std::chrono::steady_clock::now();
this->basicSolvewithsaveOriginal(spMat, fullCol, saveOriginal);
auto end = std::chrono::steady_clock::now();
auto diff = end - start;
millisecondsToRun = std::chrono::duration<double, std::milli>(diff).count();
//std::cout << "milliseconds to run = " << millisecondsToRun << std::endl;
return answerX;
}
FColDsptr MatrixSolver::timedSolvewithsaveOriginal(FMatDsptr, FColDsptr, bool)
{
return FColDsptr();
}
void MatrixSolver::findScalingsForRowRange(int begin, int end)
{
//"Row element * scaling <= 1.0."
rowScalings = std::make_shared<FullColumn<double>>(m);
for (int i = begin; i < end; i++)
{
double maxRowMagnitude = this->getmatrixArowimaxMagnitude(i);
if (maxRowMagnitude == 0.0) throwSingularMatrixError("");
rowScalings->at(i) = 1.0 / maxRowMagnitude;
}
}
void MatrixSolver::throwSingularMatrixError(const char* chars)
{
throw SingularMatrixError(chars);
}
void MatrixSolver::throwSingularMatrixError(const char* chars, std::shared_ptr<FullColumn<int>> redunEqnNos)
{
throw SingularMatrixError(chars, redunEqnNos);
}