147 lines
4.5 KiB
C++
147 lines
4.5 KiB
C++
/*
|
||
* Copyright © 2004-2011 Ondra Kamenik
|
||
* Copyright © 2019 Dynare Team
|
||
*
|
||
* This file is part of Dynare.
|
||
*
|
||
* Dynare is free software: you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation, either version 3 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* Dynare is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with Dynare. If not, see <https://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
#include "GeneralSylvester.hh"
|
||
#include "IterativeSylvester.hh"
|
||
#include "SchurDecomp.hh"
|
||
#include "SylvException.hh"
|
||
#include "TriangularSylvester.hh"
|
||
#include "int_power.hh"
|
||
|
||
#include <ctime>
|
||
|
||
GeneralSylvester::GeneralSylvester(int ord, int n, int m, int zero_cols, const ConstVector& da,
|
||
const ConstVector& db, const ConstVector& dc,
|
||
const ConstVector& dd, const SylvParams& ps) :
|
||
pars(ps),
|
||
order(ord),
|
||
a(Vector {da}, n),
|
||
b(Vector {db}, n, n - zero_cols),
|
||
c(Vector {dc}, m),
|
||
d(Vector {dd}, n, power(m, order)),
|
||
solved(false)
|
||
{
|
||
init();
|
||
}
|
||
|
||
GeneralSylvester::GeneralSylvester(int ord, int n, int m, int zero_cols, const ConstVector& da,
|
||
const ConstVector& db, const ConstVector& dc, Vector& dd,
|
||
const SylvParams& ps) :
|
||
pars(ps),
|
||
order(ord),
|
||
a(Vector {da}, n),
|
||
b(Vector {db}, n, n - zero_cols),
|
||
c(Vector {dc}, m),
|
||
d(dd, n, power(m, order)),
|
||
solved(false)
|
||
{
|
||
init();
|
||
}
|
||
|
||
GeneralSylvester::GeneralSylvester(int ord, int n, int m, int zero_cols, const ConstVector& da,
|
||
const ConstVector& db, const ConstVector& dc,
|
||
const ConstVector& dd, bool alloc_for_check) :
|
||
pars(alloc_for_check),
|
||
order(ord),
|
||
a(Vector {da}, n),
|
||
b(Vector {db}, n, n - zero_cols),
|
||
c(Vector {dc}, m),
|
||
d(Vector {dd}, n, power(m, order)),
|
||
solved(false)
|
||
{
|
||
init();
|
||
}
|
||
|
||
GeneralSylvester::GeneralSylvester(int ord, int n, int m, int zero_cols, const ConstVector& da,
|
||
const ConstVector& db, const ConstVector& dc, Vector& dd,
|
||
bool alloc_for_check) :
|
||
pars(alloc_for_check),
|
||
order(ord),
|
||
a(Vector {da}, n),
|
||
b(Vector {db}, n, n - zero_cols),
|
||
c(Vector {dc}, m),
|
||
d(dd, n, power(m, order)),
|
||
solved(false)
|
||
{
|
||
init();
|
||
}
|
||
|
||
void
|
||
GeneralSylvester::init()
|
||
{
|
||
GeneralMatrix ainvb(b);
|
||
double rcond1;
|
||
double rcondinf;
|
||
a.multInvLeft2(ainvb, d, rcond1, rcondinf);
|
||
pars.rcondA1 = rcond1;
|
||
pars.rcondAI = rcondinf;
|
||
bdecomp = std::make_unique<SchurDecompZero>(ainvb);
|
||
cdecomp = std::make_unique<SimilarityDecomp>(c.getData(), c.nrows(), *(pars.bs_norm));
|
||
cdecomp->check(pars, c);
|
||
cdecomp->infoToPars(pars);
|
||
if (*(pars.method) == SylvParams::solve_method::recurse)
|
||
sylv = std::make_unique<TriangularSylvester>(*bdecomp, *cdecomp);
|
||
else
|
||
sylv = std::make_unique<IterativeSylvester>(*bdecomp, *cdecomp);
|
||
}
|
||
|
||
void
|
||
GeneralSylvester::solve()
|
||
{
|
||
if (solved)
|
||
throw SYLV_MES_EXCEPTION("Attempt to run solve() more than once.");
|
||
|
||
clock_t start = clock();
|
||
// multiply d
|
||
d.multLeftITrans(bdecomp->getQ());
|
||
d.multRightKron(cdecomp->getQ(), order);
|
||
// convert to KronVector
|
||
KronVector dkron(d.getData(), getM(), getN(), order);
|
||
// solve
|
||
sylv->solve(pars, dkron);
|
||
// multiply d back
|
||
d.multLeftI(bdecomp->getQ());
|
||
d.multRightKron(cdecomp->getInvQ(), order);
|
||
clock_t end = clock();
|
||
pars.cpu_time = static_cast<double>(end - start) / CLOCKS_PER_SEC;
|
||
|
||
solved = true;
|
||
}
|
||
|
||
void
|
||
GeneralSylvester::check(const ConstVector& ds)
|
||
{
|
||
if (!solved)
|
||
throw SYLV_MES_EXCEPTION("Cannot run check on system, which is not solved yet.");
|
||
|
||
// calculate xcheck = A·X+B·X·⊗ⁱC−D
|
||
SylvMatrix dcheck(d.nrows(), d.ncols());
|
||
dcheck.multLeft(b.nrows() - b.ncols(), b, d);
|
||
dcheck.multRightKron(c, order);
|
||
dcheck.multAndAdd(a, d);
|
||
dcheck.getData().add(-1.0, ds);
|
||
// calculate relative norms
|
||
pars.mat_err1 = dcheck.getNorm1() / d.getNorm1();
|
||
pars.mat_errI = dcheck.getNormInf() / d.getNormInf();
|
||
pars.mat_errF = dcheck.getData().getNorm() / d.getData().getNorm();
|
||
pars.vec_err1 = dcheck.getData().getNorm1() / d.getData().getNorm1();
|
||
pars.vec_errI = dcheck.getData().getMax() / d.getData().getMax();
|
||
}
|