Menu
▾
▴
[ZooLib-checkins] SF.net SVN: zoolib:[2602] trunk/zoolib/source/cxx
|
From: <ag...@us...> - 2011-10-31 20:26:48
|
Revision: 2602
http://zoolib.svn.sourceforge.net/zoolib/?rev=2602&view=rev
Author: agreen
Date: 2011-10-31 20:26:42 +0000 (Mon, 31 Oct 2011)
Log Message:
-----------
An annoying but neccessary change in the order of ZMatrix template parameters,
so that the template params and the storage array indices are in the same
order, making the code much less confusing.
Modified Paths:
--------------
trunk/zoolib/source/cxx/more/zoolib/gameengine/ZGameEngine_Geometry.h
trunk/zoolib/source/cxx/zoolib/ZMatrix.h
trunk/zoolib/source/cxx/zoolib/ZUtil_Strim_Matrix.h
Modified: trunk/zoolib/source/cxx/more/zoolib/gameengine/ZGameEngine_Geometry.h
===================================================================
--- trunk/zoolib/source/cxx/more/zoolib/gameengine/ZGameEngine_Geometry.h 2011-10-31 03:11:56 UTC (rev 2601)
+++ trunk/zoolib/source/cxx/more/zoolib/gameengine/ZGameEngine_Geometry.h 2011-10-31 20:26:42 UTC (rev 2602)
@@ -40,18 +40,18 @@
}
template <class Val>
-ZMatrix<Val,2,1> sCVec(Val i0, Val i1)
+ZMatrix<Val,1,2> sCVec(Val i0, Val i1)
{
- ZMatrix<Val,2,1> result;
+ ZMatrix<Val,1,2> result;
result.fE[0][0] = i0;
result.fE[0][1] = i1;
return result;
}
template <class Val>
-ZMatrix<Val,3,1> sCVec(Val i0, Val i1, Val i2)
+ZMatrix<Val,1,3> sCVec(Val i0, Val i1, Val i2)
{
- ZMatrix<Val,3,1> result;
+ ZMatrix<Val,1,3> result;
result.fE[0][0] = i0;
result.fE[0][1] = i1;
result.fE[0][2] = i2;
@@ -59,9 +59,9 @@
}
template <class Val>
-ZMatrix<Val,4,1> sCVec(Val i0, Val i1, Val i2, Val i3)
+ZMatrix<Val,1,4> sCVec(Val i0, Val i1, Val i2, Val i3)
{
- ZMatrix<Val,4,1> result;
+ ZMatrix<Val,1,4> result;
result.fE[0][0] = i0;
result.fE[0][1] = i1;
result.fE[0][2] = i2;
@@ -74,16 +74,16 @@
#pragma mark * CVec3 ctors
template <class Val>
-ZMatrix<Val,3,1> sCVec3(Val x, Val y, Val z)
+ZMatrix<Val,1,3> sCVec3(Val x, Val y, Val z)
{ return sCVec(x, y, z); }
template <class Val>
-ZMatrix<Val,3,1> sCVec3(Val iVal)
+ZMatrix<Val,1,3> sCVec3(Val iVal)
{ return sCVec3(iVal, iVal, iVal); }
template <class Val>
-ZMatrix<Val,3,1> sCVec3()
- { return ZMatrix<Val,3,1>(); }
+ZMatrix<Val,1,3> sCVec3()
+ { return ZMatrix<Val,1,3>(); }
// =================================================================================================
#pragma mark -
@@ -98,7 +98,7 @@
}
template <class Val>
-ZMatrix<Val,1,2> sRVec(Val i0, Val i1)
+ZMatrix<Val,2,1> sRVec(Val i0, Val i1)
{
ZMatrix<Val,1,2> result;
result.fE[0][0] = i0;
@@ -107,7 +107,7 @@
}
template <class Val>
-ZMatrix<Val,1,3> sRVec(Val i0, Val i1, Val i2)
+ZMatrix<Val,3,1> sRVec(Val i0, Val i1, Val i2)
{
ZMatrix<Val,1,3> result;
result.fE[0][0] = i0;
@@ -117,7 +117,7 @@
}
template <class Val>
-ZMatrix<Val,1,4> sRVec(Val i0, Val i1, Val i2, Val i3)
+ZMatrix<Val,4,1> sRVec(Val i0, Val i1, Val i2, Val i3)
{
ZMatrix<Val,1,4> result;
result.fE[0][0] = i0;
@@ -132,16 +132,16 @@
#pragma mark * RVec3 ctors
template <class Val>
-ZMatrix<Val,1,3> sRVec3(Val x, Val y, Val z)
+ZMatrix<Val,3,1> sRVec3(Val x, Val y, Val z)
{ return sRVec(x, y, z); }
template <class Val>
-ZMatrix<Val,1,3> sRVec3(Val iVal)
+ZMatrix<Val,3,1> sRVec3(Val iVal)
{ return sRVec3(iVal, iVal, iVal); }
template <class Val>
-ZMatrix<Val,1,3> sRVec3()
- { return ZMatrix<Val,1,3>(); }
+ZMatrix<Val,3,1> sRVec3()
+ { return ZMatrix<Val,3,1>(); }
// =================================================================================================
#pragma mark -
Modified: trunk/zoolib/source/cxx/zoolib/ZMatrix.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZMatrix.h 2011-10-31 03:11:56 UTC (rev 2601)
+++ trunk/zoolib/source/cxx/zoolib/ZMatrix.h 2011-10-31 20:26:42 UTC (rev 2602)
@@ -33,9 +33,9 @@
#pragma mark -
#pragma mark * ZMatrix
-template <class E, size_t R, size_t C> class ZMatrix;
+template <class E, size_t C, size_t R> class ZMatrix;
-template <class E_p, size_t R_p, size_t C_p>
+template <class E_p, size_t C_p, size_t R_p>
class ZMatrix
{
public:
@@ -88,7 +88,7 @@
#pragma mark * ZMatrix, specialized for column vector
template <class E_p, size_t R_p>
-class ZMatrix<E_p, R_p, 1>
+class ZMatrix<E_p,1,R_p>
{
public:
typedef E_p E;
@@ -136,7 +136,7 @@
#pragma mark * ZMatrix, specialized for row vector
template <class E_p, size_t C_p>
-class ZMatrix<E_p, 1, C_p>
+class ZMatrix<E_p,C_p,1>
{
public:
typedef E_p E;
@@ -184,9 +184,9 @@
#pragma mark * sHomogenous (column vector)
template <class E, size_t R>
-ZMatrix<E,R+1,1> sHomogenous(const ZMatrix<E,R,1>& iMat)
+ZMatrix<E,1,R+1> sHomogenous(const ZMatrix<E,1,R>& iMat)
{
- ZMatrix<E,R+1,1> result;
+ ZMatrix<E,1,R+1> result;
for (size_t r = 0; r < R; ++r)
result.fE[0][r] = iMat.fE[0][r];
result.fE[0][R] = 1;
@@ -198,9 +198,9 @@
#pragma mark * sHomogenous (row vector)
template <class E, size_t C>
-ZMatrix<E,1,C+1> sHomogenous(const ZMatrix<E,1,C>& iMat)
+ZMatrix<E,C+1,1> sHomogenous(const ZMatrix<E,C,1>& iMat)
{
- ZMatrix<E,1,C+1> result;
+ ZMatrix<E,C+1,1> result;
for (size_t c = 0; c < C; ++c)
result.fE[c][0] = iMat.fE[c][0];
result.fE[C][0] = 1;
@@ -212,9 +212,9 @@
#pragma mark * sCartesian (column vector)
template <class E, size_t R>
-ZMatrix<E,R-1,1> sCartesian(const ZMatrix<E,R,1>& iMat)
+ZMatrix<E,1,R-1> sCartesian(const ZMatrix<E,1,R>& iMat)
{
- ZMatrix<E,R-1,1> result;
+ ZMatrix<E,1,R-1> result;
for (size_t r = 0; r < R - 1; ++r)
result.fE[0][r] = iMat.fE[0][r];
return result;
@@ -225,9 +225,9 @@
#pragma mark * sCartesian (row vector)
template <class E, size_t C>
-ZMatrix<E,1,C-1> sCartesian(const ZMatrix<E,1,C>& iMat)
+ZMatrix<E,C-1,1> sCartesian(const ZMatrix<E,C,1>& iMat)
{
- ZMatrix<E,1,C-1> result;
+ ZMatrix<E,C-1,1> result;
for (size_t c = 0; c < C - 1; ++c)
result.fE[c][0] = iMat.fE[c][0];
return result;
@@ -238,7 +238,7 @@
#pragma mark * sDot (column vector)
template <class E, size_t R>
-E sDot(const ZMatrix<E,R,1>& i0, const ZMatrix<E,R,1>& i1)
+E sDot(const ZMatrix<E,1,R>& i0, const ZMatrix<E,1,R>& i1)
{
E result = 0;
for (size_t r = 0; r < R; ++r)
@@ -251,7 +251,7 @@
#pragma mark * sDot (row vector)
template <class E, size_t C>
-E sDot(const ZMatrix<E,1,C>& i0, const ZMatrix<E,1,C>& i1)
+E sDot(const ZMatrix<E,C,1>& i0, const ZMatrix<E,C,1>& i1)
{
E result = 0;
for (size_t c = 0; c < C; ++c)
@@ -264,9 +264,9 @@
#pragma mark * sCross (column vector)
template <class E, size_t R>
-ZMatrix<E,R,1> sCross(const ZMatrix<E,R,1>& i0, const ZMatrix<E,R,1>& i1)
+ZMatrix<E,1,R> sCross(const ZMatrix<E,1,R>& i0, const ZMatrix<E,1,R>& i1)
{
- ZMatrix<E,R,1> result;
+ ZMatrix<E,1,R> result;
for (size_t r = 0; r < R; ++r)
{
for (size_t r0 = 0; r0 < R; ++r0)
@@ -289,9 +289,9 @@
#pragma mark * sCross (row vector)
template <class E, size_t C>
-ZMatrix<E,1,C> sCross(const ZMatrix<E,1,C>& i0, const ZMatrix<E,1,C>& i1)
+ZMatrix<E,C,1> sCross(const ZMatrix<E,C,1>& i0, const ZMatrix<E,C,1>& i1)
{
- ZMatrix<E,1,C> result;
+ ZMatrix<E,C,1> result;
for (size_t c = 0; c < C; ++c)
{
for (size_t c0 = 0; c0 < C; ++c0)
@@ -330,7 +330,7 @@
#pragma mark -
#pragma mark * sTransposed
-template <class E, size_t R, size_t C>
+template <class E, size_t C, size_t R>
ZMatrix<E,C,R> sTransposed(const ZMatrix<E,R,C>& iMat)
{
ZMatrix<E,C,R> result;
@@ -347,7 +347,7 @@
#pragma mark * sLengthSquared (column vector)
template <class E, size_t R>
-E sLengthSquared(const ZMatrix<E,R,1>& iVec)
+E sLengthSquared(const ZMatrix<E,1,R>& iVec)
{ return sDot(iVec, iVec); }
// =================================================================================================
@@ -355,7 +355,7 @@
#pragma mark * sLengthSquared (row vector)
template <class E, size_t C>
-E sLengthSquared(const ZMatrix<E,1,C>& iVec)
+E sLengthSquared(const ZMatrix<E,C,1>& iVec)
{ return sDot(iVec, iVec); }
// =================================================================================================
@@ -363,7 +363,7 @@
#pragma mark * sLength (column vector)
template <class E, size_t R>
-E sLength(const ZMatrix<E,R,1>& iVec)
+E sLength(const ZMatrix<E,1,R>& iVec)
{ return sqrt(sLengthSquared(iVec)); }
// =================================================================================================
@@ -371,7 +371,7 @@
#pragma mark * sLength (row vector)
template <class E, size_t C>
-E sLength(const ZMatrix<E,1,C>& iVec)
+E sLength(const ZMatrix<E,C,1>& iVec)
{ return sqrt(sLengthSquared(iVec)); }
// =================================================================================================
@@ -379,11 +379,11 @@
#pragma mark * sNormalized (row vector)
template <class E, size_t C>
-ZMatrix<E,1,C> sNormalized(const ZMatrix<E,1,C>& iVec)
+ZMatrix<E,C,1> sNormalized(const ZMatrix<E,C,1>& iVec)
{
const E length = sLength(iVec);
ZAssert(length > 0);
- ZMatrix<E,1,C> result(null);
+ ZMatrix<E,C,1> result(null);
for (size_t c = 0; c < C; ++c)
result.fE[c][0] = iVec.fE[c][0] / length;
return result;
@@ -394,11 +394,11 @@
#pragma mark * sNormalized (column vector)
template <class E, size_t R>
-ZMatrix<E,R,1> sNormalized(const ZMatrix<E,R,1>& iVec)
+ZMatrix<E,1,R> sNormalized(const ZMatrix<E,1,R>& iVec)
{
const E length = sLength(iVec);
ZAssert(length > 0);
- ZMatrix<E,R,1> result(null);
+ ZMatrix<E,1,R> result(null);
for (size_t r = 0; r < R; ++r)
result.fE[0][r] = iVec.fE[0][r] / length;
return result;
@@ -408,10 +408,10 @@
#pragma mark -
#pragma mark * sApply (binary function)
-template <class Fun, class E, size_t R, size_t C>
-ZMatrix<E,R,C> sApply(Fun iFun, const ZMatrix<E,R,C>& i0, const ZMatrix<E,R,C>& i1)
+template <class Fun, class E, size_t C, size_t R>
+ZMatrix<E,C,R> sApply(Fun iFun, const ZMatrix<E,C,R>& i0, const ZMatrix<E,C,R>& i1)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -424,10 +424,10 @@
#pragma mark -
#pragma mark * sApply (unary function)
-template <class Fun, class E, size_t R, size_t C>
-ZMatrix<E,R,C> sApply(Fun iFun, const ZMatrix<E,R,C>& iMat)
+template <class Fun, class E, size_t C, size_t R>
+ZMatrix<E,C,R> sApply(Fun iFun, const ZMatrix<E,C,R>& iMat)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -440,10 +440,10 @@
#pragma mark -
#pragma mark * sNonZero
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C> sNonZero(const ZMatrix<E,R,C>& iMat)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R> sNonZero(const ZMatrix<E,C,R>& iMat)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -457,9 +457,9 @@
#pragma mark * Multiplication (aka composition)
template <class E, size_t RL, size_t Common, size_t CR>
-ZMatrix<E,RL,CR> operator*(const ZMatrix<E,RL,Common>& iLeft, const ZMatrix<E,Common,CR>& iRight)
+ZMatrix<E,CR, RL> operator*(const ZMatrix<E,Common,RL>& iLeft, const ZMatrix<E,CR,Common>& iRight)
{
- ZMatrix<E,RL,CR> result;
+ ZMatrix<E,CR,RL> result;
for (size_t rl = 0; rl < RL; ++rl)
{
for (size_t cr = 0; cr < CR; ++cr)
@@ -471,30 +471,30 @@
return result;
}
-template <class E, size_t RL, size_t Common, size_t CR>
-ZMatrix<E,RL,CR>& operator*=(ZMatrix<E,RL,Common>& ioLeft, const ZMatrix<E,Common,CR>& iRight)
+template <class E, size_t CR, size_t Common, size_t RL>
+ZMatrix<E,CR,RL>& operator*=(ZMatrix<E,Common,RL>& ioLeft, const ZMatrix<E,CR,Common>& iRight)
{ return ioLeft = ioLeft * iRight; }
// =================================================================================================
#pragma mark -
#pragma mark * Composition
-template <class E, size_t RL, size_t Common>
-ZMatrix<E,Common,1> operator*(const ZMatrix<E,RL,Common+1>& iLeft, const ZMatrix<E,Common,1>& iRight)
+template <class E, size_t Common, size_t RL>
+ZMatrix<E,1,Common> operator*(const ZMatrix<E,Common+1,RL>& iLeft, const ZMatrix<E,1,Common>& iRight)
{ return sCartesian(iLeft * sHomogenous(iRight)); }
-template <class E, size_t RL, size_t Common>
-ZMatrix<E,Common,1>& operator*=(ZMatrix<E,RL,Common+1>& ioLeft, const ZMatrix<E,Common,1>& iRight)
+template <class E, size_t Common, size_t RL>
+ZMatrix<E,1,Common>& operator*=(ZMatrix<E,Common+1,RL>& ioLeft, const ZMatrix<E,1,Common>& iRight)
{ return ioLeft = ioLeft * iRight; }
// =================================================================================================
#pragma mark -
#pragma mark * Element-by-element multiplication
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C> sTimes(const ZMatrix<E,R,C>& iLeft, const ZMatrix<E,R,C>& iRight)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R> sTimes(const ZMatrix<E,C,R>& iLeft, const ZMatrix<E,C,R>& iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -507,10 +507,10 @@
#pragma mark -
#pragma mark * Addition
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C> operator+(const ZMatrix<E,R,C>& iLeft, const ZMatrix<E,R,C>& iRight)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R> operator+(const ZMatrix<E,C,R>& iLeft, const ZMatrix<E,C,R>& iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -519,8 +519,8 @@
return result;
}
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C>& operator+=(ZMatrix<E,R,C>& ioLeft, const ZMatrix<E,R,C>& iRight)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R>& operator+=(ZMatrix<E,C,R>& ioLeft, const ZMatrix<E,C,R>& iRight)
{
for (size_t c = 0; c < C; ++c)
{
@@ -534,10 +534,10 @@
#pragma mark -
#pragma mark * Subtraction
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C> operator-(const ZMatrix<E,R,C>& iLeft, const ZMatrix<E,R,C>& iRight)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R> operator-(const ZMatrix<E,C,R>& iLeft, const ZMatrix<E,C,R>& iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -546,8 +546,8 @@
return result;
}
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C>& operator-=(ZMatrix<E,R,C>& ioLeft, const ZMatrix<E,R,C>& iRight)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R>& operator-=(ZMatrix<E,C,R>& ioLeft, const ZMatrix<E,C,R>& iRight)
{
for (size_t c = 0; c < C; ++c)
{
@@ -561,10 +561,10 @@
#pragma mark -
#pragma mark * Negate
-template <class E, size_t R, size_t C>
-ZMatrix<E,R,C> operator-(const ZMatrix<E,R,C>& iMat)
+template <class E, size_t C, size_t R>
+ZMatrix<E,C,R> operator-(const ZMatrix<E,C,R>& iMat)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -577,10 +577,10 @@
#pragma mark -
#pragma mark * Scalar multiplication
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C> operator*(const ZMatrix<E,R,C>& iLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R> operator*(const ZMatrix<E,C,R>& iLeft, T iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -589,8 +589,8 @@
return result;
}
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C>& operator*=(ZMatrix<E,R,C>& ioLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R>& operator*=(ZMatrix<E,C,R>& ioLeft, T iRight)
{
for (size_t c = 0; c < C; ++c)
{
@@ -604,10 +604,10 @@
#pragma mark -
#pragma mark * Scalar division
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C> operator/(const ZMatrix<E,R,C>& iLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R> operator/(const ZMatrix<E,C,R>& iLeft, T iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -616,8 +616,8 @@
return result;
}
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C>& operator/=(ZMatrix<E,R,C>& ioLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R>& operator/=(ZMatrix<E,C,R>& ioLeft, T iRight)
{
for (size_t c = 0; c < C; ++c)
{
@@ -631,10 +631,10 @@
#pragma mark -
#pragma mark * Scalar addition
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C> operator+(const ZMatrix<E,R,C>& iLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R> operator+(const ZMatrix<E,C,R>& iLeft, T iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -643,8 +643,8 @@
return result;
}
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C>& operator+=(ZMatrix<E,R,C>& ioLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R>& operator+=(ZMatrix<E,C,R>& ioLeft, T iRight)
{
for (size_t c = 0; c < C; ++c)
{
@@ -658,10 +658,10 @@
#pragma mark -
#pragma mark * Scalar subtraction
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C> operator-(const ZMatrix<E,R,C>& iLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R> operator-(const ZMatrix<E,C,R>& iLeft, T iRight)
{
- ZMatrix<E,R,C> result(null);
+ ZMatrix<E,C,R> result(null);
for (size_t c = 0; c < C; ++c)
{
for (size_t r = 0; r < R; ++r)
@@ -670,8 +670,8 @@
return result;
}
-template <class E, size_t R, size_t C, class T>
-ZMatrix<E,R,C>& operator-=(ZMatrix<E,R,C>& ioLeft, T iRight)
+template <class E, size_t C, size_t R, class T>
+ZMatrix<E,C,R>& operator-=(ZMatrix<E,C,R>& ioLeft, T iRight)
{
for (size_t c = 0; c < C; ++c)
{
@@ -686,7 +686,7 @@
#pragma mark * sScale (taking column vector)
template <class E, size_t Dim>
-ZMatrix<E,Dim+1,Dim+1> sScale(const ZMatrix<E,Dim,1>& iVec)
+ZMatrix<E,Dim+1,Dim+1> sScale(const ZMatrix<E,1,Dim>& iVec)
{
ZMatrix<E,Dim+1,Dim+1> result;
for (size_t ii = 0; ii < Dim; ++ii)
@@ -700,7 +700,7 @@
#pragma mark * sTranslate (taking column vector)
template <class E, size_t Dim>
-ZMatrix<E,Dim+1,Dim+1> sTranslate(const ZMatrix<E,Dim,1>& iVec)
+ZMatrix<E,Dim+1,Dim+1> sTranslate(const ZMatrix<E,1,Dim>& iVec)
{
ZMatrix<E,Dim+1,Dim+1> result = sIdentity<E,Dim+1>();
for (size_t ii = 0; ii < Dim; ++ii)
Modified: trunk/zoolib/source/cxx/zoolib/ZUtil_Strim_Matrix.h
===================================================================
--- trunk/zoolib/source/cxx/zoolib/ZUtil_Strim_Matrix.h 2011-10-31 03:11:56 UTC (rev 2601)
+++ trunk/zoolib/source/cxx/zoolib/ZUtil_Strim_Matrix.h 2011-10-31 20:26:42 UTC (rev 2602)
@@ -28,35 +28,35 @@
namespace ZooLib {
template <class E, size_t R>
-const ZStrimW& operator<<(const ZStrimW& w, const ZMatrix<E,R,1>& mat)
+const ZStrimW& operator<<(const ZStrimW& w, const ZMatrix<E,1,R>& mat)
{
w << "C[";
for (size_t r = 0; r < R; ++r)
{
if (r)
w << ", ";
- w << mat.fE[r][0];
+ w << mat.fE[0][r];
}
w << "]";
return w;
}
template <class E, size_t C>
-const ZStrimW& operator<<(const ZStrimW& w, const ZMatrix<E,1,C>& mat)
+const ZStrimW& operator<<(const ZStrimW& w, const ZMatrix<E,C,1>& mat)
{
w << "R[";
for (size_t c = 0; c < C; ++c)
{
if (c)
w << ", ";
- w << mat.fE[0][c];
+ w << mat.fE[c][0];
}
w << "]";
return w;
}
-template <class E, size_t R, size_t C>
-const ZStrimW& operator<<(const ZStrimW& w, const ZMatrix<E,R,C>& mat)
+template <class E, size_t C, size_t R>
+const ZStrimW& operator<<(const ZStrimW& w, const ZMatrix<E,C,R>& mat)
{
w << "[";
for (size_t r = 0; r < R; ++r)
@@ -66,7 +66,7 @@
{
if (c)
w << ", ";
- w << mat.fE[r][c];
+ w << mat.fE[c][r];
}
w << "]";
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
