X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?a=blobdiff_plain;f=ginac%2Fclifford.h;h=2d33631d0cad07930152550caf55515c8aae7fc9;hb=8405f067a0f0a0e17c7f42057ddc4bce76b10deb;hp=c9b17a94439cd934f129b9d5c89a56871ac61a0d;hpb=da64e515abf7243bc4c84ca3631470931c4e6691;p=ginac.git

diff --git a/ginac/clifford.h b/ginac/clifford.h
index c9b17a94..2d33631d 100644
--- a/ginac/clifford.h
+++ b/ginac/clifford.h
@@ -3,7 +3,7 @@
  *  Interface to GiNaC's clifford algebra (Dirac gamma) objects. */
 
 /*
- *  GiNaC Copyright (C) 1999-2005 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2006 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
@@ -41,15 +41,17 @@ namespace GiNaC {
 class clifford : public indexed
 {
 	GINAC_DECLARE_REGISTERED_CLASS(clifford, indexed)
+public:
+	static const tinfo_static_t return_type_tinfo_static[256];
 
 	// other constructors
 public:
-	clifford(const ex & b, unsigned char rl = 0);
-	clifford(const ex & b, const ex & mu,  const ex & metr, unsigned char rl = 0);
+	clifford(const ex & b, unsigned char rl = 0, bool anticommut = false);
+	clifford(const ex & b, const ex & mu,  const ex & metr, unsigned char rl = 0, bool anticommut = false, int comm_sign = -1);
 
 	// internal constructors
-	clifford(unsigned char rl, const ex & metr, const exvector & v, bool discardable = false);
-	clifford(unsigned char rl, const ex & metr, std::auto_ptr<exvector> vp);
+	clifford(unsigned char rl, const ex & metr, bool anticommut, int comm_sign, const exvector & v, bool discardable = false);
+	clifford(unsigned char rl, const ex & metr, bool anticommut, int comm_sign, std::auto_ptr<exvector> vp);
 
 	// functions overriding virtual functions from base classes
 public:
@@ -60,26 +62,34 @@ protected:
 	ex thiscontainer(const exvector & v) const;
 	ex thiscontainer(std::auto_ptr<exvector> vp) const;
 	unsigned return_type() const { return return_types::noncommutative; }
-	unsigned return_type_tinfo() const { return TINFO_clifford + representation_label; }
+	tinfo_t return_type_tinfo() const { return clifford::return_type_tinfo_static+representation_label; }
 
 	// non-virtual functions in this class
 public:
 	unsigned char get_representation_label() const { return representation_label; }
 	ex get_metric() const { return metric; }
-	ex get_metric(const ex & i, const ex & j) const;
+	virtual ex get_metric(const ex & i, const ex & j, bool symmetrised = false) const;
 	bool same_metric(const ex & other) const;
+	bool is_anticommuting() const { return anticommuting; } //**< See the member variable anticommuting */
+	int get_commutator_sign() const { return commutator_sign; } //**< See the member variable commutator_sign */
+
+	inline size_t nops() const {return inherited::nops() + 1; }
+	ex op(size_t i) const;
+	ex & let_op(size_t i);
+	ex subs(const exmap & m, unsigned options = 0) const;
 
 protected:
 	void do_print_dflt(const print_dflt & c, unsigned level) const;
 	void do_print_latex(const print_latex & c, unsigned level) const;
 
 	// member variables
-private:
+protected:
 	unsigned char representation_label; /**< Representation label to distinguish independent spin lines */
-	ex metric;
+	ex metric; /**< Metric of the space, all constructors make it an indexed object */
+	bool anticommuting; /**< Simplifications for anticommuting units is much simpler and we need this info readily available */
+	int commutator_sign; /**< It is the sign in the definition e~i e~j +/- e~j e~i = B(i, j) + B(j, i)*/
 };
 
-
 /** This class represents the Clifford algebra unity element. */
 class diracone : public tensor
 {
@@ -99,7 +109,7 @@ class cliffordunit : public tensor
 
 	// other constructors
 protected:
-	cliffordunit(unsigned ti) : inherited(ti) {}
+	cliffordunit(tinfo_t ti) : inherited(ti) {}
                                                                                                     
 	// functions overriding virtual functions from base classes
 public:
@@ -178,11 +188,11 @@ protected:
 
 // global functions
 
-/** Specialization of is_exactly_a<clifford>(obj) for clifford objects. */
-template<> inline bool is_exactly_a<clifford>(const basic & obj)
-{
-	return obj.tinfo()==TINFO_clifford;
-}
+/** Check whether a given tinfo key (as returned by return_type_tinfo()
+  * is that of a clifford object (with an arbitrary representation label).
+  *
+  * @param ti tinfo key */
+bool is_clifford_tinfo(tinfo_t ti);
 
 /** Create a Clifford unity object.
  *
@@ -193,10 +203,10 @@ ex dirac_ONE(unsigned char rl = 0);
 /** Create a Clifford unit object.
  *
  *  @param mu Index (must be of class varidx or a derived class)
- *  @param metr Metric (should be of class tensmetric or a derived class, or a matrix)
+ *  @param metr Metric (should be indexed, tensmetric or a derived class, or a matrix)
  *  @param rl Representation label
  *  @return newly constructed Clifford unit object */
-ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl = 0);
+ex clifford_unit(const ex & mu, const ex & metr, unsigned char rl = 0, bool anticommuting = false);
 
 /** Create a Dirac gamma object.
  *
@@ -280,10 +290,18 @@ inline ex clifford_star(const ex & e) { return e.conjugate(); }
 /** Replaces dirac_ONE's (with a representation_label no less than rl) in e with 1.
  *  For the default value rl = 0 remove all of them. Aborts if e contains any 
  *  clifford_unit with representation_label to be removed.
- *  
+ *
+ *  @param e Expression to be processed
+ *  @param rl Value of representation label 
+ *  @param options Defines some internal use */
+ex remove_dirac_ONE(const ex & e, unsigned char rl = 0, unsigned options = 0);
+
+/** Returns the maximal representation label of a clifford object 
+ *  if e contains at least one, otherwise returns -1 
+ *
  *  @param e Expression to be processed
- *  @param rl Value of representation label */
-ex remove_dirac_ONE(const ex & e, unsigned char rl = 0);
+ *  @ignore_ONE defines if clifford_ONE should be ignored in the search*/
+char clifford_max_label(const ex & e, bool ignore_ONE = false);
 
 /** Calculation of the norm in the Clifford algebra. */
 ex clifford_norm(const ex & e);
@@ -295,11 +313,11 @@ ex clifford_inverse(const ex & e);
  *
  *  @param v List or vector of coordinates
  *  @param mu Index (must be of class varidx or a derived class)
- *  @param metr Metric (should be of class tensmetric or a derived class, or a matrix)
+ *  @param metr Metric (should be indexed, tensmetric or a derived class, or a matrix)
  *  @param rl Representation label
  *  @param e Clifford unit object
  *  @return Clifford vector with given components */
-ex lst_to_clifford(const ex & v, const ex & mu,  const ex & metr, unsigned char rl = 0);
+ex lst_to_clifford(const ex & v, const ex & mu,  const ex & metr, unsigned char rl = 0, bool anticommuting = false);
 ex lst_to_clifford(const ex & v, const ex & e);
 
 /** An inverse function to lst_to_clifford(). For given Clifford vector extracts
@@ -327,8 +345,9 @@ lst clifford_to_lst(const ex & e, const ex & c, bool algebraic=true);
  *  @param v Vector to be transformed
  *  @param G Metric of the surrounding space, may be a Clifford unit then the next parameter is ignored
  *  @param rl Representation label 
+ *  @param anticommuting indicates if Clifford units anticommutes
  *  @return List of components of the transformed vector*/
-ex clifford_moebius_map(const ex & a, const ex & b, const ex & c, const ex & d, const ex & v, const ex & G, unsigned char rl = 0);
+ex clifford_moebius_map(const ex & a, const ex & b, const ex & c, const ex & d, const ex & v, const ex & G, unsigned char rl = 0, bool anticommuting = false);
 
 /** The second form of Moebius transformations defined by a 2x2 Clifford matrix M
  *  This function takes the transformation matrix M as a single entity.
@@ -337,8 +356,9 @@ ex clifford_moebius_map(const ex & a, const ex & b, const ex & c, const ex & d,
  *  @param v Vector to be transformed
  *  @param G Metric of the surrounding space, may be a Clifford unit then the next parameter is ignored
  *  @param rl Representation label 
+ *  @param anticommuting indicates if Clifford units anticommutes
  *  @return List of components of the transformed vector*/
-ex clifford_moebius_map(const ex & M, const ex & v, const ex & G, unsigned char rl = 0);
+ex clifford_moebius_map(const ex & M, const ex & v, const ex & G, unsigned char rl = 0, bool anticommuting = false);
 
 } // namespace GiNaC