FrontISTR 5.2.0
Large-scale structural analysis program with finit element method
Loading...
Searching...
No Matches
hecmw_varray_int.c
Go to the documentation of this file.
1/*****************************************************************************
2 * Copyright (c) 2019 FrontISTR Commons
3 * This software is released under the MIT License, see LICENSE.txt
4 *****************************************************************************/
5
6#include <stdio.h>
7#include <stdlib.h>
8#include <string.h>
9#include <errno.h>
10#include "hecmw_util.h"
11#include "hecmw_malloc.h"
12#include "hecmw_config.h"
13#include "hecmw_bit_array.h"
14#include "hecmw_varray_int.h"
15
17
19 HECMW_assert(varray);
20
21 varray->n_val = 0;
22 varray->max_val = 0;
23
24 varray->vals = NULL;
25
26 return HECMW_SUCCESS;
27}
28
30 HECMW_assert(varray);
31
32 if (varray->max_val == 0) {
33 HECMW_assert(varray->n_val == 0);
34 return;
35 }
36
37 HECMW_free(varray->vals);
38 return;
39}
40
41size_t HECMW_varray_int_nval(const struct hecmw_varray_int *varray) {
42 HECMW_assert(varray);
43
44 return varray->n_val;
45}
46
47static int varray_resize(struct hecmw_varray_int *varray, size_t new_max_val) {
48 int *new_vals;
49
50 HECMW_assert(varray);
51 HECMW_assert(varray->n_val <= new_max_val);
52
53 if (varray->max_val == new_max_val) return HECMW_SUCCESS;
54
55 if (new_max_val == 0) {
56 HECMW_assert(varray->vals);
57
58 HECMW_free(varray->vals);
59 varray->vals = NULL;
60 varray->max_val = 0;
61
62 return HECMW_SUCCESS;
63 }
64
65 new_vals = (int *)HECMW_realloc(varray->vals, sizeof(int) * new_max_val);
66 if (new_vals == NULL) {
67 return HECMW_ERROR;
68 }
69
70 varray->vals = new_vals;
71 varray->max_val = new_max_val;
72
73 return HECMW_SUCCESS;
74}
75
76static int varray_grow(struct hecmw_varray_int *varray) {
77 size_t new_max_val;
78
79 HECMW_assert(varray);
80
81 if (varray->max_val == 0)
82 new_max_val = VARRAY_MAX_VAL_INIT;
83 else
84 new_max_val = varray->max_val * VARRAY_MAX_VAL_GROW;
85
86 return varray_resize(varray, new_max_val);
87}
88
89int HECMW_varray_int_append(struct hecmw_varray_int *varray, int value) {
90 HECMW_assert(varray);
91
92 if (varray->n_val == varray->max_val)
93 if (varray_grow(varray) != HECMW_SUCCESS) return HECMW_ERROR;
94
95 varray->vals[varray->n_val] = value;
96 varray->n_val++;
97
98 return HECMW_SUCCESS;
99}
100
101int HECMW_varray_int_get(const struct hecmw_varray_int *varray, size_t index) {
102 HECMW_assert(varray);
103 HECMW_assert(0 <= index && index < varray->n_val);
104
105 return varray->vals[index];
106}
107
109 const struct hecmw_varray_int *varray2) {
110 size_t i;
111
112 HECMW_assert(varray);
113 HECMW_assert(varray2);
114
115 while (varray->n_val + varray2->n_val > varray->max_val) {
116 if (varray_grow(varray) != HECMW_SUCCESS) return HECMW_ERROR;
117 }
118 for (i = 0; i < varray2->n_val; i++) {
119 varray->vals[varray->n_val] = varray2->vals[i];
120 varray->n_val++;
121 }
122 return HECMW_SUCCESS;
123}
124
125static int int_cmp(const void *v1, const void *v2) {
126 const int *i1, *i2;
127
128 i1 = (const int *)v1;
129 i2 = (const int *)v2;
130
131 if (*i1 < *i2) return -1;
132 if (*i1 > *i2) return 1;
133 return 0;
134}
135
137 HECMW_assert(varray);
138 qsort(varray->vals, varray->n_val, sizeof(int), int_cmp);
139}
140
141int HECMW_varray_int_search(struct hecmw_varray_int *varray, int value,
142 size_t *index) {
143 int *p;
144 p = bsearch(&value, varray->vals, varray->n_val, sizeof(int), int_cmp);
145 if (p == NULL) return HECMW_ERROR;
146 *index = p - varray->vals;
147 return HECMW_SUCCESS;
148}
149
151 size_t i, n_dup = 0;
152
153 HECMW_assert(varray);
154
155 for (i = 1; i < varray->n_val; i++) {
156 if (varray->vals[i - 1] == varray->vals[i]) {
157 n_dup++;
158 } else {
159 if (n_dup > 0) {
160 varray->vals[i - n_dup] = varray->vals[i];
161 }
162 }
163 }
164
165 varray->n_val -= n_dup;
166
167 if (varray->n_val * 2 < varray->max_val)
168 varray_resize(varray, varray->n_val); /* reduce memory usage */
169
170 return n_dup;
171}
172
173int HECMW_varray_int_resize(struct hecmw_varray_int *varray, size_t len) {
174 HECMW_assert(varray);
175
176 if (varray->max_val < len) {
177 if (varray_resize(varray, len) != HECMW_SUCCESS) return HECMW_ERROR;
178 }
179 varray->n_val = len;
180 return HECMW_SUCCESS;
181}
182
184 HECMW_assert(varray);
185 return varray->vals;
186}
187
188const int *HECMW_varray_int_get_cv(const struct hecmw_varray_int *varray) {
189 HECMW_assert(varray);
190 return varray->vals;
191}
192
194 struct hecmw_varray_int *varray2) {
195 size_t i;
196
197 HECMW_assert(varray);
198
199 if (HECMW_varray_int_resize(varray2, varray->n_val) != HECMW_SUCCESS)
200 return HECMW_ERROR;
201
202 for (i = 0; i < varray->n_val; i++) varray2->vals[i] = varray->vals[i];
203
204 return HECMW_SUCCESS;
205}
206
208 struct hecmw_varray_int tmp_array;
209
210 HECMW_assert(varray);
211
212 if (HECMW_varray_int_init(&tmp_array) != HECMW_SUCCESS) {
213 return HECMW_ERROR;
214 }
215 if (HECMW_varray_int_copy(varray, &tmp_array) != HECMW_SUCCESS) {
216 return HECMW_ERROR;
217 }
218 HECMW_varray_int_sort(&tmp_array);
219
220 if (HECMW_varray_int_uniq(&tmp_array) != 0) {
221 struct hecmw_bit_array ba;
222 size_t i, n_dup = 0;
223
224 HECMW_bit_array_init(&ba, tmp_array.n_val);
225 for (i = 0; i < varray->n_val; i++) {
226 int *key = varray->vals + i;
227 int *res =
228 bsearch(key, tmp_array.vals, tmp_array.n_val, sizeof(int), int_cmp);
229 size_t idx;
230
231 HECMW_assert(res != NULL);
232
233 idx = res - tmp_array.vals;
234
235 if (HECMW_bit_array_get(&ba, idx)) {
236 n_dup++;
237 } else {
238 HECMW_bit_array_set(&ba, idx);
239 varray->vals[i - n_dup] = varray->vals[i];
240 }
241 }
242 varray->n_val -= n_dup;
244
245 HECMW_assert(varray->n_val == tmp_array.n_val);
246 }
247 HECMW_varray_int_finalize(&tmp_array);
248 return HECMW_SUCCESS;
249}
250
251int HECMW_varray_int_assign(struct hecmw_varray_int *varray, size_t begin,
252 size_t end, int val) {
253 size_t i;
254
255 HECMW_assert(varray);
256 HECMW_assert(0 <= begin);
257 HECMW_assert(end <= varray->n_val);
258
259 for (i = begin; i < end; i++) {
260 varray->vals[i] = val;
261 }
262 return HECMW_SUCCESS;
263}
264
265int HECMW_varray_int_insert(struct hecmw_varray_int *varray, size_t index,
266 int val) {
267 size_t i;
268
269 HECMW_assert(varray);
270 HECMW_assert(0 <= index && index <= varray->n_val);
271
272 if (varray->n_val == varray->max_val)
273 if (varray_grow(varray) != HECMW_SUCCESS) return HECMW_ERROR;
274
275 /* for (i = varray->n_val; i > index; i--) { */
276 /* varray->vals[i] = varray->vals[i-1]; */
277 /* } */
278 memmove(varray->vals + index + 1, varray->vals + index,
279 sizeof(int) * (varray->n_val - index));
280
281 varray->vals[index] = val;
282 varray->n_val++;
283
284 return HECMW_SUCCESS;
285}
286
287int HECMW_varray_int_delete(struct hecmw_varray_int *varray, size_t index) {
288 size_t i;
289
290 HECMW_assert(varray);
291 HECMW_assert(0 <= index && index <= varray->n_val);
292
293 /* for (i = index+1; i < varray->n_val; i++) { */
294 /* varray->vals[i-1] = varray->vals[i]; */
295 /* } */
296 memmove(varray->vals + index, varray->vals + index + 1,
297 sizeof(int) * (varray->n_val - index - 1));
298
299 varray->n_val--;
300
301 return HECMW_SUCCESS;
302}
int HECMW_bit_array_init(struct hecmw_bit_array *ba, size_t len)
int HECMW_bit_array_get(struct hecmw_bit_array *ba, size_t index)
void HECMW_bit_array_set(struct hecmw_bit_array *ba, size_t index)
void HECMW_bit_array_finalize(struct hecmw_bit_array *ba)
#define HECMW_ERROR
Definition: hecmw_config.h:66
#define HECMW_SUCCESS
Definition: hecmw_config.h:64
#define NULL
#define HECMW_realloc(ptr, size)
Definition: hecmw_malloc.h:22
#define HECMW_free(ptr)
Definition: hecmw_malloc.h:24
#define HECMW_assert(cond)
Definition: hecmw_util.h:40
int HECMW_varray_int_rmdup(struct hecmw_varray_int *varray)
size_t HECMW_varray_int_nval(const struct hecmw_varray_int *varray)
size_t HECMW_varray_int_uniq(struct hecmw_varray_int *varray)
int HECMW_varray_int_search(struct hecmw_varray_int *varray, int value, size_t *index)
const int * HECMW_varray_int_get_cv(const struct hecmw_varray_int *varray)
void HECMW_varray_int_sort(struct hecmw_varray_int *varray)
int HECMW_varray_int_insert(struct hecmw_varray_int *varray, size_t index, int val)
int * HECMW_varray_int_get_v(struct hecmw_varray_int *varray)
int HECMW_varray_int_get(const struct hecmw_varray_int *varray, size_t index)
int HECMW_varray_int_init(struct hecmw_varray_int *varray)
int HECMW_varray_int_assign(struct hecmw_varray_int *varray, size_t begin, size_t end, int val)
@ VARRAY_MAX_VAL_INIT
@ VARRAY_MAX_VAL_GROW
void HECMW_varray_int_finalize(struct hecmw_varray_int *varray)
int HECMW_varray_int_append(struct hecmw_varray_int *varray, int value)
int HECMW_varray_int_cat(struct hecmw_varray_int *varray, const struct hecmw_varray_int *varray2)
int HECMW_varray_int_resize(struct hecmw_varray_int *varray, size_t len)
int HECMW_varray_int_delete(struct hecmw_varray_int *varray, size_t index)
int HECMW_varray_int_copy(const struct hecmw_varray_int *varray, struct hecmw_varray_int *varray2)