stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Dynare++: use std::unique_ptr for storage inside tensor containers

time-shift
Sébastien Villemot 2019-02-20 16:50:33 +01:00
parent 9e1df25580
commit b5793ddd22
No known key found for this signature in database
GPG Key ID: 2CECE9350ECEBE4A
21 changed files with 214 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
dynare++/extern/matlab/dynare_simul.cc vendored
View File

@ -102,8 +102,7 @@ extern "C" {
ft.zeros(); ft.zeros();
ConstTwoDMatrix gk_mat(ft.nrows(), ft.ncols(), ConstVector{gk}); ConstTwoDMatrix gk_mat(ft.nrows(), ft.ncols(), ConstVector{gk});
ft.add(1.0, gk_mat); ft.add(1.0, gk_mat);
auto *ut = new UFSTensor(ft); pol.insert(std::make_unique<UFSTensor>(ft));
pol.insert(ut);
} }
// form the decision rule // form the decision rule
UnfoldDecisionRule UnfoldDecisionRule

6
dynare++/kord/approximation.cc
View File

@ -1,5 +1,7 @@
// Copyright 2005, Ondra Kamenik // Copyright 2005, Ondra Kamenik
#include <utility>
#include "kord_exception.hh" #include "kord_exception.hh"
#include "approximation.hh" #include "approximation.hh"
#include "first_order.hh" #include "first_order.hh"
@ -261,8 +263,8 @@ Approximation::saveRuleDerivs(const FGSContainer &g)
rule_ders_ss = new FGSContainer(4); rule_ders_ss = new FGSContainer(4);
for (auto & run : (*rule_ders)) for (auto & run : (*rule_ders))
{ {
auto *ten = new FGSTensor(ypart.nstat+ypart.npred, ypart.nyss(), *(run.second)); auto ten = std::make_unique<FGSTensor>(ypart.nstat+ypart.npred, ypart.nyss(), *(run.second));
rule_ders_ss->insert(ten); rule_ders_ss->insert(std::move(ten));
} }
} }

8
dynare++/kord/decision_rule.cc
View File

@ -35,9 +35,7 @@ FoldDecisionRule::FoldDecisionRule(const UnfoldDecisionRule &udr)
udr.ypart, udr.nu, udr.ysteady) udr.ypart, udr.nu, udr.ysteady)
{ {
for (const auto & it : udr) for (const auto & it : udr)
{ insert(std::make_unique<ctraits<KOrder::fold>::Ttensym>(*(it.second)));
insert(new ctraits<KOrder::fold>::Ttensym(*(it.second)));
}
} }
// |UnfoldDecisionRule| conversion from |FoldDecisionRule| // |UnfoldDecisionRule| conversion from |FoldDecisionRule|
@ -46,9 +44,7 @@ UnfoldDecisionRule::UnfoldDecisionRule(const FoldDecisionRule &fdr)
fdr.ypart, fdr.nu, fdr.ysteady) fdr.ypart, fdr.nu, fdr.ysteady)
{ {
for (const auto & it : fdr) for (const auto & it : fdr)
{ insert(std::make_unique<ctraits<KOrder::unfold>::Ttensym>(*(it.second)));
insert(new ctraits<KOrder::unfold>::Ttensym(*(it.second)));
}
} }
SimResults::~SimResults() SimResults::~SimResults()

15
dynare++/kord/decision_rule.hh
View File

@ -198,7 +198,7 @@ DecisionRuleImpl<t>::fillTensors(const _Tg &g, double sigma)
int dfact = 1; int dfact = 1;
for (int d = 0; d <= g.getMaxDim(); d++, dfact *= d) for (int d = 0; d <= g.getMaxDim(); d++, dfact *= d)
{ {
auto *g_yud = new _Ttensym(ypart.ny(), ypart.nys()+nu, d); auto g_yud = std::make_unique<_Ttensym>(ypart.ny(), ypart.nys()+nu, d);
g_yud->zeros(); g_yud->zeros();
// fill tensor of |g_yud| of dimension |d| // fill tensor of |g_yud| of dimension |d|
@ -231,7 +231,7 @@ DecisionRuleImpl<t>::fillTensors(const _Tg &g, double sigma)
g_yud->addSubTensor(tmp); g_yud->addSubTensor(tmp);
} }
this->insert(g_yud); this->insert(std::move(g_yud));
} }
} }
@ -261,9 +261,9 @@ DecisionRuleImpl<t>::centralize(const DecisionRuleImpl &dr)
for (int d = 1; d <= dr.getMaxDim(); d++, dfac *= d) for (int d = 1; d <= dr.getMaxDim(); d++, dfac *= d)
{ {
pol.derivative(d-1); pol.derivative(d-1);
_Ttensym *der = pol.evalPartially(d, dstate); auto der = pol.evalPartially(d, dstate);
der->mult(1.0/dfac); der->mult(1.0/dfac);
this->insert(der); this->insert(std::move(der));
} }
} }
@ -567,7 +567,7 @@ DRFixPoint<t>::fillTensors(const _Tg &g, double sigma)
int dfact = 1; int dfact = 1;
for (int d = 0; d <= g.getMaxDim(); d++, dfact *= d) for (int d = 0; d <= g.getMaxDim(); d++, dfact *= d)
{ {
auto *g_yd = new _Ttensym(ypart.ny(), ypart.nys(), d); auto g_yd = std::make_unique<_Ttensym>(ypart.ny(), ypart.nys(), d);
g_yd->zeros(); g_yd->zeros();
int kfact = 1; int kfact = 1;
for (int k = 0; d+k <= g.getMaxDim(); k++, kfact *= k) for (int k = 0; d+k <= g.getMaxDim(); k++, kfact *= k)
@ -579,7 +579,7 @@ DRFixPoint<t>::fillTensors(const _Tg &g, double sigma)
g_yd->add(mult, *ten); g_yd->add(mult, *ten);
} }
} }
this->insert(g_yd); this->insert(std::move(g_yd));
} }
} }
@ -613,7 +613,7 @@ DRFixPoint<t>::solveNewton(Vector &y)
do do
{ {
_Ttensym *jacob = bigfder->evalPartially(1, sol); auto jacob = bigfder->evalPartially(1, sol);
bigf->evalHorner(delta, sol); bigf->evalHorner(delta, sol);
if (newton_iter_last == 0) if (newton_iter_last == 0)
flastnorm = delta.getNorm(); flastnorm = delta.getNorm();
@ -646,7 +646,6 @@ DRFixPoint<t>::solveNewton(Vector &y)
sol.add(-urelax, delta); sol.add(-urelax, delta);
delta_finite = delta.isFinite(); delta_finite = delta.isFinite();
} }
delete jacob;
newton_iter_last++; newton_iter_last++;
converged = delta_finite && fnorm < tol; converged = delta_finite && fnorm < tol;
flastnorm = fnorm; flastnorm = fnorm;

14
dynare++/kord/first_order.hh
View File

@ -72,12 +72,14 @@ public:
{ {
IntSequence nvs(4); IntSequence nvs(4);
nvs[0] = fo.ypart.nys(); nvs[1] = fo.nu; nvs[2] = fo.nu; nvs[3] = 1; nvs[0] = fo.ypart.nys(); nvs[1] = fo.nu; nvs[2] = fo.nu; nvs[3] = 1;
_Ttensor *ten = new _Ttensor(fo.ypart.ny(), TensorDimens(Symmetry{1, 0, 0, 0}, nvs)); auto ten = std::make_unique<_Ttensor>(fo.ypart.ny(), TensorDimens(Symmetry{1, 0, 0, 0}, nvs));
ten->zeros(); ten->add(1.0, fo.gy); ten->zeros();
this->insert(ten); ten->add(1.0, fo.gy);
ten = new _Ttensor(fo.ypart.ny(), TensorDimens(Symmetry{0, 1, 0, 0}, nvs)); this->insert(std::move(ten));
ten->zeros(); ten->add(1.0, fo.gu); ten = std::make_unique<_Ttensor>(fo.ypart.ny(), TensorDimens(Symmetry{0, 1, 0, 0}, nvs));
this->insert(ten); ten->zeros();
ten->add(1.0, fo.gu);
this->insert(std::move(ten));
} }
}; };

4
dynare++/kord/global_check.cc
View File

@ -101,9 +101,9 @@ ResidFunction::setYU(const ConstVector &ys, const ConstVector &xx)
} }
else else
{ {
auto *ten = new FFSTensor(hss->nrows(), hss->nvars(), 0); auto ten = std::make_unique<FFSTensor>(hss->nrows(), hss->nvars(), 0);
ten->getData() = ysteady_ss; ten->getData() = ysteady_ss;
hss->insert(ten); hss->insert(std::move(ten));
} }
} }

28
dynare++/kord/korder.cc
View File

@ -265,21 +265,21 @@ KOrder::KOrder(int num_stat, int num_pred, int num_both, int num_forw,
// put $g_y$ and $g_u$ to the container // put $g_y$ and $g_u$ to the container
/* Note that $g_\sigma$ is zero by the nature and we do not insert it to /* Note that $g_\sigma$ is zero by the nature and we do not insert it to
the container. We insert a new physical copies. */ the container. We insert a new physical copies. */
UGSTensor *tgy = new UGSTensor(ny, TensorDimens(Symmetry{1, 0, 0, 0}, nvs)); auto tgy = std::make_unique<UGSTensor>(ny, TensorDimens(Symmetry{1, 0, 0, 0}, nvs));
tgy->getData() = gy.getData(); tgy->getData() = gy.getData();
insertDerivative<unfold>(tgy); insertDerivative<unfold>(std::move(tgy));
UGSTensor *tgu = new UGSTensor(ny, TensorDimens(Symmetry{0, 1, 0, 0}, nvs)); auto tgu = std::make_unique<UGSTensor>(ny, TensorDimens(Symmetry{0, 1, 0, 0}, nvs));
tgu->getData() = gu.getData(); tgu->getData() = gu.getData();
insertDerivative<unfold>(tgu); insertDerivative<unfold>(std::move(tgu));
// put $G_y$, $G_u$ and $G_{u'}$ to the container // put $G_y$, $G_u$ and $G_{u'}$ to the container
/* Also note that since $g_\sigma$ is zero, so $G_\sigma$. */ /* Also note that since $g_\sigma$ is zero, so $G_\sigma$. */
UGSTensor *tGy = faaDiBrunoG<unfold>(Symmetry{1, 0, 0, 0}); auto tGy = faaDiBrunoG<unfold>(Symmetry{1, 0, 0, 0});
G<unfold>().insert(tGy); G<unfold>().insert(std::move(tGy));
UGSTensor *tGu = faaDiBrunoG<unfold>(Symmetry{0, 1, 0, 0}); auto tGu = faaDiBrunoG<unfold>(Symmetry{0, 1, 0, 0});
G<unfold>().insert(tGu); G<unfold>().insert(std::move(tGu));
UGSTensor *tGup = faaDiBrunoG<unfold>(Symmetry{0, 0, 1, 0}); auto tGup = faaDiBrunoG<unfold>(Symmetry{0, 0, 1, 0});
G<unfold>().insert(tGup); G<unfold>().insert(std::move(tGup));
} }
// |KOrder::sylvesterSolve| unfolded specialization // |KOrder::sylvesterSolve| unfolded specialization
@ -346,8 +346,8 @@ KOrder::switchToFolded()
{ {
if (si[2] == 0 && g<unfold>().check(si)) if (si[2] == 0 && g<unfold>().check(si))
{ {
auto *ft = new FGSTensor(*(g<unfold>().get(si))); auto ft = std::make_unique<FGSTensor>(*(g<unfold>().get(si)));
insertDerivative<fold>(ft); insertDerivative<fold>(std::move(ft));
if (dim > 1) if (dim > 1)
{ {
gss<unfold>().remove(si); gss<unfold>().remove(si);
@ -357,8 +357,8 @@ KOrder::switchToFolded()
} }
if (G<unfold>().check(si)) if (G<unfold>().check(si))
{ {
auto *ft = new FGSTensor(*(G<unfold>().get(si))); auto ft = std::make_unique<FGSTensor>(*(G<unfold>().get(si)));
G<fold>().insert(ft); G<fold>().insert(std::move(ft));
if (dim > 1) if (dim > 1)
{ {
G<fold>().remove(si); G<fold>().remove(si);

105
dynare++/kord/korder.hh
View File

@ -361,14 +361,14 @@ public:
} }
protected: protected:
template <int t> template <int t>
void insertDerivative(_Ttensor *der); void insertDerivative(std::unique_ptr<_Ttensor> der);
template<int t> template<int t>
void sylvesterSolve(_Ttensor &der) const; void sylvesterSolve(_Ttensor &der) const;
template <int t> template <int t>
_Ttensor *faaDiBrunoZ(const Symmetry &sym) const; std::unique_ptr<_Ttensor> faaDiBrunoZ(const Symmetry &sym) const;
template <int t> template <int t>
_Ttensor *faaDiBrunoG(const Symmetry &sym) const; std::unique_ptr<_Ttensor> faaDiBrunoG(const Symmetry &sym) const;
template<int t> template<int t>
void recover_y(int i); void recover_y(int i);
@ -403,12 +403,13 @@ protected:
template <int t> template <int t>
void void
KOrder::insertDerivative(_Ttensor *der) KOrder::insertDerivative(std::unique_ptr<_Ttensor> der)
{ {
g<t>().insert(der); auto der_ptr = der.get();
gs<t>().insert(new _Ttensor(ypart.nstat, ypart.nys(), *der)); g<t>().insert(std::move(der));
gss<t>().insert(new _Ttensor(ypart.nstat+ypart.npred, gs<t>().insert(std::make_unique<_Ttensor>(ypart.nstat, ypart.nys(), *der_ptr));
ypart.nyss(), *der)); gss<t>().insert(std::make_unique<_Ttensor>(ypart.nstat+ypart.npred,
ypart.nyss(), *der_ptr));
} }
/* Here we implement Faa Di Bruno formula /* Here we implement Faa Di Bruno formula
@ -419,12 +420,12 @@ KOrder::insertDerivative(_Ttensor *der)
symmetry. */ symmetry. */
template <int t> template <int t>
_Ttensor * std::unique_ptr<_Ttensor>
KOrder::faaDiBrunoZ(const Symmetry &sym) const KOrder::faaDiBrunoZ(const Symmetry &sym) const
{ {
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Faa Di Bruno Z container for " << sym << endrec; pa << "Faa Di Bruno Z container for " << sym << endrec;
_Ttensor *res = new _Ttensor(ny, TensorDimens(sym, nvs)); auto res = std::make_unique<_Ttensor>(ny, TensorDimens(sym, nvs));
FaaDiBruno bruno(journal); FaaDiBruno bruno(journal);
bruno.calculate(Zstack<t>(), f, *res); bruno.calculate(Zstack<t>(), f, *res);
return res; return res;
@ -434,13 +435,13 @@ KOrder::faaDiBrunoZ(const Symmetry &sym) const
$g^{**}$ and $G$ stack. */ $g^{**}$ and $G$ stack. */
template <int t> template <int t>
_Ttensor * std::unique_ptr<_Ttensor>
KOrder::faaDiBrunoG(const Symmetry &sym) const KOrder::faaDiBrunoG(const Symmetry &sym) const
{ {
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Faa Di Bruno G container for " << sym << endrec; pa << "Faa Di Bruno G container for " << sym << endrec;
TensorDimens tdims(sym, nvs); TensorDimens tdims(sym, nvs);
auto *res = new _Ttensor(ypart.nyss(), tdims); auto res = std::make_unique<_Ttensor>(ypart.nyss(), tdims);
FaaDiBruno bruno(journal); FaaDiBruno bruno(journal);
bruno.calculate(Gstack<t>(), gss<t>(), *res); bruno.calculate(Gstack<t>(), gss<t>(), *res);
return res; return res;
@ -466,20 +467,21 @@ KOrder::recover_y(int i)
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Recovering symmetry " << sym << endrec; pa << "Recovering symmetry " << sym << endrec;
_Ttensor *G_yi = faaDiBrunoG<t>(sym); auto G_yi = faaDiBrunoG<t>(sym);
G<t>().insert(G_yi); auto G_yi_ptr = G_yi.get();
G<t>().insert(std::move(G_yi));
_Ttensor *g_yi = faaDiBrunoZ<t>(sym); auto g_yi = faaDiBrunoZ<t>(sym);
g_yi->mult(-1.0); g_yi->mult(-1.0);
sylvesterSolve<t>(*g_yi); sylvesterSolve<t>(*g_yi);
insertDerivative<t>(g_yi); insertDerivative<t>(std::move(g_yi));
_Ttensor *gss_y = gss<t>().get(Symmetry{1, 0, 0, 0}); _Ttensor *gss_y = gss<t>().get(Symmetry{1, 0, 0, 0});
gs<t>().multAndAdd(*gss_y, *G_yi); gs<t>().multAndAdd(*gss_y, *G_yi_ptr);
_Ttensor *gss_yi = gss<t>().get(sym); _Ttensor *gss_yi = gss<t>().get(sym);
gs<t>().multAndAdd(*gss_yi, *G_yi); gs<t>().multAndAdd(*gss_yi, *G_yi_ptr);
} }
/* Here we solve $\left[F_{y^iu^j}\right]=0$ to obtain $g_{y^iu^j}$ for /* Here we solve $\left[F_{y^iu^j}\right]=0$ to obtain $g_{y^iu^j}$ for
@ -501,15 +503,16 @@ KOrder::recover_yu(int i, int j)
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Recovering symmetry " << sym << endrec; pa << "Recovering symmetry " << sym << endrec;
_Ttensor *G_yiuj = faaDiBrunoG<t>(sym); auto G_yiuj = faaDiBrunoG<t>(sym);
G<t>().insert(G_yiuj); auto G_yiuj_ptr = G_yiuj.get();
G<t>().insert(std::move(G_yiuj));
_Ttensor *g_yiuj = faaDiBrunoZ<t>(sym); auto g_yiuj = faaDiBrunoZ<t>(sym);
g_yiuj->mult(-1.0); g_yiuj->mult(-1.0);
matA.multInv(*g_yiuj); matA.multInv(*g_yiuj);
insertDerivative<t>(g_yiuj); insertDerivative<t>(std::move(g_yiuj));
gs<t>().multAndAdd(*(gss<t>().get(Symmetry{1, 0, 0, 0})), *G_yiuj); gs<t>().multAndAdd(*(gss<t>().get(Symmetry{1, 0, 0, 0})), *G_yiuj_ptr);
} }
/* Here we solve /* Here we solve
@ -544,10 +547,11 @@ KOrder::recover_ys(int i, int j)
if (is_even(j)) if (is_even(j))
{ {
_Ttensor *G_yisj = faaDiBrunoG<t>(sym); auto G_yisj = faaDiBrunoG<t>(sym);
G<t>().insert(G_yisj); auto G_yisj_ptr = G_yisj.get();
G<t>().insert(std::move(G_yisj));
_Ttensor *g_yisj = faaDiBrunoZ<t>(sym); auto g_yisj = faaDiBrunoZ<t>(sym);
{ {
_Ttensor *D_ij = calcD_ik<t>(i, j); _Ttensor *D_ij = calcD_ik<t>(i, j);
@ -566,10 +570,10 @@ KOrder::recover_ys(int i, int j)
sylvesterSolve<t>(*g_yisj); sylvesterSolve<t>(*g_yisj);
insertDerivative<t>(g_yisj); insertDerivative<t>(std::move(g_yisj));
Gstack<t>().multAndAdd(1, gss<t>(), *G_yisj); Gstack<t>().multAndAdd(1, gss<t>(), *G_yisj_ptr);
Gstack<t>().multAndAdd(i+j, gss<t>(), *G_yisj); Gstack<t>().multAndAdd(i+j, gss<t>(), *G_yisj_ptr);
} }
} }
@ -604,10 +608,11 @@ KOrder::recover_yus(int i, int j, int k)
if (is_even(k)) if (is_even(k))
{ {
_Ttensor *G_yiujsk = faaDiBrunoG<t>(sym); auto G_yiujsk = faaDiBrunoG<t>(sym);
G<t>().insert(G_yiujsk); auto G_yiujsk_ptr = G_yiujsk.get();
G<t>().insert(std::move(G_yiujsk));
_Ttensor *g_yiujsk = faaDiBrunoZ<t>(sym); auto g_yiujsk = faaDiBrunoZ<t>(sym);
{ {
_Ttensor *D_ijk = calcD_ijk<t>(i, j, k); _Ttensor *D_ijk = calcD_ijk<t>(i, j, k);
@ -625,9 +630,9 @@ KOrder::recover_yus(int i, int j, int k)
g_yiujsk->mult(-1.0); g_yiujsk->mult(-1.0);
matA.multInv(*g_yiujsk); matA.multInv(*g_yiujsk);
insertDerivative<t>(g_yiujsk); insertDerivative<t>(std::move(g_yiujsk));
Gstack<t>().multAndAdd(1, gss<t>(), *G_yiujsk); Gstack<t>().multAndAdd(1, gss<t>(), *G_yiujsk_ptr);
} }
} }
@ -671,10 +676,11 @@ KOrder::recover_s(int i)
if (is_even(i)) if (is_even(i))
{ {
_Ttensor *G_si = faaDiBrunoG<t>(sym); auto G_si = faaDiBrunoG<t>(sym);
G<t>().insert(G_si); auto G_si_ptr = G_si.get();
G<t>().insert(std::move(G_si));
_Ttensor *g_si = faaDiBrunoZ<t>(sym); auto g_si = faaDiBrunoZ<t>(sym);
{ {
_Ttensor *D_i = calcD_k<t>(i); _Ttensor *D_i = calcD_k<t>(i);
@ -692,10 +698,10 @@ KOrder::recover_s(int i)
g_si->mult(-1.0); g_si->mult(-1.0);
matS.multInv(*g_si); matS.multInv(*g_si);
insertDerivative<t>(g_si); insertDerivative<t>(std::move(g_si));
Gstack<t>().multAndAdd(1, gss<t>(), *G_si); Gstack<t>().multAndAdd(1, gss<t>(), *G_si_ptr);
Gstack<t>().multAndAdd(i, gss<t>(), *G_si); Gstack<t>().multAndAdd(i, gss<t>(), *G_si_ptr);
} }
} }
@ -711,8 +717,8 @@ KOrder::fillG(int i, int j, int k)
{ {
if (is_even(k-m)) if (is_even(k-m))
{ {
_Ttensor *G_yiujupms = faaDiBrunoG<t>(Symmetry{i, j, m, k-m}); auto G_yiujupms = faaDiBrunoG<t>(Symmetry{i, j, m, k-m});
G<t>().insert(G_yiujupms); G<t>().insert(std::move(G_yiujupms));
} }
} }
} }
@ -732,9 +738,8 @@ KOrder::calcD_ijk(int i, int j, int k) const
res->zeros(); res->zeros();
if (is_even(k)) if (is_even(k))
{ {
_Ttensor *tmp = faaDiBrunoZ<t>(Symmetry{i, j, k, 0}); auto tmp = faaDiBrunoZ<t>(Symmetry{i, j, k, 0});
tmp->contractAndAdd(2, *res, *(m<t>().get(Symmetry{k}))); tmp->contractAndAdd(2, *res, *(m<t>().get(Symmetry{k})));
delete tmp;
} }
return res; return res;
} }
@ -754,10 +759,9 @@ KOrder::calcE_ijk(int i, int j, int k) const
res->zeros(); res->zeros();
for (int n = 2; n <= k-1; n += 2) for (int n = 2; n <= k-1; n += 2)
{ {
_Ttensor *tmp = faaDiBrunoZ<t>(Symmetry{i, j, n, k-n}); auto tmp = faaDiBrunoZ<t>(Symmetry{i, j, n, k-n});
tmp->mult((double) (PascalTriangle::noverk(k, n))); tmp->mult((double) (PascalTriangle::noverk(k, n)));
tmp->contractAndAdd(2, *res, *(m<t>().get(Symmetry{n}))); tmp->contractAndAdd(2, *res, *(m<t>().get(Symmetry{n})));
delete tmp;
} }
return res; return res;
} }
@ -863,12 +867,11 @@ KOrder::check(int dim) const
for (int i = 0; i <= dim; i++) for (int i = 0; i <= dim; i++)
{ {
Symmetry sym{dim-i, i, 0, 0}; Symmetry sym{dim-i, i, 0, 0};
_Ttensor *r = faaDiBrunoZ<t>(sym); auto r = faaDiBrunoZ<t>(sym);
double err = r->getData().getMax(); double err = r->getData().getMax();
JournalRecord(journal) << "\terror for symmetry " << sym << "\tis " << err << endrec; JournalRecord(journal) << "\terror for symmetry " << sym << "\tis " << err << endrec;
if (err > maxerror) if (err > maxerror)
maxerror = err; maxerror = err;
delete r;
} }
// check for $F_{y^iu^ju'^k}+D_{ijk}+E_{ijk}=0$ // check for $F_{y^iu^ju'^k}+D_{ijk}+E_{ijk}=0$
@ -880,7 +883,7 @@ KOrder::check(int dim) const
if (i+j > 0 && k > 0) if (i+j > 0 && k > 0)
{ {
Symmetry sym{i, j, 0, k}; Symmetry sym{i, j, 0, k};
_Ttensor *r = faaDiBrunoZ<t>(sym); auto r = faaDiBrunoZ<t>(sym);
_Ttensor *D_ijk = calcD_ijk<t>(i, j, k); _Ttensor *D_ijk = calcD_ijk<t>(i, j, k);
r->add(1.0, *D_ijk); r->add(1.0, *D_ijk);
delete D_ijk; delete D_ijk;
@ -889,12 +892,11 @@ KOrder::check(int dim) const
delete E_ijk; delete E_ijk;
double err = r->getData().getMax(); double err = r->getData().getMax();
JournalRecord(journal) << "\terror for symmetry " << sym << "\tis " << err << endrec; JournalRecord(journal) << "\terror for symmetry " << sym << "\tis " << err << endrec;
delete r;
} }
} }
// check for $F_{\sigma^i}+D_i+E_i=0 // check for $F_{\sigma^i}+D_i+E_i=0
_Ttensor *r = faaDiBrunoZ<t>(Symmetry{0, 0, 0, dim}); auto r = faaDiBrunoZ<t>(Symmetry{0, 0, 0, dim});
_Ttensor *D_k = calcD_k<t>(dim); _Ttensor *D_k = calcD_k<t>(dim);
r->add(1.0, *D_k); r->add(1.0, *D_k);
delete D_k; delete D_k;
@ -906,7 +908,6 @@ KOrder::check(int dim) const
JournalRecord(journal) << "\terror for symmetry " << sym << "\tis " << err << endrec; JournalRecord(journal) << "\terror for symmetry " << sym << "\tis " << err << endrec;
if (err > maxerror) if (err > maxerror)
maxerror = err; maxerror = err;
delete r;
return maxerror; return maxerror;
} }

46
dynare++/kord/korder_stoch.hh
View File

@ -22,6 +22,8 @@
calculate $h$ as an extrapolation based on an approximation to $g$ at calculate $h$ as an extrapolation based on an approximation to $g$ at
lower $\sigma$. */ lower $\sigma$. */
#include <memory>
#include "korder.hh" #include "korder.hh"
#include "faa_di_bruno.hh" #include "faa_di_bruno.hh"
#include "journal.hh" #include "journal.hh"
@ -89,7 +91,7 @@ IntegDerivs<t>::IntegDerivs(int r, const IntSequence &nvs, const _Tgss &g, const
{ {
int p = d-i; int p = d-i;
Symmetry sym{i, 0, 0, p}; Symmetry sym{i, 0, 0, p};
_Ttensor *ten = new _Ttensor(r, TensorDimens(sym, nvs)); auto ten = std::make_unique<_Ttensor>(r, TensorDimens(sym, nvs));
// calculate derivative $h_{y^i\sigma^p}$ // calculate derivative $h_{y^i\sigma^p}$
/* This code calculates /* This code calculates
@ -118,7 +120,7 @@ IntegDerivs<t>::IntegDerivs(int r, const IntSequence &nvs, const _Tgss &g, const
} }
} }
this->insert(ten); this->insert(std::move(ten));
} }
} }
} }
@ -183,7 +185,7 @@ StochForwardDerivs<t>::StochForwardDerivs(const PartitionY &ypart, int nu,
_Tpol g_int_sym(r, ypart.nys()+1); _Tpol g_int_sym(r, ypart.nys()+1);
for (int d = 1; d <= maxd; d++) for (int d = 1; d <= maxd; d++)
{ {
auto *ten = new _Ttensym(r, ypart.nys()+1, d); auto ten = std::make_unique<_Ttensym>(r, ypart.nys()+1, d);
ten->zeros(); ten->zeros();
for (int i = 0; i <= d; i++) for (int i = 0; i <= d; i++)
{ {
@ -191,7 +193,7 @@ StochForwardDerivs<t>::StochForwardDerivs(const PartitionY &ypart, int nu,
if (g_int.check(Symmetry{i, 0, 0, k})) if (g_int.check(Symmetry{i, 0, 0, k}))
ten->addSubTensor(*(g_int.get(Symmetry{i, 0, 0, k}))); ten->addSubTensor(*(g_int.get(Symmetry{i, 0, 0, k})));
} }
g_int_sym.insert(ten); g_int_sym.insert(std::move(ten));
} }
// make |g_int_cent| the centralized polynomial about $(\bar y,\bar\sigma)$ // make |g_int_cent| the centralized polynomial about $(\bar y,\bar\sigma)$
@ -210,8 +212,8 @@ StochForwardDerivs<t>::StochForwardDerivs(const PartitionY &ypart, int nu,
for (int d = 1; d <= maxd; d++) for (int d = 1; d <= maxd; d++)
{ {
g_int_sym.derivative(d-1); g_int_sym.derivative(d-1);
_Ttensym *der = g_int_sym.evalPartially(d, delta); auto der = g_int_sym.evalPartially(d, delta);
g_int_cent.insert(der); g_int_cent.insert(std::move(der));
} }
// pull out general symmetry tensors from |g_int_cent| // pull out general symmetry tensors from |g_int_cent|
@ -231,9 +233,9 @@ StochForwardDerivs<t>::StochForwardDerivs(const PartitionY &ypart, int nu,
{ {
Symmetry sym{i, 0, 0, d-i}; Symmetry sym{i, 0, 0, d-i};
IntSequence coor(sym, pp); IntSequence coor(sym, pp);
_Ttensor *ten = new _Ttensor(*(g_int_cent.get(Symmetry{d})), ss, coor, auto ten = std::make_unique<_Ttensor>(*(g_int_cent.get(Symmetry{d})), ss, coor,
TensorDimens(sym, true_nvs)); TensorDimens(sym, true_nvs));
this->insert(ten); this->insert(std::move(ten));
} }
} }
} }
@ -439,9 +441,9 @@ public:
} }
protected: protected:
template <int t> template <int t>
_Ttensor *faaDiBrunoZ(const Symmetry &sym) const; std::unique_ptr<_Ttensor> faaDiBrunoZ(const Symmetry &sym) const;
template <int t> template <int t>
_Ttensor *faaDiBrunoG(const Symmetry &sym) const; std::unique_ptr<_Ttensor> faaDiBrunoG(const Symmetry &sym) const;
// convenience access methods // convenience access methods
template<int t> template<int t>
@ -472,12 +474,12 @@ protected:
of a given symmetry. */ of a given symmetry. */
template <int t> template <int t>
_Ttensor * std::unique_ptr<_Ttensor>
KOrderStoch::faaDiBrunoZ(const Symmetry &sym) const KOrderStoch::faaDiBrunoZ(const Symmetry &sym) const
{ {
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Faa Di Bruno ZX container for " << sym << endrec; pa << "Faa Di Bruno ZX container for " << sym << endrec;
_Ttensor *res = new _Ttensor(ypart.ny(), TensorDimens(sym, nvs)); auto res = std::make_unique<_Ttensor>(ypart.ny(), TensorDimens(sym, nvs));
FaaDiBruno bruno(journal); FaaDiBruno bruno(journal);
bruno.calculate(Zstack<t>(), f, *res); bruno.calculate(Zstack<t>(), f, *res);
return res; return res;
@ -487,13 +489,13 @@ KOrderStoch::faaDiBrunoZ(const Symmetry &sym) const
$G(y,u,\sigma)=h(g^*(y,u,\sigma),\sigma)$ of a given symmetry. */ $G(y,u,\sigma)=h(g^*(y,u,\sigma),\sigma)$ of a given symmetry. */
template <int t> template <int t>
_Ttensor * std::unique_ptr<_Ttensor>
KOrderStoch::faaDiBrunoG(const Symmetry &sym) const KOrderStoch::faaDiBrunoG(const Symmetry &sym) const
{ {
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Faa Di Bruno GX container for " << sym << endrec; pa << "Faa Di Bruno GX container for " << sym << endrec;
TensorDimens tdims(sym, nvs); TensorDimens tdims(sym, nvs);
auto *res = new _Ttensor(ypart.nyss(), tdims); auto res = std::make_unique<_Ttensor>(ypart.nyss(), tdims);
FaaDiBruno bruno(journal); FaaDiBruno bruno(journal);
bruno.calculate(Gstack<t>(), h<t>(), *res); bruno.calculate(Gstack<t>(), h<t>(), *res);
return res; return res;
@ -524,16 +526,18 @@ KOrderStoch::performStep(int order)
JournalRecordPair pa(journal); JournalRecordPair pa(journal);
pa << "Recovering symmetry " << si << endrec; pa << "Recovering symmetry " << si << endrec;
_Ttensor *G_sym = faaDiBrunoG<t>(si); auto G_sym = faaDiBrunoG<t>(si);
G<t>().insert(G_sym); auto G_sym_ptr = G_sym.get();
G<t>().insert(std::move(G_sym));
_Ttensor *g_sym = faaDiBrunoZ<t>(si); auto g_sym = faaDiBrunoZ<t>(si);
auto g_sym_ptr = g_sym.get();
g_sym->mult(-1.0); g_sym->mult(-1.0);
matA.multInv(*g_sym); matA.multInv(*g_sym);
g<t>().insert(g_sym); g<t>().insert(std::move(g_sym));
gs<t>().insert(new _Ttensor(ypart.nstat, ypart.nys(), *g_sym)); gs<t>().insert(std::make_unique<_Ttensor>(ypart.nstat, ypart.nys(), *g_sym_ptr));
Gstack<t>().multAndAdd(1, h<t>(), *G_sym); Gstack<t>().multAndAdd(1, h<t>(), *G_sym_ptr);
} }
} }
} }

8
dynare++/kord/tests.cc
View File

@ -63,17 +63,17 @@ Rand::discrete(double prob)
struct SparseGenerator struct SparseGenerator
{ {
static FSSparseTensor *makeTensor(int dim, int nv, int r, static std::unique_ptr<FSSparseTensor> makeTensor(int dim, int nv, int r,
double fill, double m); double fill, double m);
static void fillContainer(TensorContainer<FSSparseTensor> &c, static void fillContainer(TensorContainer<FSSparseTensor> &c,
int maxdim, int nv, int r, double m); int maxdim, int nv, int r, double m);
}; };
FSSparseTensor * std::unique_ptr<FSSparseTensor>
SparseGenerator::makeTensor(int dim, int nv, int r, SparseGenerator::makeTensor(int dim, int nv, int r,
double fill, double m) double fill, double m)
{ {
auto *res = new FSSparseTensor(dim, nv, r); auto res = std::make_unique<FSSparseTensor>(dim, nv, r);
FFSTensor dummy(0, nv, dim); FFSTensor dummy(0, nv, dim);
for (Tensor::index fi = dummy.begin(); fi != dummy.end(); ++fi) for (Tensor::index fi = dummy.begin(); fi != dummy.end(); ++fi)
for (int i = 0; i < r; i++) for (int i = 0; i < r; i++)

4
dynare++/src/dynare3.cc
View File

@ -345,8 +345,8 @@ DynareDerEvalLoader::DynareDerEvalLoader(const ogp::FineAtoms &a,
md.clear(); md.clear();
for (int iord = 1; iord <= order; iord++) for (int iord = 1; iord <= order; iord++)
{ {
auto *t = new FSSparseTensor(iord, atoms.ny()+atoms.nys()+atoms.nyss()+atoms.nexo(), atoms.ny()); auto t = std::make_unique<FSSparseTensor>(iord, atoms.ny()+atoms.nys()+atoms.nyss()+atoms.nexo(), atoms.ny());
md.insert(t); md.insert(std::move(t));
} }
} }

13
dynare++/tl/cc/normal_moments.cc
View File

@ -29,9 +29,9 @@ UNormalMoments::generateMoments(int maxdim, const TwoDMatrix &v)
"Variance-covariance matrix is not square in UNormalMoments constructor"); "Variance-covariance matrix is not square in UNormalMoments constructor");
int nv = v.nrows(); int nv = v.nrows();
auto *mom2 = new URSingleTensor(nv, 2); auto mom2 = std::make_unique<URSingleTensor>(nv, 2);
mom2->getData() = v.getData(); mom2->getData() = v.getData();
insert(mom2); insert(std::move(mom2));
auto kronv = std::make_unique<URSingleTensor>(nv, 2); auto kronv = std::make_unique<URSingleTensor>(nv, 2);
kronv->getData() = v.getData(); kronv->getData() = v.getData();
for (int d = 4; d <= maxdim; d += 2) for (int d = 4; d <= maxdim; d += 2)
@ -41,7 +41,7 @@ UNormalMoments::generateMoments(int maxdim, const TwoDMatrix &v)
ConstVector(kronv->getData()), ConstVector(kronv->getData()),
newkronv->getData()); newkronv->getData());
kronv = std::move(newkronv); kronv = std::move(newkronv);
auto *mom = new URSingleTensor(nv, d); auto mom = std::make_unique<URSingleTensor>(nv, d);
// apply $F_n$ to |kronv| // apply $F_n$ to |kronv|
/* Here we go through all equivalences, select only those having 2 /* Here we go through all equivalences, select only those having 2
elements in each class, then go through all elements in |kronv| and elements in each class, then go through all elements in |kronv| and
@ -66,7 +66,7 @@ UNormalMoments::generateMoments(int maxdim, const TwoDMatrix &v)
mom->get(*it2, 0) += kronv->get(*it, 0); mom->get(*it2, 0) += kronv->get(*it, 0);
} }
} }
insert(mom); insert(std::move(mom));
} }
} }
@ -89,8 +89,5 @@ FNormalMoments::FNormalMoments(const UNormalMoments &moms)
: TensorContainer<FRSingleTensor>(1) : TensorContainer<FRSingleTensor>(1)
{ {
for (const auto &mom : moms) for (const auto &mom : moms)
{ insert(std::make_unique<FRSingleTensor>(*(mom.second)));
auto *fm = new FRSingleTensor(*(mom.second));
insert(fm);
}
} }

12
dynare++/tl/cc/t_container.cc
View File

@ -11,11 +11,8 @@ const int FGSContainer::num_one_time = 10;
UGSContainer::UGSContainer(const FGSContainer &c) UGSContainer::UGSContainer(const FGSContainer &c)
: TensorContainer<UGSTensor>(c.num()) : TensorContainer<UGSTensor>(c.num())
{ {
for (const auto & it : c) for (const auto &it : c)
{ insert(std::make_unique<UGSTensor>(*(it.second)));
auto *unfolded = new UGSTensor(*(it.second));
insert(unfolded);
}
} }
/* We set |l| to dimension of |t|, this is a tensor which multiplies /* We set |l| to dimension of |t|, this is a tensor which multiplies
@ -58,10 +55,7 @@ FGSContainer::FGSContainer(const UGSContainer &c)
: TensorContainer<FGSTensor>(c.num()) : TensorContainer<FGSTensor>(c.num())
{ {
for (const auto & it : c) for (const auto & it : c)
{ insert(std::make_unique<FGSTensor>(*(it.second)));
auto *folded = new FGSTensor(*(it.second));
insert(folded);
}
} }
// |FGSContainer::multAndAdd| folded code // |FGSContainer::multAndAdd| folded code

79
dynare++/tl/cc/t_container.hh
View File

@ -59,6 +59,8 @@
#include <map> #include <map>
#include <string> #include <string>
#include <sstream> #include <sstream>
#include <memory>
#include <utility>
#include <matio.h> #include <matio.h>
@ -96,8 +98,7 @@ class TensorContainer
protected: protected:
using _const_ptr = const _Ttype *; using _const_ptr = const _Ttype *;
using _ptr = _Ttype *; using _ptr = _Ttype *;
using _Map = std::map<Symmetry, _ptr, ltsym>; using _Map = std::map<Symmetry, std::unique_ptr<_Ttype>, ltsym>;
using _mvtype = typename _Map::value_type;
public: public:
using iterator = typename _Map::iterator; using iterator = typename _Map::iterator;
using const_iterator = typename _Map::const_iterator; using const_iterator = typename _Map::const_iterator;
@ -113,14 +114,12 @@ public:
} }
/* This is just a copy constructor. This makes a hard copy of all tensors. */ /* This is just a copy constructor. This makes a hard copy of all tensors. */
TensorContainer(const TensorContainer<_Ttype> &c) TensorContainer(const TensorContainer<_Ttype> &c)
: n(c.n), m(), ebundle(c.ebundle) : n(c.n), ebundle(c.ebundle)
{ {
for (auto it = c.m.begin(); it != c.m.end(); ++it) for (const auto &it : c.m)
{ insert(std::make_unique<_Ttype>(*(it.second)));
auto *ten = new _Ttype(*((*it).second));
insert(ten);
}
} }
TensorContainer(TensorContainer<_Ttype> &&) = default;
// |TensorContainer| subtensor constructor // |TensorContainer| subtensor constructor
/* This constructor constructs a new tensor container, whose tensors /* This constructor constructs a new tensor container, whose tensors
@ -128,11 +127,8 @@ public:
TensorContainer(int first_row, int num, TensorContainer<_Ttype> &c) TensorContainer(int first_row, int num, TensorContainer<_Ttype> &c)
: n(c.n), ebundle(*(tls.ebundle)) : n(c.n), ebundle(*(tls.ebundle))
{ {
for (auto it = c.m.begin(); it != c.m.end(); ++it) for (const auto &it : c.m)
{ insert(std::make_unique<_Ttype>(first_row, num, *(it.second)));
auto *t = new _Ttype(first_row, num, *((*it).second));
insert(t);
}
} }
_const_ptr _const_ptr
@ -147,9 +143,7 @@ public:
return nullptr; return nullptr;
} }
else else
{ return it->second.get();
return (*it).second;
}
} }
_ptr _ptr
@ -164,9 +158,7 @@ public:
return nullptr; return nullptr;
} }
else else
{ return it->second.get();
return (*it).second;
}
} }
bool bool
@ -178,49 +170,37 @@ public:
return it != m.end(); return it != m.end();
} }
void virtual void
insert(_ptr t) insert(std::unique_ptr<_Ttype> t)
{ {
TL_RAISE_IF(t->getSym().num() != num(), TL_RAISE_IF(t->getSym().num() != num(),
"Incompatible symmetry insertion in TensorContainer::insert"); "Incompatible symmetry insertion in TensorContainer::insert");
TL_RAISE_IF(check(t->getSym()), TL_RAISE_IF(check(t->getSym()),
"Tensor already in container in TensorContainer::insert"); "Tensor already in container in TensorContainer::insert");
m.insert(_mvtype(t->getSym(), t));
if (!t->isFinite()) if (!t->isFinite())
{ throw TLException(__FILE__, __LINE__, "NaN or Inf asserted in TensorContainer::insert");
throw TLException(__FILE__, __LINE__, "NaN or Inf asserted in TensorContainer::insert"); m.emplace(t->getSym(), std::move(t));
}
} }
void void
remove(const Symmetry &s) remove(const Symmetry &s)
{ {
auto it = m.find(s); m.erase(s);
if (it != m.end())
{
_ptr t = (*it).second;
m.erase(it);
delete t;
}
} }
void void
clear() clear()
{ {
while (!m.empty()) m.clear();
{
delete (*(m.begin())).second;
m.erase(m.begin());
}
} }
int int
getMaxDim() const getMaxDim() const
{ {
int res = -1; int res = -1;
for (auto run = m.begin(); run != m.end(); ++run) for (const auto &run : m)
{ {
int dim = (*run).first.dimen(); int dim = run.first.dimen();
if (dim > res) if (dim > res)
res = dim; res = dim;
} }
@ -235,8 +215,8 @@ public:
for (const_iterator it = m.begin(); it != m.end(); ++it) for (const_iterator it = m.begin(); it != m.end(); ++it)
{ {
printf("Symmetry: "); printf("Symmetry: ");
(*it).first.print(); (it->first).print();
((*it).second)->print(); (it->second)->print();
} }
} }
@ -255,7 +235,7 @@ public:
sprintf(tmp, "_%d", sym[i]); sprintf(tmp, "_%d", sym[i]);
strcat(lname, tmp); strcat(lname, tmp);
} }
ConstTwoDMatrix m(*((*it).second)); ConstTwoDMatrix m(*(it->second));
m.writeMat(fd, lname); m.writeMat(fd, lname);
} }
} }
@ -294,10 +274,7 @@ public:
return res; return res;
} }
virtual ~TensorContainer() virtual ~TensorContainer() = default;
{
clear();
}
int int
num() const num() const
@ -342,9 +319,8 @@ public:
: TensorContainer<UGSTensor>(nn) : TensorContainer<UGSTensor>(nn)
{ {
} }
UGSContainer(const UGSContainer &uc) UGSContainer(const UGSContainer &) = default;
UGSContainer(UGSContainer &&) = default;
= default;
UGSContainer(const FGSContainer &c); UGSContainer(const FGSContainer &c);
void multAndAdd(const UGSTensor &t, UGSTensor &out) const; void multAndAdd(const UGSTensor &t, UGSTensor &out) const;
}; };
@ -370,9 +346,8 @@ public:
: TensorContainer<FGSTensor>(nn) : TensorContainer<FGSTensor>(nn)
{ {
} }
FGSContainer(const FGSContainer &fc) FGSContainer(const FGSContainer &) = default;
FGSContainer(FGSContainer &&) = default;
= default;
FGSContainer(const UGSContainer &c); FGSContainer(const UGSContainer &c);
void multAndAdd(const FGSTensor &t, FGSTensor &out) const; void multAndAdd(const FGSTensor &t, FGSTensor &out) const;
void multAndAdd(const UGSTensor &t, FGSTensor &out) const; void multAndAdd(const UGSTensor &t, FGSTensor &out) const;

12
dynare++/tl/cc/t_polynomial.cc
View File

@ -50,17 +50,13 @@ PowerProvider::~PowerProvider()
UTensorPolynomial::UTensorPolynomial(const FTensorPolynomial &fp) UTensorPolynomial::UTensorPolynomial(const FTensorPolynomial &fp)
: TensorPolynomial<UFSTensor, UGSTensor, URSingleTensor>(fp.nrows(), fp.nvars()) : TensorPolynomial<UFSTensor, UGSTensor, URSingleTensor>(fp.nrows(), fp.nvars())
{ {
for (const auto & it : fp) for (const auto &it : fp)
{ insert(std::make_unique<UFSTensor>(*(it.second)));
insert(new UFSTensor(*(it.second)));
}
} }
FTensorPolynomial::FTensorPolynomial(const UTensorPolynomial &up) FTensorPolynomial::FTensorPolynomial(const UTensorPolynomial &up)
: TensorPolynomial<FFSTensor, FGSTensor, FRSingleTensor>(up.nrows(), up.nvars()) : TensorPolynomial<FFSTensor, FGSTensor, FRSingleTensor>(up.nrows(), up.nvars())
{ {
for (const auto & it : up) for (const auto &it : up)
{ insert(std::make_unique<FFSTensor>(*(it.second)));
insert(new FFSTensor(*(it.second)));
}
} }

38
dynare++/tl/cc/t_polynomial.hh
View File

@ -175,14 +175,13 @@ public:
/* The pointer |ten| is either a new tensor or got from |this| container. */ /* The pointer |ten| is either a new tensor or got from |this| container. */
_Ttype *ten; _Ttype *ten;
if (_Tparent::check(Symmetry{j})) if (_Tparent::check(Symmetry{j}))
{ ten = _Tparent::get(Symmetry{j});
ten = _Tparent::get(Symmetry{j});
}
else else
{ {
ten = new _Ttype(nrows(), nvars(), j); auto ten_smart = std::make_unique<_Ttype>(nrows(), nvars(), j);
ten->zeros(); ten_smart->zeros();
insert(ten); ten = ten_smart.get();
insert(std::move(ten_smart));
} }
Symmetry sym{i, j}; Symmetry sym{i, j};
@ -208,14 +207,13 @@ public:
/* Same code as above */ /* Same code as above */
_Ttype *ten; _Ttype *ten;
if (_Tparent::check(Symmetry{j})) if (_Tparent::check(Symmetry{j}))
{ ten = _Tparent::get(Symmetry{j});
ten = _Tparent::get(Symmetry{j});
}
else else
{ {
ten = new _Ttype(nrows(), nvars(), j); auto ten_smart = std::make_unique<_Ttype>(nrows(), nvars(), j);
ten->zeros(); ten_smart->zeros();
insert(ten); ten = ten_smart.get();
insert(std::move(ten_smart));
} }
Symmetry sym{0, j}; Symmetry sym{0, j};
@ -308,15 +306,15 @@ public:
number of variables. Then we insert and update the |maxdim|. */ number of variables. Then we insert and update the |maxdim|. */
void void
insert(_ptr t) insert(std::unique_ptr<_Ttype> t) override
{ {
TL_RAISE_IF(t->nrows() != nr, TL_RAISE_IF(t->nrows() != nr,
"Wrong number of rows in TensorPolynomial::insert"); "Wrong number of rows in TensorPolynomial::insert");
TL_RAISE_IF(t->nvar() != nv, TL_RAISE_IF(t->nvar() != nv,
"Wrong number of variables in TensorPolynomial::insert"); "Wrong number of variables in TensorPolynomial::insert");
TensorContainer<_Ttype>::insert(t);
if (maxdim < t->dimen()) if (maxdim < t->dimen())
maxdim = t->dimen(); maxdim = t->dimen();
TensorContainer<_Ttype>::insert(std::move(t));
} }
/* The polynomial takes the form /* The polynomial takes the form
@ -359,13 +357,13 @@ public:
|g.derivative(0)|, |g.derivative(1)| and |der=g.evalPartially(2, v)| |g.derivative(0)|, |g.derivative(1)| and |der=g.evalPartially(2, v)|
calculates $2!$ multiple of the second derivative of |g| at |v|. */ calculates $2!$ multiple of the second derivative of |g| at |v|. */
_Ttype * std::unique_ptr<_Ttype>
evalPartially(int s, const ConstVector &v) evalPartially(int s, const ConstVector &v)
{ {
TL_RAISE_IF(v.length() != nvars(), TL_RAISE_IF(v.length() != nvars(),
"Wrong length of vector for TensorPolynomial::evalPartially"); "Wrong length of vector for TensorPolynomial::evalPartially");
auto *res = new _Ttype(nrows(), nvars(), s); auto res = std::make_unique<_Ttype>(nrows(), nvars(), s);
res->zeros(); res->zeros();
if (_Tparent::check(Symmetry{s})) if (_Tparent::check(Symmetry{s}))
@ -376,15 +374,13 @@ public:
if (_Tparent::check(Symmetry{d})) if (_Tparent::check(Symmetry{d}))
{ {
const _Ttype &ltmp = *(_Tparent::get(Symmetry{d})); const _Ttype &ltmp = *(_Tparent::get(Symmetry{d}));
auto *last = new _Ttype(ltmp); auto last = std::make_unique<_Ttype>(ltmp);
for (int j = 0; j < d - s; j++) for (int j = 0; j < d - s; j++)
{ {
auto *newlast = new _Ttype(*last, v); auto newlast = std::make_unique<_Ttype>(*last, v);
delete last; last = std::move(newlast);
last = newlast;
} }
res->add(1.0, *last); res->add(1.0, *last);
delete last;
} }
} }

20
dynare++/tl/testing/factory.hh
View File

@ -5,6 +5,7 @@
#define FACTORY_H #define FACTORY_H
#include <random> #include <random>
#include <memory>
#include "symmetry.hh" #include "symmetry.hh"
#include "int_sequence.hh" #include "int_sequence.hh"
@ -25,10 +26,10 @@ public:
double get(); double get();
// this can be used with UGSTensor, FGSTensor // this can be used with UGSTensor, FGSTensor
template <class _Ttype> template <class _Ttype>
_Ttype * std::unique_ptr<_Ttype>
make(int r, const Symmetry &s, const IntSequence &nvs) make(int r, const Symmetry &s, const IntSequence &nvs)
{ {
_Ttype *res = new _Ttype(r, TensorDimens(s, nvs)); auto res = std::make_unique<_Ttype>(r, TensorDimens(s, nvs));
init(s, nvs); init(s, nvs);
fillMatrix(*res); fillMatrix(*res);
return res; return res;
@ -36,10 +37,10 @@ public:
// this can be used with FFSTensor, UFSTensor, FRTensor, URTensor // this can be used with FFSTensor, UFSTensor, FRTensor, URTensor
template <class _Ttype> template <class _Ttype>
_Ttype * std::unique_ptr<_Ttype>
make(int r, int nv, int dim) make(int r, int nv, int dim)
{ {
auto *res = new _Ttype(r, nv, dim); auto res = std::make_unique<_Ttype>(r, nv, dim);
init(dim, nv); init(dim, nv);
fillMatrix(*res); fillMatrix(*res);
return res; return res;
@ -56,8 +57,7 @@ public:
{ {
// full symmetry // full symmetry
Symmetry sym{dim}; Symmetry sym{dim};
auto *t = make<_Ttype>(r, sym, nvs); res->insert(make<_Ttype>(r, sym, nvs));
res->insert(t);
} }
else else
{ {
@ -65,8 +65,7 @@ public:
for (int i = 0; i <= dim; i++) for (int i = 0; i <= dim; i++)
{ {
Symmetry sym{i, dim-i}; Symmetry sym{i, dim-i};
auto *t = make<_Ttype>(r, sym, nvs); res->insert(make<_Ttype>(r, sym, nvs));
res->insert(t);
} }
} }
return res; return res;
@ -78,10 +77,7 @@ public:
{ {
auto *p = new _Ptype(r, nv); auto *p = new _Ptype(r, nv);
for (int d = 1; d <= maxdim; d++) for (int d = 1; d <= maxdim; d++)
{ p->insert(make<_Ttype>(r, nv, d));
auto *t = make<_Ttype>(r, nv, d);
p->insert(t);
}
return p; return p;
} }

32
dynare++/tl/testing/monoms.cc
View File

@ -102,11 +102,11 @@ Monom1Vector::deriv(const IntSequence &c, Vector &out) const
out[i] = x[i].deriv(c); out[i] = x[i].deriv(c);
} }
FGSTensor * std::unique_ptr<FGSTensor>
Monom1Vector::deriv(int dim) const Monom1Vector::deriv(int dim) const
{ {
FGSTensor *res auto res = std::make_unique<FGSTensor>(len, TensorDimens(Symmetry{dim},
= new FGSTensor(len, TensorDimens(Symmetry{dim}, IntSequence(1, nx))); IntSequence(1, nx)));
for (Tensor::index it = res->begin(); it != res->end(); ++it) for (Tensor::index it = res->begin(); it != res->end(); ++it)
{ {
Vector outcol{res->getCol(*it)}; Vector outcol{res->getCol(*it)};
@ -176,11 +176,11 @@ Monom2Vector::deriv(const Symmetry &s, const IntSequence &c,
out[i] = y[i].deriv(cy) * u[i].deriv(cu); out[i] = y[i].deriv(cy) * u[i].deriv(cu);
} }
FGSTensor * std::unique_ptr<FGSTensor>
Monom2Vector::deriv(const Symmetry &s) const Monom2Vector::deriv(const Symmetry &s) const
{ {
IntSequence nvs{ny, nu}; IntSequence nvs{ny, nu};
FGSTensor *t = new FGSTensor(len, TensorDimens(s, nvs)); auto t = std::make_unique<FGSTensor>(len, TensorDimens(s, nvs));
for (Tensor::index it = t->begin(); it != t->end(); ++it) for (Tensor::index it = t->begin(); it != t->end(); ++it)
{ {
Vector col{t->getCol(*it)}; Vector col{t->getCol(*it)};
@ -318,11 +318,11 @@ Monom4Vector::deriv(const Symmetry &s, const IntSequence &coor,
} }
} }
FGSTensor * std::unique_ptr<FGSTensor>
Monom4Vector::deriv(const Symmetry &s) const Monom4Vector::deriv(const Symmetry &s) const
{ {
IntSequence nvs{nx1, nx2, nx3, nx4}; IntSequence nvs{nx1, nx2, nx3, nx4};
FGSTensor *res = new FGSTensor(len, TensorDimens(s, nvs)); auto res = std::make_unique<FGSTensor>(len, TensorDimens(s, nvs));
for (Tensor::index run = res->begin(); run != res->end(); ++run) for (Tensor::index run = res->begin(); run != res->end(); ++run)
{ {
Vector col{res->getCol(*run)}; Vector col{res->getCol(*run)};
@ -416,8 +416,7 @@ SparseDerivGenerator::~SparseDerivGenerator()
DenseDerivGenerator::DenseDerivGenerator(int ng, int nx, int ny, int nu, DenseDerivGenerator::DenseDerivGenerator(int ng, int nx, int ny, int nu,
int mx, double prob, int maxdim) int mx, double prob, int maxdim)
: maxdimen(maxdim), ts(new FGSTensor *[maxdimen]), : maxdimen(maxdim), ts(maxdimen), uts(maxdimen)
uts(new UGSTensor *[maxdimen])
{ {
intgen.init(ng, nx, ny, nu, nu, mx, prob); intgen.init(ng, nx, ny, nu, nu, mx, prob);
Monom1Vector g(nx, ng); Monom1Vector g(nx, ng);
@ -427,10 +426,7 @@ DenseDerivGenerator::DenseDerivGenerator(int ng, int nx, int ny, int nu,
rcont = r.deriv(maxdimen); rcont = r.deriv(maxdimen);
uxcont = nullptr; uxcont = nullptr;
for (int d = 1; d <= maxdimen; d++) for (int d = 1; d <= maxdimen; d++)
{ ts[d-1] = g.deriv(d);
ts[d-1] = g.deriv(d);
uts[d-1] = nullptr;
}
} }
void void
@ -438,19 +434,11 @@ DenseDerivGenerator::unfold()
{ {
uxcont = new UGSContainer(*xcont); uxcont = new UGSContainer(*xcont);
for (int i = 0; i < maxdimen; i++) for (int i = 0; i < maxdimen; i++)
uts[i] = new UGSTensor(*(ts[i])); uts[i] = std::make_unique<UGSTensor>(*(ts[i]));
} }
DenseDerivGenerator::~DenseDerivGenerator() DenseDerivGenerator::~DenseDerivGenerator()
{ {
delete xcont; delete xcont;
delete rcont; delete rcont;
for (int i = 0; i < maxdimen; i++)
{
delete ts[i];
if (uts[i])
delete uts[i];
}
delete [] ts;
delete [] uts;
} }

11
dynare++/tl/testing/monoms.hh
View File

@ -6,6 +6,7 @@
#include <vector> #include <vector>
#include <random> #include <random>
#include <memory>
#include "int_sequence.hh" #include "int_sequence.hh"
#include "gs_tensor.hh" #include "gs_tensor.hh"
@ -49,7 +50,7 @@ public:
Monom1Vector(int nxx, int l); Monom1Vector(int nxx, int l);
~Monom1Vector() = default; ~Monom1Vector() = default;
void deriv(const IntSequence &c, Vector &out) const; void deriv(const IntSequence &c, Vector &out) const;
FGSTensor *deriv(int dim) const; std::unique_ptr<FGSTensor> deriv(int dim) const;
void print() const; void print() const;
}; };
@ -66,7 +67,7 @@ public:
Monom2Vector(const Monom1Vector &g, const Monom2Vector &xmon); Monom2Vector(const Monom1Vector &g, const Monom2Vector &xmon);
~Monom2Vector() = default; ~Monom2Vector() = default;
void deriv(const Symmetry &s, const IntSequence &c, Vector &out) const; void deriv(const Symmetry &s, const IntSequence &c, Vector &out) const;
FGSTensor *deriv(const Symmetry &s) const; std::unique_ptr<FGSTensor> deriv(const Symmetry &s) const;
FGSContainer *deriv(int maxdim) const; FGSContainer *deriv(int maxdim) const;
void print() const; void print() const;
}; };
@ -88,7 +89,7 @@ public:
const Monom4Vector &g); const Monom4Vector &g);
~Monom4Vector() = default; ~Monom4Vector() = default;
FSSparseTensor *deriv(int dim) const; FSSparseTensor *deriv(int dim) const;
FGSTensor *deriv(const Symmetry &s) const; std::unique_ptr<FGSTensor> deriv(const Symmetry &s) const;
void deriv(const Symmetry &s, const IntSequence &coor, Vector &out) const; void deriv(const Symmetry &s, const IntSequence &coor, Vector &out) const;
void print() const; void print() const;
protected: protected:
@ -112,9 +113,9 @@ struct DenseDerivGenerator
int maxdimen; int maxdimen;
FGSContainer *xcont; FGSContainer *xcont;
FGSContainer *rcont; FGSContainer *rcont;
FGSTensor **const ts; std::vector<std::unique_ptr<FGSTensor>> ts;
UGSContainer *uxcont; UGSContainer *uxcont;
UGSTensor **const uts; std::vector<std::unique_ptr<UGSTensor>> uts;
DenseDerivGenerator(int ng, int nx, int ny, int nu, DenseDerivGenerator(int ng, int nx, int ny, int nu,
int mx, double prob, int maxdim); int mx, double prob, int maxdim);
void unfold(); void unfold();

24
dynare++/tl/testing/tests.cc
View File

@ -45,27 +45,24 @@ protected:
template <class _Ttype> template <class _Ttype>
static bool index_offset(const Symmetry &s, const IntSequence &nvs); static bool index_offset(const Symmetry &s, const IntSequence &nvs);
static bool fold_unfold(const FTensor *folded); static bool fold_unfold(std::unique_ptr<FTensor> folded);
static bool static bool
fs_fold_unfold(int r, int nv, int dim) fs_fold_unfold(int r, int nv, int dim)
{ {
Factory f; Factory f;
FTensor *folded = f.make<FFSTensor>(r, nv, dim); return fold_unfold(f.make<FFSTensor>(r, nv, dim));
return fold_unfold(folded); // folded deallocated in fold_unfold
} }
static bool static bool
r_fold_unfold(int r, int nv, int dim) r_fold_unfold(int r, int nv, int dim)
{ {
Factory f; Factory f;
FTensor *folded = f.make<FRTensor>(r, nv, dim); return fold_unfold(f.make<FRTensor>(r, nv, dim));
return fold_unfold(folded); // folded deallocated in fold_unfold
} }
static bool static bool
gs_fold_unfold(int r, const Symmetry &s, const IntSequence &nvs) gs_fold_unfold(int r, const Symmetry &s, const IntSequence &nvs)
{ {
Factory f; Factory f;
FTensor *folded = f.make<FGSTensor>(r, s, nvs); return fold_unfold(f.make<FGSTensor>(r, s, nvs));
return fold_unfold(folded); // folded deallocated in fold_unfold
} }
static bool dense_prod(const Symmetry &bsym, const IntSequence &bnvs, static bool dense_prod(const Symmetry &bsym, const IntSequence &bnvs,
@ -194,7 +191,7 @@ TestRunnable::index_offset(const Symmetry &s, const IntSequence &nvs)
} }
bool bool
TestRunnable::fold_unfold(const FTensor *folded) TestRunnable::fold_unfold(std::unique_ptr<FTensor> folded)
{ {
auto unfolded = folded->unfold(); auto unfolded = folded->unfold();
auto folded2 = unfolded->fold(); auto folded2 = unfolded->fold();
@ -206,8 +203,6 @@ TestRunnable::fold_unfold(const FTensor *folded)
<< "\tdifference normInf: " << normInf << '\n' << "\tdifference normInf: " << normInf << '\n'
<< "\tdifference norm1: " << norm1 << '\n'; << "\tdifference norm1: " << norm1 << '\n';
delete folded;
return normInf < 1.0e-15; return normInf < 1.0e-15;
} }
@ -218,8 +213,7 @@ TestRunnable::dense_prod(const Symmetry &bsym, const IntSequence &bnvs,
Factory f; Factory f;
FGSContainer *cont FGSContainer *cont
= f.makeCont<FGSTensor, FGSContainer>(hnv, bnvs, bsym.dimen()-hdim+1); = f.makeCont<FGSTensor, FGSContainer>(hnv, bnvs, bsym.dimen()-hdim+1);
auto *fh auto fh = f.make<FGSTensor>(rows, Symmetry{hdim}, IntSequence(1, hnv));
= f.make<FGSTensor>(rows, Symmetry{hdim}, IntSequence(1, hnv));
UGSTensor uh(*fh); UGSTensor uh(*fh);
FGSTensor fb(rows, TensorDimens(bsym, bnvs)); FGSTensor fb(rows, TensorDimens(bsym, bnvs));
fb.getData().zeros(); fb.getData().zeros();
@ -248,7 +242,6 @@ TestRunnable::dense_prod(const Symmetry &bsym, const IntSequence &bnvs,
<< "\tunfolded difference normInf: " << normInf << '\n'; << "\tunfolded difference normInf: " << normInf << '\n';
delete cont; delete cont;
delete fh;
return norm < 1.e-13; return norm < 1.e-13;
} }
@ -431,7 +424,7 @@ TestRunnable::folded_contraction(int r, int nv, int dim)
Factory fact; Factory fact;
Vector x{fact.makeVector(nv)}; Vector x{fact.makeVector(nv)};
auto *forig = fact.make<FFSTensor>(r, nv, dim); auto forig = fact.make<FFSTensor>(r, nv, dim);
auto *f = new FFSTensor(*forig); auto *f = new FFSTensor(*forig);
clock_t ctime = clock(); clock_t ctime = clock();
for (int d = dim-1; d > 0; d--) for (int d = dim-1; d > 0; d--)
@ -472,9 +465,8 @@ TestRunnable::unfolded_contraction(int r, int nv, int dim)
Factory fact; Factory fact;
Vector x{fact.makeVector(nv)}; Vector x{fact.makeVector(nv)};
auto *forig = fact.make<FFSTensor>(r, nv, dim); auto forig = fact.make<FFSTensor>(r, nv, dim);
UFSTensor uorig(*forig); UFSTensor uorig(*forig);
delete forig;
auto *u = new UFSTensor(uorig); auto *u = new UFSTensor(uorig);
clock_t ctime = clock(); clock_t ctime = clock();
for (int d = dim-1; d > 0; d--) for (int d = dim-1; d > 0; d--)

9
mex/sources/k_order_perturbation/k_ord_dynare.cc
View File

@ -51,7 +51,7 @@ KordpDynare::KordpDynare(const std::vector<std::string> &endo, int num_endo,
// Initialise ModelDerivativeContainer(*this, this->md, nOrder); // Initialise ModelDerivativeContainer(*this, this->md, nOrder);
for (int iord = 1; iord <= nOrder; iord++) for (int iord = 1; iord <= nOrder; iord++)
md.insert(new FSSparseTensor(iord, nY+nYs+nYss+nExog, nY)); md.insert(std::make_unique<FSSparseTensor>(iord, nY+nYs+nYss+nExog, nY));
} }
KordpDynare::KordpDynare(const std::vector<std::string> &endo, int num_endo, KordpDynare::KordpDynare(const std::vector<std::string> &endo, int num_endo,
@ -73,7 +73,7 @@ KordpDynare::KordpDynare(const std::vector<std::string> &endo, int num_endo,
// Initialise ModelDerivativeContainer(*this, this->md, nOrder); // Initialise ModelDerivativeContainer(*this, this->md, nOrder);
for (int iord = 1; iord <= nOrder; iord++) for (int iord = 1; iord <= nOrder; iord++)
md.insert(new FSSparseTensor(iord, nY+nYs+nYss+nExog, nY)); md.insert(std::make_unique<FSSparseTensor>(iord, nY+nYs+nYss+nExog, nY));
} }
KordpDynare::~KordpDynare() KordpDynare::~KordpDynare()
@ -162,7 +162,7 @@ void
KordpDynare::populateDerivativesContainer(const TwoDMatrix &g, int ord, const std::vector<int> &vOrder) KordpDynare::populateDerivativesContainer(const TwoDMatrix &g, int ord, const std::vector<int> &vOrder)
{ {
// model derivatives FSSparseTensor instance // model derivatives FSSparseTensor instance
FSSparseTensor *mdTi = (new FSSparseTensor(ord, nJcols, nY)); auto mdTi = std::make_unique<FSSparseTensor>(ord, nJcols, nY);
IntSequence s(ord, 0); IntSequence s(ord, 0);
@ -249,8 +249,7 @@ KordpDynare::populateDerivativesContainer(const TwoDMatrix &g, int ord, const st
// md container // md container
md.remove(Symmetry{ord}); md.remove(Symmetry{ord});
md.insert(mdTi); md.insert(std::move(mdTi));
// No need to delete mdTi, it will be deleted by TensorContainer destructor
} }
/********************************************************* /*********************************************************