From ad5dd77c6b19c4c7b8cda7f95584f02c01d17896 Mon Sep 17 00:00:00 2001 From: Christian Bauer Date: Tue, 6 Mar 2001 20:06:38 +0000 Subject: [PATCH] added checks for new indexed objects --- check/Makefile.am | 14 ++- check/exam_indexed.cpp | 208 +++++++++++++++++++++++++++++++++++++++++ check/exams.cpp | 2 +- check/exams.h | 2 +- check/exams.ref | 2 +- 5 files changed, 221 insertions(+), 7 deletions(-) create mode 100644 check/exam_indexed.cpp diff --git a/check/Makefile.am b/check/Makefile.am index a5e781b9..bb9ef632 100644 --- a/check/Makefile.am +++ b/check/Makefile.am @@ -1,14 +1,18 @@ ## Process this file with automake to produce Makefile.in + TESTS = run_exams run_checks run_times check_PROGRAMS = exams checks times + +checks_SOURCES = check_numeric.cpp check_inifcns.cpp check_matrices.cpp \ + check_lsolve.cpp genex.cpp checks.cpp checks.h +checks_LDADD = ../ginac/libginac.la + exams_SOURCES = exam_paranoia.cpp exam_numeric.cpp exam_powerlaws.cpp \ exam_inifcns.cpp exam_differentiation.cpp exam_polygcd.cpp \ exam_normalization.cpp exam_pseries.cpp exam_matrices.cpp exam_lsolve.cpp \ - exam_noncommut.cpp exam_misc.cpp exams.cpp exams.h + exam_indexed.cpp exam_misc.cpp exams.cpp exams.h exams_LDADD = ../ginac/libginac.la -checks_SOURCES = check_numeric.cpp check_inifcns.cpp check_matrices.cpp \ - check_lsolve.cpp genex.cpp checks.cpp checks.h -checks_LDADD = ../ginac/libginac.la + times_SOURCES = time_dennyfliegner.cpp time_gammaseries.cpp \ time_vandermonde.cpp time_toeplitz.cpp time_lw_A.cpp time_lw_B.cpp \ time_lw_C.cpp time_lw_D.cpp time_lw_E.cpp time_lw_F.cpp time_lw_G.cpp \ @@ -16,6 +20,8 @@ times_SOURCES = time_dennyfliegner.cpp time_gammaseries.cpp \ time_lw_O.cpp time_lw_P.cpp time_lw_Pprime.cpp time_lw_Q.cpp \ time_lw_Qprime.cpp time_antipode.cpp timer.cpp times.cpp times.h times_LDADD = ../ginac/libginac.la + INCLUDES = -I$(srcdir)/../ginac -I../ginac + CLEANFILES = exams.out checks.out times.out EXTRA_DIST = exams.ref checks.ref times.ref run_exams run_checks run_times diff --git a/check/exam_indexed.cpp b/check/exam_indexed.cpp new file mode 100644 index 00000000..11182cb9 --- /dev/null +++ b/check/exam_indexed.cpp @@ -0,0 +1,208 @@ +/** @file exam_indexed.cpp + * + * Here we test manipulations on GiNaC's indexed objects. */ + +/* + * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "exams.h" + +static unsigned check_equal(const ex &e1, const ex &e2) +{ + ex e = e1 - e2; + if (!e.is_zero()) { + clog << e1 << "-" << e2 << " erroneously returned " + << e << " instead of 0" << endl; + return 1; + } + return 0; +} + +static unsigned check_equal_simplify(const ex &e1, const ex &e2) +{ + ex e = simplify_indexed(e1) - e2; + if (!e.is_zero()) { + clog << "simplify_indexed(" << e1 << ")-" << e2 << " erroneously returned " + << e << " instead of 0" << endl; + return 1; + } + return 0; +} + +static unsigned delta_check(void) +{ + // checks identities of the delta tensor + + unsigned result = 0; + + symbol s_i("i"), s_j("j"), s_k("k"); + idx i(s_i, 3), j(s_j, 3), k(s_k, 3); + symbol A("A"); + + // symmetry + result += check_equal(delta_tensor(i, j), delta_tensor(j, i)); + + // trace = dimension of index space + result += check_equal(delta_tensor(i, i), 3); + result += check_equal_simplify(delta_tensor(i, j) * delta_tensor(i, j), 3); + + // contraction with delta tensor + result += check_equal_simplify(delta_tensor(i, j) * indexed(A, k), delta_tensor(i, j) * indexed(A, k)); + result += check_equal_simplify(delta_tensor(i, j) * indexed(A, j), indexed(A, i)); + result += check_equal_simplify(delta_tensor(i, j) * indexed(A, i), indexed(A, j)); + result += check_equal_simplify(delta_tensor(i, j) * delta_tensor(j, k) * indexed(A, i), indexed(A, k)); + + return result; +} + +static unsigned metric_check(void) +{ + // checks identities of the metric tensor + + unsigned result = 0; + + symbol s_mu("mu"), s_nu("nu"), s_rho("rho"), s_sigma("sigma"); + varidx mu(s_mu, 4), nu(s_nu, 4), rho(s_rho, 4), sigma(s_sigma, 4); + symbol A("A"); + + // becomes delta tensor if indices have opposite variance + result += check_equal(metric_tensor(mu, nu.toggle_variance()), delta_tensor(mu, nu.toggle_variance())); + + // scalar contraction = dimension of index space + result += check_equal(metric_tensor(mu, mu.toggle_variance()), 4); + result += check_equal_simplify(metric_tensor(mu, nu) * metric_tensor(mu.toggle_variance(), nu.toggle_variance()), 4); + + // contraction with metric tensor + result += check_equal_simplify(metric_tensor(mu, nu) * indexed(A, nu), metric_tensor(mu, nu) * indexed(A, nu)); + result += check_equal_simplify(metric_tensor(mu, nu) * indexed(A, nu.toggle_variance()), indexed(A, mu)); + result += check_equal_simplify(metric_tensor(mu, nu) * indexed(A, mu.toggle_variance()), indexed(A, nu)); + result += check_equal_simplify(metric_tensor(mu, nu) * metric_tensor(mu.toggle_variance(), rho.toggle_variance()) * indexed(A, nu.toggle_variance()), indexed(A, rho.toggle_variance())); + result += check_equal_simplify(metric_tensor(mu, rho) * metric_tensor(nu, sigma) * indexed(A, rho.toggle_variance(), sigma.toggle_variance()), indexed(A, mu, nu)); + result += check_equal_simplify(indexed(A, mu.toggle_variance()) * metric_tensor(mu, nu) - indexed(A, mu.toggle_variance()) * metric_tensor(nu, mu), 0); + result += check_equal_simplify(indexed(A, mu.toggle_variance(), nu.toggle_variance()) * metric_tensor(nu, rho), indexed(A, mu.toggle_variance(), rho)); + + // contraction with delta tensor yields a metric tensor + result += check_equal_simplify(delta_tensor(mu, nu.toggle_variance()) * metric_tensor(nu, rho), metric_tensor(mu, rho)); + result += check_equal_simplify(metric_tensor(mu, nu) * indexed(A, nu.toggle_variance()) * delta_tensor(mu.toggle_variance(), rho), indexed(A, rho)); + + return result; +} + +static unsigned symmetry_check(void) +{ + // check symmetric/antisymmetric objects + + unsigned result = 0; + + symbol s_i("i"), s_j("j"), s_k("k"); + idx i(s_i, 3), j(s_j, 3), k(s_k, 3); + symbol A("A"); + ex e, e1, e2; + + result += check_equal(indexed(A, indexed::symmetric, i, j), indexed(A, indexed::symmetric, j, i)); + result += check_equal(indexed(A, indexed::antisymmetric, i, j) + indexed(A, indexed::antisymmetric, j, i), 0); + result += check_equal(indexed(A, indexed::antisymmetric, i, j, k) - indexed(A, indexed::antisymmetric, j, k, i), 0); + + return result; +} + +static unsigned edyn_check(void) +{ + // relativistic electrodynamics: check transformation laws of electric + // and magnetic fields by applying a Lorentz boost to the field tensor + + unsigned result = 0; + + symbol beta("beta"); + ex gamma = 1 / sqrt(1 - pow(beta, 2)); + symbol Ex("Ex"), Ey("Ey"), Ez("Ez"); + symbol Bx("Bx"), By("By"), Bz("Bz"); + + // Lorentz transformation matrix (boost along x axis) + matrix L(4, 4); + L.set(0, 0, gamma); + L.set(0, 1, -beta*gamma); + L.set(1, 0, -beta*gamma); + L.set(1, 1, gamma); + L.set(2, 2, 1); + L.set(3, 3, 1); + + // Electromagnetic field tensor + matrix F(4, 4); + F.set(0, 1, -Ex); + F.set(1, 0, Ex); + F.set(0, 2, -Ey); + F.set(2, 0, Ey); + F.set(0, 3, -Ez); + F.set(3, 0, Ez); + F.set(1, 2, -Bz); + F.set(2, 1, Bz); + F.set(1, 3, By); + F.set(3, 1, -By); + F.set(2, 3, -Bx); + F.set(3, 2, Bx); + + // Indices + symbol s_mu("mu"), s_nu("nu"), s_rho("rho"), s_sigma("sigma"); + varidx mu(s_mu, 4), nu(s_nu, 4), rho(s_rho, 4), sigma(s_sigma, 4); + + // Apply transformation law of second rank tensor + ex e = (indexed(L, mu, rho.toggle_variance()) + * indexed(L, nu, sigma.toggle_variance()) + * indexed(F, rho, sigma)).simplify_indexed(); + + // Extract transformed electric and magnetic fields + ex Ex_p = e.subs(lst(mu == 1, nu == 0)).normal(); + ex Ey_p = e.subs(lst(mu == 2, nu == 0)).normal(); + ex Ez_p = e.subs(lst(mu == 3, nu == 0)).normal(); + ex Bx_p = e.subs(lst(mu == 3, nu == 2)).normal(); + ex By_p = e.subs(lst(mu == 1, nu == 3)).normal(); + ex Bz_p = e.subs(lst(mu == 2, nu == 1)).normal(); + + // Check results + result += check_equal(Ex_p, Ex); + result += check_equal(Ey_p, gamma * (Ey - beta * Bz)); + result += check_equal(Ez_p, gamma * (Ez + beta * By)); + result += check_equal(Bx_p, Bx); + result += check_equal(By_p, gamma * (By + beta * Ez)); + result += check_equal(Bz_p, gamma * (Bz - beta * Ey)); + + return result; +} + +unsigned exam_indexed(void) +{ + unsigned result = 0; + + cout << "examining indexed objects" << flush; + clog << "----------indexed objects:" << endl; + + result += delta_check(); cout << '.' << flush; + result += metric_check(); cout << '.' << flush; + result += symmetry_check(); cout << '.' << flush; + result += edyn_check(); cout << '.' << flush; + + if (!result) { + cout << " passed " << endl; + clog << "(no output)" << endl; + } else { + cout << " failed " << endl; + } + + return result; +} diff --git a/check/exams.cpp b/check/exams.cpp index 068e936c..385ed9a3 100644 --- a/check/exams.cpp +++ b/check/exams.cpp @@ -100,7 +100,7 @@ int main() } try { - result += exam_noncommut(); + result += exam_indexed(); } catch (const exception &e) { cout << "Error: caught exception " << e.what() << endl; ++result; diff --git a/check/exams.h b/check/exams.h index 259b54d2..6677659d 100644 --- a/check/exams.h +++ b/check/exams.h @@ -38,7 +38,7 @@ unsigned exam_normalization(); unsigned exam_pseries(); unsigned exam_matrices(); unsigned exam_lsolve(); -unsigned exam_noncommut(); +unsigned exam_indexed(); unsigned exam_misc(); #endif // ndef EXAMS_H diff --git a/check/exams.ref b/check/exams.ref index 51e47b22..f9c4afb4 100644 --- a/check/exams.ref +++ b/check/exams.ref @@ -18,7 +18,7 @@ (no output) ----------linear solve: (no output) -----------behaviour of noncommutative objects: +----------indexed objects: (no output) ----------miscellaneous other things: (no output) -- 2.44.0