diff --git a/math/matrix/inc/LinkDef.h b/math/matrix/inc/LinkDef.h
index 3fc07289cf2ce518bae3055c077b8aed2b7f727e..157399ca62a054018b0f6bf6cc9526049ff3aefe 100644
--- a/math/matrix/inc/LinkDef.h
+++ b/math/matrix/inc/LinkDef.h
@@ -44,7 +44,7 @@
#pragma link C++ class TMatrixTBase <float>-;
#pragma link C++ class TMatrixT <float>-;
#pragma link C++ class TMatrixTSym <float>-;
-#pragma link C++ class TMatrixTSparse <float>+;
+#pragma link C++ class TMatrixTSparse <float>-;
#pragma link C++ class TMatrixTLazy <float>+;
#pragma link C++ class TMatrixTSymLazy <float>+;
@@ -102,7 +102,7 @@
#pragma link C++ class TMatrixTBase <double>-;
#pragma link C++ class TMatrixT <double>-;
#pragma link C++ class TMatrixTSym <double>-;
-#pragma link C++ class TMatrixTSparse <double>+;
+#pragma link C++ class TMatrixTSparse <double>-;
#pragma link C++ class TMatrixTLazy <double>+;
#pragma link C++ class TMatrixTSymLazy <double>+;
@@ -175,7 +175,10 @@
#pragma link C++ function operator* (const TMatrixFSym &,const TVectorF &);
#pragma link C++ function operator* (const TMatrixFSparse &,const TVectorF &);
#pragma link C++ function operator* ( Float_t ,const TVectorF &);
-#pragma link C++ function Dot (const TVectorF &,const TVectorF &)
+#pragma link C++ function Dot (const TVectorF &,const TVectorF &);
+#pragma link C++ function OuterProduct (const TVectorF &,const TVectorF &);
+#pragma link C++ function OuterProduct ( TMatrixF &,const TVectorF &,const TVectorF &);
+#pragma link C++ function Mult (const TVectorF &,const TMatrixF &,const TVectorF &);
#pragma link C++ function Add ( TVectorF &, Float_t ,const TVectorF &);
#pragma link C++ function Add ( TVectorF &, Float_t ,const TMatrixF &,const TVectorF &);
#pragma link C++ function Add ( TVectorF &, Float_t ,const TMatrixFSym &,const TVectorF &);
@@ -192,6 +195,9 @@
#pragma link C++ function ElementDiv ( TVectorF &,const TVectorF &,const TVectorF &);
#pragma link C++ function AreCompatible (const TVectorF &,const TVectorF &, Int_t);
#pragma link C++ function AreCompatible (const TVectorF &,const TVectorD &, Int_t);
+#pragma link C++ function AreCompatible (const TMatrixF &,const TVectorF &, Int_t);
+#pragma link C++ function AreCompatible (const TVectorF &,const TMatrixF &, Int_t);
+
#pragma link C++ function Compare (const TVectorF &,const TVectorF &);
#pragma link C++ function VerifyVectorValue (const TVectorF &, Float_t , Int_t, Float_t);
#pragma link C++ function VerifyVectorIdentity(const TVectorF &,const TVectorF &, Int_t, Float_t);
@@ -303,7 +309,10 @@
#pragma link C++ function operator* (const TMatrixDSym &,const TVectorD &);
#pragma link C++ function operator* (const TMatrixDSparse &,const TVectorD &);
#pragma link C++ function operator* ( Double_t ,const TVectorD &);
-#pragma link C++ function Dot (const TVectorD &,const TVectorD &)
+#pragma link C++ function Dot (const TVectorD &,const TVectorD &);
+#pragma link C++ function OuterProduct (const TVectorD &,const TVectorD &);
+#pragma link C++ function OuterProduct ( TMatrixD &,const TVectorD &,const TVectorD &);
+#pragma link C++ function Mult (const TVectorD &,const TMatrixD &,const TVectorD &);
#pragma link C++ function Add ( TVectorD &, Double_t ,const TVectorD &);
#pragma link C++ function Add ( TVectorD &, Double_t ,const TMatrixD &,const TVectorD &);
#pragma link C++ function Add ( TVectorD &, Double_t ,const TMatrixDSym &,const TVectorD &);
@@ -320,6 +329,8 @@
#pragma link C++ function ElementDiv ( TVectorD &,const TVectorD &,const TVectorD &);
#pragma link C++ function AreCompatible (const TVectorD &,const TVectorD &, Int_t);
#pragma link C++ function AreCompatible (const TVectorD &,const TVectorF &, Int_t);
+#pragma link C++ function AreCompatible (const TMatrixD &,const TVectorD &, Int_t);
+#pragma link C++ function AreCompatible (const TVectorD &,const TMatrixD &, Int_t);
#pragma link C++ function Compare (const TVectorD &,const TVectorD &);
#pragma link C++ function VerifyVectorValue (const TVectorD &, Double_t , Int_t, Double_t);
#pragma link C++ function VerifyVectorIdentity(const TVectorD &,const TVectorD &, Int_t, Double_t);
diff --git a/math/matrix/inc/TVectorT.h b/math/matrix/inc/TVectorT.h
index f339d45968fd0f5930b1be2a93123b31a1519e7f..0cf08addd13242f37e02fcfbd1bf275a860e40a2 100644
--- a/math/matrix/inc/TVectorT.h
+++ b/math/matrix/inc/TVectorT.h
@@ -204,7 +204,7 @@ template<class Element> inline TVectorT<Element> TVectorT<Element>::GetSu
return tmp;
}
-template<class Element> inline const Element &TVectorT<Element>::operator()(Int_t ind) const
+template<class Element> inline const Element &TVectorT<Element>::operator()(Int_t ind) const
{
// Access a vector element.
@@ -217,7 +217,7 @@ template<class Element> inline const Element &TVectorT<Element>::opera
return fElements[aind];
}
-template<class Element> inline Element &TVectorT<Element>::operator()(Int_t ind)
+template<class Element> inline Element &TVectorT<Element>::operator()(Int_t ind)
{
// Access a vector element.
@@ -230,53 +230,59 @@ template<class Element> inline Element &TVectorT<Element>::operator()(
return fElements[aind];
}
-template<class Element1,class Element2>
- Bool_t AreCompatible(const TVectorT <Element1> &source1,const TVectorT <Element2> &source2, Int_t verbose=0);
-template<class Element> Bool_t operator== (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
-template<class Element> TVectorT<Element> operator+ (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
-template<class Element> TVectorT<Element> operator- (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
-template<class Element> Element operator* (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
-template<class Element> TVectorT<Element> operator* (const TMatrixT <Element> &a, const TVectorT <Element> &source);
-template<class Element> TVectorT<Element> operator* (const TMatrixTSym <Element> &a, const TVectorT <Element> &source);
-template<class Element> TVectorT<Element> operator* (const TMatrixTSparse<Element> &a, const TVectorT <Element> &source);
-template<class Element> TVectorT<Element> operator* ( Element val, const TVectorT <Element> &source);
-template<class Element> Element Dot (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
-template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TVectorT<Element> &source);
-template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element , const TMatrixT <Element> &a,
+
+template<class Element> Bool_t operator== (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
+template<class Element> TVectorT<Element> operator+ (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
+template<class Element> TVectorT<Element> operator- (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
+template<class Element> Element operator* (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
+template<class Element> TVectorT<Element> operator* (const TMatrixT <Element> &a, const TVectorT <Element> &source);
+template<class Element> TVectorT<Element> operator* (const TMatrixTSym <Element> &a, const TVectorT <Element> &source);
+template<class Element> TVectorT<Element> operator* (const TMatrixTSparse<Element> &a, const TVectorT <Element> &source);
+template<class Element> TVectorT<Element> operator* ( Element val, const TVectorT <Element> &source);
+
+template<class Element> Element Dot (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
+template <class Element1,class Element2>
+ TMatrixT<Element1> OuterProduct(const TVectorT <Element1> &v1, const TVectorT <Element2> &v2);
+template <class Element1,class Element2,class Element3>
+ TMatrixT<Element1> &OuterProduct( TMatrixT <Element1> &target, const TVectorT <Element2> &v1, const TVectorT <Element3> &v2);
+template <class Element1,class Element2,class Element3>
+ Element1 Mult (const TVectorT <Element1> &v1, const TMatrixT <Element2> &m, const TVectorT <Element3> &v2);
+
+template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source);
+template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixT <Element> &a,
const TVectorT<Element> &source);
-template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element , const TMatrixTSym <Element> &a,
+template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixTSym <Element> &a,
const TVectorT<Element> &source);
-template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element , const TMatrixTSparse<Element> &a,
+template<class Element> TVectorT<Element> &Add ( TVectorT <Element> &target, Element scalar, const TMatrixTSparse<Element> &a,
const TVectorT<Element> &source);
-template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT<Element> &source1,
+template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
const TVectorT <Element> &source2);
-template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT<Element> &source1,
- const TVectorT <Element> &source2,const TVectorT <Element> &select);
-template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT<Element> &source1,
+template<class Element> TVectorT<Element> &AddElemMult ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
+ const TVectorT <Element> &source2,const TVectorT <Element> &select);
+template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
const TVectorT <Element> &source2);
-template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT<Element> &source1,
- const TVectorT <Element> &source2,const TVectorT <Element> &select);
-template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source);
-template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT<Element> &select);
-template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source);
-template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT<Element> &select);
-template<class Element> void Compare (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
-template<class Element> Bool_t VerifyVectorValue
- (const TVectorT <Element> &m, Element val, Int_t verbose,
- Element maxDevAllow);
-template<class Element> Bool_t VerifyVectorValue
- (const TVectorT <Element> &m, Element val, Int_t verbose)
- { return VerifyVectorValue(m,val,verbose,Element(0.0)); }
-template<class Element> Bool_t VerifyVectorValue
- (const TVectorT <Element> &m, Element val)
- { return VerifyVectorValue(m,val,1,Element(0.0)); }
-template<class Element> Bool_t VerifyVectorIdentity
- (const TVectorT <Element> &m1, const TVectorT <Element> &m2, Int_t verbose,
- Element maxDevAllow);
-template<class Element> Bool_t VerifyVectorIdentity
- (const TVectorT <Element> &m1, const TVectorT <Element> &m2, Int_t verbose)
- { return VerifyVectorIdentity(m1,m2,verbose,Element(0.0)); }
-template<class Element> Bool_t VerifyVectorIdentity
- (const TVectorT <Element> &m1, const TVectorT <Element> &m2)
- { return VerifyVectorIdentity(m1,m2,1,Element(0.0)); }
+template<class Element> TVectorT<Element> &AddElemDiv ( TVectorT <Element> &target, Element scalar, const TVectorT <Element> &source1,
+ const TVectorT <Element> &source2,const TVectorT <Element> &select);
+template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source);
+template<class Element> TVectorT<Element> &ElementMult ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT <Element> &select);
+template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source);
+template<class Element> TVectorT<Element> &ElementDiv ( TVectorT <Element> &target, const TVectorT <Element> &source, const TVectorT <Element> &select);
+
+template<class Element1,class Element2> Bool_t AreCompatible(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2,Int_t verbose=0);
+// Check matrix and vector for compatibility in multiply: M * v and v * M
+template<class Element1,class Element2> Bool_t AreCompatible(const TMatrixT<Element1> &m, const TVectorT<Element2> &v, Int_t verbose=0);
+template<class Element1,class Element2> Bool_t AreCompatible(const TVectorT<Element1> &v, const TMatrixT<Element2> &m, Int_t verbose=0);
+
+template<class Element> void Compare (const TVectorT <Element> &source1,const TVectorT <Element> &source2);
+template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val,Int_t verbose, Element maxDevAllow);
+template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val,Int_t verbose)
+ { return VerifyVectorValue(m,val,verbose,Element(0.0)); }
+template<class Element> Bool_t VerifyVectorValue (const TVectorT <Element> &m, Element val)
+ { return VerifyVectorValue(m,val,1,Element(0.0)); }
+template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2, Int_t verbose, Element maxDevAllow);
+template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2, Int_t verbose)
+ { return VerifyVectorIdentity(m1,m2,verbose,Element(0.0)); }
+template<class Element> Bool_t VerifyVectorIdentity (const TVectorT <Element> &m1,const TVectorT <Element> &m2)
+ { return VerifyVectorIdentity(m1,m2,1,Element(0.0)); }
+
#endif
diff --git a/math/matrix/src/TMatrixTSparse.cxx b/math/matrix/src/TMatrixTSparse.cxx
index e15b41ba7d664fee8960db93c7e66ac0cd72a36c..612e24e252ced172cedac0d6e6187bff33092aa5 100644
--- a/math/matrix/src/TMatrixTSparse.cxx
+++ b/math/matrix/src/TMatrixTSparse.cxx
@@ -2737,6 +2737,24 @@ Bool_t AreCompatible(const TMatrixTSparse<Element> &m1,const TMatrixTSparse<Elem
return kTRUE;
}
+//______________________________________________________________________________
+template<class Element>
+void TMatrixTSparse<Element>::Streamer(TBuffer &R__b)
+{
+// Stream an object of class TMatrixTSparse.
+
+ if (R__b.IsReading()) {
+ UInt_t R__s, R__c;
+ Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
+ Clear();
+ R__b.ReadClassBuffer(TMatrixTSparse<Element>::Class(),this,R__v,R__s,R__c);
+ if (this->fNelems < 0)
+ this->Invalidate();
+ } else {
+ R__b.WriteClassBuffer(TMatrixTSparse<Element>::Class(),this);
+ }
+}
+
template class TMatrixTSparse<Float_t>;
#ifndef ROOT_TMatrixFSparsefwd
diff --git a/math/matrix/src/TVectorT.cxx b/math/matrix/src/TVectorT.cxx
index afea92caea06840aa1fa073253584102e522e324..e4c77dde9bc614ca8e5c502a12faa92341e977ff 100644
--- a/math/matrix/src/TVectorT.cxx
+++ b/math/matrix/src/TVectorT.cxx
@@ -1484,6 +1484,99 @@ Element Dot(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
return sum;
}
+//______________________________________________________________________________
+template <class Element1, class Element2>
+TMatrixT<Element1>
+OuterProduct(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2)
+{
+ // Return the matrix M = v1 * v2'
+
+ // TMatrixD::GetSub does:
+ // TMatrixT tmp;
+ // Doesn't compile here, because we are outside the class?
+ // So we'll be explicit:
+ TMatrixT<Element1> target;
+
+ return OuterProduct(target,v1,v2);
+}
+
+//______________________________________________________________________________
+template <class Element1,class Element2,class Element3>
+TMatrixT<Element1>
+&OuterProduct(TMatrixT<Element1> &target,const TVectorT<Element2> &v1,const TVectorT<Element3> &v2)
+{
+ // Return the matrix M = v1 * v2'
+
+ target.ResizeTo(v1.GetLwb(), v1.GetUpb(), v2.GetLwb(), v2.GetUpb());
+
+ Element1 * mp = target.GetMatrixArray();
+ const Element1 * const m_last = mp + target.GetNoElements();
+
+ const Element2 * v1p = v1.GetMatrixArray();
+ const Element2 * const v1_last = v1p + v1.GetNrows();
+
+ const Element3 * const v20 = v2.GetMatrixArray();
+ const Element3 * v2p = v20;
+ const Element3 * const v2_last = v2p + v2.GetNrows();
+
+ while (v1p < v1_last) {
+ v2p = v20;
+ while (v2p < v2_last) {
+ *mp++ = *v1p * *v2p++ ;
+ }
+ v1p++;
+ }
+
+ R__ASSERT(v1p == v1_last && mp == m_last && v2p == v2_last);
+
+ return target;
+}
+
+//______________________________________________________________________________
+template <class Element1, class Element2, class Element3>
+Element1 Mult(const TVectorT<Element1> &v1,const TMatrixT<Element2> &m,
+ const TVectorT<Element3> &v2)
+{
+ // Perform v1 * M * v2, a scalar result
+
+ if (gMatrixCheck) {
+ if (!AreCompatible(v1, m)) {
+ ::Error("Mult", "Vector v1 and matrix m incompatible");
+ return 0;
+ }
+ if (!AreCompatible(m, v2)) {
+ ::Error("Mult", "Matrix m and vector v2 incompatible");
+ return 0;
+ }
+ }
+
+ const Element1 * v1p = v1.GetMatrixArray(); // first of v1
+ const Element1 * const v1_last = v1p + v1.GetNrows(); // last of v1
+
+ const Element2 * mp = m.GetMatrixArray(); // first of m
+ const Element2 * const m_last = mp + m.GetNoElements(); // last of m
+
+ const Element3 * const v20 = v2.GetMatrixArray(); // first of v2
+ const Element3 * v2p = v20; // running v2
+ const Element3 * const v2_last = v2p + v2.GetNrows(); // last of v2
+
+ Element1 sum = 0; // scalar result accumulator
+ Element3 dot = 0; // M_row * v2 dot product accumulator
+
+ while (v1p < v1_last) {
+ v2p = v20; // at beginning of v2
+ while (v2p < v2_last) { // compute (M[i] * v2) dot product
+ dot += *mp++ * *v2p++;
+ }
+ sum += *v1p++ * dot; // v1[i] * (M[i] * v2)
+ dot = 0; // start next dot product
+ }
+
+ R__ASSERT(v1p == v1_last && mp == m_last && v2p == v2_last);
+
+ return sum;
+}
+
//______________________________________________________________________________
template<class Element>
TVectorT<Element> &Add(TVectorT<Element> &target,Element scalar,const TVectorT<Element> &source)
@@ -2054,6 +2147,58 @@ Bool_t AreCompatible(const TVectorT<Element1> &v1,const TVectorT<Element2> &v2,I
return kTRUE;
}
+//______________________________________________________________________________
+template<class Element1, class Element2>
+Bool_t AreCompatible(const TMatrixT<Element1> &m,const TVectorT<Element2> &v,Int_t verbose=0)
+{
+ // Check if m and v are both valid and have compatible shapes for M * v
+
+ if (!m.IsValid()) {
+ if (verbose)
+ ::Error("AreCompatible", "Matrix not valid");
+ return kFALSE;
+ }
+ if (!v.IsValid()) {
+ if (verbose)
+ ::Error("AreCompatible", "vector not valid");
+ return kFALSE;
+ }
+
+ if (m.GetNcols() != v.GetNrows() ) {
+ if (verbose)
+ ::Error("AreCompatible", "matrix and vector not compatible");
+ return kFALSE;
+ }
+
+ return kTRUE;
+}
+
+//______________________________________________________________________________
+template<class Element1, class Element2>
+Bool_t AreCompatible(const TVectorT<Element1> &v,const TMatrixT<Element2> &m,Int_t verbose=0)
+{
+ // Check if m and v are both valid and have compatible shapes for v * M
+
+ if (!m.IsValid()) {
+ if (verbose)
+ ::Error("AreCompatible", "Matrix not valid");
+ return kFALSE;
+ }
+ if (!v.IsValid()) {
+ if (verbose)
+ ::Error("AreCompatible", "vector not valid");
+ return kFALSE;
+ }
+
+ if (v.GetNrows() != m.GetNrows() ) {
+ if (verbose)
+ ::Error("AreCompatible", "vector and matrix not compatible");
+ return kFALSE;
+ }
+
+ return kTRUE;
+}
+
//______________________________________________________________________________
template<class Element>
void Compare(const TVectorT<Element> &v1,const TVectorT<Element> &v2)
@@ -2233,35 +2378,43 @@ template TVectorF operator* <Float_t>(const TMatrixF &a, c
template TVectorF operator* <Float_t>(const TMatrixFSym &a, const TVectorF &source);
template TVectorF operator* <Float_t>(const TMatrixFSparse &a, const TVectorF &source);
template TVectorF operator* <Float_t>( Float_t val, const TVectorF &source);
+
template Float_t Dot <Float_t>(const TVectorF &v1, const TVectorF &v2);
-template TVectorF &Add <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source);
+template TMatrixF OuterProduct <Float_t,Float_t>
+ (const TVectorF &v1, const TVectorF &v2);
+template TMatrixF &OuterProduct <Float_t,Float_t,Float_t>
+ ( TMatrixF &target, const TVectorF &v1, const TVectorF &v2);
+template Float_t Mult <Float_t,Float_t,Float_t>
+ (const TVectorF &v1, const TMatrixF &m, const TVectorF &v2);
+
+template TVectorF &Add <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source);
template TVectorF &Add <Float_t>( TVectorF &target, Float_t scalar, const TMatrixF &a,
const TVectorF &source);
template TVectorF &Add <Float_t>( TVectorF &target, Float_t scalar, const TMatrixFSym &a,
const TVectorF &source);
template TVectorF &Add <Float_t>( TVectorF &target, Float_t scalar, const TMatrixFSparse &a,
const TVectorF &source);
-template TVectorF &AddElemMult <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
+template TVectorF &AddElemMult <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
const TVectorF &source2);
-template TVectorF &AddElemMult <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
- const TVectorF &source2,const TVectorF &select);
-template TVectorF &AddElemDiv <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
+template TVectorF &AddElemMult <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
+ const TVectorF &source2,const TVectorF &select);
+template TVectorF &AddElemDiv <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
const TVectorF &source2);
-template TVectorF &AddElemDiv <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
- const TVectorF &source2,const TVectorF &select);
+template TVectorF &AddElemDiv <Float_t>( TVectorF &target, Float_t scalar, const TVectorF &source1,
+ const TVectorF &source2,const TVectorF &select);
template TVectorF &ElementMult <Float_t>( TVectorF &target, const TVectorF &source);
-template TVectorF &ElementMult <Float_t>( TVectorF &target, const TVectorF &source, const TVectorF &select);
+template TVectorF &ElementMult <Float_t>( TVectorF &target, const TVectorF &source, const TVectorF &select);
template TVectorF &ElementDiv <Float_t>( TVectorF &target, const TVectorF &source);
-template TVectorF &ElementDiv <Float_t>( TVectorF &target, const TVectorF &source, const TVectorF &select);
-template Bool_t AreCompatible <Float_t,Float_t>
- (const TVectorF &source1,const TVectorF &source2, Int_t verbose);
-template Bool_t AreCompatible <Float_t,Double_t>
- (const TVectorF &source1,const TVectorD &source2, Int_t verbose);
-template void Compare <Float_t>(const TVectorF &source1,const TVectorF &source2);
-template Bool_t VerifyVectorValue <Float_t>(const TVectorF &m, Float_t val, Int_t verbose,
- Float_t maxDevAllow);
-template Bool_t VerifyVectorIdentity<Float_t>(const TVectorF &m1, const TVectorF &m2, Int_t verbose,
- Float_t maxDevAllow);
+template TVectorF &ElementDiv <Float_t>( TVectorF &target, const TVectorF &source, const TVectorF &select);
+
+template Bool_t AreCompatible <Float_t,Float_t> (const TVectorF &v1,const TVectorF &v2,Int_t verbose);
+template Bool_t AreCompatible <Float_t,Double_t>(const TVectorF &v1,const TVectorD &v2,Int_t verbose);
+template Bool_t AreCompatible <Float_t,Float_t> (const TMatrixF &m, const TVectorF &v, Int_t verbose=0);
+template Bool_t AreCompatible <Float_t,Float_t> (const TVectorF &v, const TMatrixF &m, Int_t verbose=0);
+
+template void Compare <Float_t> (const TVectorF &v1,const TVectorF &v2);
+template Bool_t VerifyVectorValue <Float_t> (const TVectorF &m, Float_t val,Int_t verbose,Float_t maxDevAllow);
+template Bool_t VerifyVectorIdentity<Float_t> (const TVectorF &m1,const TVectorF &m2, Int_t verbose,Float_t maxDevAllow);
#ifndef ROOT_TMatrixDfwd
#include "TMatrixDfwd.h"
@@ -2283,32 +2436,40 @@ template TVectorD operator* <Double_t>(const TMatrixD &a,
template TVectorD operator* <Double_t>(const TMatrixDSym &a, const TVectorD &source);
template TVectorD operator* <Double_t>(const TMatrixDSparse &a, const TVectorD &source);
template TVectorD operator* <Double_t>( Double_t val, const TVectorD &source);
+
template Double_t Dot <Double_t>(const TVectorD &v1, const TVectorD &v2);
-template TVectorD &Add <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source);
+template TMatrixD OuterProduct <Double_t,Double_t>
+ (const TVectorD &v1, const TVectorD &v2);
+template TMatrixD &OuterProduct <Double_t,Double_t,Double_t>
+ ( TMatrixD &target, const TVectorD &v1, const TVectorD &v2);
+template Double_t Mult <Double_t,Double_t,Double_t>
+ (const TVectorD &v1, const TMatrixD &m, const TVectorD &v2);
+
+template TVectorD &Add <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source);
template TVectorD &Add <Double_t>( TVectorD &target, Double_t scalar, const TMatrixD &a,
const TVectorD &source);
template TVectorD &Add <Double_t>( TVectorD &target, Double_t scalar, const TMatrixDSym &a
, const TVectorD &source);
template TVectorD &Add <Double_t>( TVectorD &target, Double_t scalar, const TMatrixDSparse &a
, const TVectorD &source);
-template TVectorD &AddElemMult <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
+template TVectorD &AddElemMult <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
const TVectorD &source2);
-template TVectorD &AddElemMult <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
- const TVectorD &source2,const TVectorD &select);
-template TVectorD &AddElemDiv <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
+template TVectorD &AddElemMult <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
+ const TVectorD &source2,const TVectorD &select);
+template TVectorD &AddElemDiv <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
const TVectorD &source2);
-template TVectorD &AddElemDiv <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
- const TVectorD &source2,const TVectorD &select);
+template TVectorD &AddElemDiv <Double_t>( TVectorD &target, Double_t scalar, const TVectorD &source1,
+ const TVectorD &source2,const TVectorD &select);
template TVectorD &ElementMult <Double_t>( TVectorD &target, const TVectorD &source);
-template TVectorD &ElementMult <Double_t>( TVectorD &target, const TVectorD &source, const TVectorD &select);
+template TVectorD &ElementMult <Double_t>( TVectorD &target, const TVectorD &source, const TVectorD &select);
template TVectorD &ElementDiv <Double_t>( TVectorD &target, const TVectorD &source);
-template TVectorD &ElementDiv <Double_t>( TVectorD &target, const TVectorD &source, const TVectorD &select);
-template Bool_t AreCompatible<Double_t,Double_t>
- (const TVectorD &source1,const TVectorD &source2, Int_t verbose);
-template Bool_t AreCompatible<Double_t,Float_t>
- (const TVectorD &source1,const TVectorF &source2, Int_t verbose);
-template void Compare <Double_t>(const TVectorD &source1,const TVectorD &source2);
-template Bool_t VerifyVectorValue <Double_t>(const TVectorD &m, Double_t val, Int_t verbose,
- Double_t maxDevAllow);
-template Bool_t VerifyVectorIdentity<Double_t>(const TVectorD &m1, const TVectorD &m2, Int_t verbose,
- Double_t maxDevAllow);
+template TVectorD &ElementDiv <Double_t>( TVectorD &target, const TVectorD &source, const TVectorD &select);
+
+template Bool_t AreCompatible <Double_t,Double_t>(const TVectorD &v1,const TVectorD &v2,Int_t verbose);
+template Bool_t AreCompatible <Double_t,Float_t> (const TVectorD &v1,const TVectorF &v2,Int_t verbose);
+template Bool_t AreCompatible <Double_t,Double_t>(const TMatrixD &m, const TVectorD &v, Int_t verbose=0);
+template Bool_t AreCompatible <Double_t,Double_t>(const TVectorD &v, const TMatrixD &m, Int_t verbose=0);
+
+template void Compare <Double_t> (const TVectorD &v1,const TVectorD &v2);
+template Bool_t VerifyVectorValue <Double_t> (const TVectorD &m, Double_t val,Int_t verbose,Double_t maxDevAllow);
+template Bool_t VerifyVectorIdentity<Double_t> (const TVectorD &m1,const TVectorD &m2, Int_t verbose,Double_t maxDevAllow);