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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 82 - (show annotations)
Tue Oct 26 06:53:54 2004 UTC (14 years, 5 months ago) by jgs
Original Path: trunk/esys2/doc/user/escript.tex
File MIME type: application/x-tex
File size: 22311 byte(s)
Initial revision

1 % $Id$
2
3 \chapter{The module \escript}
4
5 \declaremodule{extension}{escript} \modulesynopsis{Handling data on
6 data points like \class{Nodes}, \class{Elements}}
7
8 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
16 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
31 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
45 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
59 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
78 The returned \Data object has the same shape and is defined on
79 the data points like \var{arg1} or \var{arg2}.
80
81 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
98
99 %TODO:
100 Slicing \index{slicing}.
101
102 \begin{classdesc}{Data}{}
103 A class that holds values assigned to data points.
104 \end{classdesc}
105
106 \begin{classdesc}{Scalar}{value=None,where=None,expand=None}
107 A class that holds a single value per data point.
108 \end{classdesc}
109
110 \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
114 \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
118 \begin{classdesc}{Tensor3}{value=None,dim=None,where=None,expand=None}
119 A class that holds a tensor order 3 per data point.
120 \end{classdesc}
121
122 \begin{classdesc}{Tensor4}{value=None,dim=None,where=None,expand=None}
123 A class that holds a tensor order 4 per data point.
124 \end{classdesc}
125
126 \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
134 \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
139 \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
144 \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
149 \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
154 \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
161 \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
168 \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 \end{funcdesc}
174
175 \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 \end{funcdesc}
181
182 \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 \end{funcdesc}
188
189 \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 \end{funcdesc}
195
196 \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 \end{funcdesc}
201
202 \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 \end{funcdesc}
207
208 \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 \end{funcdesc}
213
214 \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
220 \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
227 \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
239 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
251 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
258 %==================================================================
259 \section{\Data class}
260 \begin{classdesc}{Data}{value=None,shape=None,where=None,expand=None}
261 \end{classdesc}
262
263 \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 \end{methoddesc}
267
268 \begin{methoddesc}[Data]{getShape}{}
269 returns the shape of the data on each data point as a \class{tuple} of
270 integers. \index{shape}
271 \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 \begin{methoddesc}[Data]{hasShape}{shape}
278 is true if the object has the shape \var{shape}.
279 \end{methoddesc}
280
281 \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 \end{methoddesc}
285
286 \begin{methoddesc}[Data]{makeExpanded}{}
287 turns the object into an expanded \Data
288 object. \index{expanded}
289 \end{methoddesc}
290
291 \begin{methoddesc}[Data]{isExpanded}{}
292 is true if the object is expanded. \index{expanded}
293 \end{methoddesc}
294
295 \begin{methoddesc}[Data]{isTagged}{}
296 is true if the object is defined using tags. \index{tagged}
297 \end{methoddesc}
298
299 \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 \end{methoddesc}
305
306 \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
315 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 \end{methoddesc}
320
321 \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 \end{methoddesc}
326
327 \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 \end{methoddesc}
332
333 \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 \index{gradient}
339 \end{methoddesc}
340
341 \begin{methoddesc}[Data]{integrate}{}
342 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 component of the returned object is the integral of the corresponding
345 component of the object. \index{integral}
346 \end{methoddesc}
347
348 \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 \index{interpolation}
353 \end{methoddesc}
354
355 \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 \end{methoddesc}
372
373 \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 \end{methoddesc}
392
393 \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 \begin{methoddesc}[Data]{sqrt}{}
403 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 \end{methoddesc}
410
411 \begin{methoddesc}[Data]{sin}{}
412 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 \end{methoddesc}
418
419 \begin{methoddesc}[Data]{cos}{}
420 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 \end{methoddesc}
426
427 \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 \end{methoddesc}
432
433 \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 \end{methoddesc}
438
439 \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 \end{methoddesc}
443
444 \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 \end{methoddesc}
448
449 \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 \end{methoddesc}
454
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 \end{methoddesc}
460
461 \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 \end{methoddesc}
466
467 \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 \end{methoddesc}
472
473 \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 \end{methoddesc}
479
480 \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 \end{methoddesc}
486
487 \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 \end{methoddesc}
491
492 \begin{methoddesc}[Data]{saveMM}{fileName}
493 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 %=====================================================
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