Initial revision
[blender.git] / intern / iksolver / intern / TNT / fcscmat.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 //  Templated compressed sparse column matrix (Fortran conventions).
59 //  uses 1-based offsets in storing row indices.
60 //  Used primarily to interface with Fortran sparse matrix libaries.
61 //  (CANNOT BE USED AS AN STL CONTAINER.)
62
63
64 #ifndef FCSCMAT_H
65 #define FCSCMAT_H
66
67 #include <iostream>
68 #include <cassert>
69 #include "tnt.h"
70 #include "vec.h"
71
72 using namespace std;
73
74 namespace TNT
75 {
76
77 template <class T>
78 class Fortran_Sparse_Col_Matrix 
79 {
80
81    protected:
82
83        Vector<T>           val_;       // data values (nz_ elements)
84        Vector<Subscript>   rowind_;    // row_ind (nz_ elements)
85        Vector<Subscript>   colptr_;    // col_ptr (n_+1 elements)
86
87        int nz_;                   // number of nonzeros
88        Subscript m_;              // global dimensions
89        Subscript n_;
90   
91    public:
92
93
94        Fortran_Sparse_Col_Matrix(void);
95        Fortran_Sparse_Col_Matrix(const Fortran_Sparse_Col_Matrix<T> &S)
96         : val_(S.val_), rowind_(S.rowind_), colptr_(S.colptr_), nz_(S.nz_),
97             m_(S.m_), n_(S.n_) {};
98        Fortran_Sparse_Col_Matrix(Subscript M, Subscript N, 
99             Subscript nz, const T  *val,  const Subscript *r, 
100             const Subscript *c) : val_(nz, val), rowind_(nz, r), 
101             colptr_(N+1, c), nz_(nz), m_(M), n_(N) {};
102
103        Fortran_Sparse_Col_Matrix(Subscript M, Subscript N, 
104             Subscript nz, char *val,  char  *r, 
105             char *c) : val_(nz, val), rowind_(nz, r), 
106             colptr_(N+1, c), nz_(nz), m_(M), n_(N) {};
107
108        Fortran_Sparse_Col_Matrix(Subscript M, Subscript N, 
109             Subscript nz, const T  *val, Subscript *r, Subscript *c)
110             : val_(nz, val), rowind_(nz, r), colptr_(N+1, c), nz_(nz), 
111                     m_(M), n_(N) {};
112     
113       ~Fortran_Sparse_Col_Matrix() {};
114         
115
116        T &      val(Subscript i) { return val_(i); }
117        const T &      val(Subscript i) const { return val_(i); }
118
119        Subscript &   row_ind(Subscript i) { return rowind_(i); }
120        const Subscript &   row_ind(Subscript i) const { return rowind_(i); }
121
122        Subscript    col_ptr(Subscript i) { return colptr_(i);}
123        const Subscript    col_ptr(Subscript i) const { return colptr_(i);}
124
125
126        Subscript    num_cols() const { return m_;}
127        Subscript    num_rows() const { return n_; }
128
129        Subscript          dim(Subscript i) const 
130        {
131 #ifdef TNT_BOUNDS_CHECK
132             assert( 1 <= i );
133             assert( i <= 2 );
134 #endif
135             if (i==1) return m_;
136             else if (i==2) return m_;
137             else return 0;
138         }
139
140        Subscript          num_nonzeros() const {return nz_;};
141        Subscript          lbound() const {return 1;}
142
143
144
145        Fortran_Sparse_Col_Matrix& operator=(const 
146             Fortran_Sparse_Col_Matrix &C)
147         {
148             val_ = C.val_;
149             rowind_ = C.rowind_;
150             colptr_ = C.colptr_;
151             nz_ = C.nz_;
152             m_ = C.m_;
153             n_ = C.n_;
154
155             return *this;
156         }
157
158        Fortran_Sparse_Col_Matrix& newsize(Subscript M, Subscript N, 
159                 Subscript nz)
160         {
161             val_.newsize(nz);
162             rowind_.newsize(nz);
163             colptr_.newsize(N+1);
164             return *this;
165         }
166 };
167
168 template <class T>
169 ostream& operator<<(ostream &s, const Fortran_Sparse_Col_Matrix<T> &A)
170 {
171     Subscript M=A.num_rows();
172     Subscript N=A.num_cols();
173
174     s << M << " " << N << " " << A.num_nonzeros() <<  endl;
175
176
177     for (Subscript k=1; k<=N; k++)
178     {
179         Subscript start = A.col_ptr(k);
180         Subscript end = A.col_ptr(k+1);
181
182         for (Subscript i= start; i<end; i++)
183         {
184             s << A.row_ind(i) << " " << k << " " << A.val(i) << endl;
185         }
186     }
187
188     return s;
189 }
190
191
192
193 } // namespace TNT
194
195 #endif  
196 /* FCSCMAT_H */
197