std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
}
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
}
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FullMatrix<double> matrix(2);
matrix(0,0) = 0.;
logfile.precision (3);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Create triangulation
Triangulation<2> tri;
std::ofstream logfile("output");
deallog.attach(logfile);
deallog << std::setprecision(8);
- deallog.threshold_double(1.e-8);
test_projection<2>(logfile);
test_projection<3>(logfile);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid(Triangulation<3>::allow_anisotropic_smoothing);
deallog << std::setprecision (4);
logfile << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
transfer<2>(logfile);
transfer<3>(logfile);
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
using namespace dealii;
initlog();
- deallog.threshold_double(1.e-10);
EigenvalueProblem<2> problem(4);
{
std::ofstream logfile("output");
dealii::deallog.attach(logfile,/*do not print job id*/false);
- dealii::deallog.threshold_double(eps);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile,/*do not print job id*/false);
- deallog.threshold_double(eps);
try
{
using namespace Step36;
initlog();
- deallog.threshold_double(1.e-10);
EigenvalueProblem<2> problem ("");
using namespace Step36;
initlog();
- deallog.threshold_double(1.e-10);
EigenvalueProblem<2> problem ("");
{
std::ofstream logfile("output");
dealii::deallog.attach(logfile,/*do not print job id*/false);
- dealii::deallog.threshold_double(eps);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile,/*do not print job id*/false);
- deallog.threshold_double(eps);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile,/*do not print job id*/false);
- deallog.threshold_double(eps);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile,/*do not print job id*/false);
- deallog.threshold_double(eps);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile,/*do not print job id*/false);
- deallog.threshold_double(eps);
try
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim=2;
AutoSinExp<dim> auto_function;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << boost::math::erf (0.5) << std::endl;
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ConditionalOStream o(logfile, true);
o << "Yes" << std::endl;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ConvergenceTable table;
ConvergenceTable table_2;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ConvergenceTable table;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ConvergenceTable table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ConvergenceTable table_1;
ConvergenceTable table_2;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Tensor<2,2> t;
t[0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Tensor<2,3> t;
t[0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Tensor<4,2> t;
t[0][0][0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Tensor<4,3> t;
t[0][0][0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<4> ();
test<5> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
check_sine<2>(3);
check_sine<3>(3);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// Define some constants that will be used by the function parser
std::map<std::string, double> constants;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
if (true)
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << "Functions PillowFunction" << std::endl;
check_value (Functions::PillowFunction<1>());
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
if (true)
{
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check1<1> ();
check1<2> ();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check1<1> ();
check1<2> ();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check1<1> ();
check1<2> ();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1,1>();
check<2,1>();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
std::ofstream logfile(LOG_FILE);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_n_components<1,NUMBER> (component_data);
test_n_components<2,NUMBER> (component_data);
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
}
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
}
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3>();
}
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3>();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int n=2; n<20; ++n)
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// create 4 threads, run the test function on them
Threads::Thread<std::pair<double,double> > tg[4];
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::endl << "GeometryInfo<dim>::face_to_cell_vertices:" << std::endl;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const std::vector<Polynomial<double> >
p = Hierarchical::generate_complete_basis (10);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// the isnan() function (which we call in is_finite()) helpfully
// produces a floating point exception when called with a signalling
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// the isnan() function (which we call in is_finite()) helpfully
// produces a floating point exception when called with a signalling
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << std::numeric_limits<double>::infinity() << std::endl;
deallog << -std::numeric_limits<double>::infinity() << std::endl;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// the isnan() function (which we call in is_finite()) helpfully
// produces a floating point exception when called with a signalling
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << numbers::PI << std::endl;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << numbers::PI*2 << 42 << std::endl;
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
LogStream log;
log.attach(logfile);
- log.threshold_double(1.e-10);
log.log_thread_id (false);
log << "This should be printed!";
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << "Test" << std::endl;
deallog.push("l1");
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
std::vector<int> mpi_error_codes;
mpi_error_codes.push_back(MPI_ERR_BUFFER);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
#ifdef DEAL_II_WITH_THREADS
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check (std::complex<float>(1.5, 2.5));
check (std::complex<float>(-1.5, -2.5));
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check ((float)1.5);
check ((float)-1.5);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
const int N = 10000;
const int s = parallel::accumulate_from_subranges<int> (&sum, 0, N, 10);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
const unsigned int N=10000;
Vector<double> x(N), y(N);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
const unsigned int N=10000;
Vector<double> x(N), y(N), z(N);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
const unsigned int N=10000;
Vector<double> x(N), y(N), z(N), a(N);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// create a pattern and let it
// output its description
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.log_cerr();
polynomial_arithmetic();
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
interpolation_conditions(HermiteInterpolation::generate_complete_basis(6));
plot(HermiteInterpolation::generate_complete_basis(6));
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
-// deallog.threshold_double(1.e-10);
QTrapez<1> trapez;
QSimpson<1> simpson;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("LagrangeEquidistant");
for (unsigned i=1; i<10; i+=2)
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("LagrangeEquidistant");
for (unsigned i=8; i<18; i+=2)
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("LagrangeEquidistant");
for (unsigned i=1; i<8; i+=2)
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_poly(10);
check_poly(50);
std::ofstream logfile("output");
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("Lagrange");
std::vector<Polynomial<double> > p;
std::ofstream logfile(logname.c_str());
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
PolynomialsBDM<2> p20(0);
PolynomialsBDM<2> p21(1);
std::ofstream logfile(logname.c_str());
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
PolynomialsBDM<3> p31(1);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_poly(25);
}
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
PolynomialsRaviartThomas<2> p20(0);
PolynomialsRaviartThomas<2> p21(1);
std::ofstream logfile("output");
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("BDM");
check_bdm<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
check<double,double,double>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// check product with SymmetricTensor<2,dim>
check<SymmetricTensor<2,2,double>,double,SymmetricTensor<2,2,double> >();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
check<Tensor<1,1,double>,double,Tensor<1,1,double> >();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
check<Tensor<2,1,double>,double,Tensor<2,1,double> >();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
check<SymmetricTensor<2,1,double>,double,SymmetricTensor<2,1,double> >();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// try it for a rank-1 tensor
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
{
SymmetricTensor<2,2> t;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
check<double,double,double>();
deallog << ProductType<double,double>::type(2.345)*ProductType<double,double>::type(3.456)
initlog();
deallog << std::setprecision(2);
- deallog.threshold_double(1.e-10);
Quadrature<1> none(0);
check(none);
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision(8);
deallog << "* 1d Gauss-Chebyshev" << std::endl;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
check ("gauss", 2, QGauss<1>(2));
check ("gauss", 2, QGauss<2>(2));
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
std::vector<Quadrature<1> *> q1;
std::vector<Quadrature<2> *> q2;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
std::vector<Quadrature<1> *> q1;
std::vector<Quadrature<2> *> q2;
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
{
typedef Sacado::Fad::DFad<double> Sdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
typedef Sacado::Fad::DFad<double> Sdouble;
typedef Sacado::Fad::DFad<Sdouble> SSdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
typedef Sacado::Fad::DFad<double> Sdouble;
typedef Sacado::Fad::DFad<Sdouble> SSdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product of scalars
typedef Sacado::Fad::DFad<double> Sdouble;
typedef Sacado::Fad::DFad<Sdouble> SSdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product with Tensor<1,dim>
typedef Sacado::Fad::DFad<double> Sdouble;
typedef Sacado::Fad::DFad<Sdouble> SSdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product with Tensor<2,dim>
{
typedef Sacado::Fad::DFad<double> Sdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product with Tensor<2,dim>
typedef Sacado::Fad::DFad<double> Sdouble;
typedef Sacado::Fad::DFad<Sdouble> SSdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product with Tensor<2,dim>
{
typedef Sacado::Fad::DFad<double> Sdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product with Tensor<2,dim>
typedef Sacado::Fad::DFad<double> Sdouble;
typedef Sacado::Fad::DFad<Sdouble> SSdouble;
initlog();
- deallog.threshold_double(1.e-10);
// check product with Tensor<2,dim>
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
typedef Tensor<0,1> T;
T t1(13.), t2(42);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float> ();
check<double> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float> ();
check<double> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float> ();
check<double> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float> ();
check<double> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float> ();
check<double> ();
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
std::vector<int> v(7);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
constexpr int max_1 = std_cxx14::max(0,1);
deallog << max_1 << std::endl;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
std_cxx1x::shared_ptr<int> p;
deallog << "OK" << std::endl;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SymmetricTensor<2,2> t;
t[0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SymmetricTensor<2,3> t;
t[0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SymmetricTensor<4,2> t;
t[0][0][0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SymmetricTensor<4,3> t;
t[0][0][0][0] = 1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim=3;
SymmetricTensor<2,dim> t;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim=3;
SymmetricTensor<4,dim> t;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
const unsigned int dim=2;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
SymmetricTensor<2,1> t;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3> ();
test<5> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3> ();
test<5> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "check rank 2 tensors" << std::endl;
check_2<1>();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "check rank 2 tensors" << std::endl;
check<2,1>();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "check rank 2 tensors" << std::endl;
check<2,1>();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "checking rank 2 tensors" << std::endl;
check<2,1>();
std::ofstream logfile("output");
deallog << std::setprecision(5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Symmetric Tensor dim 1" << std::endl;
SymmetricTensor<2,1> t1;
std::ofstream logfile("output");
deallog << std::setprecision(5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_fixed_rank<2>();
test_fixed_rank<3>();
std::ofstream logfile("output");
deallog << std::setprecision(5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const int dim = 3;
Tensor<1,dim> v1;
std::ofstream logfile("output");
deallog << std::setprecision(5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const int dim = 3;
SymmetricTensor<2,dim,VectorizedArray<float> > s1;
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// a square table
if (true)
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// rank=1
{
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const std::string elements = "1 2 3 4 5 6";
{
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// rank=1
{
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
/* Like in _06 */
TableHandler table;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
/* Like in _06 */
TableHandler table;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// set precision on the output
// stream to 4 digits
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
TableHandler table;
table.set_auto_fill_mode (true);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const TableIndices<2> t1(84,42);
TableIndices<2> t2;
int main()
{
initlog();
- deallog.threshold_double(1.0e-10);
const unsigned int entries[] = {1, 2, 3, 4, 5, 6};
Table<2, unsigned int> t (2, 3);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Threads::Task<> t = Threads::new_task (test);
t.join ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Threads::Task<int> t = Threads::new_task (test);
AssertThrow (t.return_value() == 42, ExcInternalError());
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
Threads::Task<> t1 = Threads::new_task (test, 1);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Threads::Task<> t1 = Threads::new_task (test, 1);
Threads::Task<> t2 = Threads::new_task (test, 2);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Threads::Task<int> tasks[] =
{
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
Threads::Thread<> t1 = Threads::new_thread (test, 1);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Threads::TaskGroup<> tg;
tg += Threads::new_task (test, 1);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
Threads::new_task (test, 1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
{
const std::size_t n_tasks = MultithreadInfo::n_cores()*2;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Threads::Task<> t;
AssertThrow (t.joinable() == false, ExcInternalError());
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
const unsigned int n = testing_max_num_threads();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Threads::TaskGroup<double> tg;
tg += Threads::new_task (std::bind (test, 1));
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
int arg1=1;
int arg2=2;
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Threads::TaskGroup<double> tg;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
double a[3][3] = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
double b[3][3] = {{25,31,37}, {45,57,69}, {75,96,117}};
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
double a[3][3] = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
double a[3] = {1, 2, 3};
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
double a[3][3] = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
deallog << std::setprecision(3);
- deallog.threshold_double(1.e-10);
double a[3][3] = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_tensor<1>();
test_tensor<2>();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_tensor<1>();
test_tensor<2>();
std::ofstream logfile("output");
deallog << std::setprecision(5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Tensor dim 1" << std::endl;
Tensor<2,1> t1;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
double a_double[3][3][2] = {{{1,-1}, {2,0}, {3,0}},
{{3,0}, {4,0}, {5,0}},
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "First test" << std::endl;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
float a[3][3] = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
float b[3][3] = {{25,31,37}, {45,57,69}, {75,96,117}};
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
float a[3][3] = {{1, 2, 3}, {3, 4, 5}, {6, 7, 8}};
float b[3] = {25,31,37};
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Threads::ThreadGroup<double> tg;
tg += Threads::new_thread (std::bind (test, 1));
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
deallog << "OK" << std::endl;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
deallog << "OK" << std::endl;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test1 ();
test2 ();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
worker_thread = Threads::new_thread (worker);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
mutex.acquire ();
// start and abandon the
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
mutex.acquire ();
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Threads::Thread<int> t;
// join non-existing thread
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog<<"Forward Euler"<<std::endl;
TimeStepping::ExplicitRungeKutta<Vector<double> > fe(TimeStepping::FORWARD_EULER);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
TimeStepping::EmbeddedExplicitRungeKutta<Vector<double> > he(TimeStepping::HEUN_EULER);
test(he,f,my);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Timer t;
burn(50);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-1);
{
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Timer t1,t2;
TimerOutput tO(std::cout,
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Timer t;
burn(50);
{
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
mpi_initlog();
- deallog.threshold_double(1.e-10);
Timer t1(MPI_COMM_WORLD, false);
Timer t2(MPI_COMM_WORLD, true);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// test with plain new/delete
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
verify ("abc");
verify ("1.23.4");
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
verify ("abc");
verify ("1.23.4");
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<0> ();
test<1> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double,1> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
do_project();
}
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
do_project();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
SystemTest<2>().run();
SystemTest<3>().run();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
SystemTest<2>().run();
SystemTest<3>().run();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
SystemTest<2>().run();
SystemTest<3>().run();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
FindBug<2>().run ();
FindBug<3>().run ();
std::ofstream logfile("output");
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ImposeBC<2>().run ();
ImposeBC<3>().run ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
FullMatrix<double> A1(4,4);
FullMatrix<double> A2(4,4);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tria;
GridGenerator::hyper_cube (tria,0,1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tria;
GridGenerator::hyper_cube (tria,0,1);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// build test-case trias
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria;
GridGenerator::hyper_cube(tria, 0, 1);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
create_L_shape (coarse_grid);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
logfile << std::setprecision (2);
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
logfile << std::setprecision (2);
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
// generate a cylinder
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<3> ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<3> ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
// generate a hyperball in 3d
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
// generate a hyperball in 3d
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
SolverControl control(100, 1.e-3);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
SolverControl control(100, 1.e-3);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
deallog << std::fixed;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int testcase=1; testcase<=2; ++testcase)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<3> ();
}
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
// only twisted cells for FEValues (pinched cells are OK on Gauss points)
check<1> (2);
std::ofstream logfile ("output");
deallog << std::setprecision(4) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
std::ofstream logfile ("output");
deallog << std::setprecision(4) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3>();
}
std::ofstream logfile("output");
deallog << std::setprecision (6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
std::ofstream logfile("output");
deallog << std::setprecision (6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
unsigned int ref_level[] = {4,3,2};
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
std::ofstream logfile("output");
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1);
CHECK_ALL(Q,2);
std::ofstream logfile("output");
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1);
CHECK_ALL(Q,2);
std::ofstream logfile("output");
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1);
CHECK_ALL(Q,2);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
{
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
// generate a hyperball in 3d
deallog << std::setprecision (3);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// The general idea behind the
// layout of this function is as
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tria;
create_grid(tria);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
FE_Q<dim> fe(1);
DoFHandler<dim> dof_handler (tria);
dof_handler.distribute_dofs (fe);
- deallog.threshold_double(1.e-10);
QGauss<dim-1> q_face(3);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// this test only needs to compile, not run
if (false)
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Test<1>();
Test<2>();
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Deal2PeriodicBug Deal2Bug;
Deal2Bug.run();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
create_two_cubes (coarse_grid);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<3> ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<3; ++degree)
for (unsigned int q_order=1; q_order<=3; ++q_order)
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
Point<2> p1 (0,0),
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << " 1D solution transfer" << std::endl;
transfer<1>(logfile);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
SmartPointer<SparseLUDecomposition<double> > sparse_decomp;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
logfile << std::setprecision(16);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
compute_pi_by_area<2> ();
compute_pi_by_perimeter<2> ();
logfile << std::setprecision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
gnuplot_output<2>();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int mapping_degree=1; mapping_degree<=3; ++mapping_degree)
LaplaceProblem<2>(mapping_degree).run ();
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
DGMethod<2> dgmethod;
dgmethod.run ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
solve_problem<2> ("global");
solve_problem<2> ("kelly");
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim = 2;
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int n_realizations = 10;
for (unsigned int realization=0; realization<n_realizations; ++realization)
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem<2> laplace_problem_2d;
laplace_problem_2d.run ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
make_grid (triangulation);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem laplace_problem;
laplace_problem.run ();
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
LaplaceProblem<2> laplace_problem_2d;
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
logfile << std::setprecision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
Step51::HDG<1> hdg_problem (1);
logfile << std::setprecision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
Step51::HDG<1> hdg_problem (1);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim = 2;
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
{
logfile.precision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
deallog<<"Test <1,2>"<<std::endl;
test<1,2>(SOURCE_DIR "/grids/circle_4.inp");
{
logfile.precision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
deallog<<"Test <1,2>, Q1, Q2, Q3"<<std::endl;
test<1,2>(SOURCE_DIR "/grids/circle_4.inp",1);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
{
logfile.open("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
}
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
{
logfile.open("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
}
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{\r
std::ofstream logfile("output");\r
deallog.attach(logfile);\r
- deallog.threshold_double(1.e-10);\r
\r
deallog.push("2d");\r
test<2>(n_refinements);\r
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tria;
parallel::distributed::Triangulation<2> tria2(MPI_COMM_WORLD);
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main ()
{
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int test_case=1; test_case<=2; ++test_case)
{
logfile << std::setprecision (2);
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_this ();
return 0;
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Test for 2D, Q1:" << std::endl << std::endl;
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Generate a triangulation and match:
Triangulation<2> triangulation;
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Generate a triangulation and match:
Triangulation<2> triangulation;
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Generate a triangulation and match:
Triangulation<2> triangulation;
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Test for 2D, Q1:" << std::endl << std::endl;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
FindBug<2>().run ();
FindBug<3>().run ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim=2;
Triangulation<dim> tria;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
Step6<2> laplace_problem_2d;
laplace_problem_2d.run ();
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
check<2>();
check<3>();
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
DoFHandler<2> *dof_handler,
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
LaplaceProblem<3> laplace_problem;
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim = 2;
Framework<dim>::ProblemDescription descriptor;
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int n_realizations = 10;
for (unsigned int realization=0; realization<n_realizations; ++realization)
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<4; ++degree)
test<2>(degree);
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
DoFHandler<2> *dof_handler,
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
Point<2> p1 (0,0),
logfile << std::setprecision(PRECISION);
logfile << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=1; degree<4; ++degree)
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=1; degree<4; ++degree)
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=1; degree<4; ++degree)
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=1; degree<4; ++degree)
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<4; ++i)
{
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
MultithreadInfo::set_thread_limit(1);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision (4);
- deallog.threshold_double(1.e-7);
test<1>();
test<2>();
{
initlog();
deallog << std::setprecision (4);
- deallog.threshold_double(1.e-7);
test<1>();
test<2>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<2>();
//test<3>();
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision (4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test();
}
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// no constraints in 1d, but we had
// the matrices precomputed up to
{
initlog();
deallog << std::setprecision(7);
- deallog.threshold_double(1.e-10);
FE_Nedelec<3> fe1(0); // works
test<3>(fe1);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<=4; ++degree)
test<1>(degree);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// we had the matrices precomputed
// up to Q4 for 1d, Q3 for 2d and
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree1=1; degree1<=4; ++degree1)
for (unsigned int degree2=1; degree2<=4; ++degree2)
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree1=0; degree1<=4; ++degree1)
for (unsigned int degree2=0; degree2<=4; ++degree2)
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>(1e-6);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
// deallog.log_execution_time(true);
// deallog.log_time_differences(true);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
int main ()
{
initlog();
- deallog.threshold_double (1.e-10);
Triangulation<3> tria_ref;
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (true, false, false);
}
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (false, false, true);
}
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (false, true, false);
}
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (false, true, true);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
run (false, false, false);
}
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (true, false, true);
}
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (true, true, false);
}
main()
{
initlog();
- deallog.threshold_double (1.e-10);
run (true, true, true);
}
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// -----------------------
// Tests for dim=1
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
deallog << std::setprecision(7);\r
deallog << std::fixed;\r
deallog.attach(logfile);\r
- deallog.threshold_double (1e-8);\r
\r
const static unsigned dim = 2;\r
unsigned order = 1;\r
deallog << std::setprecision(7);\r
deallog << std::fixed;\r
deallog.attach(logfile);\r
- deallog.threshold_double (1e-8);\r
\r
const static unsigned dim = 3;\r
unsigned order = 1;\r
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(BDM, 1, 2);
CHECK_ALL(BDM, 2, 2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(DGP,0,2);
CHECK_ALL(DGP,1,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << std::setprecision(9);
CHECK_ALL(DGQ,0,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Nedelec, 0, 2);
CHECK_ALL(Nedelec, 0, 3);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,2);
CHECK_ALL(Q,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_Bubbles,1,2);
CHECK_ALL(Q_Bubbles,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_DG0,1,2);
CHECK_ALL(Q_DG0,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_Hierarchical,1,2);
CHECK_ALL(Q_Hierarchical,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_iso_Q1,1,2);
CHECK_ALL(Q_iso_Q1,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(RaviartThomas, 0, 2);
CHECK_ALL(RaviartThomas, 0, 3);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_Q<2>(1),3,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_DGQ<2>(2),2,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2(FE_Q<2>(1),3,FE_DGQ<2>(2),2,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_DGQ<2>(2),2,FE_DGQ<2>(2),2,FE_Q<2>(QIterated<1>(QTrapez<1>(),3)),3,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3((FESystem<2>(FE_Q<2>(1),3)), 3,
FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
FESystem<2>(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)),3), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2 (FE_DGQ<2>(3), 1,
FE_Nedelec<2>(0), 2,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_Nedelec<2>(0), 1,
FESystem<2>(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)),3), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2 (FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
FE_Nedelec<2>(1), 2,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_Nedelec<2>(1), 1,
FESystem<2>(FE_DGQ<2>(3),3), 1,
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
{
initlog();
deallog.depth_file (1);
- deallog.threshold_double(1.e-11);
for (unsigned int degree = 1; degree <=3; ++degree)
{
// {
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(BDM, 1, 2);
CHECK_ALL(BDM, 2, 2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(DGP,0,2);
CHECK_ALL(DGP,1,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(DGQ,0,2);
CHECK_ALL(DGQ,1,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Nedelec, 0, 2);
CHECK_ALL(Nedelec, 0, 3);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,2);
CHECK_ALL(Q,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_Bubbles,1,2);
CHECK_ALL(Q_Bubbles,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_DG0,1,2);
CHECK_ALL(Q_DG0,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_Hierarchical,1,2);
CHECK_ALL(Q_Hierarchical,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_iso_Q1,1,2);
CHECK_ALL(Q_iso_Q1,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(RaviartThomas, 0, 2);
CHECK_ALL(RaviartThomas, 0, 3);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_Q<2>(1),3,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_DGQ<2>(2),2,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2(FE_Q<2>(1),3,FE_DGQ<2>(2),2,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_DGQ<2>(2),2,FE_DGQ<2>(2),2,FE_Q<2>(QIterated<1>(QTrapez<1>(),3)),3,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3((FESystem<2>(FE_Q<2>(1),3)), 3,
FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
FESystem<2>(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)),3), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2 (FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
FE_Nedelec<2>(0), 2,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_Nedelec<2>(0), 1,
FESystem<2>(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)),3), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2 (FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
FE_Nedelec<2>(1), 2,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_Nedelec<2>(1), 1,
FESystem<2>(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)),3), 1,
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>(1e-6);
test_hyper_cube<3>(1e-6);
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>(1e-6);
test_hyper_cube<3>(1e-6);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test_1d();
}
const int dim = 1;
initlog();
- deallog.threshold_double(1.e-10);
{
std::vector<double> coeff_in(2);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << "L2_norm" << std::endl;
test2d(VectorTools::L2_norm);
const int dim = 1;
initlog();
- deallog.threshold_double(1e-8);
test_legendre_orthonormal(3);
LegendreFunction<dim> function;
std::ofstream logfile("output");
dealii::deallog.attach(logfile,/*do not print job id*/false);
dealii::deallog.depth_console(0);
- dealii::deallog.threshold_double(1e-8);
{
const unsigned int dim = 2;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test_2d();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << "L2_norm" << std::endl;
test2d(VectorTools::L2_norm);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(BDM, 1, 2);
CHECK_ALL(BDM, 2, 2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Nedelec, 0, 2);
CHECK_ALL(Nedelec, 0, 3);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,2);
CHECK_ALL(Q,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_Bubbles,1,2);
CHECK_ALL(Q_Bubbles,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_DG0,1,2);
CHECK_ALL(Q_DG0,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_Hierarchical,1,2);
CHECK_ALL(Q_Hierarchical,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q_iso_Q1,1,2);
CHECK_ALL(Q_iso_Q1,2,2);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_ALL(RaviartThomas, 0, 2);
CHECK_ALL(RaviartThomas, 0, 3);
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_Q<2>(1),3,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_DGQ<2>(2),2,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2(FE_Q<2>(1),3,FE_DGQ<2>(2),2,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_DGQ<2>(2),2,FE_DGQ<2>(2),2,FE_Q<2>(QIterated<1>(QTrapez<1>(),3)),3,2);
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3((FESystem<2>(FE_Q<2>(1),3)), 3,
FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)), 1,
FESystem<2>(FE_DGQArbitraryNodes<2>(QIterated<1>(QTrapez<1>(),3)),3), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2 (FE_DGQ<2>(3), 1,
FE_Nedelec<2>(0), 2,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_Nedelec<2>(0), 1,
FESystem<2>(FE_DGQ<2>(3),3), 1,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS2 (FE_DGQ<2>(3), 1,
FE_Nedelec<2>(1), 2,
main()
{
initlog();
- deallog.threshold_double(1.e-10);
CHECK_SYS3(FE_Nedelec<2>(1), 1,
FESystem<2>(FE_DGQ<2>(3),3), 1,
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_ball<2>(1e-6);
test_hyper_ball<3>(1e-6);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
MySimulator<1>(1);
MySimulator<2>(1);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_projection<1>(logfile);
test_projection<2>(logfile);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tria;
MappingQGeneric<2> mapping(1);
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-8);
{
std::vector<FEValuesExtractors::Scalar> x;
std::ofstream logfile ("output");
deallog << std::setprecision(8) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-5);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-5);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-5);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
{
for (unsigned int e=0; e<dim; ++e)
for (unsigned int f=0; f<dim; ++f)
- deallog << selected_vector_values[q][d][e][f] << (e<dim-1 && f<dim-1 ? " " : "");
+ deallog << selected_vector_values[q][d][e][f] << " ";
deallog << std::endl;
Assert ((selected_vector_values[q][d] - vector_values[q][c+d]).norm()
<= 1e-12 * selected_vector_values[q][d].norm(),
int main()
{
- std::ofstream logfile ("output");
- deallog << std::setprecision (3);
-
- deallog.attach(logfile);
- deallog.threshold_double(1.e-5);
+ initlog();
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
MixedElastoPlasticity < 3 > elasto_plasticity(1);
elasto_plasticity.run();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
MixedElastoPlasticity < 3 > elasto_plasticity(1);
elasto_plasticity.run();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
MixedElastoPlasticity < 3 > elasto_plasticity(1);
elasto_plasticity.run();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<1>();
test_hyper_cube<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<1>();
test_hyper_cube<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>();
}
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test_hyper_cube<2>();
}
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-5);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<1>();
test<2>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<1>();
test<2>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<1>();
test<2>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
test<1>();
test<2>();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-7);
check ();
}
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test_vectors<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test(FE_Q<1>(2));
test(FE_Q<2>(2));
{
initlog();
- deallog.threshold_double(1.e-10);
Test gen;
// For some of the finite element types, their
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(2.e-15);
Q1WedgeFunction<1,1> w1;
check(w1,1);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(2.e-15);
Q1WedgeFunction<1,1> w1;
check_q_bubbles(w1,1);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(2.e-15);
Q1WedgeFunction<1,1> w1;
check_q_dg0(w1,1);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(2.e-15);
Q1WedgeFunction<1,1> w1;
check(w1,1);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-15);
// Q1WedgeFunction<1,1,2> w1;
// check1(w1,1,2);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-13);
// Q1WedgeFunction<1,1,2> w1;
// check1(w1,1,2);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-15);
Q1WedgeFunction<1,1,2> w1;
check1(w1,1,2);
std::ofstream logfile ("output");
deallog << std::setprecision(8) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision(8) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision(8) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision(8) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_shape_functions<2> (0);
plot_shape_functions<2> (1);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Degree 0:" << std::endl;
check<2> (0);
check<3> (0);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Degree 0: " << std::endl;
check<2> (0);
check<3> (0);
const std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// generate a version of the
// Nedelec element but force it to
logfile.precision (7);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << "Degree 0: " << std::endl;
test<2> (0);
test<3> (0);
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::fixed;
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check<2>();
}
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// no constraints in 1d, but we had the matrices precomputed up to Q4 for 2d
// and Q2 for 3d
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// we had the matrices precomputed up to Q4 for 1d, Q3 for 2d and Q2 for 3d
for (unsigned int degree=1; degree<=4; ++degree)
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// we had the matrices precomputed up to Q4 for 1d, 2d and 3d
for (unsigned int degree=1; degree<=4; ++degree)
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree1=1; degree1<=4; ++degree1)
for (unsigned int degree2=1; degree2<=4; ++degree2)
{
initlog();
deallog.depth_file (1);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<=3; ++i)
{
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<4; ++degree)
plot_shape_functions<2>(degree);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<4; ++degree)
plot_shape_functions<2>(degree);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<4; ++degree)
test<2>(degree);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int degree=0; degree<3; ++degree)
{
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_shape_functions<2>(2);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=0; i<4; ++i)
test<2>(i);
logfile << std::setprecision(PRECISION);
logfile << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
DoFHandler<2> *dof_handler,
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-8);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tria_test;
DoFHandler<2> *dof_handler;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>(0);
test<2>(1);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FE_RaviartThomasNodal<2> e20(0);
check_support_points(e20);
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_shape_functions<2>(2);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_Bernstein_shape_functions<1>();
plot_FE_Bernstein_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_DGP_shape_functions<1>();
plot_FE_DGP_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_DGPMonomial_shape_functions<1>();
plot_FE_DGPMonomial_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_DGPNonparametric_shape_functions<1>();
plot_FE_DGPNonparametric_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_DGQ_shape_functions<1>();
plot_FE_DGQ_shape_functions<2>();
std::ofstream logfile(logname.c_str());
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_FaceQ_shape_functions<1>();
plot_FE_FaceQ_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "FE_Nedelec<2>" << std::endl;
plot_FE_Nedelec_shape_functions<2>();
deallog << "FE_Nedelec<3>" << std::endl;
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_Q_shape_functions<1>();
plot_FE_Q_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_Q_Bubbles_shape_functions<1>();
plot_FE_Q_Bubbles_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_Q_DG0_shape_functions<1>();
plot_FE_Q_DG0_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_Q_Hierarchical_shape_functions<1>();
plot_FE_Q_Hierarchical_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_Q_shape_functions<1>();
plot_FE_Q_shape_functions<2>();
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "FE_System<1>" << std::endl;
plot_FE_System_shape_functions<1>();
deallog << "FE_System<2>" << std::endl;
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "FE_System<1>" << std::endl;
plot_FE_System_shape_functions<1>();
deallog << "FE_System<2>" << std::endl;
std::ofstream logfile(logname.c_str());
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
plot_FE_TraceQ_shape_functions<2>();
plot_FE_TraceQ_shape_functions<3>();
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
CHECK_SYS1(FE_Q<1>(1), 3,
FE_Q<1>(2), 3,
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
FESystem<2> fe(FE_Q<2>(1), 2, FE_Q<2>(1), 1);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<2>();
check<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
{
initlog();
deallog << std::setprecision(7);
- deallog.threshold_double(1.e-10);
Triangulation<2> tr2(Triangulation<2>::limit_level_difference_at_vertices);
deallog << std::setprecision(PRECISION);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Testing::srand(3391466);
FullMatrix<double> T(3,3,entries);
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Testing::srand(3391466);
FullMatrix<double> A(3,3,entries_A);
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Testing::srand(3391466);
FullMatrix<double> A(3,3,entries_A);
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FullMatrix<double> A(3,3,entries_A);
FullMatrix<double> C(3,3);
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FullMatrix<double> A(3,3,entries_A);
FullMatrix<double> C(3,3);
int main()
{
initlog();
- deallog.threshold_double(1e-5);
test<double>();
test<float>();
int main()
{
initlog();
- deallog.threshold_double(1e-5);
test<double>();
test<float>();
int main()
{
initlog();
- deallog.threshold_double(1e-5);
test<double>();
test<float>();
deallog << std::fixed;
deallog << std::setprecision(4);
// deallog.attach(logfile);
-// deallog.threshold_double(1.e-10);
Testing::srand(3391466);
FullMatrix<double> T2(2,2,entries2), S2(2,2), R2(2,2);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
const unsigned int N = 4;
FullMatrix<double> f(N,N);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main()
{
initlog();
- deallog.threshold_double(1.0e-10);
size_t m = 2, n = 3;
FullMatrix<double> A(m, n);
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
logfile << numbers::PI << std::endl;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
{
deallog.push("PETSc");
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
{
deallog.push("PETSc");
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
{
deallog.push("PETSc");
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> (true);
test1<1> (false);
std::ofstream logfile ("output");
deallog << std::setprecision (PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision (PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(logfile);
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(logfile);
}
{
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test (SOURCE_DIR "/grid_in_3d/1.in");
test (SOURCE_DIR "/grid_in_3d/2.in");
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
using namespace dealii;
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3>(logfile);
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3>(logfile);
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>(logfile);
test<3>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("1-2");
test<1,2>(logfile);
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
check_grid ();
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1,2>(logfile);
test<2,3>(logfile);
{
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<2> (4., 5., 10);
check<3> (3., 5., 6);
{
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3> (.5, 1, 6);
}
{
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3> (.5, 1, 12);
}
{
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3> (.5, 1, 96);
}
{
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3> (6);
check<3> (12);
{
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<3> (.5, 1, 6);
check<3> (.5, 1, 12);
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<2> ();
test2<2> ();
{
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test (SOURCE_DIR "/grid_in_3d/1.in");
test (SOURCE_DIR "/grid_in_3d/2.in");
{
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test (SOURCE_DIR "/grid_in_3d_02/747.ucd");
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_file ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_file ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (5);
logfile << std::setprecision (5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (5);
logfile << std::setprecision (5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
filename_resolution();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>(logfile);
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int i=1; i<=3; ++i)
test<2> (i);
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> ();
test1<2> ();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> ();
test1<2> ();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> ();
test1<2> ();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> ();
test1<2> ();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
deallog << "Test for 2D: Hypercube" << std::endl << std::endl;
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
deallog << "Test for 2D: Hypercube" << std::endl << std::endl;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> ();
test1<2> ();
std::ofstream logfile ("output");
deallog << std::setprecision (PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision (PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile ("output");
deallog << std::setprecision (5);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// run the tests but continue when finding an exception: we will try
// out a distorted cell for which TriaAccessor::measure() will error
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int t=0; t<3; ++t)
{
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
make_grid();
}
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
create_L_shape (coarse_grid);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
GridIn<3> in;
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_with_wrong_face_orientation ();
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_with_wrong_face_orientation ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
create_two_cubes (coarse_grid);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.0e-10);
Triangulation<3> triangulation;
GridIn<3> grid_in;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.0e-10);
Triangulation<3> triangulation;
GridIn<3> grid_in;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.0e-10);
Triangulation<3> triangulation;
GridIn<3> grid_in;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.0e-10);
Triangulation<3> triangulation;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.0e-10);
Triangulation<3> triangulation;
GridGenerator::hyper_ball(triangulation);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
create_two_cubes (coarse_grid);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<3> coarse_grid;
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
test();
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
test();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<1> ();
test1<2> ();
{
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> (SOURCE_DIR "/grid_in/2d.xda");
{
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1>();
check<2>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test<1>();
test<2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
initlog();
- deallog.threshold_double(1.e-10);
{
const int dim = 1;
deallog << std::setprecision(2);
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
check<2>();
check<3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3> ();
logfile << std::setprecision (2);
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
logfile << std::setprecision (2);
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
hp::FECollection<3> fe;
for (unsigned int i=0; i<4; ++i)
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
std::vector<Point<2> > points_glob;
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// create a mesh like this:
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// create a mesh like this (viewed
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// this test depends on the right
// starting value of the random
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// create a mesh like this (viewed
logfile.precision (7);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<3> ();
}
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
LaplaceProblem<3> laplace_problem_2d;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
LaplaceProblem<3> laplace_problem_2d;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
- std::ofstream logfile ("output");
- deallog << std::setprecision (2);
- deallog << std::fixed;
- deallog.attach(logfile);
- deallog.test_mode(true, 0., 0.);
+ initlog();
deallog.push ("1d");
check<1> ();
int main ()
{
- std::ofstream logfile ("output");
- deallog << std::setprecision (2);
- deallog << std::fixed;
- deallog.attach(logfile);
- deallog.test_mode(true, 0., 0.);
+ initlog();
deallog.push ("1d");
check<1> ();
int main ()
{
- std::ofstream logfile ("output");
- deallog << std::setprecision (2);
- deallog << std::fixed;
- deallog.attach(logfile);
- deallog.test_mode(true, 0., 0.);
+ initlog();
deallog.push ("1d");
check<1> ();
int main ()
{
- std::ofstream logfile ("output");
- deallog << std::setprecision (2);
- deallog << std::fixed;
- deallog.attach(logfile);
- deallog.test_mode(true, 0., 0.);
+ initlog();
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<dim> triangulation;
std::vector<unsigned int> subdivisions(dim, 1U);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<dim> triangulation;
std::vector<unsigned int> subdivisions(dim, 1U);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
MixedFECollection<2> mixed_FECollection_problem;
mixed_FECollection_problem.run ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Try dim == 1" << std::flush << std::endl;
test<1> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Try dim == 1" << std::flush << std::endl;
test<1> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Try dim == 1" << std::flush << std::endl;
test<1> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "Try dim == 1" << std::flush << std::endl;
test<1> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << " 1D solution transfer" << std::endl;
transfer<1>(logfile);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
ElasticProblem <2> elastic_problem;
elastic_problem.run();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deal_II_exceptions::disable_abort_on_exception();
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
logfile.precision (1);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(4);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
deallog << std::setprecision(4);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim=2;
Triangulation<dim> tria;
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FE_Q<2> fe_1 (1);
FE_Q<2> fe_2 (2);
logfile.precision(8);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
unsigned int index[] =
{
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(2.e-15);
test<2>(true,0);
test<2>(true,1);
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2> ();
test<3> ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
diffusionMechanics<DIMS> problem(1,1);
problem.run ();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("1d");
test<1>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1);
CHECK_ALL(Q,2);
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Step27::MixedFECollection<1>().run();
Step27::MixedFECollection<2>().run();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deal_II_exceptions::disable_abort_on_exception();
logfile.precision (PRECISION);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
logfile.precision (1);
logfile.setf(std::ios::fixed);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << " 1D solution transfer" << std::endl;
transfer<1>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << " 1D solution transfer" << std::endl;
transfer<1>(logfile);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
GridGenerator::hyper_cube (triangulation);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation(Triangulation<2>::none);
GridGenerator::hyper_cube (triangulation);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << " 1D solution transfer" << std::endl;
transfer<1>(logfile);
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << " 1D solution transfer" << std::endl;
transfer<1>(logfile);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation(Triangulation<2>::none);
GridGenerator::hyper_cube (triangulation);
logfile.precision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
gnuplot_output<2>();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int mapping_degree=1; mapping_degree<=3; ++mapping_degree)
LaplaceProblem<2>(mapping_degree).run ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
DGMethod<2> dgmethod;
dgmethod.run ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
solve_problem<2> ("global");
solve_problem<2> ("kelly");
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> triangulation;
make_grid (triangulation);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem laplace_problem;
laplace_problem.run ();
logfile.precision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem laplace_problem;
laplace_problem.run ();
logfile.precision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem laplace_problem;
laplace_problem.run ();
logfile.precision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem laplace_problem;
laplace_problem.run ();
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
LaplaceProblem<2> laplace_problem_2d;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int dim = 2;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
cell_matrix(M,fev,fev,vel);
{
LogStream::Prefix pre("cell");
- M.print(deallog,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
cell_residual(w, fev, uval[0],vel);
M.vmult(v,u);
w.add(-1., v);
- deallog << " e" << w.l2_norm();
+ deallog << " e " << w.l2_norm();
}
}
deallog << std::endl;
upwind_value_matrix(M, fev, fev, vel);
{
LogStream::Prefix pre("bdry");
- M.print(deallog,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
upwind_value_residual(w, fev, uval[0], null_val[0], vel);
M.vmult(v,u);
w.add(-1., v);
- deallog << " e" << w.l2_norm();
+ deallog << " e " << w.l2_norm();
}
}
deallog << std::endl;
{
LogStream::Prefix pre("M11");
- M11.print(deallog,8);
+ M11.print(deallog,14,8);
}
{
LogStream::Prefix pre("M12");
- M12.print(deallog,8);
+ M12.print(deallog,14,8);
}
{
LogStream::Prefix pre("M21");
- M21.print(deallog,8);
+ M21.print(deallog,14,8);
}
{
LogStream::Prefix pre("M22");
- M22.print(deallog,8);
+ M22.print(deallog,14,8);
}
Vector<double> u1(n1), v1(n1), w1(n1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tr2;
TestGrids::hypercube(tr2, 1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
FE_Q<2> fe(1);
deallog.push(fe.get_name());
deallog.log_execution_time(false);
if (!debugging)
{
- deallog.threshold_double(1.e-10);
}
run2d(0);
FullMatrix<double> Md(ns,nv);
cell_matrix(Md,fev,fes);
- Md.print(deallog,8);
+ Md.print(deallog,16,8);
deallog << "gradient_matrix" << std::endl;
FullMatrix<double> Mg(nv,ns);
gradient_matrix(Mg,fes,fev);
- Mg.print(deallog,8);
+ Mg.print(deallog,16,8);
Vector<double> u(nv), v(ns), w(ns);
FullMatrix<double> M(ns,nv);
u_dot_n_matrix(M, fev, fes);
- M.print(deallog,8);
+ M.print(deallog,16,8);
Vector<double> u(nv), v(ns), w(ns);
std::vector<std::vector<double> >
u_dot_n_matrix(M11, M12, M21, M22, fev1, fev2, fes1, fes2);
deallog << "M11" << std::endl;
- M11.print(deallog,8);
+ M11.print(deallog,16,8);
deallog << "M22" << std::endl;
- M22.print(deallog,8);
+ M22.print(deallog,16,8);
deallog << "M12" << std::endl;
- M12.print(deallog,8);
+ M12.print(deallog,16,8);
deallog << "M21" << std::endl;
- M21.print(deallog,8);
-
- // Vector<double> u1(n1), v1(n1), w1(n1);
- // Vector<double> u2(n2), v2(n2), w2(n2);
- // std::vector<std::vector<double> >
- // u1val (d,std::vector<double>(fev1.n_quadrature_points)),
- // u2val (d,std::vector<double>(fev2.n_quadrature_points));
- // std::vector<std::vector<Tensor<1,dim> > >
- // u1grad(d,std::vector<Tensor<1,dim> >(fev1.n_quadrature_points)),
- // u2grad(d,std::vector<Tensor<1,dim> >(fev2.n_quadrature_points));
-
- // std::vector<unsigned int> indices1(n1), indices2(n2);
- // for (unsigned int i=0;i<n1;++i) indices1[i] = i;
- // for (unsigned int i=0;i<n2;++i) indices2[i] = i;
-
- // deallog << "Residuals"; for (unsigned int i=0;i<n1;++i) indices1[i] = i;
-
- // for (unsigned int i1=0;i1<n1;++i1)
- // for (unsigned int i2=0;i2<n2;++i2)
- // {
- // u1 = 0.;
- // u1(i1) = 1.;
- // w1 = 0.;
- // fev1.get_function_values(u1, indices1, u1val, true);
- // fev1.get_function_gradients(u1, indices1, u1grad, true);
- // u2 = 0.;
- // u2(i2) = 1.;
- // w2 = 0.;
- // fev2.get_function_values(u2, indices2, u2val, true);
- // fev2.get_function_gradients(u2, indices2, u2grad, true);
- // ip_residual(w1, w2, fev1, fev2,
- // make_slice(u1val), make_slice(u1grad),
- // make_slice(u2val), make_slice(u2grad),
- // 17);
- // M11.vmult(v1,u1); w1.add(-1., v1);
- // M12.vmult(v1,u2); w1.add(-1., v1);
- // M21.vmult(v2,u1); w2.add(-1., v2);
- // M22.vmult(v2,u2); w2.add(-1., v2);
- // deallog << ' ' << w1.l2_norm() + w2.l2_norm();
- // if (d==1)
- // {
- // ip_residual(w1, w2, fev1, fev2, u1val[0], u1grad[0], u2val[0], u2grad[0], 17);
- // M11.vmult(v1,u1); w1.add(-1., v1);
- // M12.vmult(v1,u2); w1.add(-1., v1);
- // M21.vmult(v2,u1); w2.add(-1., v2);
- // M22.vmult(v2,u2); w2.add(-1., v2);
- // deallog << " e" << w1.l2_norm() + w2.l2_norm();
- // }
- // }
- // deallog << std::endl;
+ M21.print(deallog,16,8);
}
const std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Triangulation<2> tr2;
TestGrids::hypercube(tr2, 1);
test(tr2);
-
-// Triangulation<3> tr3;
-// TestGrids::hypercube(tr3, 1);
-// test(tr3);
-
}
cell_matrix(M,fev);
{
LogStream::Prefix pre("cell");
- M.print(deallog,12,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
nitsche_matrix(M, fev, 17);
{
LogStream::Prefix pre("bdry");
- M.print(deallog,12,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
{
LogStream::Prefix pre("M11");
- M11.print(deallog,12,8);
+ M11.print(deallog,14,8);
}
{
LogStream::Prefix pre("M12");
- M12.print(deallog,12,8);
+ M12.print(deallog,14,8);
}
{
LogStream::Prefix pre("M21");
- M21.print(deallog,12,8);
+ M21.print(deallog,14,8);
}
{
LogStream::Prefix pre("M22");
- M22.print(deallog,12,8);
+ M22.print(deallog,14,8);
}
Vector<double> u1(n1), v1(n1), w1(n1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.precision(8);
Triangulation<2> tr2;
nitsche_tangential_matrix(M, fev, 17);
{
LogStream::Prefix pre("bdry");
- M.print(deallog,12,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.precision(8);
Triangulation<2> tr2;
cell_matrix(M,fev);
{
LogStream::Prefix pre("cell");
- M.print(deallog,12,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
nitsche_matrix(M, fev, 17);
{
LogStream::Prefix pre("bdry");
- M.print(deallog,12,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
{
LogStream::Prefix pre("M11");
- M11.print(deallog,12,8);
+ M11.print(deallog,14,8);
}
{
LogStream::Prefix pre("M12");
- M12.print(deallog,12,8);
+ M12.print(deallog,14,8);
}
{
LogStream::Prefix pre("M21");
- M21.print(deallog,12,8);
+ M21.print(deallog,14,8);
}
{
LogStream::Prefix pre("M22");
- M22.print(deallog,12,8);
+ M22.print(deallog,14,8);
}
Vector<double> u1(n1), v1(n1), w1(n1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.precision(8);
Triangulation<2> tr2;
cell_matrix(M,fev);
{
LogStream::Prefix pre("cell");
- M.print(deallog,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
cell_residual(w, fev, ugrad[0]);
M.vmult(v,u);
w.add(-1., v);
- deallog << " e" << w.l2_norm();
+ deallog << " e " << w.l2_norm();
}
}
deallog << std::endl;
nitsche_matrix(M, fev, 17);
{
LogStream::Prefix pre("bdry");
- M.print(deallog,8);
+ M.print(deallog,14,8);
}
Vector<double> u(n), v(n), w(n);
nitsche_residual(w, fev, uval[0], ugrad[0], null_val[0], 17);
M.vmult(v,u);
w.add(-1., v);
- deallog << " e" << w.l2_norm();
+ deallog << " e " << w.l2_norm();
}
}
deallog << std::endl;
{
LogStream::Prefix pre("M11");
- M11.print(deallog,8);
+ M11.print(deallog,14,8);
}
{
LogStream::Prefix pre("M12");
- M12.print(deallog,8);
+ M12.print(deallog,14,8);
}
{
LogStream::Prefix pre("M21");
- M21.print(deallog,8);
+ M21.print(deallog,14,8);
}
{
LogStream::Prefix pre("M22");
- M22.print(deallog,8);
+ M22.print(deallog,14,8);
}
Vector<double> u1(n1), v1(n1), w1(n1);
w1.add(-1., v1);
M21.vmult(v2,u1);
w2.add(-1., v2);
- deallog << " e" << w1.l2_norm() + w2.l2_norm();
+ deallog << " e " << w1.l2_norm() + w2.l2_norm();
}
w1 = 0.;
w1.add(-1., v1);
M22.vmult(v2,u1);
w2.add(-1., v2);
- deallog << " e" << w1.l2_norm() + w2.l2_norm();
+ deallog << " e " << w1.l2_norm() + w2.l2_norm();
}
}
deallog << std::endl;
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<2> tr2;
TestGrids::hypercube(tr2, 1);
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
SolverControl control(100, 1.e-3);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity_pattern(4,4);
sparsity_pattern.compress();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
BlockSparsityPattern bsp(3,2);
// set sizes
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
BlockSparsityPattern bsp(2,2);
// set sizes
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
BlockSparsityPattern bsp(2,2);
// set sizes
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// vector of solution vectors
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// do the same weird stuff as in
// tests/base/reference.cc
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// do the same weird stuff as in
// tests/base/reference.cc
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// do the same weird stuff as in
// tests/base/reference.cc
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallogfile << std::setprecision(8);
- deallog.threshold_double(1.e-10);
test<3> ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FiniteElement<3> *fe = nullptr;
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// setting up some constants
const unsigned int dim = 2;
int main ()
{
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << std::setprecision (2);
{
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-14);
test<2>();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-14);
test<2>(1);
test<2>(2);
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
merge_check ();
}
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.0e-10);
ConstraintMatrix constraints;
unsigned int IDs[] = {1, 2, 3, 5, 8, 13, 21};
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
SolverControl control(1000, 1.e-5);
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 };
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile("output");
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-8);
deallog.push("double");
test<double>(0);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double>(0);
test<double>(4);
test<double>(5);
deallog.pop();
- deallog.threshold_double(1.e-4);
deallog.push("float");
test<float>(0);
test<float>(1);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double>();
deallog.pop();
- deallog.threshold_double(2.e-4);
deallog.push("float");
test<float>();
deallog.pop();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double>(0);
test<double>(4);
test<double>(5);
deallog.pop();
- deallog.threshold_double(1.e-4);
deallog.push("float");
test<float>(0);
test<float>(1);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double>();
deallog.pop();
- deallog.threshold_double(2.e-4);
deallog.push("float");
test<float>();
deallog.pop();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push("double");
test<double>();
deallog.pop();
- deallog.threshold_double(1.e-4);
deallog.push("float");
test<float>();
deallog.pop();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_vmult<double>();
check_vmult<float>();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_vmult<double>();
check_vmult<float>();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_vmult<double>();
check_vmult<float>();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_vmult<double>();
check_vmult<float>();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_vmult<double>();
check_vmult<float>();
logfile.setf(std::ios::fixed);
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_vmult<double>();
check_vmult<float>();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
deallog.push("2d");
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Use the constraints for the right-hand-side
{
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Use the constraints for the right-hand-side
{
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Use the constraints for the right-hand-side
{
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
AdvectionProblem<2> advection_problem;
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
{
AdvectionProblem<2> advection_problem;
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem<2> laplace_problem_2d;
laplace_problem_2d.run ();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
}
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << IsBlockMatrix<SparseMatrix<double> >::value << ' '
<< IsBlockMatrix<SparseMatrix<float> >::value << ' '
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << IsBlockVector<Vector<double> >::value << ' '
<< IsBlockVector<Vector<float> >::value << ' '
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
}
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_norms<float>();
check_norms<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float>();
check<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_large_numbers();
}
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_norms<float>();
check_norms<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LinearAlgebra::Vector<double> d1(N), d2(N);
LinearAlgebra::Vector<float> f1(N), f2(N);
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// test for a rectangular sparse
// matrix
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
checkConstructor1<double>();
}
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
char *name = "Matrix A";
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double Adata[] =
{ 2, 3, 4, 5 };
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int size=4; size <= 16; size *= 2)
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
deallog << std::fixed;
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SparseMatrixEZ<double> ez(5,4);
ez.set(0,0,2.);
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
{
StokesProblem<2> flow_problem(1);
flow_problem.run ();
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
SolverControl control(100, 1.e-3);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<SolverGMRES<Vector<double> > >();
test<SolverCG<Vector<double> > >();
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
const unsigned int size = 32;
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
const unsigned int size = 32;
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
ConsecutiveControl solver_control(12345, 1.e-3, 3, false, false);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_value( 10, -2, 1e-15);
check_value(-0.1, 0.1, 1e-15);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_value( 2, 1e-14);
check_value(10, 1e-14);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int size=4; size <= 30; size *= 3)
{
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SolverControl control(10, 1.e-3);
SolverRichardson<> rich(control);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SolverControl control(10, 1.e-3);
SolverRichardson<> rich(control);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SolverControl control(10, 1.e-3);
SolverRichardson<> rich(control);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SolverControl control(10, 1.e-3);
SolverRelaxation<> relax(control);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog << "OK" << std::endl;
}
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
unsigned int size=37;
unsigned int dim = (size-1)*(size-1);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
unsigned int size=37;
unsigned int dim = (size-1)*(size-1);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
SolverControl solver_control(100, 1.e-3);
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int size=4; size <= 16; size *= 2)
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int N=1; N<5; ++N)
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int size=4; size <= 16; size *= 2)
// Switch between regression test
// and benchmark
//#ifdef DEBUG
- deallog.threshold_double(1.e-10);
const unsigned int size = 5;
const unsigned int row_length = 3;
/*#else
deallog << std::fixed;
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
for (unsigned int size=4; size <= 16; size *= 2)
int main()
{
initlog();
- deallog.threshold_double(1e-11);
do_test<1>(1);
do_test<1>(2);
int main()
{
initlog();
- deallog.threshold_double(1e-11);
do_test<1,1>();
do_test<1,2>();
int main()
{
initlog();
- deallog.threshold_double(5e-3);
do_test<1,1>();
do_test<1,2>();
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int N=20;
FullMatrix<double> m (N,N);
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<double>(5);
check<float>(4);
deallog << std::fixed;
deallog << std::setprecision(0);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<double>(5);
check<float>(4);
{
initlog();
deallog << std::setprecision(6);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
std::ofstream logfile("output");
deallog.attach(logfile,/*do not print job id*/false);
- deallog.threshold_double(eps);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog << "No scaling:" << std::endl;
// no scaling:
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Vector<double> d1(N), d2(N);
Vector<float> f1(N), f2(N);
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_norms<float>();
check_norms<double>();
std::ofstream logfile("output");
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1e-50); // exact equality required!
check_norms<float>();
check_norms<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float>();
check<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_large_numbers();
}
main()
{
initlog();
- deallog.threshold_double(1.e-10);
deal_II_exceptions::disable_abort_on_exception();
test_stat<Vector<double> >();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_norms<float>();
check_norms<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float>();
check<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<float>();
check<double>();
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Vector<double> v1(N);
fill(v1);
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Vector<double> V1(5);
V1(0) = 1;
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
checkReinit1<double, int>(10, false);
checkReinit1<double, int>(10, true);
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Vector<double> V1(5);
V1(0) = 1;
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Vector<double> V1(5);
V1(0) = 1;
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Vector<double> V1(5);
V1(0) = 1;
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// Test square matrix initialisation
test (4, true);
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_rect(3,4,rect);
test_rect(4,3,rect);
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(4, false);
test(4, true);
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(false);
test(true);
// logfile.setf(std::ios::fixed);
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
GrowingVectorMemory<> mem;
SolverControl control(100, 1.e-3);
const std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_laplacian<double>(10);
test_laplacian<double>(20);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<2,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>(2, MappingQ<2>(4, false));
test<2,2>(2, MappingQ<2>(4, true));
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>(2, MappingQ<2>(4, false));
test<2,2>(2, MappingQ<2>(4, true));
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<2,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>(2, MappingQ<2>(4, false));
test<2,2>(2, MappingQ<2>(4, true));
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,2>();
test<2,3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2,2>();
test<2,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<2,2>();
test<3,3>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
const Point<2> center (0,0);
const SphericalManifold<2> boundary_description (center);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
const CylindricalManifold<3> boundary_description;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
const Point<2> center (0,0);
const SphericalManifold<2> boundary_description (center);
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// -----------------------
// Tests for dim=1
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// -----------------------
// Tests for dim=1
std::ofstream logfile ("output");
deallog << std::setprecision(PRECISION);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// -----------------------
// Tests for dim=1
deallog << std::fixed;
deallog << std::setprecision(PRECISION) << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// create grid of circle, somehow
// arbitrarily from only one cell,
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
{
Triangulation<2> coarse_grid;
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
test_real_to_unit_cell<2,2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1,1>();
test<1,2>();
logfile << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
LaplaceProblem laplace_problem;
laplace_problem.run ();
deallog << std::setprecision(2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.attach(logfile);
deallog << std::setprecision (4);
logfile << std::setprecision (4);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
Triangulation<3> coarse_grid;
GridGenerator::hyper_cube (coarse_grid, -1, 1);
deallog << std::setprecision(2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// convergence studies
deallog.attach(logfile);
deallog << std::setprecision (4);
logfile << std::setprecision (4);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog.attach(logfile);
deallog << std::setprecision (4);
logfile << std::setprecision (4);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog.attach(logfile);
deallog << std::setprecision (4);
logfile << std::setprecision (4);
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
deallog << std::setprecision (5);
deallog.attach (std::cout);
deallog.depth_console (0);
- deallog.threshold_double (1e-12);
const static unsigned dim = 3;
deallog << std::setprecision (5);
deallog.attach (std::cout);
deallog.depth_console (0);
- deallog.threshold_double (1e-12);
test<2>();
test<3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-14);
test<2>();
test<3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-14);
test<2>();
test<3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test2<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<2,3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_real_to_unit_cell<1,1>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2>();
deallog.pop();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2>();
deallog.pop();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2>();
test_cube<2>();
{
deallog << "Test doubles" << std::endl;
sub_test<dim,fe_degree,double>();
- deallog.threshold_double(1.e-6);
deallog << "Test floats" << std::endl;
sub_test<dim,fe_degree,float>();
}
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
{
// iterations taken from results at tolerance 1e-9
- deallog.threshold_double(1.e-8);
deallog.push("2d");
test<2,1>(FE_Q<2>(1), 15);
test<2,1>(FE_DGQ<2>(1), 3);
int main ()
{
initlog();
- deallog.threshold_double(1e-14);
deallog.push("values");
test<4,4,0,false>();
int main ()
{
initlog();
- deallog.threshold_double(1e-14);
deallog.push("values");
test<4,4,0,false>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
FEEvaluationAccess<1,1,double> *test; // didn't compile before
deallog << "OK" << std::endl;
{
if (types_are_equal<Number,double>::value == true)
{
- deallog.threshold_double (4e-14);
deallog << "Error function values FE " << i << ": "
<< errors[i*3+0]/total[i*3+0] << std::endl;
deallog << "Error function gradients FE " << i << ": "
// some elements, it might also be zero
// (linear elements on quadrilaterals), so
// need to check for division by 0, too.
- deallog.threshold_double (5e-7);
const double output2 = total[i*3+2] == 0 ? 0. : errors[i*3+2] / total[i*3+2];
deallog << "Error function Laplacians FE " << i << ": " << output2 << std::endl;
}
else if (types_are_equal<Number,float>::value == true)
{
- deallog.threshold_double (1e-6);
deallog << "Error function values FE " << i << ": "
<< errors[i*3+0]/total[i*3+0] << std::endl;
deallog << "Error function gradients FE " << i << ": "
<< errors[i*3+1]/total[i*3+1] << std::endl;
const double output2 = total[i*3+2] == 0 ? 0. : errors[i*3+2] / total[i*3+2];
- deallog.threshold_double (1e-6);
deallog << "Error function Laplacians FE " << i << ": " << output2 << std::endl;
}
}
// need to set quite a loose tolerance because
// FEValues approximates Hessians with finite
// differences, which are not so accurate
- deallog.threshold_double(2.e-5);
deallog << std::setprecision (3);
{
{
if (types_are_equal<Number,double>::value == true)
{
- deallog.threshold_double (4e-14);
deallog << "Error function values FE " << i << ": "
<< errors[i*3+0]/total[i*3+0] << std::endl;
deallog << "Error function gradients FE " << i << ": "
// some elements, it might also be zero
// (linear elements on quadrilaterals), so
// need to check for division by 0, too.
- deallog.threshold_double (2e-6);
const double output2 = total[i*3+2] == 0 ? 0. : errors[i*3+2] / total[i*3+2];
deallog << "Error function Laplacians FE " << i << ": " << output2 << std::endl;
}
else if (types_are_equal<Number,float>::value == true)
{
- deallog.threshold_double (1e-6);
deallog << "Error function values FE " << i << ": "
<< errors[i*3+0]/total[i*3+0] << std::endl;
deallog << "Error function gradients FE " << i << ": "
<< errors[i*3+1]/total[i*3+1] << std::endl;
const double output2 = total[i*3+2] == 0 ? 0. : errors[i*3+2] / total[i*3+2];
- deallog.threshold_double (1e-6);
deallog << "Error function Laplacians FE " << i << ": " << output2 << std::endl;
}
}
// need to set quite a loose tolerance because
// FEValues approximates Hessians with finite
// differences, which are not so accurate
- deallog.threshold_double(2.e-5);
deallog << std::setprecision (3);
{
{
deallog.attach(logfile);
- deallog.threshold_double(1.e-14);
deallog << std::setprecision (3);
{
{
deallog.attach(logfile);
- deallog.threshold_double(1.e-14);
deallog << std::setprecision (3);
{
data.cell_loop (&MatrixFreeTest<dim,fe_degree,n_q_points_1d,Number>::operator(),
this, dst_dummy, src);
- deallog.threshold_double(1e-10);
deallog << "Error read_dof_values vs read_dof_values_plain: "
<< error/total << std::endl << std::endl;
};
deallog << std::setprecision (3);
{
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1,double>();
test<2,2,double>();
{
deallog << std::endl << "Test with floats" << std::endl << std::endl;
- deallog.threshold_double(1.e-7);
deallog.push("2d");
test<2,1,float>();
deallog.pop();
deallog << std::setprecision (3);
{
- deallog.threshold_double(1.e-11);
deallog.push("2d");
test<2,1,double>();
test<2,2,double>();
{
deallog << std::endl << "Test with floats" << std::endl << std::endl;
- deallog.threshold_double(1.e-7);
deallog.push("2d");
test<2,1,float>();
deallog.pop();
if (dim == 2)
{
deallog.push("float");
- deallog.threshold_double(2.e-6);
do_test<dim, fe_degree, float> (dof);
- deallog.threshold_double(1.e-10);
deallog.pop();
}
}
deallog << std::setprecision (3);
{
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog.attach(logfile);
deallog << std::setprecision (3);
- deallog.threshold_double(1.e-12);
test<2>();
test<3>();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
if (dim == 2)
{
deallog.push("float");
- deallog.threshold_double(1.e-6);
do_test<dim, fe_degree, float> (dof, constraints);
- deallog.threshold_double(5.e-11);
deallog.pop();
}
}
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(5.e-11);
deallog.push("2d");
test<2,1>();
test<2,2>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(1.e-9);
deallog.push("1d");
test<1,1>();
test<1,2>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
initlog();
deallog << std::setprecision(4);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
initlog();
deallog << std::setprecision(4);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
mpi_initlog();
- deallog.threshold_double(1e-10);
deallog.push("2d");
test<2,1>();
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
mpi_initlog();
- deallog.threshold_double(1e-10);
deallog.push("2d");
test<2,1>();
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
DoFTools::make_hanging_node_constraints(dof, constraints);
constraints.close();
- deallog.threshold_double (5e-6);
do_test<dim, fe_degree, float, fe_degree+1> (dof, constraints);
}
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1e-10);
test<2,9>();
}
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
int main(int /*argc*/, char ** /*argv*/)
{
initlog();
- deallog.test_mode();
deallog.push("2D");
test<2,1>();
test<2,2>();
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2>(1);
test<2>(2);
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
{
deallog << std::endl << "Test with doubles" << std::endl << std::endl;
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2>(1);
test<2>(2);
if (types_are_equal<number,float>::value == true)
{
deallog.push("float");
- deallog.threshold_double(1e-6);
}
else
{
- deallog.threshold_double(5.e-11);
}
deallog << "Testing " << dof.get_fe().get_name();
}
{
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
test<2,2>();
if (types_are_equal<number,float>::value == true)
{
deallog.push("float");
- deallog.threshold_double(1e-6);
}
else
{
- deallog.threshold_double(5.e-11);
}
deallog << "Testing " << dof.get_fe().get_name();
}
{
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
test<2,2>();
if (types_are_equal<number,float>::value == true)
{
deallog.push("float");
- deallog.threshold_double(1e-6);
}
else
{
- deallog.threshold_double(5.e-11);
}
deallog << "Testing " << dof.get_fe().get_name();
}
{
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
deallog.pop();
if (types_are_equal<number,float>::value == true)
{
deallog.push("float");
- deallog.threshold_double(1e-6);
}
else
{
- deallog.threshold_double(5.e-11);
}
deallog << "Testing " << dof.get_fe().get_name();
}
{
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
test<2,3>();
testing_max_num_threads());
mpi_initlog();
- deallog.threshold_double(1e-9);
test<2,1,double>();
test<2,2,float>();
if (types_are_equal<number,float>::value == true)
{
deallog.push("float");
- deallog.threshold_double(1e-6);
}
else
{
- deallog.threshold_double(5.e-11);
}
deallog << "Testing " << dof.get_fe().get_name();
}
{
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2,1>();
deallog.pop();
Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 2);
mpi_initlog();
- deallog.threshold_double(1e-9);
test<2,1,double>();
}
Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1);
mpi_initlog();
- deallog.threshold_double(1e-9);
{
test<2,1,double>();
deallog << std::setprecision (3);
{
- deallog.threshold_double(1.e-12);
deallog.push("2d");
test<2,1>();
test<2,2>();
{
initlog();
deallog << std::setprecision (3);
- deallog.threshold_double(1e-10);
{
deallog.push("2d");
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
{
deallog.push("2d");
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Step48::SineGordonProblem<2> sg_problem;
sg_problem.run ();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
{
deallog.push("2d");
{
deallog << "Test doubles" << std::endl;
sub_test<dim,fe_degree,double>();
- deallog.threshold_double(2.e-6);
deallog << "Test floats" << std::endl;
sub_test<dim,fe_degree,float>();
}
else
return;
deallog.push("double");
- deallog.threshold_double(1.e-12);
do_test<dim,double>(parallel_option);
deallog.pop();
deallog.push("float");
- deallog.threshold_double(1.e-6);
do_test<dim,float>(parallel_option);
deallog.pop();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test<PETScWrappers::MPI::BlockVector>();
//test<TrilinosWrappers::MPI::BlockVector>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<2> (true);
test1<2> (false);
deallog << std::setprecision(4);
logfile << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test1<2> (true);
test1<2> (false);
{
using namespace dealii;
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization
(argc, argv, 1);
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test_mpi();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test_mpi();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,Q,1);
CHECK_ALL(Q,1,Q,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,Q,1);
CHECK_ALL(Q,1,Q,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,Q,1);
CHECK_ALL(Q,1,Q,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,Q,1);
CHECK_ALL(Q,1,Q,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,Q,1);
CHECK_ALL(Q,1,Q,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
CHECK_ALL(Q,1,Q,1);
CHECK_ALL(Q,1,Q,2);
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
int main (int argc, char *argv[])
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
test_int<2>(0,0);
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
{
StokesProblem<2> flow_problem(1);
flow_problem.run ();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("3d");
test<3>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 1)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{
initlog();
deallog.depth_file(3);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
deallog.push ("2d");
test<2>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(12);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
{
LaplaceProblem<2> laplace_problem;
laplace_problem.run ();
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
{
StokesProblem<2> flow_problem(1);
flow_problem.run ();
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
{
StokesProblem<3> flow_problem(1);
flow_problem.run ();
MPILogInitAll log;
- deallog.threshold_double(1.e-10);
{
deallog << "Test for 2D" << std::endl << std::endl;
for (int i = 0; i < 2; ++i)
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test_mpi();
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(max_n_cell_ratio);
}
{
std::ofstream logfile("output", std::ofstream::app);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(max_n_cell_ratio);
}
{
std::ofstream logfile("output", std::ofstream::app);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test(max_n_cell_ratio);
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
deallog.push ("2d");
test<2>();
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
deallog.push ("2d");
test<2>();
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
deallog.push ("2d");
test<2>();
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
deallog.push ("2d");
test<2>();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test_mpi();
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test_mpi();
if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("mpi");
test_mpi();
{
static std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
}
parallel::distributed::Triangulation<2,3> triangulation(MPI_COMM_WORLD,
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
deallog.push("2d");
test<2>();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
if (myid == 0)
{
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
unsigned int myid = Utilities::MPI::this_mpi_process (MPI_COMM_WORLD);
deallog.push(Utilities::int_to_string(myid));
- deallog.threshold_double(1.e-10);
if (myid == 0)
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<2> ();
check<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1> ();
check<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
test_cycles (0,4);
test_cycles (2,5);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//check_simple (FESystem<2>(FE_Q<2>(1), 2));
check_simple (FESystem<2>(FE_Q<2>(1), 4));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//check_simple (FESystem<2>(FE_Q<2>(1), 2));
check_simple (FESystem<2>(FE_Q<2>(1), 4));
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
LaplaceProblem<2> laplace_problem_2d(1);
laplace_problem_2d.run ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
LaplaceProblem<2> laplace_problem_2d(1);
laplace_problem_2d.run ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check();
}
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi(argc, argv, 1);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_simple (FE_DGP<2>(0));
check_simple (FE_DGP<2>(1));
std::ofstream logfile("output");
deallog << std::setprecision(6);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check_simple (FE_DGP<2>(0));
check_simple (FE_DGP<2>(1));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//check_simple (FESystem<2>(FE_Q<2>(1), 2));
check_simple (FESystem<2>(FE_Q<2>(1), 4));
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
std::vector<double> factors;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
FE_DGQ<2> q0(0);
FE_DGQ<2> q1(1);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
std::vector<double> factors;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_Q<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_Q<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_Q<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_DGQ<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_DGQ<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FESystem<dim> fe (FE_Q<dim>(fe_degree), 2);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_DGQLegendre<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
template <int dim, typename Number>
void check(const FiniteElement<dim> &fe)
{
- deallog.threshold_double(std::max(1e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
deallog << "FE: " << fe.get_name() << std::endl;
// run a few different sizes...
template <int dim, typename Number>
void check(const FiniteElement<dim> &fe)
{
- deallog.threshold_double(std::max(1e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
deallog << "FE: " << fe.get_name() << std::endl;
MGConstrainedDoFs mg_constrained_dofs;
template <int dim, typename Number>
void check(const FiniteElement<dim> &fe)
{
- deallog.threshold_double(std::max(1e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
deallog << "FE: " << fe.get_name() << std::endl;
MGConstrainedDoFs mg_constrained_dofs;
template <int dim, typename Number>
void check(const unsigned int fe_degree)
{
- deallog.threshold_double(std::max(5e2*(double)std::numeric_limits<Number>::epsilon(),
- 1e-11));
FE_Q<dim> fe(fe_degree);
deallog << "FE: " << fe.get_name() << std::endl;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
std::vector<unsigned int> v1(4);
std::vector<unsigned int> v2(4);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),3));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),5),0);
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),2));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),3));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),3));
std::ofstream logfile("output");
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
//TODO: do in 1d
check (FESystem<2>(FE_Q<2>(1),5),0);
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix 1: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector 1: " << test_rhs.l2_norm() << std::endl;
// multiplied by PI there can be roundoff differences
- deallog.threshold_double(1.e-10);
test_matrix_2.add(-numbers::PI, reference_matrix);
deallog << "error in matrix 2: " << test_matrix_2.frobenius_norm() << std::endl;
test_rhs_2.add(-numbers::PI, reference_rhs);
frobenius_norm += test_matrix.block(i,j).frobenius_norm();
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1e-30);
deallog << "error in matrix: " << frobenius_norm << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
{
deallog.push("2d");
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
std::ofstream logfile ("output");
deallog << std::setprecision (3);
deallog.attach(logfile);
- deallog.threshold_double(1e-10);
deallog.push ("1d");
check<1> ();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<2>();
deallog.attach(logfile);
deallog << std::setprecision (4);
logfile << std::setprecision (4);
- deallog.threshold_double(1.e-10);
curved_grid (logfile);
}
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (2);
logfile << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
run<1> ();
run<2> ();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog<<"------------ 2D ------------"<<endl<<endl;
derivatives<2>();
int main()
{
initlog();
- deallog.threshold_double(1.e-10);
deallog<<"------------ 2D ------------"<<endl<<endl;
derivatives<2>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
deallog.push ("1d");
loop<1> ();
{
std::ofstream logfile("output");
dealii::deallog.attach(logfile);
- dealii::deallog.threshold_double(1e-8);
{
NeumanBC<2> func(1.25);
logfile.precision (3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
return 0;
}
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<3>();
}
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<3>();
}
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_sphere<2>();
test_hyper_sphere<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
logfile << std::setprecision(2);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
TestPointValueHistory<2> test;
test.run();
logfile << std::setprecision(2);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
TestPointValueHistory<2> test;
test.run();
logfile << std::setprecision(2);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
TestPointValueHistory<2> test;
test.run();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
{
std::ofstream logfile ("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1>();
test<2>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
FE_RaviartThomasNodal<2> rt21(1);
test_hyper_cube(rt21);
{
deallog << std::setprecision (2);
deallog.attach (logfile);
- deallog.threshold_double (1e-12);
FE_Nedelec<2> fe_2 (1);
{\r
deallog << std::setprecision (2);\r
deallog.attach (logfile);\r
- deallog.threshold_double (1e-12);\r
\r
test<2>(0);\r
test<2>(1);\r
{
deallog << std::setprecision (2);
deallog.attach (logfile);
- deallog.threshold_double (1e-12);
FE_RaviartThomas<2> fe_2 (1);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
numbers::invalid_unsigned_int);
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
numbers::invalid_unsigned_int);
initlog();
- deallog.threshold_double(1.e-10);
test<2>();
test<3>();
deallog << std::setprecision (2);
deallog << std::fixed;
deallog.attach(logfile);
- deallog.threshold_double(1.e-12);
test_hyper_cube<2>();
test_hyper_cube<3>();
{
deallog << std::setprecision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/multiple_parameter_loop_02.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_1.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_10.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_11.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_13.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_13a.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ("subsection bar\nend");
test ("");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
deal_II_exceptions::disable_abort_on_exception();
initlog();
- deallog.threshold_double(1.e-10);
check ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_1_exception.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// go into the source dir to read files there. this
// is necessary so that we can include files there
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// go into the source dir to read files there. this
// is necessary so that we can include files there
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_1a.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check ("subsection bar\nend #comment is okay");
check ("subsection bar\nend ");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
// go into the source dir to read files there. this
// is necessary so that we can include files there
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// same as parameter_handler_3
ParameterHandler prm;
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// same as parameter_handler_3
ParameterHandler prm;
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing testing");
try
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.enter_subsection ("Testing testing");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
for (unsigned int i = 0; i < 2; ++i)
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
test ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_1.prm");
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
check (SOURCE_DIR "/prm/parameter_handler_1.prm");
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
ParameterHandler prm;
prm.declare_entry ("int1",
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
if (typeid(PetscScalar)==typeid(double))
deallog << "double" << std::endl;
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
logfile.setf(std::ios::fixed);
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
dealii::Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-6);
// create stiffness and mass matrix templates
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
initlog();
- deallog.threshold_double(1.e-10);
std::vector<int> petsc_error_codes;
petsc_error_codes.push_back(PETSC_ERR_MIN_VALUE);
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
deallog << std::fixed;
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// test for a rectangular sparse
// matrix
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
test ();
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
{
std::ofstream logfile ("output");
dealii::deallog.attach (logfile);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile ("output");
dealii::deallog.attach (logfile);
dealii::deallog.depth_console (0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile ("output");
dealii::deallog.attach (logfile);
dealii::deallog.depth_console (0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile ("output");
dealii::deallog.attach (logfile);
dealii::deallog.depth_console (0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile ("output");
dealii::deallog.attach (logfile);
dealii::deallog.depth_console (0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
int main (int argc, char *argv[])
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
initlog();
deallog << std::setprecision(4);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
initlog();
deallog << std::setprecision(4);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
initlog();
deallog << std::setprecision(4);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile ("output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog.attach(logfile);
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_kinematic_tensors<2> ();
test_kinematic_tensors<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_standard_tensors<2> ();
test_standard_tensors<3> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
try
{
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
using namespace dealii;
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const double deg_to_rad = M_PI/180.0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-9);
test<2> ();
}
std::string logname = "output";
std::ofstream logfile(logname.c_str());
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
check<1>();
}
std::ofstream logfile(logname.c_str());
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_rect(3,4,rect);
test_rect(4,3,rect);
int main ()
{
initlog();
- deallog.threshold_double(1.e-9);
test<2> ();
test<2> (/*transpose =*/ true);
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1,1> ();
test<1,2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1,1> ();
test<1,2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test<1,1> ();
test<1,2> ();
std::ofstream logfile("output");
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
{
initlog();
deallog << std::setprecision(7);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
{
initlog();
deallog << std::setprecision(6);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
{
std::ofstream logfile("output");
dealii::deallog.attach(logfile,/*do not print job id*/false);
dealii::deallog.depth_console(0);
- dealii::deallog.threshold_double(eps);
try
{
std::ofstream logfile("output");
dealii::deallog.attach(logfile,/*do not print job id*/false);
dealii::deallog.depth_console(0);
- dealii::deallog.threshold_double(eps);
try
{
std::ofstream logfile("output");
dealii::deallog.attach(logfile,/*do not print job id*/false);
dealii::deallog.depth_console(0);
- dealii::deallog.threshold_double(eps);
try
{
logfile.setf(std::ios::fixed);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
BlockDynamicSparsityPattern csp(2,2);
csp.block(0,0).reinit(2,2);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
IndexSet a(5);
IndexSet b(3);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
BlockSparsityPattern sparsity;
std::vector<types::global_dof_index> row_blocks(4);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
std::vector<types::global_dof_index> row_blocks(4);
row_blocks[0] = 4;
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
const unsigned int chunk_sizes[] = { 1, 2, 4, 5, 7 };
for (unsigned int i=0; i<sizeof(chunk_sizes)/sizeof(chunk_sizes[0]); ++i)
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
matrix_position<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
block_read_write<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
row_length<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
print_gnuplot<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
print<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_with_offdiagonals_1<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_with_offdiagonals_2<DynamicSparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_index_set<DynamicSparsityPattern> (true);
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
test_index_set<DynamicSparsityPattern> (false);
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
// generate usual sparsity pattern
const unsigned int N = 15;
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
row_length<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
print_gnuplot<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
print<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_with_offdiagonals_1<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_with_offdiagonals_2<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_from_1<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_from_2<SparsityPattern, DynamicSparsityPattern> ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
return 0;
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
copy_from_4<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
matrix_position<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
block_read_write<SparsityPattern> ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
DynamicSparsityPattern csp (10, 0);
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
DynamicSparsityPattern csp (10000000, 100);
csp.add(9999999, 1);
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
DynamicSparsityPattern dsp (4,4);
for (unsigned int i=0; i<4; ++i)
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
DynamicSparsityPattern dsp (8,8);
for (unsigned int i=0; i<8; ++i)
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
test_matrix.compress(VectorOperation::add);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
double frobenius_norm = 0;
for (unsigned int i=0; i<2; ++i)
for (unsigned int j=0; j<2; ++j)
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
double frobenius_norm = 0;
for (unsigned int i=0; i<2; ++i)
for (unsigned int j=0; j<2; ++j)
test_matrix.add(-1, reference_matrix);
// there should not even be roundoff difference between matrices
- deallog.threshold_double(1.e-30);
deallog << "error in matrix: " << test_matrix.frobenius_norm() << std::endl;
test_rhs.add(-1., reference_rhs);
deallog << "error in vector: " << test_rhs.l2_norm() << std::endl;
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
logfile.setf(std::ios::fixed);
logfile.precision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
test();
}
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(2);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
using namespace dealii;
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
LinearAdvectionTest::AdvectionProblem<2> advection_problem;
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1);
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1);
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_init(argc, argv, 1);
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
test();
std::ofstream logfile("output");
deallog << std::setprecision(6);
- deallog.threshold_double(1.e-10);
deallog.attach(logfile);
check_simple (FE_DGP<2>(0));
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-5);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, 1);
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
test();
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
std::ofstream logfile("output");
logfile.precision(4);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (5,5,5);
sparsity.add (1,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (5,5,5);
sparsity.add (1,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (5,5,5);
sparsity.add (1,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (5,5,5);
sparsity.add (1,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (5,5,5);
sparsity.add (1,2);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (4,5,5);
sparsity.add (1,2);
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
initlog();
- deallog.threshold_double(1.e-10);
SparsityPattern sparsity (5,5,5);
sparsity.add (1,2);
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc,char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
test();
}
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
row_length ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
print_gnuplot ();
}
logfile.setf(std::ios::fixed);
deallog << std::setprecision(3);
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
print ();
}
{
initlog();
deallog << std::setprecision(4);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
std::ofstream logfile("output");
deallog.attach(logfile, false);
- deallog.threshold_double(1.e-10);
{
StokesProblem<3> flow_problem(1);
flow_problem.run ();
{
std::ofstream logfile("output");
deallog.attach(logfile);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
test();
}
{
std::ofstream logfile ("output");
deallog.attach (logfile);
- deallog.threshold_double (1.e-10);
test();
}
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
{
initlog();
deallog.depth_console(0);
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
{
int main (int argc, char **argv)
{
initlog();
- deallog.threshold_double(1.e-10);
Utilities::MPI::MPI_InitFinalize mpi_initialization (argc, argv, testing_max_num_threads());
int main ()
{
initlog();
- deallog.threshold_double(1.e-9);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-9);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
test ();
}
int main ()
{
initlog();
- deallog.threshold_double(1.e-9);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-8);
test<1> ();
test<2> ();
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
int main ()
{
initlog();
- deallog.threshold_double(1.e-10);
try
{
projects / dealii.git / commitdiff