1 /* basics.C */
2
3 #include "../DV.h"
4
5 /*--------------------------------------------------------------------*/
6 /*
7 -----------------------------------------------------------
8 shift the base of the entries and adjust the dimensions
9 note: this is a dangerous operation because the dv->vec
10 does not point to the base of the entries any longer,
11 and thus if the object owns its entries and it is called
12 to resize them or to free them, malloc and free will choke.
13
14 USE WITH CAUTION!
15
16 created -- 96aug25, cca
17 modified -- 96aug28, cca
18 structure changed
19 -----------------------------------------------------------
20 */
21 void
DV_shiftBase(DV * dv,int offset)22 DV_shiftBase (
23 DV *dv,
24 int offset
25 ) {
26 if ( dv == NULL ) {
27 fprintf(stderr, "\n fatal error in DV_shiftBase(%p,%d)"
28 "\n bad input\n", dv, offset) ;
29 exit(-1) ;
30 }
31 dv->vec += offset ;
32 dv->maxsize -= offset ;
33 dv->size -= offset ;
34
35 return ; }
36
37 /*--------------------------------------------------------------------*/
38 /*
39 --------------------------------------
40 push an entry onto the list
41
42 created -- 95oct06, cca
43 --------------------------------------
44 */
45 void
DV_push(DV * dv,double val)46 DV_push (
47 DV *dv,
48 double val
49 ) {
50 if ( dv == NULL ) {
51 fprintf(stderr, "\n fatal error in DV_push(%p,%f)"
52 "\n bad input\n", dv, val) ;
53 exit(-1) ;
54 }
55 if ( dv->size == dv->maxsize ) {
56 if ( dv->maxsize > 0 ) {
57 DV_setMaxsize(dv, 2*dv->maxsize) ;
58 } else {
59 DV_setMaxsize(dv, 10) ;
60 }
61 }
62 dv->vec[dv->size++] = val ;
63
64 return ; }
65
66 /*--------------------------------------------------------------------*/
67 /*
68 -----------------------------------
69 minimum and maximum entries and sum
70
71 created -- 95oct06, cca
72 -----------------------------------
73 */
74 double
DV_min(DV * dv)75 DV_min (
76 DV *dv
77 ) {
78 int i ;
79
80 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
81 fprintf(stderr, "\n fatal error in DV_min(%p), size = %d, vec = %p",
82 dv, dv->size, dv->vec) ;
83 exit(-1) ;
84 }
85 return(DVmin(dv->size, dv->vec, &i)) ; }
86
87 double
DV_max(DV * dv)88 DV_max (
89 DV *dv
90 ) {
91 int i ;
92
93 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
94 fprintf(stderr, "\n fatal error in DV_max(%p), size = %d, vec = %p",
95 dv, dv->size, dv->vec) ;
96 exit(-1) ;
97 }
98 return(DVmax(dv->size, dv->vec, &i)) ; }
99
100 double
DV_sum(DV * dv)101 DV_sum (
102 DV *dv
103 ) {
104 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
105 fprintf(stderr, "\n fatal error in DV_sum(%p), size = %d, vec = %p",
106 dv, dv->size, dv->vec) ;
107 exit(-1) ;
108 }
109 return(DVsum(dv->size, dv->vec)) ; }
110
111 /*--------------------------------------------------------------------*/
112 /*
113 -------------------------------------------------------
114 sort each index list into ascending or descending order
115
116 created -- 95oct06, cca
117 -------------------------------------------------------
118 */
119 void
DV_sortUp(DV * dv)120 DV_sortUp (
121 DV *dv
122 ) {
123 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
124 fprintf(stderr,
125 "\n fatal error in DV_sortUp(%p), size = %d, vec = %p",
126 dv, dv->size, dv->vec) ;
127 exit(-1) ;
128 }
129 DVqsortUp(dv->size, dv->vec) ;
130
131 return ; }
132
133 void
DV_sortDown(DV * dv)134 DV_sortDown (
135 DV *dv
136 ) {
137 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
138 fprintf(stderr,
139 "\n fatal error in DV_sortDown(%p), size = %d, vec = %p",
140 dv, dv->size, dv->vec) ;
141 exit(-1) ;
142 }
143 DVqsortDown(dv->size, dv->vec) ;
144
145 return ; }
146
147 /*--------------------------------------------------------------------*/
148 /*
149 -----------------------
150 ramp the entries
151
152 created -- 95oct06, cca
153 -----------------------
154 */
155 void
DV_ramp(DV * dv,double base,double incr)156 DV_ramp (
157 DV *dv,
158 double base,
159 double incr
160 ) {
161 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
162 fprintf(stderr,
163 "\n fatal error in DV_ramp(%p,%f,%f), size = %d, vec = %p",
164 dv, base, incr, dv->size, dv->vec) ;
165 exit(-1) ;
166 }
167 DVramp(dv->size, dv->vec, base, incr) ;
168
169 return ; }
170
171 /*--------------------------------------------------------------------*/
172 /*
173 -----------------------
174 shuffle the list
175
176 created -- 95oct06, cca
177 -----------------------
178 */
179 void
DV_shuffle(DV * dv,int seed)180 DV_shuffle (
181 DV *dv,
182 int seed
183 ) {
184 if ( dv == NULL || dv->size <= 0 || dv->vec == NULL ) {
185 fprintf(stderr,
186 "\n fatal error in DV_shuffle(%p,%d), size = %d, vec = %p",
187 dv, seed, dv->size, dv->vec) ;
188 exit(-1) ;
189 }
190 DVshuffle(dv->size, dv->vec, seed) ;
191
192 return ; }
193
194 /*--------------------------------------------------------------------*/
195 /*
196 ----------------------------------------------
197 return the number of bytes taken by the object
198
199 created -- 95oct06, cca
200 ----------------------------------------------
201 */
202 int
DV_sizeOf(DV * dv)203 DV_sizeOf (
204 DV *dv
205 ) {
206 int nbytes ;
207
208 if ( dv == NULL ) {
209 fprintf(stderr, "\n fatal error in DV_sizeOf(%p)"
210 "\n bad input \n", dv) ;
211 exit(-1) ;
212 }
213 nbytes = sizeof(struct _DV) ;
214 if ( dv->owned == 1 ) {
215 nbytes += + dv->maxsize*sizeof(double) ;
216 }
217 return(nbytes) ; }
218
219 /*--------------------------------------------------------------------*/
220 /*
221 --------------------------------------------
222 iterator :
223 return the pointer to the head of the vector
224
225 created -- 95oct06, cca
226 --------------------------------------------
227 */
228 double *
DV_first(DV * dv)229 DV_first (
230 DV *dv
231 ) {
232 double *pd ;
233 /*
234 ---------------
235 check the input
236 ---------------
237 */
238 if ( dv == NULL ) {
239 fprintf(stderr, "\n fatal error in DV_first(%p)"
240 "\n bad input", dv) ;
241 exit(-1) ;
242 }
243 if ( dv->size == 0 ) {
244 pd = NULL ;
245 } else {
246 pd = dv->vec ;
247 }
248 return(pd) ; }
249
250 /*--------------------------------------------------------------------*/
251 /*
252 -----------------------------------------------------
253 iterator :
254 return the pointer to the next location in the vector
255
256 created -- 95oct06, cca
257 -----------------------------------------------------
258 */
259 double *
DV_next(DV * dv,double * pd)260 DV_next (
261 DV *dv,
262 double *pd
263 ) {
264 int offset ;
265 /*
266 ---------------
267 check the input
268 ---------------
269 */
270 if ( pd == NULL ) {
271 fprintf(stderr, "\n fatal error in DV_next(%p,%p)"
272 "\n bad input", dv, pd) ;
273 fflush(stderr) ;
274 exit(-1) ;
275 }
276 /*
277 ---------------
278 check the input
279 ---------------
280 */
281 if ( (offset = pd - dv->vec) < 0 || offset >= dv->size ) {
282 /*
283 -----------------------------
284 error, offset is out of range
285 -----------------------------
286 */
287 fprintf(stderr, "\n fatal error in DV_next(%p,%p)"
288 "\n offset = %d, must be in [0,%d)",
289 dv, pd, offset, dv->size) ;
290 fflush(stderr) ;
291 exit(-1) ;
292 } else if ( offset == dv->size - 1 ) {
293 /*
294 ----------------------------
295 end of the list, return NULL
296 ----------------------------
297 */
298 pd = NULL ;
299 } else {
300 /*
301 ----------------------------------------
302 middle of the list, return next location
303 ----------------------------------------
304 */
305 pd++ ;
306 }
307 return(pd) ; }
308
309 /*--------------------------------------------------------------------*/
310 /*
311 --------------------------
312 fill a vector with a value
313
314 created -- 96jun22, cca
315 --------------------------
316 */
317 void
DV_fill(DV * dv,double value)318 DV_fill (
319 DV *dv,
320 double value
321 ) {
322 /*
323 ---------------
324 check the input
325 ---------------
326 */
327 if ( dv == NULL ) {
328 fprintf(stderr, "\n fatal error in DV_fill(%p,%f)"
329 "\n bad input\n", dv, value) ;
330 exit(-1) ;
331 }
332 if ( dv->size > 0 ) {
333 DVfill(dv->size, dv->vec, value) ;
334 }
335
336 return ; }
337
338 /*--------------------------------------------------------------------*/
339 /*
340 --------------------------
341 fill a vector with zeros
342
343 created -- 98jun02, cca
344 --------------------------
345 */
346 void
DV_zero(DV * dv)347 DV_zero (
348 DV *dv
349 ) {
350 /*
351 ---------------
352 check the input
353 ---------------
354 */
355 if ( dv == NULL ) {
356 fprintf(stderr, "\n fatal error in DV_zero(%p)"
357 "\n bad input\n", dv) ;
358 exit(-1) ;
359 }
360 if ( dv->size > 0 ) {
361 DVzero(dv->size, dv->vec) ;
362 }
363 return ; }
364
365 /*--------------------------------------------------------------------*/
366 /*
367 --------------------------------------
368 copy entries from dv2 into dv1.
369 note: this is a "mapped" copy,
370 dv1 and dv2 need not be the same size.
371
372 created -- 96aug31, cca
373 --------------------------------------
374 */
375 void
DV_copy(DV * dv1,DV * dv2)376 DV_copy (
377 DV *dv1,
378 DV *dv2
379 ) {
380 int ii, size ;
381 double *vec1, *vec2 ;
382 /*
383 ---------------
384 check the input
385 ---------------
386 */
387 if ( dv1 == NULL || dv2 == NULL ) {
388 fprintf(stderr, "\n fatal error in DV_copy(%p,%p)"
389 "\n bad input\n", dv1, dv2) ;
390 exit(-1) ;
391 }
392 size = dv1->size ;
393 if ( size > dv2->size ) {
394 size = dv2->size ;
395 }
396 vec1 = dv1->vec ;
397 vec2 = dv2->vec ;
398 for ( ii = 0 ; ii < size ; ii++ ) {
399 vec1[ii] = vec2[ii] ;
400 }
401 return ; }
402
403 /*--------------------------------------------------------------------*/
404