/[escript]/trunk/doc/user/escript.tex
ViewVC logotype

Annotation of /trunk/doc/user/escript.tex

Parent Directory Parent Directory | Revision Log Revision Log


Revision 100 - (hide annotations)
Wed Dec 15 03:48:48 2004 UTC (14 years, 4 months ago) by jgs
Original Path: trunk/esys2/doc/user/escript.tex
File MIME type: application/x-tex
File size: 22311 byte(s)
*** empty log message ***

1 jgs 82 % $Id$
2    
3     \chapter{The module \escript}
4    
5 jgs 100 \declaremodule{extension}{escript} \modulesynopsis{Handling data on
6     data points like \class{Nodes}, \class{Elements}}
7 jgs 82
8 jgs 100 The class \Data of the module \escript allows handling
9     data which are hold on data points \index{data points}. Examples for
10     data points are nodes or the quadrature points in elements of a finite
11     element mesh. Another examples a particles or the connection between
12     particles in the case of discrete element methods. Handlers to data
13     points are issued by the structure which contains the data points,
14     e.g. a \finley mesh.
15 jgs 82
16 jgs 100 The simplest form of data attached to a data point is a single scalar
17     $a$ value which for instance represent the temperature or pressure at
18     this particular data point. Another example is a velocity field. in
19     this case each data point holds a vector $a(0),a(1),a(2)$ representing
20     the velocity at the particular data point. For the case that the
21     values are representing a stress tensor the value is a matrix of the
22     form
23     $a(0,0),a(0,1),a(0,2),a(1,0),a(1,1),a(1,2),a(2,0),a(2,1),a(2,2)$. In
24     general, values hald by data points can have up to four indices. The
25     number of indices is called rank \index{rank}. The tuple of length
26     rank which defines the upper-bound for each index component is called
27     the shape. A stress has rank 2 and the shape is (3,3). For a vector we
28     have rank 1 and shape (3,). A scalar can have rank 0 or rank 1 with
29     shape (1,).
30 jgs 82
31 jgs 100 In general, the data are stored for each data point. This status of
32     the data is called expanded \index{expanded}. But in some cases, all
33     data points hold the same value. In this case only a single value is
34     stored, which is refered by each data point if needed. This saves
35     memory as well as compute time. In some cases, it is very usefull to
36     have slightly more general way which allows to define piecewise
37     constant data. For this, each data point has to wear a tag which is an
38     integer \index{tag}. The tag is used to distingish between various
39     types of data points. Typical example of the usage of tags is to
40     assign different material parameters to various subdomains. Then one
41     assigns the same tag to all elements in a finite element mesh which
42     lay in the same subdomain. Later each tag can be assigns individual
43     material parameters.
44 jgs 82
45 jgs 100 The following table shows unitary operations that can be applied to an
46     \Data object \var{arg}:
47     \begin{tableii}{l|l}{textrm}{expression}{Description}
48     \lineii{+\var{arg}} {just \var{arg} \index{+}}
49     \lineii{-\var{arg}} {swapping the sign\index{-}}
50     \lineii{\function{abs}(\var{arg})} {absolute value}
51     \lineii{\function{sin}(\var{arg})} {sine function}
52     \lineii{\function{cos}(\var{arg})} {cosine function}
53     \lineii{\function{exp}(\var{arg})} {exponential function}
54     \lineii{\function{sqrt}(\var{arg})} {square root}
55     \end{tableii}
56     An unitary operation returns a \Data objects of the same shape
57     and defined on the data points like \var{arg}.
58 jgs 82
59 jgs 100 The following table shows binary operations that can be applied to
60     \Data objects:
61     \begin{tableii}{l|l}{textrm}{expression}{Description}
62     \lineii{\var{arg1}+\var{arg2}} {adds \var{arg1} and \var{arg2} \index{+}}
63     \lineii{\var{arg1}*\var{arg2}} {multiplies \var{arg1} and \var{arg2} \index{*}}
64     \lineii{\var{arg1}-\var{arg2}} {difference \var{arg2} from\var{arg2} \index{-}}
65     \lineii{\var{arg1}/\var{arg2}} {ratio \var{arg1} by \var{arg2} \index{/}}
66     \lineii{\var{arg1}**\var{arg2}} {raises \var{arg1} to the power of \var{arg2} \index{**}}
67     \end{tableii}
68     At least on of the arguments \var{arg1} or \var{arg2} must be a
69     \Data object. One of the arguments may be an object that can be
70     converted into a \Data object. If \var{arg1} or \var{arg2} are
71     defined on different data points it is tried to interpolate \var{arg1}
72     onto the data points of \var{arg2} or to interpolate \var{arg2} onto
73     the data points of \var{arg1}. Boths arguments must have the same
74     shape or one of the arguments my be of rank 0 or shape (1,). In the
75     latter case it is assumed that the particular argument is of the same
76     shape like the other argument but constant over all components.
77 jgs 82
78 jgs 100 The returned \Data object has the same shape and is defined on
79     the data points like \var{arg1} or \var{arg2}.
80 jgs 82
81 jgs 100 The following table shows the update operations that can be applied to
82     \Data objects:
83     \begin{tableii}{l|l}{textrm}{expression}{Description}
84     \lineii{\var{arg1}+=\var{arg2}} {adds \var{arg1} to \var{arg2} \index{+}}
85     \lineii{\var{arg1}*=\var{arg2}} {multiplies \var{arg1} with \var{arg2} \index{*}}
86     \lineii{\var{arg1}-=\var{arg2}} {subtracts \var{arg2} from\var{arg2} \index{-}}
87     \lineii{\var{arg1}/=\var{arg2}} {divides \var{arg1} by \var{arg2} \index{/}}
88     \end{tableii}
89     \var{arg1} must be a \Data object. \var{arg1} must be a
90     \Data object or an object that can be converted into a
91     \Data object. \var{arg1} must have the same shape like
92     \var{arg1} or has rank 0 or shape (1,). In the latter case it is
93     assumed that the values of \var{arg1} are constant for all
94     components. \var{arg2} must be defined on the same data points like
95     \var{arg1} or it must be possible to interpolate \var{arg2} onto the
96     data points where \var{arg1} is hold.
97 jgs 82
98    
99 jgs 100 %TODO:
100     Slicing \index{slicing}.
101 jgs 82
102 jgs 100 \begin{classdesc}{Data}{}
103     A class that holds values assigned to data points.
104     \end{classdesc}
105 jgs 82
106 jgs 100 \begin{classdesc}{Scalar}{value=None,where=None,expand=None}
107     A class that holds a single value per data point.
108     \end{classdesc}
109 jgs 82
110 jgs 100 \begin{classdesc}{Vector}{value=None,dim=None,where=None,expand=None}
111     A class that holds a vector per data point.
112     \end{classdesc}
113 jgs 82
114 jgs 100 \begin{classdesc}{Tensor}{value=None,dim=None,where=None,expand=None}
115     A class that holds a tensor order 2 (matrix) per data point.
116     \end{classdesc}
117 jgs 82
118 jgs 100 \begin{classdesc}{Tensor3}{value=None,dim=None,where=None,expand=None}
119     A class that holds a tensor order 3 per data point.
120 jgs 82 \end{classdesc}
121    
122 jgs 100 \begin{classdesc}{Tensor4}{value=None,dim=None,where=None,expand=None}
123     A class that holds a tensor order 4 per data point.
124 jgs 82 \end{classdesc}
125    
126 jgs 100 \begin{funcdesc}{abs}{arg}
127     returns the absulute value of \Data \var{arg}. The returned
128     \Data object has the same rank, shape and is defined on the
129     same \class{_Atom} like \var{arg}. An entries in the returned object
130     is the absolute value of the corresponding entry in \var{arg}.
131     \index{absolute value}
132     \end{funcdesc}
133 jgs 82
134 jgs 100 \begin{funcdesc}{L2}{arg}
135     returns the $L^2$-norm of the \Data \var{arg} by using method
136     \method{arg.L2()}. \index{$L^2$-norm}
137     \end{funcdesc}
138 jgs 82
139 jgs 100 \begin{funcdesc}{grad}{arg}
140     returns the gradient of the interpolation function of \Data
141     \var{arg} by using \method{arg.grad}. \index{gradient}
142     \end{funcdesc}
143 jgs 82
144 jgs 100 \begin{funcdesc}{integrate}{arg}
145     returns the integral of the interpolation function of \Data
146     \var{arg} by using \method{arg.integrate}. \index{integral}
147     \end{funcdesc}
148 jgs 82
149 jgs 100 \begin{funcdesc}{interpolate}{arg,where}
150     interpolates the \Data \var{arg} onto \class{_Atom} where by
151     using \method{arg.interpolate}. \index{interpolation}
152     \end{funcdesc}
153 jgs 82
154 jgs 100 \begin{funcdesc}{transpose}{arg}
155     returns the transpose of \var{arg} where \var{arg} has to be
156     \Data or \class{numarray.array}. If \var{arg} is of
157     \Data the method \method{arg.transpose} is used otherwise
158     \function{numarray.transpose} is called. \index{transpose}
159     \end{funcdesc}
160 jgs 82
161 jgs 100 \begin{funcdesc}{trace}{arg}
162     returns the trace of \var{arg} where \var{arg} has to be \Data
163     or \class{numarray.array} of rank 2. If \var{arg} is of \Data
164     the method \method{arg.trace} is used otherwise
165     \function{numarray.trace} is called. \index{trace}
166     \end{funcdesc}
167 jgs 82
168 jgs 100 \begin{funcdesc}{exp}{arg}
169     applies the exponential function to \var{arg} where \var{arg} has to
170     be \Data or \class{numarray.array}. If \var{arg} is of
171     \Data the method \method{arg.exp} is used otherwise
172     \function{numarray.exp} is called. \index{exponential function}
173 jgs 82 \end{funcdesc}
174    
175 jgs 100 \begin{funcdesc}{sqrt}{arg}
176     applies the square root function to \var{arg} where \var{arg} has to
177     be \Data or \class{numarray.array}. If \var{arg} is of
178     \Data the method \method{arg.sqrt} is used otherwise
179     \function{numarray.sqrt} is called. \index{square root}
180 jgs 82 \end{funcdesc}
181    
182 jgs 100 \begin{funcdesc}{sin}{arg}
183     applies the sine function to \var{arg} where \var{arg} has to be
184     \Data or \class{numarray.array}. If \var{arg} is of
185     \Data the method \method{arg.sin} is used otherwise
186     \function{numarray.sin} is called. \index{sine function}
187 jgs 82 \end{funcdesc}
188    
189 jgs 100 \begin{funcdesc}{cos}{arg}
190     applies the cosine function to \var{arg} where \var{arg} has to be
191     \Data or \class{numarray.array}. If \var{arg} is of
192     \Data the method \method{arg.cos} is used otherwise
193     \function{numarray.cos} is called. \index{cosine function}
194 jgs 82 \end{funcdesc}
195    
196 jgs 100 \begin{funcdesc}{maxval}{arg}
197     returns for each data point the maximum value over all components of
198     \Data \var{arg} by using \method{arg.maxval}. \index{maximum
199     value}
200 jgs 82 \end{funcdesc}
201    
202 jgs 100 \begin{funcdesc}{minval}{arg}
203     returns for each data point the minimum value over all components of
204     \Data \var{arg} by using \method{arg.minval}. \index{minimum
205     value}
206 jgs 82 \end{funcdesc}
207    
208 jgs 100 \begin{funcdesc}{inf}{arg}
209     returns the minimum value (infimum) over all components and all data
210     points of \Data \var{arg} by using \method{arg.inf}.
211     \index{infimum}
212 jgs 82 \end{funcdesc}
213    
214 jgs 100 \begin{funcdesc}{sup}{arg}
215     returns the maximum value (supremum) over all components and all data
216     points of \Data \var{arg} by using \method{arg.sup}.
217     \index{supremum}
218     \end{funcdesc}
219 jgs 82
220 jgs 100 \begin{funcdesc}{Lsup}{arg}
221     returns the maximum absulute value ($L^{sup}$-norm) over all
222     components and all data points of \Data \var{arg} by using
223     \method{arg.sup}. The returned value equals
224     \function{sup}(\function(arg)). \index{$L^{sup}$-norm}
225     \end{funcdesc}
226 jgs 82
227 jgs 100 \begin{funcdesc}{matmult}{arg1,arg2}
228     returns for each data point the matrix-matrix product of \var{arg1}
229     and \var{arg2} \index{matrix-matrix product}. At least of the
230     arguments \var{arg1} and \var{arg2} has to be a \Data
231     object. If the other argument is not a \Data object it must be
232     convertable into a \Data object. The returned \Data
233     object has rank \var{arg1.getRank()}+\var{arg2.getRank()}-2 and shape
234     (\var{arg1.getShape()}[r-1],\var{arg2.getShape()}[1:]), where
235     \var{r}=\var{arg1.getRank()}. The last dimension of \var{arg1} and the
236     first dimension of \var{arg2} have to match,
237     i.e. \var{arg1.getShape()[r-1]}=\var{arg2.getShape()[0]}
238 jgs 82
239 jgs 100 For the case that \var{arg1} and \var{arg2} are both of rank $2$ the
240     result \var{res} is calculated as
241     \begin{equation}
242     res(i,j;s)=
243     arg1(i,0;s) \cdot arg2(0,j;s)+
244     \ldots
245     arg1(i,n-1;s) \cdot arg2(n-1,j;s)
246     \end{equation}
247     for all $0\le i <$ \var{arg1.getShape()[0]}, $0\le j <$
248     \var{arg2.getShape()[1]} and all data points $s$, where
249     $n$=\var{arg2.getShape()[0]},
250 jgs 82
251 jgs 100 If the arguments are not defined on the same data points, \var{arg1}
252     is tried to be interpolated on the data points of \var{arg2} or
253     \var{arg2} is tried to be interpolated on the data points of
254     \var{arg1}. What ever case works defines the data points of the
255     result.
256     \end{funcdesc}
257 jgs 82
258 jgs 100 %==================================================================
259     \section{\Data class}
260     \begin{classdesc}{Data}{value=None,shape=None,where=None,expand=None}
261 jgs 82 \end{classdesc}
262    
263 jgs 100 \begin{methoddesc}[Data]{getAtoms}{}
264     returns a handel to the data points on which the object is definded
265     \index{data points}. The returned object is of \class{_Atoms}.
266 jgs 82 \end{methoddesc}
267    
268     \begin{methoddesc}[Data]{getShape}{}
269 jgs 100 returns the shape of the data on each data point as a \class{tuple} of
270     integers. \index{shape}
271 jgs 82 \end{methoddesc}
272    
273     \begin{methoddesc}[Data]{getRank}{}
274     returns the rank of the data on each data point. \index{rank}
275     \end{methoddesc}
276    
277 jgs 100 \begin{methoddesc}[Data]{hasShape}{shape}
278     is true if the object has the shape \var{shape}.
279 jgs 82 \end{methoddesc}
280    
281 jgs 100 \begin{methoddesc}[Data]{expand}{}
282     returns an expanded version of the object if the object is not
283     expanded. Otherwise it returns itself. \index{expanded}
284 jgs 82 \end{methoddesc}
285    
286 jgs 100 \begin{methoddesc}[Data]{makeExpanded}{}
287     turns the object into an expanded \Data
288     object. \index{expanded}
289 jgs 82 \end{methoddesc}
290    
291 jgs 100 \begin{methoddesc}[Data]{isExpanded}{}
292     is true if the object is expanded. \index{expanded}
293 jgs 82 \end{methoddesc}
294    
295 jgs 100 \begin{methoddesc}[Data]{isTagged}{}
296     is true if the object is defined using tags. \index{tagged}
297 jgs 82 \end{methoddesc}
298    
299 jgs 100 \begin{methoddesc}[Data]{asArray}{}
300     returns the object as a \class{numarray.array} array. The array is one
301     rank higher than the rank of the object. The extra dimension is the
302     number of data points.
303     % TODO: be more accurate on the shape
304 jgs 82 \end{methoddesc}
305    
306 jgs 100 \begin{methoddesc}[Data]{addTaggedValue}{tag,value=0}
307     assigns the \var{value} to all data points which have the tag
308     \var{tag} which has to be an integer or a list of
309     integers. \var{value} must be an object of class
310     \class{numarray.array} or must be convertable into a
311     \class{numarray.array} object. \var{value} (or the cooresponding
312     \class{numarray.array} object) must be of rank $0$ or must have the
313     same rank like the object. \index{tagged}
314 jgs 82
315 jgs 100 If a value has allready be defined for tag \var{tag} within the object
316     it is overwritten by the new \var{value}. If the object is expanded,
317     the value assigned to data points with tag \var{tag} is replaced by
318     \var{value}.
319 jgs 82 \end{methoddesc}
320    
321 jgs 100 \begin{methoddesc}[Data]{getTaggedValue}{tag}
322     returns the value assigned to \var{tag}. An exception is raised if the
323     object is not defined by tagged data, e.g. if the object is
324     expanded.\index{tagged}
325 jgs 82 \end{methoddesc}
326    
327 jgs 100 \begin{methoddesc}[Data]{L2}{}
328     returns the $L^2$-norm of the object. This is square root of sum of
329     the squares of all values over all components and all data points.
330     \index{$L^2$-norm}
331 jgs 82 \end{methoddesc}
332    
333 jgs 100 \begin{methoddesc}[Data]{grad}{}
334     returns the gradient of the interpolation function. The returned
335     \Data object is of rank r+1 where r is the rank of the object.
336     Typically the object of to be defined on nodes and the returned
337     gradient is defined on the quadrature points of elements.
338 jgs 82 \index{gradient}
339     \end{methoddesc}
340    
341     \begin{methoddesc}[Data]{integrate}{}
342 jgs 100 returns the integral of the interpolation function. The method returns
343     a \class{numarray.array} object of the same shape like the object. A
344 jgs 82 component of the returned object is the integral of the corresponding
345 jgs 100 component of the object. \index{integral}
346 jgs 82 \end{methoddesc}
347    
348 jgs 100 \begin{methoddesc}[Data]{interpolate}{where}
349     interpolates onto the data points of the \class{_Atom}
350     \var{where}. The returned \Data object is of the same shape
351     like the object and is defined on the data points \var{where}.
352 jgs 82 \index{interpolation}
353     \end{methoddesc}
354    
355 jgs 100 \begin{methoddesc}[Data]{transpose}{}
356     returns the transpose of the object. The return value is an object has
357     the same shape and is defined on the same data points like the object.
358     For each data point the value is set to transposed of the
359     corresponding value of the object by reversing the index of the data.
360    
361     For the case that object \var{self} is of rank 3 the result \var{res} is
362     \begin{equation}
363     res(i,j,k;s)=self(k,j,i;s)
364     \end{equation}
365     for all
366     $0\le i <$ \var{self.getShape()[2]},
367     $0\le j <$ \var{self.getShape()[1]},
368     $0\le k <$ \var{self.getShape()[0]}
369     and all data points $s$.
370     \index{transpose}
371 jgs 82 \end{methoddesc}
372    
373 jgs 100 \begin{methoddesc}[Data]{trace}{}
374     returns the trace of the object of rank 2. The return value is an
375     object has rank 0 or shape (1,) and is defined on the same data points
376     like the object. For each data point the value is set to sum of the
377     main diagonal entries.
378    
379     For the case that object \var{self} is of rank 2 the result \var{res}
380     is
381     \begin{equation}
382     res(0;s)=
383     self(0,0;s)+
384     self(1,1;s)+
385     \ldots +
386     self(n,n;s)
387     \end{equation}
388     for all data points $s$ where
389     $n=min($\var{self.getShape()[0]},\var{self.getShape()[1]}$)$.
390     \index{trace}
391 jgs 82 \end{methoddesc}
392    
393 jgs 100 \begin{methoddesc}[Data]{exp}{}
394     applies the exponential function to the values of the object. The
395     return value is an object has the same shape and is defined on the
396     same data points like the object. For each data point and all
397     components the value is calculated by applying the exponention
398     function to the corresponding value of the object. \index{exponential
399     function}
400     \end{methoddesc}
401    
402 jgs 82 \begin{methoddesc}[Data]{sqrt}{}
403 jgs 100 applies the square root function to the values of the object. The
404     return value is an object has the same shape and is defined on the
405     same data points like the object. For each data point and all
406     components the value is calculated by applying the square root
407     function to the corresponding value of the object. An exception is
408     raised if the value is negative. \index{square root}
409 jgs 82 \end{methoddesc}
410    
411     \begin{methoddesc}[Data]{sin}{}
412 jgs 100 applies the sine function to the values of the object. The return
413     value is an object has the same shape and is defined on the same data
414     points like the object. For each data point and all components the
415     value is calculated by applying the sine function to the
416     corresponding value of the object. \index{sine function}
417 jgs 82 \end{methoddesc}
418    
419     \begin{methoddesc}[Data]{cos}{}
420 jgs 100 applies the cosine function to the values of the object. The return
421     value is an object has the same shape and is defined on the same data
422     points like the object. For each data point and all components the
423     value is calculated by applying the cosine function to the
424     corresponding value of the object. \index{cosine function}
425 jgs 82 \end{methoddesc}
426    
427 jgs 100 \begin{methoddesc}[Data]{maxval}{}
428     returns for each data point the maximum value over all components. The
429     return value is an object of rank 0 or shape (1,) and is defined on
430     the same data points like the object. \index{maximum value}
431 jgs 82 \end{methoddesc}
432    
433 jgs 100 \begin{methoddesc}[Data]{minval}{}
434     returns for each data point the minimum value over all components. The
435     return value is an object of rank 0 or shape (1,) and is defined on
436     the same data points like the object. \index{minimum value}
437 jgs 82 \end{methoddesc}
438    
439 jgs 100 \begin{methoddesc}[Data]{inf}{}
440     returns the minimum value (infimum) of the object. The minimum is
441     taken over all components and all data points. \index{infimum}
442 jgs 82 \end{methoddesc}
443    
444 jgs 100 \begin{methoddesc}[Data]{sup}{}
445     returns the maximum value (supremum) of the object. The maximum is
446     taken over all components and all data points. \index{supremum}
447 jgs 82 \end{methoddesc}
448    
449 jgs 100 \begin{methoddesc}[Data]{Lsup}{}
450     returns the $L^{sup}$-norm of the object. This is maximum value of the
451     absolut values of the object over all data points and all components.
452     \index{$L^{sup}$-norm}
453 jgs 82 \end{methoddesc}
454 jgs 100
455     \begin{methoddesc}[Data]{wherePositive}{}
456     returns \Data object which has the same shape and is defined on
457     the same data points like the object. The returned values are $1$
458     where the object is positive and $0$ elsewhere.
459 jgs 82 \end{methoddesc}
460    
461 jgs 100 \begin{methoddesc}[Data]{whereNonnegative}{}
462     returns \Data object which has the same shape and is defined on
463     the same data points like the object. The returned values are $1$
464     where the object is non-negative and $0$ elsewhere.
465 jgs 82 \end{methoddesc}
466    
467 jgs 100 \begin{methoddesc}[Data]{whereNegative}{}
468     returns \Data object which has the same shape and is defined on
469     the same data points like the object. The returned values are $1$
470     where the object is negative and $0$ elsewhere.
471 jgs 82 \end{methoddesc}
472    
473 jgs 100 \begin{methoddesc}[Data]{whereZero}{tolerance=Constants.EPSILON}
474     returns \Data object which has the same shape and is defined on
475     the same data points like the object. The returned values are $1$
476     where the object is nearly zero, i.e. where the absolute value is less
477     than \var{tolerance}, and $0$ elsewhere.
478 jgs 82 \end{methoddesc}
479    
480 jgs 100 \begin{methoddesc}[Data]{whereNonzero}{tolerance=Constants.EPSILON}
481     returns \Data object which has the same shape and is defined on
482     the same data points like the object. The returned values are $1$
483     where the object is nearly non-zero, i.e. where the absolute value is
484     greater or equal than \var{tolerance}, and $0$ elsewhere.
485 jgs 82 \end{methoddesc}
486    
487 jgs 100 \begin{methoddesc}[Data]{saveDX}{fileName}
488     saves the object to an openDX format file of name \var{fileName}, see
489     \ulink{www.opendx.org}{\url{www.opendx.org}}. \index{openDX}
490 jgs 82 \end{methoddesc}
491    
492 jgs 100 \begin{methoddesc}[Data]{saveMM}{fileName}
493 jgs 82 saves the object to a matrix market format file of name
494     \var{fileName}, see
495     \ulink{maths.nist.gov/MatrixMarket}{\url{http://maths.nist.gov/MatrixMarket}}.
496     \index{Matrix Market}
497     \end{methoddesc}
498    
499 jgs 100 %=====================================================
500     \section{Subclasses of \var{class}}
501     \begin{classdesc}{Scalar}{value=None,where=None,expand=None}
502     \Data object with a single value (scalar) per data
503     point. \var{value} must be a float number. If \var{expand} is true,
504     the \var{value} is copied to each data point.
505     \end{classdesc}
506    
507     \begin{classdesc}{Vector}{value=None,dim=None,where=None,expand=None}
508     \Data object with a vector of length \var{dim} value (scalar)
509     per data point. If \var{dim} is not present or equals \var{None},
510     \var{dim} is assumed to be the spatial dimension of the data points
511     defined by \var{where}. \var{value} may be a float number or a
512     \class{numarray.array} object with shape (\var{dim},). If
513     \var{expand} is true, the \var{value} is copied to each data point.
514     \end{classdesc}
515    
516     \begin{classdesc}{Tensor}{value=None,dim=None,where=None,expand=None}
517     \Data object with a \var{dim} $\times$ \var{dim} - tensor of
518     order 2 per data point. If \var{dim} is not present or equals
519     \var{None}, \var{dim} is assumed to be the spatial dimension of the
520     data points defined by \var{where}. \var{value} may be a float number
521     or a \class{numarray.array} object with shape (\var{dim},\var{dim}).
522     If \var{expand} is true, the \var{value} is copied to each data point.
523     \end{classdesc}
524    
525     \begin{classdesc}{Tensor3}{value=None,dim=None,where=None,expand=None}
526     \Data object with a \var{dim} $\times$ \var{dim} $\times$
527     \var{dim} - tensor of order 3 per data point. If \var{dim} is not
528     present or equals \var{None}, \var{dim} is assumed to be the spatial
529     dimension of the data points defined by \var{where}. \var{value} may
530     be a float number or a \class{numarray.array} object with shape
531     (\var{dim},\var{dim},var{dim}). If \var{expand} is true, the
532     \var{value} is copied to each data point.
533     \end{classdesc}
534    
535     \begin{classdesc}{Tensor4}{value=None,dim=None,where=None,expand=None}
536     \Data object with a \var{dim} $\times$ \var{dim} $\times$
537     \var{dim} $\times$ \var{dim} - tensor of order 4 per data point. If
538     \var{dim} is not present or equals \var{None}, \var{dim} is assumed to
539     be the spatial dimension of the data points defined by
540     \var{where}. \var{value} may be a float number or a
541     \class{numarray.array} object with shape
542     (\var{dim},\var{dim},var{dim},var{dim}). If \var{expand} is true, the
543     \var{value} is copied to each data point.
544     \end{classdesc}

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26