1 | /********************************************************************* |
---|
2 | * Copyright 1993, UCAR/Unidata |
---|
3 | * See netcdf/COPYRIGHT file for copying and redistribution conditions. |
---|
4 | * $Header: /upc/share/CVS/netcdf-3/libncdap3/dapodom.c,v 1.12 2010/05/27 21:34:08 dmh Exp $ |
---|
5 | *********************************************************************/ |
---|
6 | |
---|
7 | #include "ncdap3.h" |
---|
8 | #include "dapodom.h" |
---|
9 | |
---|
10 | /**********************************************/ |
---|
11 | /* Define methods for a dimension dapodometer*/ |
---|
12 | |
---|
13 | Dapodometer* |
---|
14 | newdapodometer(DCEslice* slices, unsigned int first, unsigned int rank) |
---|
15 | { |
---|
16 | int i; |
---|
17 | Dapodometer* odom = (Dapodometer*)calloc(1,sizeof(Dapodometer)); |
---|
18 | MEMCHECK(odom,NULL); |
---|
19 | if(rank == 0) { |
---|
20 | return newdapodometer1(1); |
---|
21 | } |
---|
22 | odom->rank = rank; |
---|
23 | ASSERT(odom->rank <= NC_MAX_VAR_DIMS); |
---|
24 | for(i=0;i<odom->rank;i++) { |
---|
25 | DCEslice* slice = slices+(first+i); |
---|
26 | odom->slices[i] = *slice; |
---|
27 | odom->index[i] = odom->slices[i].first; |
---|
28 | } |
---|
29 | return odom; |
---|
30 | } |
---|
31 | |
---|
32 | Dapodometer* |
---|
33 | newsimpledapodometer(DCEsegment* segment, unsigned int rank) |
---|
34 | { |
---|
35 | int i; |
---|
36 | Dapodometer* odom = (Dapodometer*)calloc(1,sizeof(Dapodometer)); |
---|
37 | MEMCHECK(odom,NULL); |
---|
38 | if(rank == 0) { |
---|
39 | return newdapodometer1(1); |
---|
40 | } |
---|
41 | odom->rank = rank; |
---|
42 | assert(odom->rank <= NC_MAX_VAR_DIMS); |
---|
43 | assert(segment->slicesdefined && segment->slicesdeclized); |
---|
44 | for(i=0;i<odom->rank;i++) { |
---|
45 | DCEslice* odslice = &odom->slices[i]; |
---|
46 | DCEslice* segslice = &segment->slices[i]; |
---|
47 | odslice->first = 0; |
---|
48 | odslice->stride = 1; |
---|
49 | odslice->declsize = segslice->count; |
---|
50 | odslice->length = odslice->declsize; |
---|
51 | odslice->stop = odslice->declsize; |
---|
52 | odslice->count = odslice->declsize; |
---|
53 | odom->index[i] = 0; |
---|
54 | } |
---|
55 | return odom; |
---|
56 | } |
---|
57 | |
---|
58 | Dapodometer* |
---|
59 | newdapodometer1(unsigned int count) |
---|
60 | { |
---|
61 | Dapodometer* odom = (Dapodometer*)calloc(1,sizeof(Dapodometer)); |
---|
62 | MEMCHECK(odom,NULL); |
---|
63 | odom->rank = 1; |
---|
64 | odom->slices[0].first = 0; |
---|
65 | odom->slices[0].length = count; |
---|
66 | odom->slices[0].stride = 1; |
---|
67 | odom->slices[0].stop = count; |
---|
68 | odom->slices[0].declsize = count; |
---|
69 | odom->slices[0].count = count; |
---|
70 | odom->index[0] = 0; |
---|
71 | return odom; |
---|
72 | } |
---|
73 | |
---|
74 | void |
---|
75 | freedapodometer(Dapodometer* odom) |
---|
76 | { |
---|
77 | if(odom) free(odom); |
---|
78 | } |
---|
79 | |
---|
80 | char* |
---|
81 | dapodometerprint(Dapodometer* odom) |
---|
82 | { |
---|
83 | int i; |
---|
84 | static char line[1024]; |
---|
85 | char tmp[64]; |
---|
86 | line[0] = '\0'; |
---|
87 | if(odom->rank == 0) { |
---|
88 | strcat(line,"[]"); |
---|
89 | } else for(i=0;i<odom->rank;i++) { |
---|
90 | sprintf(tmp,"[%lu/%lu:%lu:%lu]", |
---|
91 | (unsigned long)odom->index[i], |
---|
92 | (unsigned long)odom->slices[i].first, |
---|
93 | (unsigned long)odom->slices[i].stride, |
---|
94 | (unsigned long)odom->slices[i].length); |
---|
95 | strcat(line,tmp); |
---|
96 | } |
---|
97 | return line; |
---|
98 | } |
---|
99 | |
---|
100 | int |
---|
101 | dapodometermore(Dapodometer* odom) |
---|
102 | { |
---|
103 | return (odom->index[0] < odom->slices[0].stop); |
---|
104 | } |
---|
105 | |
---|
106 | void |
---|
107 | dapodometerreset(Dapodometer* odom) |
---|
108 | { |
---|
109 | int rank = odom->rank; |
---|
110 | while(rank-- > 0) {odom->index[rank] = odom->slices[rank].first;} |
---|
111 | } |
---|
112 | |
---|
113 | /* Convert current dapodometer settings to a single integer count*/ |
---|
114 | size_t |
---|
115 | dapodometercount(Dapodometer* odom) |
---|
116 | { |
---|
117 | int i; |
---|
118 | size_t offset = 0; |
---|
119 | for(i=0;i<odom->rank;i++) { |
---|
120 | offset *= odom->slices[i].declsize; |
---|
121 | offset += odom->index[i]; |
---|
122 | } |
---|
123 | return offset; |
---|
124 | } |
---|
125 | |
---|
126 | /* |
---|
127 | Given a dapodometer, compute the total |
---|
128 | number of elements in its space |
---|
129 | as determined by declsize; start at |
---|
130 | offset wheel |
---|
131 | */ |
---|
132 | |
---|
133 | size_t |
---|
134 | dapodometerspace(Dapodometer* odom, unsigned int wheel) |
---|
135 | { |
---|
136 | unsigned int i,rank = odom->rank; |
---|
137 | size_t count = 1; |
---|
138 | DCEslice* slice; |
---|
139 | ASSERT((wheel < rank)); |
---|
140 | slice = odom->slices+wheel; |
---|
141 | for(i=wheel;i<rank;i++,slice++) { |
---|
142 | count *= slice->declsize; |
---|
143 | } |
---|
144 | return count; |
---|
145 | } |
---|
146 | |
---|
147 | /* |
---|
148 | Compute the number of elements |
---|
149 | that will be returned as the odometer |
---|
150 | is incremented to its stop point. |
---|
151 | */ |
---|
152 | |
---|
153 | size_t |
---|
154 | dapodometerpoints(Dapodometer* odom) |
---|
155 | { |
---|
156 | unsigned int i,rank = odom->rank; |
---|
157 | size_t count = 1; |
---|
158 | DCEslice* slice = odom->slices; |
---|
159 | for(i=0;i<rank;i++,slice++) { |
---|
160 | size_t slicecount = (slice->length/slice->stride); |
---|
161 | count *= slicecount; |
---|
162 | } |
---|
163 | return count; |
---|
164 | } |
---|
165 | |
---|
166 | int |
---|
167 | dapodometerincr(Dapodometer* odom) |
---|
168 | { |
---|
169 | return dapodometerincrith(odom,-1); |
---|
170 | } |
---|
171 | |
---|
172 | int |
---|
173 | dapodometerincrith(Dapodometer* odom, int wheel) |
---|
174 | { |
---|
175 | int i; /* do not make unsigned */ |
---|
176 | DCEslice* slice; |
---|
177 | if(odom->rank == 0) return 0; |
---|
178 | if(wheel < 0) wheel = (odom->rank - 1); |
---|
179 | for(slice=odom->slices+(wheel),i=wheel;i>=0;i--,slice--) { |
---|
180 | odom->index[i] += slice->stride; |
---|
181 | if(odom->index[i] < slice->stop) break; |
---|
182 | if(i == 0) return 0; /* leave the 0th entry if it overflows*/ |
---|
183 | odom->index[i] = slice->first; /* reset this position*/ |
---|
184 | } |
---|
185 | return 1; |
---|
186 | } |
---|
187 | |
---|
188 | /**************************************************/ |
---|
189 | int |
---|
190 | dapodometervarmcount(Dapodometer* odom, const ptrdiff_t* steps, const size_t* declsizes) |
---|
191 | { |
---|
192 | int i; |
---|
193 | size_t offset = 0; |
---|
194 | for(i=0;i<odom->rank;i++) { |
---|
195 | size_t tmp; |
---|
196 | tmp = odom->index[i]; |
---|
197 | tmp = tmp - odom->slices[i].first; |
---|
198 | tmp = tmp / odom->slices[i].stride; |
---|
199 | tmp = tmp * steps[i]; |
---|
200 | offset += tmp; |
---|
201 | } |
---|
202 | return offset; |
---|
203 | } |
---|
204 | |
---|
205 | |
---|
206 | /* Return the current set of indices */ |
---|
207 | size_t* |
---|
208 | dapodometerindices(Dapodometer* odom) |
---|
209 | { |
---|
210 | if(odom == NULL) return NULL; |
---|
211 | return odom->index; |
---|
212 | } |
---|
213 | |
---|
214 | Dapodometer* |
---|
215 | newdapodometer2(const size_t* start, const size_t* count, const ptrdiff_t* stride, |
---|
216 | unsigned int first, unsigned int rank) |
---|
217 | { |
---|
218 | int i; |
---|
219 | Dapodometer* odom = (Dapodometer*)calloc(1,sizeof(Dapodometer)); |
---|
220 | MEMCHECK(odom,NULL); |
---|
221 | odom->rank = rank; |
---|
222 | assert(odom->rank <= NC_MAX_VAR_DIMS); |
---|
223 | for(i=0;i<odom->rank;i++) { |
---|
224 | odom->slices[i].first = start[first+i]; |
---|
225 | odom->slices[i].stride = (size_t)stride[first+i]; |
---|
226 | odom->slices[i].length = count[first+i] * stride[first+i]; |
---|
227 | odom->slices[i].stop = (odom->slices[i].first+odom->slices[i].length); |
---|
228 | odom->slices[i].declsize = odom->slices[i].stop; |
---|
229 | odom->slices[i].count = (odom->slices[i].length /odom->slices[i].stride); |
---|
230 | odom->index[i] = odom->slices[i].first; |
---|
231 | } |
---|
232 | return odom; |
---|
233 | } |
---|
234 | |
---|
235 | Dapodometer* |
---|
236 | newdapodometer3(int rank, size_t* dimsizes) |
---|
237 | { |
---|
238 | int i; |
---|
239 | Dapodometer* odom = (Dapodometer*)calloc(1,sizeof(Dapodometer)); |
---|
240 | MEMCHECK(odom,NULL); |
---|
241 | odom->rank = rank; |
---|
242 | for(i=0;i<rank;i++) { |
---|
243 | odom->slices[i].first = 0; |
---|
244 | odom->slices[i].length = dimsizes[i]; |
---|
245 | odom->slices[i].stride = 1; |
---|
246 | odom->slices[i].stop = dimsizes[i]; |
---|
247 | odom->slices[i].declsize = dimsizes[i]; |
---|
248 | odom->slices[i].count = (odom->slices[i].length / odom->slices[i].stride); |
---|
249 | odom->index[i] = 0; |
---|
250 | } |
---|
251 | return odom; |
---|
252 | } |
---|