1 /*
2 not.c -- Algae's `not' operator.
3
4 Copyright (C) 1994-97 K. Scott Hunziker.
5 Copyright (C) 1990-94 The Boeing Company.
6
7 See the file COPYING for license, warranty, and permission details.
8 */
9
10 static char rcsid[] =
11 "$Id: not.c,v 1.2 1997/02/21 09:54:02 ksh Exp $";
12
13 #include "not.h"
14 #include "entity.h"
15 #include "scalar.h"
16 #include "vector.h"
17 #include "matrix.h"
18 #include "apply.h"
19 #include "dense.h"
20
21 static int
not_integer(i)22 not_integer (i)
23 int i;
24 {
25 return (!i);
26 }
27
28 static int
not_real(i)29 not_real (i)
30 REAL i;
31 {
32 return (!i);
33 }
34
35 static int
not_complex(i)36 not_complex (i)
37 COMPLEX i;
38 {
39 return (!i.real && !i.imag);
40 }
41
42 static int
not_character(i)43 not_character (i)
44 char *i;
45 {
46 return (!*i);
47 }
48
49 ENTITY *
not_scalar(p)50 not_scalar (p)
51 SCALAR *p;
52 {
53 SCALAR *s = NULL;
54
55 EASSERT (p, scalar, 0);
56
57 switch (p->type)
58 {
59 case integer:
60 s = (SCALAR *) int_to_scalar (!p->v.integer);
61 break;
62 case real:
63 s = (SCALAR *) int_to_scalar (!p->v.real);
64 break;
65 case complex:
66 s = (SCALAR *) int_to_scalar (!p->v.complex.real &&
67 !p->v.complex.imag);
68 break;
69 case character:
70 s = (SCALAR *) int_to_scalar (!*p->v.character);
71 break;
72 default:
73 BAD_TYPE (p->type);
74 delete_scalar (p);
75 raise_exception ();
76 }
77
78 delete_scalar (p);
79 return (ENT (s));
80 }
81
82 ENTITY *
not_vector(p)83 not_vector (p)
84 VECTOR *p;
85 {
86 VECTOR *m;
87
88 EASSERT (p, vector, 0);
89
90 switch (p->type)
91 {
92 case integer:
93 p = (VECTOR *) dense_vector (p);
94 m = (VECTOR *) apply_vector_integer_integer (not_integer, p);
95 break;
96 case real:
97 p = (VECTOR *) dense_vector (p);
98 m = (VECTOR *) apply_vector_integer_real (not_real, p);
99 break;
100 case complex:
101 p = (VECTOR *) dense_vector (p);
102 m = (VECTOR *) apply_vector_integer_complex (not_complex, p);
103 break;
104 case character:
105 p = (VECTOR *) dense_vector (p);
106 m = (VECTOR *) apply_vector_integer_character (not_character, p);
107 break;
108 default:
109 BAD_TYPE (p->type);
110 delete_vector (p);
111 raise_exception ();
112 }
113 return (ENT (m));
114 }
115
116 ENTITY *
not_matrix(p)117 not_matrix (p)
118 MATRIX *p;
119 {
120 MATRIX *m;
121
122 EASSERT (p, matrix, 0);
123
124 switch (p->type)
125 {
126 case integer:
127 p = (MATRIX *) dense_matrix (p);
128 m = (MATRIX *) apply_matrix_integer_integer (not_integer, p);
129 break;
130 case real:
131 p = (MATRIX *) dense_matrix (p);
132 m = (MATRIX *) apply_matrix_integer_real (not_real, p);
133 break;
134 case complex:
135 p = (MATRIX *) dense_matrix (p);
136 m = (MATRIX *) apply_matrix_integer_complex (not_complex, p);
137 break;
138 case character:
139 p = (MATRIX *) dense_matrix (p);
140 m = (MATRIX *) apply_matrix_integer_character (not_character, p);
141 break;
142 default:
143 BAD_TYPE (p->type);
144 delete_matrix (p);
145 raise_exception ();
146 }
147 return (ENT (m));
148 }
149
150 ENTITY *
notnot_scalar(p)151 notnot_scalar (p)
152 SCALAR *p;
153 {
154 SCALAR *s = NULL;
155
156 EASSERT (p, scalar, 0);
157
158 switch (p->type)
159 {
160 case integer:
161 s = (SCALAR *) int_to_scalar (p->v.integer != 0);
162 break;
163 case real:
164 s = (SCALAR *) int_to_scalar (p->v.real != 0.0);
165 break;
166 case complex:
167 s = (SCALAR *) int_to_scalar (p->v.complex.real != 0.0 ||
168 p->v.complex.imag != 0.0);
169 break;
170 case character:
171 s = (SCALAR *) int_to_scalar (*p->v.character != '\0');
172 break;
173 default:
174 BAD_TYPE (p->type);
175 delete_scalar (p);
176 raise_exception ();
177 }
178
179 delete_scalar (p);
180 return (ENT (s));
181 }
182
183 ENTITY *
notnot_vector(p)184 notnot_vector (p)
185 VECTOR *p;
186 {
187 int i;
188 VECTOR *m;
189
190 EASSERT (p, vector, 0);
191
192 switch (p->type)
193 {
194
195 case integer:
196
197 m = (VECTOR *) dup_vector (EAT (p));
198
199 for (i = 0; i < m->nn; i++)
200 m->a.integer[i] = m->a.integer[i] != 0;
201
202 break;
203
204 case real:
205
206 m = (VECTOR *) form_vector (p->ne, integer, p->density);
207 if (p->eid)
208 m->eid = copy_entity (p->eid);
209 if (p->ja)
210 m->ja = dup_mem (p->ja, p->nn * sizeof (int));
211
212 m->nn = p->nn;
213
214 if (p->a.real)
215 {
216 if (m->a.integer == NULL)
217 m->a.integer = MALLOC (m->nn * sizeof (int));
218 for (i = 0; i < m->nn; i++)
219 m->a.integer[i] = p->a.real[i] != 0.0;
220 }
221
222 break;
223
224 case complex:
225
226 m = (VECTOR *) form_vector (p->ne, integer, p->density);
227 if (p->eid)
228 m->eid = copy_entity (p->eid);
229 if (p->ja)
230 m->ja = dup_mem (p->ja, p->nn * sizeof (int));
231
232 m->nn = p->nn;
233
234 if (p->a.complex)
235 {
236 if (m->a.integer == NULL)
237 m->a.integer = MALLOC (m->nn * sizeof (int));
238 for (i = 0; i < m->nn; i++)
239 m->a.integer[i] = (p->a.complex[i].real != 0.0 ||
240 p->a.complex[i].imag != 0.0);
241 }
242
243 break;
244
245 case character:
246
247 m = (VECTOR *) form_vector (p->ne, integer, p->density);
248 if (p->eid)
249 m->eid = copy_entity (p->eid);
250 if (p->ja)
251 m->ja = dup_mem (p->ja, p->nn * sizeof (int));
252
253 m->nn = p->nn;
254
255 if (p->a.character)
256 {
257 if (m->a.integer == NULL)
258 m->a.integer = MALLOC (m->nn * sizeof (int));
259 for (i = 0; i < m->nn; i++)
260 m->a.integer[i] = *p->a.character[i] != '\0';
261 }
262
263 break;
264
265 default:
266 BAD_TYPE (p->type);
267 delete_vector (p);
268 raise_exception ();
269 }
270
271 delete_vector (p);
272 return (ENT (m));
273 }
274
275 ENTITY *
notnot_matrix(p)276 notnot_matrix (p)
277 MATRIX *p;
278 {
279 int i;
280 MATRIX *m;
281
282 EASSERT (p, matrix, 0);
283
284 switch (p->type)
285 {
286
287 case integer:
288
289 m = (MATRIX *) dup_matrix (EAT (p));
290
291 if (m->a.integer)
292 {
293 for (i = 0; i < m->nn; i++)
294 m->a.integer[i] = m->a.integer[i] != 0;
295 }
296
297 if (m->d.integer)
298 {
299 for (i = 0; i < m->nr; i++)
300 m->d.integer[i] = m->d.integer[i] != 0;
301 }
302
303 break;
304
305 case real:
306
307 m = (MATRIX *) form_matrix (p->nr, p->nc, integer, p->density);
308 m->symmetry = p->symmetry;
309 if (p->rid)
310 m->rid = copy_entity (p->rid);
311 if (p->cid)
312 m->cid = copy_entity (p->cid);
313 if (p->ia)
314 m->ia = dup_mem (p->ia, (p->nr + 1) * sizeof (int));
315 if (p->ja)
316 m->ja = dup_mem (p->ja, p->nn * sizeof (int));
317
318 m->nn = p->nn;
319
320 if (p->a.real)
321 {
322 if (m->a.integer == NULL)
323 m->a.integer = MALLOC (m->nn * sizeof (int));
324 for (i = 0; i < m->nn; i++)
325 m->a.integer[i] = p->a.real[i] != 0.0;
326 }
327
328 if (p->d.real)
329 {
330 if (m->d.integer == NULL)
331 m->d.integer = MALLOC (m->nr * sizeof (int));
332 for (i = 0; i < m->nr; i++)
333 m->d.integer[i] = p->d.real[i] != 0.0;
334 }
335
336 break;
337
338 case complex:
339
340 m = (MATRIX *) form_matrix (p->nr, p->nc, integer, p->density);
341 m->symmetry = (p->symmetry == general) ? general : symmetric;
342 if (p->rid)
343 m->rid = copy_entity (p->rid);
344 if (p->cid)
345 m->cid = copy_entity (p->cid);
346 if (p->ia)
347 m->ia = dup_mem (p->ia, (p->nr + 1) * sizeof (int));
348 if (p->ja)
349 m->ja = dup_mem (p->ja, p->nn * sizeof (int));
350
351 m->nn = p->nn;
352
353 if (p->a.complex)
354 {
355 if (m->a.integer == NULL)
356 m->a.integer = MALLOC (m->nn * sizeof (int));
357 for (i = 0; i < m->nn; i++)
358 m->a.integer[i] = (p->a.complex[i].real != 0.0 ||
359 p->a.complex[i].imag != 0.0);
360 }
361
362 if (p->d.complex)
363 {
364 if (m->d.integer == NULL)
365 m->d.integer = MALLOC (m->nr * sizeof (int));
366 for (i = 0; i < m->nr; i++)
367 m->d.integer[i] = (p->d.complex[i].real != 0.0 ||
368 p->d.complex[i].imag != 0.0);
369 }
370
371 break;
372
373 case character:
374
375 m = (MATRIX *) form_matrix (p->nr, p->nc, integer, p->density);
376 m->symmetry = p->symmetry;
377 if (p->rid)
378 m->rid = copy_entity (p->rid);
379 if (p->cid)
380 m->cid = copy_entity (p->cid);
381 if (p->ia)
382 m->ia = dup_mem (p->ia, (p->nr + 1) * sizeof (int));
383 if (p->ja)
384 m->ja = dup_mem (p->ja, p->nn * sizeof (int));
385
386 m->nn = p->nn;
387
388 if (p->a.character)
389 {
390 if (m->a.integer == NULL)
391 m->a.integer = MALLOC (m->nn * sizeof (int));
392 for (i = 0; i < m->nn; i++)
393 m->a.integer[i] = *p->a.character[i] != '\0';
394 }
395
396 if (p->d.character)
397 {
398 if (m->d.integer == NULL)
399 m->d.integer = MALLOC (m->nr * sizeof (int));
400 for (i = 0; i < m->nr; i++)
401 m->d.integer[i] = *p->d.character[i] != '\0';
402 }
403
404 break;
405
406 default:
407 BAD_TYPE (p->type);
408 delete_matrix (p);
409 raise_exception ();
410 }
411
412 delete_matrix (p);
413 return (ENT (m));
414 }
415