[frames] | no frames]

# Source Code for Module hedge.polynomial

```  1  """Jacobi polynomials and Vandermonde matrices."""
2
3  from __future__ import division
4
6
8  This program is free software: you can redistribute it and/or modify
10  the Free Software Foundation, either version 3 of the License, or
11  (at your option) any later version.
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, see U{http://www.gnu.org/licenses/}.
20  """
21
22
23
24
25
26  import numpy
27  import hedge._internal
28  import numpy.linalg as la
29
30
31
32
33  JacobiFunction = hedge._internal.JacobiPolynomial
34  DiffJacobiFunction = hedge._internal.DiffJacobiPolynomial
35
36
37
38
39 -class LegendreFunction(JacobiFunction):
40 -    def __init__(self, N):
41          JacobiFunction.__init__(self, 0, 0, N)
42
43 -class DiffLegendreFunction(DiffJacobiFunction):
44 -    def __init__(self, N):
45          DiffJacobiFunction.__init__(self, 0, 0, N)
46
47
48
49
50 -def generic_vandermonde(points, functions):
51      """Return a Vandermonde matrix.
52
53      The Vandermonde Matrix is given by M{V_{i,j} := f_j(x_i)}
54      where C{functions} is the list of M{f_j} and points is
55      the list of M{x_i}.
56      """
57      v = numpy.zeros((len(points), len(functions)))
58      for i, x in enumerate(points):
59          for j, f in enumerate(functions):
60              v[i,j] = f(x)
61      return v
62
63
64
65
66 -def generic_multi_vandermonde(points, functions):
67      """Return multiple Vandermonde matrices.
68
69      The Vandermonde Matrix is given by M{V_{i,j} := f_j(x_i)}
70      where C{functions} is the list of M{f_j} and points is
71      the list of M{x_i}.
72
73      The functions M{f_j} are multi-valued (i.e. return iterables), and one
74      matrix is returned for each return value.
75      """
76      count = len(functions(points))
77      result = [numpy.zeros((len(points), len(functions))) for n in range(count)]
78
79      for i, x in enumerate(points):
80          for j, f in enumerate(functions):
81              for n, f_n in enumerate(f(x)):
82                  result[n][i,j] = f_n
83      return result
84
85
86
87
88 -def legendre_vandermonde(points, N):
89      return generic_vandermonde(points,
90              [LegendreFunction(i) for i in range(N+1)])
91
92
93
94
95 -def monomial_vdm(levels):
96      class Monomial:
97          def __init__(self, expt):
98              self.expt = expt
99          def __call__(self, x):
100              return x**self.expt
101
102      return generic_vandermonde(levels,
103              [Monomial(i) for i in range(len(levels))])
104
105
106
107
108 -def make_interpolation_coefficients(levels, tap):
109      point_eval_vec = numpy.array([ tap**n for n in range(len(levels))])
110      return la.solve(monomial_vdm(levels).T, point_eval_vec)
111
<!--
expandto(location.href);
// -->

```

 Generated by Epydoc 3.0.1 on Sat Aug 29 14:33:52 2009 http://epydoc.sourceforge.net