X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Ftensor.cpp;h=0c36a68002423d712f4d8afa5ec903716ffba7e7;hp=f4e49451d907a70cbb541973984035cf872c6b1e;hb=b8b8cfbb72bfa59b01371f67f542914cf55f2ab9;hpb=0117bd6ef4af029934703940d59e1c70866937b0 diff --git a/ginac/tensor.cpp b/ginac/tensor.cpp index f4e49451..0c36a680 100644 --- a/ginac/tensor.cpp +++ b/ginac/tensor.cpp @@ -3,7 +3,7 @@ * Implementation of GiNaC's special tensors. */ /* - * GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany + * GiNaC Copyright (C) 1999-2002 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 @@ -20,19 +20,21 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ +#include #include #include #include "tensor.h" #include "idx.h" #include "indexed.h" +#include "symmetry.h" #include "relational.h" #include "lst.h" #include "numeric.h" +#include "matrix.h" #include "print.h" #include "archive.h" #include "utils.h" -#include "debugmsg.h" namespace GiNaC { @@ -44,14 +46,9 @@ GINAC_IMPLEMENT_REGISTERED_CLASS(spinmetric, tensmetric) GINAC_IMPLEMENT_REGISTERED_CLASS(tensepsilon, tensor) ////////// -// default constructor, destructor, copy constructor assignment operator and helpers +// default ctor, dtor, copy ctor, assignment operator and helpers ////////// -tensor::tensor(unsigned ti) : inherited(ti) -{ - debugmsg("tensor constructor from unsigned", LOGLEVEL_CONSTRUCT); \ -} - DEFAULT_CTORS(tensor) DEFAULT_CTORS(tensdelta) DEFAULT_CTORS(tensmetric) @@ -62,19 +59,16 @@ DEFAULT_DESTROY(tensepsilon) minkmetric::minkmetric() : pos_sig(false) { - debugmsg("minkmetric default constructor", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_minkmetric; } spinmetric::spinmetric() { - debugmsg("spinmetric default constructor", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_spinmetric; } minkmetric::minkmetric(bool ps) : pos_sig(ps) { - debugmsg("minkmetric constructor from bool", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_minkmetric; } @@ -86,13 +80,11 @@ void minkmetric::copy(const minkmetric & other) tensepsilon::tensepsilon() : minkowski(false), pos_sig(false) { - debugmsg("tensepsilon default constructor", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_tensepsilon; } tensepsilon::tensepsilon(bool mink, bool ps) : minkowski(mink), pos_sig(ps) { - debugmsg("tensepsilon constructor from bool,bool", LOGLEVEL_CONSTRUCT); tinfo_key = TINFO_tensepsilon; } @@ -116,7 +108,6 @@ DEFAULT_UNARCHIVE(tensepsilon) minkmetric::minkmetric(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("minkmetric constructor from archive_node", LOGLEVEL_CONSTRUCT); n.find_bool("pos_sig", pos_sig); } @@ -128,7 +119,6 @@ void minkmetric::archive(archive_node &n) const tensepsilon::tensepsilon(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst) { - debugmsg("tensepsilon constructor from archive_node", LOGLEVEL_CONSTRUCT); n.find_bool("minkowski", minkowski); n.find_bool("pos_sig", pos_sig); } @@ -141,7 +131,7 @@ void tensepsilon::archive(archive_node &n) const } ////////// -// functions overriding virtual functions from bases classes +// functions overriding virtual functions from base classes ////////// DEFAULT_COMPARE(tensor) @@ -151,7 +141,7 @@ DEFAULT_COMPARE(spinmetric) int minkmetric::compare_same_type(const basic & other) const { - GINAC_ASSERT(is_of_type(other, minkmetric)); + GINAC_ASSERT(is_a(other)); const minkmetric &o = static_cast(other); if (pos_sig != o.pos_sig) @@ -162,7 +152,7 @@ int minkmetric::compare_same_type(const basic & other) const int tensepsilon::compare_same_type(const basic & other) const { - GINAC_ASSERT(is_of_type(other, tensepsilon)); + GINAC_ASSERT(is_a(other)); const tensepsilon &o = static_cast(other); if (minkowski != o.minkowski) @@ -182,24 +172,29 @@ DEFAULT_PRINT_LATEX(tensepsilon, "eps", "\\varepsilon") /** Automatic symbolic evaluation of an indexed delta tensor. */ ex tensdelta::eval_indexed(const basic & i) const { - GINAC_ASSERT(is_of_type(i, indexed)); + GINAC_ASSERT(is_a(i)); GINAC_ASSERT(i.nops() == 3); - GINAC_ASSERT(is_ex_of_type(i.op(0), tensdelta)); + GINAC_ASSERT(is_a(i.op(0))); - const idx & i1 = ex_to_idx(i.op(1)); - const idx & i2 = ex_to_idx(i.op(2)); + const idx & i1 = ex_to(i.op(1)); + const idx & i2 = ex_to(i.op(2)); - // Trace of delta tensor is the dimension of the space - if (is_dummy_pair(i1, i2)) - return i1.get_dim(); + // Trace of delta tensor is the (effective) dimension of the space + if (is_dummy_pair(i1, i2)) { + try { + return i1.minimal_dim(i2); + } catch (std::exception &e) { + return i.hold(); + } + } // Numeric evaluation if (static_cast(i).all_index_values_are(info_flags::integer)) { - int n1 = ex_to_numeric(i1.get_value()).to_int(), n2 = ex_to_numeric(i2.get_value()).to_int(); + int n1 = ex_to(i1.get_value()).to_int(), n2 = ex_to(i2.get_value()).to_int(); if (n1 == n2) - return _ex1(); + return _ex1; else - return _ex0(); + return _ex0; } // No further simplifications @@ -209,14 +204,21 @@ ex tensdelta::eval_indexed(const basic & i) const /** Automatic symbolic evaluation of an indexed metric tensor. */ ex tensmetric::eval_indexed(const basic & i) const { - GINAC_ASSERT(is_of_type(i, indexed)); + GINAC_ASSERT(is_a(i)); GINAC_ASSERT(i.nops() == 3); - GINAC_ASSERT(is_ex_of_type(i.op(0), tensmetric)); - GINAC_ASSERT(is_ex_of_type(i.op(1), varidx)); - GINAC_ASSERT(is_ex_of_type(i.op(2), varidx)); - - const varidx & i1 = ex_to_varidx(i.op(1)); - const varidx & i2 = ex_to_varidx(i.op(2)); + GINAC_ASSERT(is_a(i.op(0))); + GINAC_ASSERT(is_a(i.op(1))); + GINAC_ASSERT(is_a(i.op(2))); + + const varidx & i1 = ex_to(i.op(1)); + const varidx & i2 = ex_to(i.op(2)); + + // The dimension of the indices must be equal, otherwise we use the minimal + // dimension + if (!i1.get_dim().is_equal(i2.get_dim())) { + ex min_dim = i1.minimal_dim(i2); + return i.subs(lst(i1 == i1.replace_dim(min_dim), i2 == i2.replace_dim(min_dim))); + } // A metric tensor with one covariant and one contravariant index gets // replaced by a delta tensor @@ -230,24 +232,24 @@ ex tensmetric::eval_indexed(const basic & i) const /** Automatic symbolic evaluation of an indexed Lorentz metric tensor. */ ex minkmetric::eval_indexed(const basic & i) const { - GINAC_ASSERT(is_of_type(i, indexed)); + GINAC_ASSERT(is_a(i)); GINAC_ASSERT(i.nops() == 3); - GINAC_ASSERT(is_ex_of_type(i.op(0), minkmetric)); - GINAC_ASSERT(is_ex_of_type(i.op(1), varidx)); - GINAC_ASSERT(is_ex_of_type(i.op(2), varidx)); + GINAC_ASSERT(is_a(i.op(0))); + GINAC_ASSERT(is_a(i.op(1))); + GINAC_ASSERT(is_a(i.op(2))); - const varidx & i1 = ex_to_varidx(i.op(1)); - const varidx & i2 = ex_to_varidx(i.op(2)); + const varidx & i1 = ex_to(i.op(1)); + const varidx & i2 = ex_to(i.op(2)); // Numeric evaluation if (static_cast(i).all_index_values_are(info_flags::nonnegint)) { - int n1 = ex_to_numeric(i1.get_value()).to_int(), n2 = ex_to_numeric(i2.get_value()).to_int(); + int n1 = ex_to(i1.get_value()).to_int(), n2 = ex_to(i2.get_value()).to_int(); if (n1 != n2) - return _ex0(); + return _ex0; else if (n1 == 0) - return pos_sig ? _ex_1() : _ex1(); + return pos_sig ? _ex_1 : _ex1; else - return pos_sig ? _ex1() : _ex_1(); + return pos_sig ? _ex1 : _ex_1; } // Perform the usual evaluations of a metric tensor @@ -257,28 +259,28 @@ ex minkmetric::eval_indexed(const basic & i) const /** Automatic symbolic evaluation of an indexed metric tensor. */ ex spinmetric::eval_indexed(const basic & i) const { - GINAC_ASSERT(is_of_type(i, indexed)); + GINAC_ASSERT(is_a(i)); GINAC_ASSERT(i.nops() == 3); - GINAC_ASSERT(is_ex_of_type(i.op(0), spinmetric)); - GINAC_ASSERT(is_ex_of_type(i.op(1), spinidx)); - GINAC_ASSERT(is_ex_of_type(i.op(2), spinidx)); + GINAC_ASSERT(is_a(i.op(0))); + GINAC_ASSERT(is_a(i.op(1))); + GINAC_ASSERT(is_a(i.op(2))); - const spinidx & i1 = ex_to_spinidx(i.op(1)); - const spinidx & i2 = ex_to_spinidx(i.op(2)); + const spinidx & i1 = ex_to(i.op(1)); + const spinidx & i2 = ex_to(i.op(2)); // Convolutions are zero - if (static_cast(i).get_dummy_indices().size() != 0) - return _ex0(); + if (!(static_cast(i).get_dummy_indices().empty())) + return _ex0; // Numeric evaluation if (static_cast(i).all_index_values_are(info_flags::nonnegint)) { - int n1 = ex_to_numeric(i1.get_value()).to_int(), n2 = ex_to_numeric(i2.get_value()).to_int(); + int n1 = ex_to(i1.get_value()).to_int(), n2 = ex_to(i2.get_value()).to_int(); if (n1 == n2) - return _ex0(); + return _ex0; else if (n1 < n2) - return _ex1(); + return _ex1; else - return _ex_1(); + return _ex_1; } // No further simplifications @@ -288,13 +290,13 @@ ex spinmetric::eval_indexed(const basic & i) const /** Automatic symbolic evaluation of an indexed epsilon tensor. */ ex tensepsilon::eval_indexed(const basic & i) const { - GINAC_ASSERT(is_of_type(i, indexed)); + GINAC_ASSERT(is_a(i)); GINAC_ASSERT(i.nops() > 1); - GINAC_ASSERT(is_ex_of_type(i.op(0), tensepsilon)); + GINAC_ASSERT(is_a(i.op(0))); // Convolutions are zero - if (static_cast(i).get_dummy_indices().size() != 0) - return _ex0(); + if (!(static_cast(i).get_dummy_indices().empty())) + return _ex0; // Numeric evaluation if (static_cast(i).all_index_values_are(info_flags::nonnegint)) { @@ -304,7 +306,7 @@ ex tensepsilon::eval_indexed(const basic & i) const std::vector v; v.reserve(i.nops() - 1); for (unsigned j=1; j(ex_to(i.op(j)).get_value()).to_int()); int sign = permutation_sign(v.begin(), v.end()); // In a Minkowski space, check for covariant indices @@ -313,8 +315,8 @@ ex tensepsilon::eval_indexed(const basic & i) const const ex & x = i.op(j); if (!is_ex_of_type(x, varidx)) throw(std::runtime_error("indices of epsilon tensor in Minkowski space must be of type varidx")); - if (ex_to_varidx(x).is_covariant()) - if (ex_to_idx(x).get_value().is_zero()) + if (ex_to(x).is_covariant()) + if (ex_to(x).get_value().is_zero()) sign = (pos_sig ? -sign : sign); else sign = (pos_sig ? sign : -sign); @@ -328,39 +330,39 @@ ex tensepsilon::eval_indexed(const basic & i) const return i.hold(); } -/** Contraction of an indexed delta tensor with something else. */ -bool tensdelta::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const +bool tensor::replace_contr_index(exvector::iterator self, exvector::iterator other) const { - GINAC_ASSERT(is_ex_of_type(*self, indexed)); - GINAC_ASSERT(is_ex_of_type(*other, indexed)); - GINAC_ASSERT(self->nops() == 3); - GINAC_ASSERT(is_ex_of_type(self->op(0), tensdelta)); - - // Try to contract first index - const idx *self_idx = &ex_to_idx(self->op(1)); - const idx *free_idx = &ex_to_idx(self->op(2)); + // Try to contract the first index + const idx *self_idx = &ex_to(self->op(1)); + const idx *free_idx = &ex_to(self->op(2)); bool first_index_tried = false; again: if (self_idx->is_symbolic()) { - for (int i=1; inops(); i++) { - const idx &other_idx = ex_to_idx(other->op(i)); + for (unsigned i=1; inops(); i++) { + const idx &other_idx = ex_to(other->op(i)); if (is_dummy_pair(*self_idx, other_idx)) { - // Contraction found, remove delta tensor and substitute - // index in second object - *self = _ex1(); - *other = other->subs(other_idx == *free_idx); - return true; + // Contraction found, remove this tensor and substitute the + // index in the second object + try { + // minimal_dim() throws an exception when index dimensions are not comparable + ex min_dim = self_idx->minimal_dim(other_idx); + *self = _ex1; + *other = other->subs(other_idx == free_idx->replace_dim(min_dim)); + return true; + } catch (std::exception &e) { + return false; + } } } } if (!first_index_tried) { - // No contraction with first index found, try second index - self_idx = &ex_to_idx(self->op(2)); - free_idx = &ex_to_idx(self->op(1)); + // No contraction with the first index found, try the second index + self_idx = &ex_to(self->op(2)); + free_idx = &ex_to(self->op(1)); first_index_tried = true; goto again; } @@ -368,87 +370,73 @@ again: return false; } +/** Contraction of an indexed delta tensor with something else. */ +bool tensdelta::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const +{ + GINAC_ASSERT(is_a(*self)); + GINAC_ASSERT(is_a(*other)); + GINAC_ASSERT(self->nops() == 3); + GINAC_ASSERT(is_a(self->op(0))); + + // Replace the dummy index with this tensor's other index and remove + // the tensor (this is valid for contractions with all other tensors) + return replace_contr_index(self, other); +} + /** Contraction of an indexed metric tensor with something else. */ bool tensmetric::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const { - GINAC_ASSERT(is_ex_of_type(*self, indexed)); - GINAC_ASSERT(is_ex_of_type(*other, indexed)); + GINAC_ASSERT(is_a(*self)); + GINAC_ASSERT(is_a(*other)); GINAC_ASSERT(self->nops() == 3); - GINAC_ASSERT(is_ex_of_type(self->op(0), tensmetric)); + GINAC_ASSERT(is_a(self->op(0))); // If contracting with the delta tensor, let the delta do it // (don't raise/lower delta indices) if (is_ex_of_type(other->op(0), tensdelta)) return false; - // Try to contract first index - const idx *self_idx = &ex_to_idx(self->op(1)); - const idx *free_idx = &ex_to_idx(self->op(2)); - bool first_index_tried = false; - -again: - if (self_idx->is_symbolic()) { - for (int i=1; inops(); i++) { - const idx &other_idx = ex_to_idx(other->op(i)); - if (is_dummy_pair(*self_idx, other_idx)) { - - // Contraction found, remove metric tensor and substitute - // index in second object - *self = _ex1(); - *other = other->subs(other_idx == *free_idx); - return true; - } - } - } - - if (!first_index_tried) { - - // No contraction with first index found, try second index - self_idx = &ex_to_idx(self->op(2)); - free_idx = &ex_to_idx(self->op(1)); - first_index_tried = true; - goto again; - } - - return false; + // Replace the dummy index with this tensor's other index and remove + // the tensor (this is valid for contractions with all other tensors) + return replace_contr_index(self, other); } /** Contraction of an indexed spinor metric with something else. */ bool spinmetric::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const { - GINAC_ASSERT(is_ex_of_type(*self, indexed)); - GINAC_ASSERT(is_ex_of_type(*other, indexed)); + GINAC_ASSERT(is_a(*self)); + GINAC_ASSERT(is_a(*other)); GINAC_ASSERT(self->nops() == 3); - GINAC_ASSERT(is_ex_of_type(self->op(0), spinmetric)); + GINAC_ASSERT(is_a(self->op(0))); // Contractions between spinor metrics if (is_ex_of_type(other->op(0), spinmetric)) { - const idx &self_i1 = ex_to_idx(self->op(1)); - const idx &self_i2 = ex_to_idx(self->op(2)); - const idx &other_i1 = ex_to_idx(other->op(1)); - const idx &other_i2 = ex_to_idx(other->op(2)); + const idx &self_i1 = ex_to(self->op(1)); + const idx &self_i2 = ex_to(self->op(2)); + const idx &other_i1 = ex_to(other->op(1)); + const idx &other_i2 = ex_to(other->op(2)); if (is_dummy_pair(self_i1, other_i1)) { if (is_dummy_pair(self_i2, other_i2)) - *self = _ex2(); + *self = _ex2; else *self = delta_tensor(self_i2, other_i2); - *other = _ex1(); + *other = _ex1; return true; } else if (is_dummy_pair(self_i1, other_i2)) { if (is_dummy_pair(self_i2, other_i1)) - *self = _ex_2(); + *self = _ex_2; else *self = -delta_tensor(self_i2, other_i1); - *other = _ex1(); + *other = _ex1; return true; } else if (is_dummy_pair(self_i2, other_i1)) { *self = -delta_tensor(self_i1, other_i2); - *other = _ex1(); + *other = _ex1; return true; } else if (is_dummy_pair(self_i2, other_i2)) { *self = delta_tensor(self_i1, other_i1); - *other = _ex1(); + *other = _ex1; return true; } } @@ -459,15 +447,15 @@ bool spinmetric::contract_with(exvector::iterator self, exvector::iterator other return false; // Try to contract first index - const idx *self_idx = &ex_to_idx(self->op(1)); - const idx *free_idx = &ex_to_idx(self->op(2)); + const idx *self_idx = &ex_to(self->op(1)); + const idx *free_idx = &ex_to(self->op(2)); bool first_index_tried = false; int sign = 1; again: if (self_idx->is_symbolic()) { - for (int i=1; inops(); i++) { - const idx &other_idx = ex_to_idx(other->op(i)); + for (unsigned i=1; inops(); i++) { + const idx &other_idx = ex_to(other->op(i)); if (is_dummy_pair(*self_idx, other_idx)) { // Contraction found, remove metric tensor and substitute @@ -482,8 +470,8 @@ again: if (!first_index_tried) { // No contraction with first index found, try second index - self_idx = &ex_to_idx(self->op(2)); - free_idx = &ex_to_idx(self->op(1)); + self_idx = &ex_to(self->op(2)); + free_idx = &ex_to(self->op(1)); first_index_tried = true; sign = -sign; goto again; @@ -492,6 +480,36 @@ again: return false; } +/** Contraction of epsilon tensor with something else. */ +bool tensepsilon::contract_with(exvector::iterator self, exvector::iterator other, exvector & v) const +{ + GINAC_ASSERT(is_a(*self)); + GINAC_ASSERT(is_a(*other)); + GINAC_ASSERT(is_a(self->op(0))); + unsigned num = self->nops() - 1; + + if (is_ex_exactly_of_type(other->op(0), tensepsilon) && num+1 == other->nops()) { + + // Contraction of two epsilon tensors is a determinant + ex dim = ex_to(self->op(1)).get_dim(); + matrix M(num, num); + for (int i=0; iop(i+1), other->op(j+1), pos_sig); + else + M(i, j) = metric_tensor(self->op(i+1), other->op(j+1)); + } + } + int sign = minkowski ? -1 : 1; + *self = sign * M.determinant().simplify_indexed(); + *other = _ex1; + return true; + } + + return false; +} + ////////// // global functions ////////// @@ -501,7 +519,7 @@ ex delta_tensor(const ex & i1, const ex & i2) if (!is_ex_of_type(i1, idx) || !is_ex_of_type(i2, idx)) throw(std::invalid_argument("indices of delta tensor must be of type idx")); - return indexed(tensdelta(), indexed::symmetric, i1, i2); + return indexed(tensdelta(), sy_symm(), i1, i2); } ex metric_tensor(const ex & i1, const ex & i2) @@ -509,7 +527,7 @@ ex metric_tensor(const ex & i1, const ex & i2) if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx)) throw(std::invalid_argument("indices of metric tensor must be of type varidx")); - return indexed(tensmetric(), indexed::symmetric, i1, i2); + return indexed(tensmetric(), sy_symm(), i1, i2); } ex lorentz_g(const ex & i1, const ex & i2, bool pos_sig) @@ -517,17 +535,17 @@ ex lorentz_g(const ex & i1, const ex & i2, bool pos_sig) if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx)) throw(std::invalid_argument("indices of metric tensor must be of type varidx")); - return indexed(minkmetric(pos_sig), indexed::symmetric, i1, i2); + return indexed(minkmetric(pos_sig), sy_symm(), i1, i2); } ex spinor_metric(const ex & i1, const ex & i2) { if (!is_ex_of_type(i1, spinidx) || !is_ex_of_type(i2, spinidx)) throw(std::invalid_argument("indices of spinor metric must be of type spinidx")); - if (!ex_to_idx(i1).get_dim().is_equal(2) || !ex_to_idx(i2).get_dim().is_equal(2)) + if (!ex_to(i1).get_dim().is_equal(2) || !ex_to(i2).get_dim().is_equal(2)) throw(std::runtime_error("index dimension for spinor metric must be 2")); - return indexed(spinmetric(), indexed::antisymmetric, i1, i2); + return indexed(spinmetric(), sy_anti(), i1, i2); } ex epsilon_tensor(const ex & i1, const ex & i2) @@ -535,13 +553,13 @@ ex epsilon_tensor(const ex & i1, const ex & i2) if (!is_ex_of_type(i1, idx) || !is_ex_of_type(i2, idx)) throw(std::invalid_argument("indices of epsilon tensor must be of type idx")); - ex dim = ex_to_idx(i1).get_dim(); - if (!dim.is_equal(ex_to_idx(i2).get_dim())) + ex dim = ex_to(i1).get_dim(); + if (!dim.is_equal(ex_to(i2).get_dim())) throw(std::invalid_argument("all indices of epsilon tensor must have the same dimension")); - if (!ex_to_idx(i1).get_dim().is_equal(_ex2())) + if (!ex_to(i1).get_dim().is_equal(_ex2)) throw(std::runtime_error("index dimension of epsilon tensor must match number of indices")); - return indexed(tensepsilon(), indexed::antisymmetric, i1, i2); + return indexed(tensepsilon(), sy_anti(), i1, i2); } ex epsilon_tensor(const ex & i1, const ex & i2, const ex & i3) @@ -549,13 +567,13 @@ ex epsilon_tensor(const ex & i1, const ex & i2, const ex & i3) if (!is_ex_of_type(i1, idx) || !is_ex_of_type(i2, idx) || !is_ex_of_type(i3, idx)) throw(std::invalid_argument("indices of epsilon tensor must be of type idx")); - ex dim = ex_to_idx(i1).get_dim(); - if (!dim.is_equal(ex_to_idx(i2).get_dim()) || !dim.is_equal(ex_to_idx(i3).get_dim())) + ex dim = ex_to(i1).get_dim(); + if (!dim.is_equal(ex_to(i2).get_dim()) || !dim.is_equal(ex_to(i3).get_dim())) throw(std::invalid_argument("all indices of epsilon tensor must have the same dimension")); - if (!ex_to_idx(i1).get_dim().is_equal(_ex3())) + if (!ex_to(i1).get_dim().is_equal(_ex3)) throw(std::runtime_error("index dimension of epsilon tensor must match number of indices")); - return indexed(tensepsilon(), indexed::antisymmetric, i1, i2, i3); + return indexed(tensepsilon(), sy_anti(), i1, i2, i3); } ex lorentz_eps(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool pos_sig) @@ -563,25 +581,13 @@ ex lorentz_eps(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx) || !is_ex_of_type(i3, varidx) || !is_ex_of_type(i4, varidx)) throw(std::invalid_argument("indices of Lorentz epsilon tensor must be of type varidx")); - ex dim = ex_to_idx(i1).get_dim(); - if (!dim.is_equal(ex_to_idx(i2).get_dim()) || !dim.is_equal(ex_to_idx(i3).get_dim()) || !dim.is_equal(ex_to_idx(i4).get_dim())) + ex dim = ex_to(i1).get_dim(); + if (!dim.is_equal(ex_to(i2).get_dim()) || !dim.is_equal(ex_to(i3).get_dim()) || !dim.is_equal(ex_to(i4).get_dim())) throw(std::invalid_argument("all indices of epsilon tensor must have the same dimension")); - if (!ex_to_idx(i1).get_dim().is_equal(_ex4())) + if (!ex_to(i1).get_dim().is_equal(_ex4)) throw(std::runtime_error("index dimension of epsilon tensor must match number of indices")); - return indexed(tensepsilon(true, pos_sig), indexed::antisymmetric, i1, i2, i3, i4); -} - -ex eps0123(const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool pos_sig) -{ - if (!is_ex_of_type(i1, varidx) || !is_ex_of_type(i2, varidx) || !is_ex_of_type(i3, varidx) || !is_ex_of_type(i4, varidx)) - throw(std::invalid_argument("indices of epsilon tensor must be of type varidx")); - - ex dim = ex_to_idx(i1).get_dim(); - if (dim.is_equal(4)) - return lorentz_eps(i1, i2, i3, i4, pos_sig); - else - return indexed(tensepsilon(true, pos_sig), indexed::antisymmetric, i1, i2, i3, i4); + return indexed(tensepsilon(true, pos_sig), sy_anti(), i1, i2, i3, i4); } } // namespace GiNaC