Initial revision
[blender.git] / intern / iksolver / intern / TNT / transv.h
1 /**
2  * $Id$
3  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version. The Blender
9  * Foundation also sells licenses for use in proprietary software under
10  * the Blender License.  See http://www.blender.org/BL/ for information
11  * about this.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software Foundation,
20  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
21  *
22  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
23  * All rights reserved.
24  *
25  * The Original Code is: all of this file.
26  *
27  * Contributor(s): none yet.
28  *
29  * ***** END GPL/BL DUAL LICENSE BLOCK *****
30  */
31
32 /*
33
34 *
35 * Template Numerical Toolkit (TNT): Linear Algebra Module
36 *
37 * Mathematical and Computational Sciences Division
38 * National Institute of Technology,
39 * Gaithersburg, MD USA
40 *
41 *
42 * This software was developed at the National Institute of Standards and
43 * Technology (NIST) by employees of the Federal Government in the course
44 * of their official duties. Pursuant to title 17 Section 105 of the
45 * United States Code, this software is not subject to copyright protection
46 * and is in the public domain.  The Template Numerical Toolkit (TNT) is
47 * an experimental system.  NIST assumes no responsibility whatsoever for
48 * its use by other parties, and makes no guarantees, expressed or implied,
49 * about its quality, reliability, or any other characteristic.
50 *
51 * BETA VERSION INCOMPLETE AND SUBJECT TO CHANGE
52 * see http://math.nist.gov/tnt for latest updates.
53 *
54 */
55
56
57
58 // Matrix Transpose Views
59
60 #ifndef TRANSV_H
61 #define TRANSV_H
62
63 #include <iostream>
64 #include <cassert>
65 #include "vec.h"
66
67 namespace TNT
68 {
69
70 template <class Array2D>
71 class Transpose_View
72 {
73     protected:
74
75         const Array2D &  A_;
76
77     public:
78
79         typedef typename Array2D::element_type T;
80         typedef         T   value_type;
81         typedef         T   element_type;
82         typedef         T*  pointer;
83         typedef         T*  iterator;
84         typedef         T&  reference;
85         typedef const   T*  const_iterator;
86         typedef const   T&  const_reference;
87
88
89         const Array2D & array()  const { return A_; }
90         Subscript num_rows() const { return A_.num_cols();}
91         Subscript num_cols() const { return A_.num_rows();}
92         Subscript lbound() const { return A_.lbound(); }
93         Subscript dim(Subscript i) const
94         {
95 #ifdef TNT_BOUNDS_CHECK
96             assert( A_.lbound() <= i);
97             assert( i<= A_.lbound()+1);
98 #endif
99             if (i== A_.lbound())
100                 return num_rows();
101             else
102                 return num_cols();
103         }
104
105
106         Transpose_View(const Transpose_View<Array2D> &A) : A_(A.A_) {};
107         Transpose_View(const Array2D &A) : A_(A) {};
108
109
110         inline const typename Array2D::element_type & operator()(
111             Subscript i, Subscript j) const
112         {
113 #ifdef TNT_BOUNDS_CHECK
114         assert(lbound()<=i);
115         assert(i<=A_.num_cols() + lbound() - 1);
116         assert(lbound()<=j);
117         assert(j<=A_.num_rows() + lbound() - 1);
118 #endif
119
120             return A_(j,i);
121         }
122
123
124 };
125
126 template <class Matrix>
127 Transpose_View<Matrix> Transpose_view(const Matrix &A)
128 {
129     return Transpose_View<Matrix>(A);
130 }
131
132 template <class Matrix, class T>
133 Vector<T> matmult(
134     const Transpose_View<Matrix> & A, 
135     const Vector<T> &B)
136 {
137     Subscript  M = A.num_rows();
138     Subscript  N = A.num_cols();
139
140     assert(B.dim() == N);
141
142     Vector<T> x(N);
143
144     Subscript i, j;
145     T tmp = 0;
146
147     for (i=1; i<=M; i++)
148     {
149         tmp = 0;
150         for (j=1; j<=N; j++)
151             tmp += A(i,j) * B(j);
152         x(i) = tmp;
153     }
154
155     return x;
156 }
157
158 template <class Matrix, class T>
159 inline Vector<T> operator*(const Transpose_View<Matrix> & A, const Vector<T> &B)
160 {
161     return matmult(A,B);
162 }
163
164
165 template <class Matrix>
166 std::ostream& operator<<(std::ostream &s, const Transpose_View<Matrix> &A)
167 {
168     Subscript M=A.num_rows();
169     Subscript N=A.num_cols();
170
171     Subscript start = A.lbound();
172     Subscript Mend = M + A.lbound() - 1;
173     Subscript Nend = N + A.lbound() - 1;
174
175     s << M << "  " << N << endl;
176     for (Subscript i=start; i<=Mend; i++)
177     {
178         for (Subscript j=start; j<=Nend; j++)
179         {
180             s << A(i,j) << " ";
181         }
182         s << endl;
183     }
184
185
186     return s;
187 }
188
189 } // namespace TNT
190
191 #endif
192 // TRANSV_H