← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rheolef/trusty

« back to all changes in this revision

Viewing changes to nfem/basis/tiny_matvec.h

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito
  • Date: 2012-04-06 09:12:21 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120406091221-m58me99p1nxqui49
Tags: 6.0-1
http://bugs.debian.org/667356
http://bugs.debian.org/661689
* New upstream release 6.0 (major changes):
  - massively distributed and parallel support
  - full FEM characteristic method (Lagrange-Gakerkin method) support
  - enhanced users documentation 
  - source code supports g++-4.7 (closes: #667356)
* debian/control: dependencies for MPI distributed solvers added
* debian/rules: build commands simplified
* debian/librheolef-dev.install: man1/* to man9/* added
* debian/changelog: package description rewritted (closes: #661689)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nfem/basis/tiny_matvec.h
1
 
# ifndef _RHEO_TINY_MATVEC_H
2
 
# define _RHEO_TINY_MATVEC_H
3
 
///
4
 
/// This file is part of Rheolef.
5
 
///
6
 
/// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
7
 
///
8
 
/// Rheolef is free software; you can redistribute it and/or modify
9
 
/// it under the terms of the GNU General Public License as published by
10
 
/// the Free Software Foundation; either version 2 of the License, or
11
 
/// (at your option) any later version.
12
 
///
13
 
/// Rheolef 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 Rheolef; if not, write to the Free Software
20
 
/// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21
 
/// 
22
 
/// =========================================================================
23
 
//
24
 
// very small matrix - vector
25
 
//
26
 
// authors: Pierre.Saramito@imag.fr
27
 
//
28
 
// date: 7 july 1997
29
 
//
30
 
#include "rheolef/compiler.h"
31
 
 
32
 
namespace rheolef { 
33
 
// take a 2^n since a(i,j) -> table (tiny_size_max*j + i)
34
 
// and tiny_size_max*j == j << log2(tiny_size_max*j) is fast
35
 
 
36
 
const unsigned int tiny_size_max = 32;
37
 
 
38
 
template <class T>
39
 
class tiny_vector {
40
 
public:
41
 
    typedef typename std::vector<int>::size_type size_type;
42
 
 
43
 
    tiny_vector (size_type n = 0);
44
 
    tiny_vector (size_type n, const T& value);
45
 
    size_type size() const { return size_; }
46
 
    void resize(size_type n);
47
 
    const T& operator() (size_type i) const { return t_[i+i0_]; }
48
 
    const T& operator[] (size_type i) const { return t_[i+i0_]; }
49
 
    T& operator() (size_type i) { return t_[i+i0_]; }
50
 
    T& operator[] (size_type i) { return t_[i+i0_]; }
51
 
    void set_origin(size_type i) { i0_ = i; }
52
 
    size_type get_origin() const { return i0_; }
53
 
    void fill(const T& val) {
54
 
        for (size_type i = i0_; i < i0_ + size_; i++) t_ [i] = val; }
55
 
    void reset() { fill(T()); }
56
 
protected:
57
 
    T t_ [tiny_size_max];
58
 
    size_type size_;
59
 
    size_type i0_;
60
 
};
61
 
template <class T>
62
 
class tiny_matrix {
63
 
public:
64
 
    typedef typename tiny_vector<T>::size_type size_type;
65
 
    tiny_matrix (size_type nr = 0, size_type nc = 0);
66
 
    size_type nrow() const { return nrow_; }
67
 
    size_type ncol() const { return ncol_; }
68
 
    T& operator() (size_type i, size_type j) { return t_[i+i0_][j+j0_]; }
69
 
    const T& operator() (size_type i, size_type j) const { return t_[i+i0_][j+j0_]; }
70
 
    T& operator() (size_type i) { return t_[i+i0_][i+j0_]; }
71
 
    const T& operator() (size_type i) const { return t_[i+i0_][i+j0_]; }
72
 
    void set_origin(size_type i, size_type j) { i0_ = i; j0_ = j; }
73
 
    void resize(size_type nr, size_type nc);
74
 
    size_type get_row_origin() const { return i0_; }
75
 
    size_type get_col_origin() const { return j0_; }
76
 
    void fill(const T& val);
77
 
    void reset() { fill(T()); }
78
 
private:
79
 
    T t_ [tiny_size_max][tiny_size_max];
80
 
    size_type nrow_;
81
 
    size_type ncol_;
82
 
    size_type i0_;
83
 
    size_type j0_;
84
 
};
85
 
// =====================================================================
86
 
// inlined
87
 
// =====================================================================
88
 
 
89
 
template <class T>
90
 
inline
91
 
tiny_vector<T>::tiny_vector (size_type n)
92
 
  : size_(n), i0_(0)
93
 
{ 
94
 
    check_macro (n <= tiny_size_max, "invalid size"); 
95
 
#ifdef _RHEOLEF_PARANO
96
 
    std::fill (t_, t_+tiny_size_max, std::numeric_limits<T>::max());
97
 
#endif // _RHEOLEF_PARANO
98
 
}
99
 
template <class T>
100
 
inline
101
 
tiny_vector<T>::tiny_vector (size_type n, const T& value)
102
 
  : size_(n), i0_(0)
103
 
{ 
104
 
    check_macro (n <= tiny_size_max, "invalid size"); 
105
 
    fill (t_, t_+tiny_size_max, value);
106
 
}
107
 
template <class T>
108
 
inline
109
 
void
110
 
tiny_vector<T>::resize(size_type n)
111
 
{
112
 
    size_ = n;
113
 
    check_macro (n <= tiny_size_max, "invalid size"); 
114
 
#ifdef _RHEOLEF_PARANO
115
 
    std::fill (t_, t_+tiny_size_max, std::numeric_limits<T>::max());
116
 
#endif // _RHEOLEF_PARANO
117
 
}
118
 
template <class T>
119
 
inline
120
 
tiny_matrix<T>::tiny_matrix (size_type nr, size_type nc)
121
 
  : nrow_(nr), ncol_(nc), i0_(0), j0_(0)
122
 
{
123
 
    check_macro (nr <= tiny_size_max && nc <= tiny_size_max, "invalid sizes");
124
 
#ifdef _RHEOLEF_PARANO
125
 
    for (size_type i = 0; i < tiny_size_max; i++) 
126
 
      for (size_type j = 0; j < tiny_size_max; j++) 
127
 
        t_[i][j] = std::numeric_limits<T>::max();
128
 
#endif // _RHEOLEF_PARANO
129
 
 
130
 
}
131
 
template <class T>
132
 
inline
133
 
void
134
 
tiny_matrix<T>::resize(size_type nr, size_type nc)
135
 
{
136
 
    nrow_ = nr;
137
 
    ncol_ = nc;
138
 
    check_macro (nr <= tiny_size_max && nc <= tiny_size_max, "invalid sizes");
139
 
#ifdef _RHEOLEF_PARANO
140
 
    for (size_type i = 0; i < tiny_size_max; i++) 
141
 
      for (size_type j = 0; j < tiny_size_max; j++) 
142
 
        t_[i][j] = std::numeric_limits<T>::max();
143
 
#endif // _RHEOLEF_PARANO
144
 
}
145
 
template <class T>
146
 
inline
147
 
void
148
 
tiny_matrix<T>::fill(const T& val)
149
 
{
150
 
    for (size_type i = i0_; i < i0_ + nrow_; i++) 
151
 
      for (size_type j = j0_; j < j0_ + ncol_; j++) 
152
 
        t_ [i][j] = val;
153
 
}
154
 
template <class T>
155
 
void
156
 
trans(const tiny_matrix<T>& a, tiny_matrix<T>& b)
157
 
{
158
 
    typedef typename tiny_matrix<T>::size_type size_type;
159
 
    b.resize (a.ncol(), a.nrow());
160
 
    for (size_type i = 0; i < a.nrow(); i++) 
161
 
      for (size_type j = 0; j < a.ncol(); j++)
162
 
        b(j,i) = a(i,j);
163
 
}
164
 
template<class T>
165
 
tiny_matrix<T>
166
 
operator* (const tiny_matrix<T>& a, const tiny_matrix<T>& b)
167
 
 {
168
 
    check_macro(a.ncol()==b.nrow(),"Error in matrices sizes for multiplication, "
169
 
        << a.nrow()<<"x"<<a.ncol() <<" and "<< b.nrow()<<"x"<<b.ncol());
170
 
    typedef typename tiny_matrix<T>::size_type size_type;
171
 
    tiny_matrix<T> c(a.nrow(),b.ncol());
172
 
    c.fill(0);
173
 
    for (size_type i=0; i<a.nrow(); i++)
174
 
     for (size_type j=0; j<b.ncol(); j++)
175
 
      for (size_type k=0; k<b.nrow(); k++)
176
 
       c(i,j)+=a(i,k)*b(k,j);
177
 
    return c;
178
 
 }
179
 
template<class T>
180
 
tiny_vector<T>
181
 
operator* (const tiny_matrix<T>& a, const tiny_vector<T>& u)
182
 
 {
183
 
    check_macro(a.ncol()==u.size(),"Error in matrice-vector sizes for multiplication, "
184
 
        << a.nrow()<<"x"<<a.ncol() <<" and "<< u.size());
185
 
    typedef typename tiny_matrix<T>::size_type size_type;
186
 
    tiny_vector<T> v(a.nrow());
187
 
    v.fill(0);
188
 
    for (size_type i=0; i<a.nrow(); i++)
189
 
     for (size_type j=0; j<u.size(); j++)
190
 
      v(i)+=a(i,j)*u(j);
191
 
    return v;
192
 
 }
193
 
}// namespace rheolef
194
 
# endif /* _RHEO_TINY_MATVEC_H */