/[ascend]/trunk/base/generic/solver/mtx_use_only.h
ViewVC logotype

Diff of /trunk/base/generic/solver/mtx_use_only.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 11 by aw0a, Sat Nov 13 16:45:56 2004 UTC revision 33 by ben.allan, Sun Dec 26 20:06:01 2004 UTC
# Line 1  Line 1 
1  #ifdef __MTX_C_SEEN__  #ifdef __MTX_C_SEEN__
2  /*  /**<
3   *  mtx2: Ascend Sparse Matrix Package   *  mtx2: Ascend Sparse Matrix Package
4   *  by Benjamin Andrew Allan   *  by Benjamin Andrew Allan
5   *  Derived from mtx by Karl Michael Westerberg   *  Derived from mtx by Karl Michael Westerberg
# Line 61  Line 61 
61  \*********************************************************************/  \*********************************************************************/
62  #ifndef __MTX_INTERNAL_USE_ONLY_H__  #ifndef __MTX_INTERNAL_USE_ONLY_H__
63  #define __MTX_INTERNAL_USE_ONLY_H__  #define __MTX_INTERNAL_USE_ONLY_H__
64  /* requires #include <stdio.h> */  /**< requires #include <stdio.h> */
65  /* requires #include "mem.h" */  /**< requires #include "mem.h" */
66  /* requires #include "mtx.h" */  /**< requires #include "mtx.h" */
67    
68  #ifndef FALSE  #ifndef FALSE
69  /* these should have come in from base.h. */  /**< these should have come in from base.h. */
70  #define FALSE 0  #define FALSE 0
71  #define TRUE 1  #define TRUE 1
72  #endif  #endif
73    
74  #define MTX_DEBUG FALSE  #define MTX_DEBUG FALSE
75  /* MTX_DEBUG is a no holds barred sanity checking flag for use when  /**< MTX_DEBUG is a no holds barred sanity checking flag for use when
76   * nothing else is giving a clue why something is going wrong. It   * nothing else is giving a clue why something is going wrong. It
77   * slows down the code to a crawl. Do not under any conditions change   * slows down the code to a crawl. Do not under any conditions change
78   * its value or undefine it except at this location. If you need some   * its value or undefine it except at this location. If you need some
# Line 83  Line 83 
83  #define EVEN FALSE  #define EVEN FALSE
84  #define ODD TRUE  #define ODD TRUE
85  #define SWAPS_PRESERVE_ORDER TRUE  #define SWAPS_PRESERVE_ORDER TRUE
86  /**  /**<
87   ***  Do row and column swaps preserve the ordering of non-zeros in rows   ***  Do row and column swaps preserve the ordering of non-zeros in rows
88   ***  and columns?  Setting this to TRUE means swapping only entails the   ***  and columns?  Setting this to TRUE means swapping only entails the
89   ***  movement of integer row or column numbers and NOT the exchange of   ***  movement of integer row or column numbers and NOT the exchange of
# Line 91  Line 91 
91   **/   **/
92  #define WIDTHMAGIC 2048  #define WIDTHMAGIC 2048
93  #define LENMAGIC 10  #define LENMAGIC 10
94  /**  /**<
95   *** WIDTHMAGIC is the byte size to aim for in allocating groups of elements.   *** WIDTHMAGIC is the byte size to aim for in allocating groups of elements.
96   *** LENMAGIC initial # of groups of elements, hence the smallest   *** LENMAGIC initial # of groups of elements, hence the smallest
97   *** possible number of elements a matrix will ever have is LENM*WIDTHM/eltsize.   *** possible number of elements a matrix will ever have is LENM*WIDTHM/eltsize.
98   **/   **/
99    
100  extern FILE *g_mtxerr;  extern FILE *g_mtxerr;
101  /**  /**<
102   *** Global file pointer to which errors are reported. Should never be   *** Global file pointer to which errors are reported. Should never be
103   *** NULL. Also useful when running ascend in gdb and you can't find   *** NULL. Also useful when running ascend in gdb and you can't find
104   *** any other file pointer to use.   *** any other file pointer to use.
# Line 108  struct next_element_t { Line 108  struct next_element_t {
108    struct element_t *row;    struct element_t *row;
109    struct element_t *col;    struct element_t *col;
110  };  };
111  /* just a struct to make resulting code more readable. */  /**< just a struct to make resulting code more readable. */
112    
113  struct element_t {  struct element_t {
114    real64 value;    real64 value;
# Line 116  struct element_t { Line 116  struct element_t {
116    int32 col;    int32 col;
117    struct next_element_t next;    struct next_element_t next;
118  };  };
119  /**  /**<
120   ***  This is the basic jacobian element of an mtx.   ***  This is the basic jacobian element of an mtx.
121   ***  It's size is 24 bytes on 4 byte pointer machines and   ***  It's size is 24 bytes on 4 byte pointer machines and
122   ***  32 bytes on 8 byte pointer machines.   ***  32 bytes on 8 byte pointer machines.
# Line 130  struct nz_headers_t { Line 130  struct nz_headers_t {
130    struct element_t **row;    struct element_t **row;
131    struct element_t **col;    struct element_t **col;
132  };  };
133  /**  /**<
134   ***  Each matrix is really just a pair of arrays of pointers to   ***  Each matrix is really just a pair of arrays of pointers to
135   ***  elements. The index of a row or column in THESE arrays is   ***  elements. The index of a row or column in THESE arrays is
136   ***  what is referred to as an org index. A value of NULL in   ***  what is referred to as an org index. A value of NULL in
# Line 147  struct nz_headers_t { Line 147  struct nz_headers_t {
147   **/   **/
148    
149  struct permutation_t {  struct permutation_t {
150    int32 *org_to_cur;          /* org_to_cur[-1] = -1 */    int32 *org_to_cur;          /**< org_to_cur[-1] = -1 */
151    int32 *cur_to_org;          /* cur_to_org[-1] = -1 */    int32 *cur_to_org;          /**< cur_to_org[-1] = -1 */
152    boolean parity;    boolean parity;
153  };  };
154  /**  /**<
155   ***  We maintain, rather than rederiving, the information required to   ***  We maintain, rather than rederiving, the information required to
156   ***  answer all possible permutation questions.   ***  answer all possible permutation questions.
157   ***  This is a policy decision based on the fact that mtx is research   ***  This is a policy decision based on the fact that mtx is research
# Line 165  struct permutation_t { Line 165  struct permutation_t {
165   ***  Special note: The -1th element of nz_header arrays is NOT allocated.   ***  Special note: The -1th element of nz_header arrays is NOT allocated.
166   **/   **/
167    
168  /* Do not access the parity field of a slave matrix, refer to its master. */  /**< Do not access the parity field of a slave matrix, refer to its master. */
169  /* Conduct all permuting operations on the master. */  /**< Conduct all permuting operations on the master. */
170    
171  struct permutations_t {  struct permutations_t {
172    struct permutation_t row;    struct permutation_t row;
# Line 175  struct permutations_t { Line 175  struct permutations_t {
175  };  };
176    
177  struct structural_data_t {  struct structural_data_t {
178    int32 symbolic_rank;        /* Symbolic rank (< 0 if invalid) */    int32 symbolic_rank;        /**< Symbolic rank (< 0 if invalid) */
179    int32 nblocks;              /* # blocks in matrix */    int32 nblocks;              /**< # blocks in matrix */
180    mtx_region_t *block;              /* Pointer to array of blocks */    mtx_region_t *block;              /**< Pointer to array of blocks */
181  };  };
182  /**  /**<
183   *** There is a list of blocks associated with a matrix.   *** There is a list of blocks associated with a matrix.
184   *** This is an artifact of POOR solver API design between   *** This is an artifact of POOR solver API design between
185   *** Peter Piela and Karl Westerberg. The blockwise decomposition   *** Peter Piela and Karl Westerberg. The blockwise decomposition
# Line 190  struct structural_data_t { Line 190  struct structural_data_t {
190   **/   **/
191    
192  struct mtx_header {  struct mtx_header {
193    int integrity;                    /* Integrity integer */    int integrity;                    /**< Integrity integer */
194    int32 order;                /* Order of the matrix */    int32 order;                /**< Order of the matrix */
195    int32 capacity;             /* Capacity of all the arrays */    int32 capacity;             /**< Capacity of all the arrays */
196    int32 nslaves;              /* number of slave matrices */    int32 nslaves;              /**< number of slave matrices */
197    struct nz_headers_t hdr;          /* Non-zero headers of the matrix */    struct nz_headers_t hdr;          /**< Non-zero headers of the matrix */
198    struct element_t *last_value;     /* value/set_value memory */    struct element_t *last_value;     /**< value/set_value memory */
199    mem_store_t ms;                   /* element cache memory */    mem_store_t ms;                   /**< element cache memory */
200    struct permutations_t perm;       /* Permutation vectors */    struct permutations_t perm;       /**< Permutation vectors */
201    struct structural_data_t *data;   /* Pointer to structural information */    struct structural_data_t *data;   /**< Pointer to structural information */
202    mtx_matrix_t master;              /* the master of this mtx, if slave */    mtx_matrix_t master;              /**< the master of this mtx, if slave */
203    mtx_matrix_t *slaves;             /* array of slave matrices */    mtx_matrix_t *slaves;             /**< array of slave matrices */
204  };  };
205  /**  /**<
206   ***  capacity may be > order.   ***  capacity may be > order.
207   ***  A matrix of capacity 0 doesn't have a mem_store_t yet and elements   ***  A matrix of capacity 0 doesn't have a mem_store_t yet and elements
208   ***  cannot be queried about without a core dump.   ***  cannot be queried about without a core dump.
# Line 210  struct mtx_header { Line 210  struct mtx_header {
210    
211  struct mtx_block_perm_structure {  struct mtx_block_perm_structure {
212    int integrity;    int integrity;
213    int32 order;                /* Order of the matrix */    int32 order;                /**< Order of the matrix */
214    int32 capacity;             /* Capacity of all the arrays */    int32 capacity;             /**< Capacity of all the arrays */
215    mtx_matrix_t mtx;                 /* matrix of origin */    mtx_matrix_t mtx;                 /**< matrix of origin */
216    struct permutations_t perm;       /* Permutation vectors */    struct permutations_t perm;       /**< Permutation vectors */
217    struct structural_data_t *data;    /* Pointers to structural information */    struct structural_data_t *data;    /**< Pointers to structural information */
218  };  };
219  /**  /**<
220   *** If you want to save a permutation for restoration, you   *** If you want to save a permutation for restoration, you
221   *** have to make a copy of that data, eh? Here's the place you   *** have to make a copy of that data, eh? Here's the place you
222   *** put it. Note that the block list should be disappearing from   *** put it. Note that the block list should be disappearing from
# Line 226  struct mtx_block_perm_structure { Line 226  struct mtx_block_perm_structure {
226    
227  #define OK        ((int)201539237)  #define OK        ((int)201539237)
228  #define DESTROYED ((int)531503871)  #define DESTROYED ((int)531503871)
229  /* matrix integrity values. */  /**< matrix integrity values. */
230    
231  #define ZERO      ((int32)0)  #define ZERO      ((int32)0)
232  #define D_ZERO    ((real64)0.0)  #define D_ZERO    ((real64)0.0)
233  #define D_ONE    ((real64)1.0)  #define D_ONE    ((real64)1.0)
234  /* useful constants if your C compiler is not too bright about ANSI */  /**< useful constants if your C compiler is not too bright about ANSI */
235    
236  #define ISSLAVE(m) ((m)->master!=NULL)  #define ISSLAVE(m) ((m)->master!=NULL)
237  /**  /**<
238   ***  Returns 1 if m is a slave matrix, 0 if not.   ***  Returns 1 if m is a slave matrix, 0 if not.
239   **/   **/
240    
241  #define ordered3(a,b,c) ((a) <= (b) && (b) <= (c))  #define ordered3(a,b,c) ((a) <= (b) && (b) <= (c))
242  #define in_range(rng,ndx) ordered3((rng)->low,ndx,(rng)->high)  #define in_range(rng,ndx) ordered3((rng)->low,ndx,(rng)->high)
243  #define legal(mtx,ndx) ordered3(ZERO,ndx,(mtx)->order-1)  #define legal(mtx,ndx) ordered3(ZERO,ndx,(mtx)->order-1)
244  /**  /**<
245   ***  Boolean operators to compare a row or column   ***  Boolean operators to compare a row or column
246   ***  index with some specified range or the maximum   ***  index with some specified range or the maximum
247   ***  range of the matrix in which it is used.   ***  range of the matrix in which it is used.
# Line 249  struct mtx_block_perm_structure { Line 249  struct mtx_block_perm_structure {
249    
250  #define fast_in_range(l,h,i) ( ordered3(l,i,h) )  #define fast_in_range(l,h,i) ( ordered3(l,i,h) )
251  #define not_in_range(l,h,i) ( (i)<(l) || (i)>(h) )  #define not_in_range(l,h,i) ( (i)<(l) || (i)>(h) )
252  /**  /**<
253   ***  Boolean operators to compare 3 integers.   ***  Boolean operators to compare 3 integers.
254   ***  l <= h must be TRUE or these will lie. In many cases,   ***  l <= h must be TRUE or these will lie. In many cases,
255   ***  this condition can (or should) be met before in_range   ***  this condition can (or should) be met before in_range
# Line 266  struct mtx_block_perm_structure { Line 266  struct mtx_block_perm_structure {
266    
267  #define zero(ptr,nelts,type)  \  #define zero(ptr,nelts,type)  \
268     mem_zero_byte_cast((ptr),0,(nelts)*sizeof(type))     mem_zero_byte_cast((ptr),0,(nelts)*sizeof(type))
269  /**  /**<
270   ***  Zeros a vector of specified length and type.   ***  Zeros a vector of specified length and type.
271   ***  It is inefficient to use, however, if you know the type   ***  It is inefficient to use, however, if you know the type
272   ***  is one of the basic types (int,double,ptr,char)   ***  is one of the basic types (int,double,ptr,char)
# Line 277  struct mtx_block_perm_structure { Line 277  struct mtx_block_perm_structure {
277    Private check routines    Private check routines
278  \**************************************************************************/  \**************************************************************************/
279  extern int super_check_matrix(mtx_matrix_t);  extern int super_check_matrix(mtx_matrix_t);
280  /**  /**<
281   *** After somevery extensive checking, returns an error count.   *** After somevery extensive checking, returns an error count.
282   *** More or less assume MTX_DEBUG is TRUE, and that is the only   *** More or less assume MTX_DEBUG is TRUE, and that is the only
283   *** condition under which this should be called.   *** condition under which this should be called.
# Line 297  extern int super_check_matrix(mtx_matrix Line 297  extern int super_check_matrix(mtx_matrix
297  \**************************************************************************/  \**************************************************************************/
298    
299  struct element_t *mtx_find_element( mtx_matrix_t, int32, int32);  struct element_t *mtx_find_element( mtx_matrix_t, int32, int32);
300  /**  /**<
301   ***  mtx_find_element(mtx,org_row,org_col)   ***  mtx_find_element(mtx,org_row,org_col)
302   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
303   ***  int32 org_row;   ***  int32 org_row;
# Line 310  struct element_t *mtx_find_element( mtx_ Line 310  struct element_t *mtx_find_element( mtx_
310   **/   **/
311    
312  struct element_t *mtx_create_element( mtx_matrix_t, int32, int32);  struct element_t *mtx_create_element( mtx_matrix_t, int32, int32);
313  /**  /**<
314   ***  mtx_create_element(mtx,org_row,org_col);   ***  mtx_create_element(mtx,org_row,org_col);
315   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
316   ***  int32 org_row;   ***  int32 org_row;
# Line 325  struct element_t *mtx_create_element( mt Line 325  struct element_t *mtx_create_element( mt
325    
326  struct element_t *mtx_create_element_value(mtx_matrix_t, int32,  struct element_t *mtx_create_element_value(mtx_matrix_t, int32,
327                                             int32,real64);                                             int32,real64);
328  /**  /**<
329   ***  mtx_create_element_value(mtx,org_row,org_col,val);   ***  mtx_create_element_value(mtx,org_row,org_col,val);
330   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
331   ***  int32 org_row;   ***  int32 org_row;
# Line 345  struct element_t *mtx_create_element_val Line 345  struct element_t *mtx_create_element_val
345  \**************************************************************************/  \**************************************************************************/
346  extern struct element_t *mtx_next_col(register struct element_t *,  extern struct element_t *mtx_next_col(register struct element_t *,
347                                        mtx_range_t *, int32 *);                                        mtx_range_t *, int32 *);
348  /**  /**<
349   ***  enext = struct element_t *mtx_next_col(elt,rng,tocur);   ***  enext = struct element_t *mtx_next_col(elt,rng,tocur);
350   ***  struct element_t *elt, *enext;   ***  struct element_t *elt, *enext;
351   ***  mtx_range_t *rng;   ***  mtx_range_t *rng;
# Line 357  extern struct element_t *mtx_next_col(re Line 357  extern struct element_t *mtx_next_col(re
357    
358  extern struct element_t *mtx_next_row(register struct element_t *,  extern struct element_t *mtx_next_row(register struct element_t *,
359                                        mtx_range_t *, int32 *);                                        mtx_range_t *, int32 *);
360  /**  /**<
361   ***  enext = struct element_t *mtx_next_row(elt,rng,tocur);   ***  enext = struct element_t *mtx_next_row(elt,rng,tocur);
362   ***  struct element_t *elt, *enext;   ***  struct element_t *elt, *enext;
363   ***  mtx_range_t *rng;   ***  mtx_range_t *rng;
# Line 371  extern struct element_t *mtx_next_row(re Line 371  extern struct element_t *mtx_next_row(re
371    Permutation memory management.    Permutation memory management.
372  \**************************************************************************/  \**************************************************************************/
373  extern int32 *mtx_alloc_perm(int32);  extern int32 *mtx_alloc_perm(int32);
374  /**  /**<
375   ***  p = mtx_alloc_perm(cap);   ***  p = mtx_alloc_perm(cap);
376   ***  int32 cap, *p;   ***  int32 cap, *p;
377   ***  Allocates a permutation vector.  The user need   ***  Allocates a permutation vector.  The user need
# Line 379  extern int32 *mtx_alloc_perm(int32); Line 379  extern int32 *mtx_alloc_perm(int32);
379   **/   **/
380    
381  extern void mtx_copy_perm(int32 *, int32 *, int32);  extern void mtx_copy_perm(int32 *, int32 *, int32);
382  /**  /**<
383   ***  mtx_copy_perm(tarperm,srcperm,cap)   ***  mtx_copy_perm(tarperm,srcperm,cap)
384   ***  int32 *tarperm;   ***  int32 *tarperm;
385   ***  int32 *srcperm;   ***  int32 *srcperm;
# Line 389  extern void mtx_copy_perm(int32 *, int32 Line 389  extern void mtx_copy_perm(int32 *, int32
389   **/   **/
390    
391  extern void mtx_free_perm(int32 *);  extern void mtx_free_perm(int32 *);
392  /**  /**<
393   ***  mtx_free_perm(perm);   ***  mtx_free_perm(perm);
394   ***  int32 *perm;   ***  int32 *perm;
395   **/   **/
# Line 406  extern void mtx_free_perm(int32 *); Line 406  extern void mtx_free_perm(int32 *);
406  \**************************************************************************/  \**************************************************************************/
407    
408  struct reusable_data_vector {  struct reusable_data_vector {
409    void *arr;          /* pointer to array of objects size entrysize */    void *arr;          /**< pointer to array of objects size entrysize */
410    int capacity;       /* number of object slots in array */    int capacity;       /**< number of object slots in array */
411    size_t entry_size;  /* size of slots */    size_t entry_size;  /**< size of slots */
412    int last_line;      /* line most recently associated with this structure,    int last_line;      /**< line most recently associated with this structure,
413                           should be 0 if the array is not in use. */                           should be 0 if the array is not in use. */
414  };  };
415    
416  extern struct reusable_data_vector  extern struct reusable_data_vector
417    g_mtx_null_index_data,        /* bunch of int32 */    g_mtx_null_index_data,        /**< bunch of int32 */
418    g_mtx_null_sum_data,          /* bunch of mtx_value_t */    g_mtx_null_sum_data,          /**< bunch of mtx_value_t */
419    g_mtx_null_mark_data,         /* bunch of char */    g_mtx_null_mark_data,         /**< bunch of char */
420    g_mtx_null_vector_data,       /* bunch of element pointers */    g_mtx_null_vector_data,       /**< bunch of element pointers */
421    g_mtx_null_col_vector_data,       /* bunch of element pointers */    g_mtx_null_col_vector_data,       /**< bunch of element pointers */
422    g_mtx_null_row_vector_data;       /* bunch of element pointers */    g_mtx_null_row_vector_data;       /**< bunch of element pointers */
423    
424  /**  /**<
425   ***  vec = mtx_null_vector(nptrs);   ***  vec = mtx_null_vector(nptrs);
426   ***  vec = mtx_null_col_vector(nptrs);   ***  vec = mtx_null_col_vector(nptrs);
427   ***  vec = mtx_null_row_vector(nptrs);   ***  vec = mtx_null_row_vector(nptrs);
# Line 514  extern struct reusable_data_vector Line 514  extern struct reusable_data_vector
514    
515  extern void *mtx_null_vector_f(int32, int, CONST char *,  extern void *mtx_null_vector_f(int32, int, CONST char *,
516                                 struct reusable_data_vector *, char *);                                 struct reusable_data_vector *, char *);
517  /**  /**<
518   *** v = mtx_null_vector_f(cap,line,file, ptr,fn);   *** v = mtx_null_vector_f(cap,line,file, ptr,fn);
519   *** int32 cap;   *** int32 cap;
520   *** int line;   *** int line;
# Line 533  extern void *mtx_null_vector_f(int32, in Line 533  extern void *mtx_null_vector_f(int32, in
533    
534  extern void mtx_null_vector_release_f(int, CONST char *,  extern void mtx_null_vector_release_f(int, CONST char *,
535                                        struct reusable_data_vector *, char *);                                        struct reusable_data_vector *, char *);
536  /**  /**<
537   *** mtx_null_vector_release_f(line,file,ptr,fn);   *** mtx_null_vector_release_f(line,file,ptr,fn);
538   *** int line;   *** int line;
539   *** CONST char *file,   *** CONST char *file,
# Line 546  extern void mtx_null_vector_release_f(in Line 546  extern void mtx_null_vector_release_f(in
546   **/   **/
547    
548  extern void mtx_reset_null_vectors(void);  extern void mtx_reset_null_vectors(void);
549  /**  /**<
550   *** This resets the reusable arrays of zeroes to zero in the event   *** This resets the reusable arrays of zeroes to zero in the event
551   *** that they may have been corrupted.   *** that they may have been corrupted.
552   **/   **/
553    
554  /*  /**<
555   ** INTERNAL element vector operations of some utility.   ** INTERNAL element vector operations of some utility.
556   */   */
557    
558  extern struct element_t **mtx_expand_row(mtx_matrix_t, int32);  extern struct element_t **mtx_expand_row(mtx_matrix_t, int32);
559  /**  /**<
560   ***  buf = mtx_expand_row(mtx,orgrow);   ***  buf = mtx_expand_row(mtx,orgrow);
561   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
562   ***  int32 orgrow;   ***  int32 orgrow;
# Line 570  extern struct element_t **mtx_expand_row Line 570  extern struct element_t **mtx_expand_row
570   **/   **/
571    
572  extern struct element_t **mtx_expand_col(mtx_matrix_t, int32);  extern struct element_t **mtx_expand_col(mtx_matrix_t, int32);
573  /**  /**<
574   ***  buf = mtx_expand_col(mtx,orgcol);   ***  buf = mtx_expand_col(mtx,orgcol);
575   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
576   ***  int32 orgcol;   ***  int32 orgcol;
# Line 585  extern struct element_t **mtx_expand_col Line 585  extern struct element_t **mtx_expand_col
585    
586  extern void mtx_renull_using_row(mtx_matrix_t, int32,  extern void mtx_renull_using_row(mtx_matrix_t, int32,
587                                   struct element_t **);                                   struct element_t **);
588  /**  /**<
589   ***  mtx_renull_using_row(mtx,orgrow,arr)   ***  mtx_renull_using_row(mtx,orgrow,arr)
590   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
591   ***  int32 orgrow;   ***  int32 orgrow;
# Line 598  extern void mtx_renull_using_row(mtx_mat Line 598  extern void mtx_renull_using_row(mtx_mat
598    
599  extern void mtx_renull_using_col(mtx_matrix_t, int32,  extern void mtx_renull_using_col(mtx_matrix_t, int32,
600                                   struct element_t **);                                   struct element_t **);
601  /**  /**<
602   ***  mtx_renull_using_row(mtx,orgcol,arr);   ***  mtx_renull_using_row(mtx,orgcol,arr);
603   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
604   ***  int32 orgcol;   ***  int32 orgcol;
# Line 610  extern void mtx_renull_using_col(mtx_mat Line 610  extern void mtx_renull_using_col(mtx_mat
610   **/   **/
611    
612  extern void mtx_renull_all(mtx_matrix_t, struct element_t **);  extern void mtx_renull_all(mtx_matrix_t, struct element_t **);
613  /**  /**<
614   ***  mtx_renull_all(mtx,arr);   ***  mtx_renull_all(mtx,arr);
615   ***  mtx_matrix_t mtx;   ***  mtx_matrix_t mtx;
616   ***  struct element_t **arr;   ***  struct element_t **arr;
# Line 619  extern void mtx_renull_all(mtx_matrix_t, Line 619  extern void mtx_renull_all(mtx_matrix_t,
619   ***     ***  
620   **/   **/
621    
622  #endif /* __MTX_INTERNAL_USE_ONLY_H__ */  #endif /**< __MTX_INTERNAL_USE_ONLY_H__ */
623  #endif /* none of your business if you aren't mtx_*.c */  #endif /**< none of your business if you aren't mtx_*.c */

Legend:
Removed from v.11  
changed lines
  Added in v.33

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22