BRL-CAD
bn_tabdata.c
Go to the documentation of this file.
1 /* B N _ T A B D A T A . C
2  * BRL-CAD
3  *
4  * Copyright (c) 2013-2014 United States Government as represented by
5  * the U.S. Army Research Laboratory.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public License
9  * version 2.1 as published by the Free Software Foundation.
10  *
11  * This library is distributed in the hope that it will be useful, but
12  * WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this file; see the file named COPYING for more
18  * information.
19  */
20 
21 #include "common.h"
22 
23 #include <math.h>
24 #include <string.h>
25 #include "bio.h"
26 
27 #include "bu/log.h"
28 #include "bu/malloc.h"
29 #include "vmath.h"
30 #include "bn.h"
31 
32 static int
33 tab_equal(const struct bn_table *a, const struct bn_table *b)
34 {
35  unsigned int i;
36 
37  if (a->nx != b->nx) {
38  return 1;
39  }
40 
41  for (i = 0; i < a->nx; i++) {
42  if (!NEAR_EQUAL(a->x[i], b->x[i], BN_TOL_DIST)) {
43  return 0;
44  }
45  }
46 
47  return 1;
48 }
49 
50 
51 static int
52 tabdata_equal(const struct bn_tabdata *a, const struct bn_tabdata *b)
53 {
54  unsigned int i;
55 
56  if (a->ny != b->ny) {
57  return 1;
58  }
59 
60  for (i = 0; i < a->ny; i++) {
61  if (!NEAR_EQUAL(a->y[i], b->y[i], BN_TOL_DIST)) {
62  return 0;
63  }
64  }
65 
66  return 1;
67 }
68 
69 /* This function expects the string that is passed in to hold a table
70  * of the form nx,x0,x1,x2,...,x(nx) (note: there are nx+1 items after nx).
71  */
72 static void
73 scan_tab_args(char *in, struct bn_table **tab_in)
74 {
75  int i;
76  int nx;
77  int offset;
78  int new_offset;
79  struct bn_table *tab;
80 
81  sscanf(in, "%d%n", &nx, &offset);
82  new_offset = offset;
83 
84  BN_GET_TABLE(tab, nx);
85 
86  for (i = 0; i <= nx; i++) {
87  sscanf(in+offset, ",%lg%n", &((tab->x)[i]), &new_offset);
88  offset += new_offset;
89  }
90  *tab_in = tab;
91 }
92 
93 /* This function expects the string that is passed in to hold a tabdata
94  * of the form y0,y1,y2,...,y(nx-1). The number of ys is determined by
95  * the table argument's nx.
96  */
97 static void
98 scan_tabdata_args(char *in, struct bn_tabdata **tabdata_in, struct bn_table *table)
99 {
100  int i;
101  struct bn_tabdata *tabdata;
102  int new_offset;
103  int offset;
104 
105  BN_GET_TABDATA(tabdata, table);
106 
107  sscanf(in, "%lg%n", &((tabdata->y)[0]), &offset);
108  for (i = 1; i <= (int)tabdata->ny; i++) {
109  sscanf(in+offset, ",%lg%n", &((tabdata->y)[i]), &new_offset);
110  offset += new_offset;
111  }
112  *tabdata_in = tabdata;
113 }
114 
115 static int
116 test_bn_table_make_uniform(int argc, char *argv[])
117 {
118  struct bn_table *expected;
119  struct bn_table *actual;
120  double first, last;
121  unsigned int num;
122 
123  if (argc != 6) {
124  bu_exit(1, "<args> format: first last num expected [%s]\n", argv[0]);
125  }
126 
127  sscanf(argv[2], "%lf", &first);
128  sscanf(argv[3], "%lf", &last);
129  sscanf(argv[4], "%u", &num);
130  scan_tab_args(argv[5], &expected);
131 
132  actual = bn_table_make_uniform(num, first, last);
133 
134  bn_pr_table("Result", actual);
135 
136  return !tab_equal(expected, actual);
137 }
138 
139 static int
140 test_bn_tabdata_add(int argc, char *argv[])
141 {
142  struct bn_table *tab_in;
143  struct bn_tabdata *td_in1;
144  struct bn_tabdata *td_in2;
145  struct bn_tabdata *expected;
146  struct bn_tabdata *actual;
147 
148  if (argc != 6) {
149  bu_exit(1, "<args> format: table tabdata1 tabdata2 expected_tabdata [%s]\n", argv[0]);
150  }
151 
152  scan_tab_args(argv[2], &tab_in);
153  scan_tabdata_args(argv[3], &td_in1, tab_in);
154  scan_tabdata_args(argv[4], &td_in2, tab_in);
155  scan_tabdata_args(argv[5], &expected, tab_in);
156  BN_GET_TABDATA(actual, tab_in);
157 
158  bn_tabdata_add(actual, td_in1, td_in2);
159 
160  bn_pr_tabdata("Result", actual);
161 
162  return !tabdata_equal(expected, actual);
163 }
164 
165 static int
166 test_bn_tabdata_mul(int argc, char *argv[])
167 {
168  struct bn_table *tab_in;
169  struct bn_tabdata *td_in1;
170  struct bn_tabdata *td_in2;
171  struct bn_tabdata *expected;
172  struct bn_tabdata *actual;
173 
174  if (argc != 6) {
175  bu_exit(1, "<args> format: table tabdata1 tabdata2 expected_tabdata [%s]\n", argv[0]);
176  }
177 
178  scan_tab_args(argv[2], &tab_in);
179  scan_tabdata_args(argv[3], &td_in1, tab_in);
180  scan_tabdata_args(argv[4], &td_in2, tab_in);
181  scan_tabdata_args(argv[5], &expected, tab_in);
182  BN_GET_TABDATA(actual, tab_in);
183 
184  bn_tabdata_mul(actual, td_in1, td_in2);
185 
186  bn_pr_tabdata("Result", actual);
187 
188  return !tabdata_equal(expected, actual);
189 }
190 
191 static int
192 test_bn_tabdata_mul3(int argc, char *argv[])
193 {
194  struct bn_table *tab_in;
195  struct bn_tabdata *td_in1;
196  struct bn_tabdata *td_in2;
197  struct bn_tabdata *td_in3;
198  struct bn_tabdata *expected;
199  struct bn_tabdata *actual;
200 
201  if (argc != 7) {
202  bu_exit(1, "<args> format: table tabdata1 tabdata2 tabdata3 expected_tabdata [%s]\n", argv[0]);
203  }
204 
205  scan_tab_args(argv[2], &tab_in);
206  scan_tabdata_args(argv[3], &td_in1, tab_in);
207  scan_tabdata_args(argv[4], &td_in2, tab_in);
208  scan_tabdata_args(argv[5], &td_in3, tab_in);
209  scan_tabdata_args(argv[6], &expected, tab_in);
210  BN_GET_TABDATA(actual, tab_in);
211 
212  bn_tabdata_mul3(actual, td_in1, td_in2, td_in3);
213 
214  bn_pr_tabdata("Result", actual);
215 
216  return !tabdata_equal(expected, actual);
217 }
218 
219 static int
220 test_bn_tabdata_incr_mul3_scale(int argc, char *argv[])
221 {
222  struct bn_table *tab_in;
223  struct bn_tabdata *td_in1;
224  struct bn_tabdata *td_in2;
225  struct bn_tabdata *td_in3;
226  struct bn_tabdata *expected;
227  struct bn_tabdata *actual;
228  fastf_t scale;
229 
230  if (argc != 9) {
231  bu_exit(1, "<args> format: table tabdataout_orig tabdata1 tabdata2 tabdata3 scale expected_tabdata [%s]\n", argv[0]);
232  }
233 
234  scan_tab_args(argv[2], &tab_in);
235  scan_tabdata_args(argv[3], &actual, tab_in);
236  scan_tabdata_args(argv[4], &td_in1, tab_in);
237  scan_tabdata_args(argv[5], &td_in2, tab_in);
238  scan_tabdata_args(argv[6], &td_in3, tab_in);
239  sscanf(argv[7], "%lg", &scale);
240  scan_tabdata_args(argv[8], &expected, tab_in);
241 
242  bn_tabdata_incr_mul3_scale(actual, td_in1, td_in2, td_in3, scale);
243 
244  bn_pr_tabdata("Result", actual);
245 
246  return !tabdata_equal(expected, actual);
247 }
248 
249 static int
250 test_bn_tabdata_incr_mul2_scale(int argc, char *argv[])
251 {
252  struct bn_table *tab_in;
253  struct bn_tabdata *td_in1;
254  struct bn_tabdata *td_in2;
255  struct bn_tabdata *expected;
256  struct bn_tabdata *actual;
257  fastf_t scale;
258 
259  if (argc != 8) {
260  bu_exit(1, "<args> format: table tabdataout_orig tabdata1 tabdata2 scale expected_tabdata [%s]\n", argv[0]);
261  }
262 
263  scan_tab_args(argv[2], &tab_in);
264  scan_tabdata_args(argv[3], &actual, tab_in);
265  scan_tabdata_args(argv[4], &td_in1, tab_in);
266  scan_tabdata_args(argv[5], &td_in2, tab_in);
267  sscanf(argv[6], "%lg", &scale);
268  scan_tabdata_args(argv[7], &expected, tab_in);
269 
270  bn_tabdata_incr_mul2_scale(actual, td_in1, td_in2, scale);
271 
272  bn_pr_tabdata("Result", actual);
273 
274  return !tabdata_equal(expected, actual);
275 }
276 
277 static int
278 test_bn_tabdata_scale(int argc, char *argv[])
279 {
280  struct bn_table *tab_in;
281  struct bn_tabdata *td;
282  struct bn_tabdata *expected;
283  struct bn_tabdata *actual;
284  fastf_t scale;
285 
286  if (argc != 6) {
287  bu_exit(1, "<args> format: table tabdata scale expected_tabdata [%s]\n", argv[0]);
288  }
289 
290  scan_tab_args(argv[2], &tab_in);
291  scan_tabdata_args(argv[3], &td, tab_in);
292  sscanf(argv[4], "%lg", &scale);
293  scan_tabdata_args(argv[5], &expected, tab_in);
294  BN_GET_TABDATA(actual, tab_in);
295 
296  bn_tabdata_scale(actual, td, scale);
297 
298  bn_pr_tabdata("Result", actual);
299 
300  return !tabdata_equal(expected, actual);
301 }
302 
303 static int
304 test_bn_table_scale(int argc, char *argv[])
305 {
306  struct bn_table *expected;
307  struct bn_table *actual;
308  fastf_t scale;
309 
310  if (argc != 5) {
311  bu_exit(1, "<args> format: table scale expected_tabdata [%s]\n", argv[0]);
312  }
313 
314  scan_tab_args(argv[2], &actual);
315  sscanf(argv[3], "%lg", &scale);
316  scan_tab_args(argv[4], &expected);
317 
318  bn_table_scale(actual, scale);
319 
320  bn_pr_table("Result", actual);
321 
322  return !tab_equal(expected, actual);
323 }
324 
325 static int
326 test_bn_tabdata_join1(int argc, char *argv[])
327 {
328  struct bn_table *tab_in;
329  struct bn_tabdata *td_in1;
330  struct bn_tabdata *td_in2;
331  struct bn_tabdata *expected;
332  struct bn_tabdata *actual;
333  fastf_t scale;
334 
335  if (argc != 7) {
336  bu_exit(1, "<args> format: table tabdata1 tabdata2 scale expected_tabdata [%s]\n", argv[0]);
337  }
338 
339  scan_tab_args(argv[2], &tab_in);
340  scan_tabdata_args(argv[3], &td_in1, tab_in);
341  scan_tabdata_args(argv[4], &td_in2, tab_in);
342  sscanf(argv[5], "%lg", &scale);
343  scan_tabdata_args(argv[6], &expected, tab_in);
344  BN_GET_TABDATA(actual, tab_in);
345 
346  bn_tabdata_join1(actual, td_in1, scale, td_in2);
347 
348  bn_pr_tabdata("Result", actual);
349 
350  return !tabdata_equal(expected, actual);
351 }
352 
353 static int
354 test_bn_tabdata_join2(int argc, char *argv[])
355 {
356  struct bn_table *tab_in;
357  struct bn_tabdata *td_in1;
358  struct bn_tabdata *td_in2;
359  struct bn_tabdata *td_in3;
360  struct bn_tabdata *expected;
361  struct bn_tabdata *actual;
362  fastf_t scale_1, scale_2;
363 
364  if (argc != 9) {
365  bu_exit(1, "<args> format: table tabdata1 tabdata2 tabdata3 scale1 scale2 scale3 expected_tabdata [%s]\n", argv[0]);
366  }
367 
368  scan_tab_args(argv[2], &tab_in);
369  scan_tabdata_args(argv[3], &td_in1, tab_in);
370  scan_tabdata_args(argv[4], &td_in2, tab_in);
371  scan_tabdata_args(argv[5], &td_in3, tab_in);
372  sscanf(argv[6], "%lg", &scale_1);
373  sscanf(argv[7], "%lg", &scale_2);
374  scan_tabdata_args(argv[8], &expected, tab_in);
375  BN_GET_TABDATA(actual, tab_in);
376 
377  bn_tabdata_join2(actual, td_in1, scale_1, td_in2, scale_2, td_in3);
378 
379  bn_pr_tabdata("Result", actual);
380 
381  return !tabdata_equal(expected, actual);
382 }
383 
384 static int
385 test_bn_tabdata_blend2(int argc, char *argv[])
386 {
387  struct bn_table *tab_in;
388  struct bn_tabdata *td_in1;
389  struct bn_tabdata *td_in2;
390  struct bn_tabdata *expected;
391  struct bn_tabdata *actual;
392  fastf_t scale_1, scale_2;
393 
394  if (argc != 8) {
395  bu_exit(1, "<args> format: table tabdata1 tabdata2 scale1 scale2 expected_result [%s]\n", argv[0]);
396  }
397 
398  scan_tab_args(argv[2], &tab_in);
399  scan_tabdata_args(argv[3], &td_in1, tab_in);
400  scan_tabdata_args(argv[4], &td_in2, tab_in);
401  sscanf(argv[5], "%lg", &scale_1);
402  sscanf(argv[6], "%lg", &scale_2);
403  scan_tabdata_args(argv[7], &expected, tab_in);
404  BN_GET_TABDATA(actual, tab_in);
405 
406  bn_tabdata_blend2(actual, scale_1, td_in1, scale_2, td_in2);
407 
408  bn_pr_tabdata("Result", actual);
409 
410  return !tabdata_equal(expected, actual);
411 }
412 
413 static int
414 test_bn_tabdata_blend3(int argc, char *argv[])
415 {
416  struct bn_table *tab_in;
417  struct bn_tabdata *td_in1;
418  struct bn_tabdata *td_in2;
419  struct bn_tabdata *td_in3;
420  struct bn_tabdata *expected;
421  struct bn_tabdata *actual;
422  fastf_t scale_1, scale_2, scale_3;
423 
424  if (argc != 10) {
425  bu_exit(1, "<args> format: table tabdata1 tabdata2 tabdata3 scale1 scale2 scale3 expected_result [%s]\n", argv[0]);
426  }
427 
428  scan_tab_args(argv[2], &tab_in);
429  scan_tabdata_args(argv[3], &td_in1, tab_in);
430  scan_tabdata_args(argv[4], &td_in2, tab_in);
431  scan_tabdata_args(argv[5], &td_in3, tab_in);
432  sscanf(argv[6], "%lg", &scale_1);
433  sscanf(argv[7], "%lg", &scale_2);
434  sscanf(argv[8], "%lg", &scale_3);
435  scan_tabdata_args(argv[9], &expected, tab_in);
436  BN_GET_TABDATA(actual, tab_in);
437 
438  bn_tabdata_blend3(actual, scale_1, td_in1, scale_2, td_in2, scale_3, td_in3);
439 
440  bn_pr_tabdata("Result", actual);
441 
442  return !tabdata_equal(expected, actual);
443 }
444 
445 static int
446 test_bn_tabdata_area1(int argc, char *argv[])
447 {
448  struct bn_table *tab_in;
449  struct bn_tabdata *td_in;
450  fastf_t expected, actual;
451 
452  if (argc != 5) {
453  bu_exit(1, "<args> format: table tabdata expected_result [%s]\n", argv[0]);
454  }
455 
456  scan_tab_args(argv[2], &tab_in);
457  scan_tabdata_args(argv[3], &td_in, tab_in);
458  sscanf(argv[4], "%lg", &expected);
459 
460  actual = bn_tabdata_area1(td_in);
461 
462  bu_log("Result: %g\n", actual);
463 
464  return !NEAR_EQUAL(expected, actual, BN_TOL_DIST);
465 }
466 
467 static int
468 test_bn_tabdata_area2(int argc, char *argv[])
469 {
470  struct bn_table *tab_in;
471  struct bn_tabdata *td_in;
472  fastf_t expected, actual;
473 
474  if (argc != 5) {
475  bu_exit(1, "<args> format: table tabdata expected_result [%s]\n", argv[0]);
476  }
477 
478  scan_tab_args(argv[2], &tab_in);
479  scan_tabdata_args(argv[3], &td_in, tab_in);
480  sscanf(argv[4], "%lg", &expected);
481 
482  actual = bn_tabdata_area2(td_in);
483 
484  bu_log("Result: %g\n", actual);
485 
486  return !NEAR_EQUAL(expected, actual, BN_TOL_DIST);
487 }
488 
489 static int
490 test_bn_tabdata_mul_area1(int argc, char *argv[])
491 {
492  struct bn_table *tab_in;
493  struct bn_tabdata *td_in1;
494  struct bn_tabdata *td_in2;
495  fastf_t expected, actual;
496 
497  if (argc != 6) {
498  bu_exit(1, "<args> format: table tabdata1 tabdata2 expected_result [%s]\n", argv[0]);
499  }
500 
501  scan_tab_args(argv[2], &tab_in);
502  scan_tabdata_args(argv[3], &td_in1, tab_in);
503  scan_tabdata_args(argv[4], &td_in2, tab_in);
504  sscanf(argv[5], "%lg", &expected);
505 
506  actual = bn_tabdata_mul_area1(td_in1, td_in2);
507 
508  bu_log("Result: %g\n", actual);
509 
510  return !NEAR_EQUAL(expected, actual, BN_TOL_DIST);
511 }
512 
513 static int
514 test_bn_tabdata_mul_area2(int argc, char *argv[])
515 {
516  struct bn_table *tab_in;
517  struct bn_tabdata *td_in1;
518  struct bn_tabdata *td_in2;
519  fastf_t expected, actual;
520 
521  if (argc != 6) {
522  bu_exit(1, "<args> format: table tabdata1 tabdata2 expected_result [%s]\n", argv[0]);
523  }
524 
525  scan_tab_args(argv[2], &tab_in);
526  scan_tabdata_args(argv[3], &td_in1, tab_in);
527  scan_tabdata_args(argv[4], &td_in2, tab_in);
528  sscanf(argv[5], "%lg", &expected);
529 
530  actual = bn_tabdata_mul_area2(td_in1, td_in2);
531 
532  bu_log("Result: %g\n", actual);
533 
534  return !NEAR_EQUAL(expected, actual, BN_TOL_DIST);
535 }
536 
537 static int
538 test_bn_table_lin_interp(int argc, char *argv[])
539 {
540  struct bn_table *tab_in;
541  struct bn_tabdata *td_in;
542  fastf_t wl;
543  fastf_t expected, actual;
544 
545  if (argc != 6) {
546  bu_exit(1, "<args> format: table tabdata wl expected_result [%s]\n", argv[0]);
547  }
548 
549  scan_tab_args(argv[2], &tab_in);
550  scan_tabdata_args(argv[3], &td_in, tab_in);
551  sscanf(argv[4], "%lg", &wl);
552  sscanf(argv[5], "%lg", &expected);
553 
554  actual = bn_table_lin_interp(td_in, wl);
555 
556  bu_log("Result: %g\n", actual);
557 
558  return !NEAR_EQUAL(expected, actual, BN_TOL_DIST);
559 }
560 
561 static int
562 test_bn_tabdata_copy(int argc, char *argv[])
563 {
564  struct bn_table *tab_in;
565  struct bn_tabdata *td_in;
566  struct bn_tabdata *actual;
567 
568  if (argc != 4) {
569  bu_exit(1, "<args> format: table tabdata [%s]\n", argv[0]);
570  }
571 
572  scan_tab_args(argv[2], &tab_in);
573  scan_tabdata_args(argv[3], &td_in, tab_in);
574  BN_GET_TABDATA(actual, tab_in);
575 
576  bn_tabdata_copy(actual, td_in);
577 
578  bn_pr_tabdata("Result", actual);
579 
580  return !tabdata_equal(td_in, actual);
581 }
582 
583 static int
584 test_bn_tabdata_dup(int argc, char *argv[])
585 {
586  struct bn_table *tab_in;
587  struct bn_tabdata *td_in;
588  struct bn_tabdata *actual;
589 
590  if (argc != 4) {
591  bu_exit(1, "<args> format: table tabdata [%s]\n", argv[0]);
592  }
593 
594  scan_tab_args(argv[2], &tab_in);
595  scan_tabdata_args(argv[3], &td_in, tab_in);
596 
597  actual = bn_tabdata_dup(td_in);
598 
599  bn_pr_tabdata("Result", actual);
600 
601  return !tabdata_equal(td_in, actual);
602 }
603 
604 static int
605 test_bn_tabdata_get_constval(int argc, char *argv[])
606 {
607  struct bn_table *tab_in;
608  fastf_t val;
609  struct bn_tabdata *expected; struct bn_tabdata *actual;
610 
611  if (argc != 5) {
612  bu_exit(1, "<args> format: table val expected_tabdata [%s]\n", argv[0]);
613  }
614 
615  scan_tab_args(argv[2], &tab_in);
616  sscanf(argv[3], "%lg", &val);
617  scan_tabdata_args(argv[4], &expected, tab_in);
618 
619  actual = bn_tabdata_get_constval(val, tab_in);
620 
621  bn_pr_tabdata("Result", actual);
622 
623  return !tabdata_equal(expected, actual);
624 }
625 
626 
627 int
628 main(int argc, char *argv[])
629 {
630  int function_num = 0;
631 
632  if (argc < 3) {
633  bu_exit(1, "Argument format: <function_number> <args> [%s]\n", argv[0]);
634  }
635 
636  sscanf(argv[1], "%d", &function_num);
637 
638  switch (function_num) {
639  case 1:
640  return test_bn_table_make_uniform(argc, argv);
641  case 2:
642  return test_bn_tabdata_add(argc, argv);
643  case 3:
644  return test_bn_tabdata_mul(argc, argv);
645  case 4:
646  return test_bn_tabdata_mul3(argc, argv);
647  case 5:
648  return test_bn_tabdata_incr_mul3_scale(argc, argv);
649  case 6:
650  return test_bn_tabdata_incr_mul2_scale(argc, argv);
651  case 7:
652  return test_bn_tabdata_scale(argc, argv);
653  case 8:
654  return test_bn_table_scale(argc, argv);
655  case 9:
656  return test_bn_tabdata_join1(argc, argv);
657  case 10:
658  return test_bn_tabdata_join2(argc, argv);
659  case 11:
660  return test_bn_tabdata_blend2(argc, argv);
661  case 12:
662  return test_bn_tabdata_blend3(argc, argv);
663  case 13:
664  return test_bn_tabdata_area1(argc, argv);
665  case 14:
666  return test_bn_tabdata_area2(argc, argv);
667  case 15:
668  return test_bn_tabdata_mul_area1(argc, argv);
669  case 16:
670  return test_bn_tabdata_mul_area2(argc, argv);
671  case 17:
672  return test_bn_table_lin_interp(argc, argv);
673  case 18:
674  return test_bn_tabdata_copy(argc, argv);
675  case 19:
676  return test_bn_tabdata_dup(argc, argv);
677  case 20:
678  return test_bn_tabdata_get_constval(argc, argv);
679  }
680 
681  bu_log("ERROR: function_num %d is not valid [%s]\n", function_num, argv[0]);
682  return 1;
683 }
684 
685 /*
686  * Local Variables:
687  * mode: C
688  * tab-width: 8
689  * indent-tabs-mode: t
690  * c-file-style: "stroustrup"
691  * End:
692  * ex: shiftwidth=4 tabstop=8
693  */
Definition: db_flip.c:35
void bu_log(const char *,...) _BU_ATTR_PRINTF12
Definition: log.c:176
void bn_tabdata_incr_mul2_scale(struct bn_tabdata *out, const struct bn_tabdata *in1, const struct bn_tabdata *in2, double scale)
#define BN_GET_TABDATA(_data, _table)
Definition: tabdata.h:114
size_t ny
Definition: tabdata.h:102
void bn_tabdata_blend2(struct bn_tabdata *out, double scale1, const struct bn_tabdata *in1, double scale2, const struct bn_tabdata *in2)
Header file for the BRL-CAD common definitions.
double bn_tabdata_area2(const struct bn_tabdata *in)
Definition: tabdata.c:433
void bn_tabdata_copy(struct bn_tabdata *out, const struct bn_tabdata *in)
Definition: tabdata.c:1025
void bn_tabdata_blend3(struct bn_tabdata *out, double scale1, const struct bn_tabdata *in1, double scale2, const struct bn_tabdata *in2, double scale3, const struct bn_tabdata *in3)
size_t nx
Definition: tabdata.h:75
void bu_exit(int status, const char *fmt,...) _BU_ATTR_NORETURN _BU_ATTR_PRINTF23
Definition: bomb.c:195
void bn_tabdata_scale(struct bn_tabdata *out, const struct bn_tabdata *in1, double scale)
fastf_t y[1]
array of ny samples, dynamically sized
Definition: tabdata.h:104
struct bn_table * bn_table_make_uniform(size_t num, double first, double last)
Definition: tabdata.c:98
void bn_table_scale(struct bn_table *tabp, double scale)
void bn_tabdata_mul(struct bn_tabdata *out, const struct bn_tabdata *in1, const struct bn_tabdata *in2)
Definition: tabdata.c:149
#define BN_TOL_DIST
Definition: tol.h:109
struct bn_tabdata * bn_tabdata_get_constval(double val, const struct bn_table *tabp)
Definition: tabdata.c:1054
int main(int argc, char *argv[])
Definition: bn_tabdata.c:628
void bn_tabdata_add(struct bn_tabdata *out, const struct bn_tabdata *in1, const struct bn_tabdata *in2)
Definition: tabdata.c:123
Definition: analyze.c:106
double bn_tabdata_mul_area2(const struct bn_tabdata *in1, const struct bn_tabdata *in2)
Definition: tabdata.c:475
void bn_pr_tabdata(const char *title, const struct bn_tabdata *data)
Definition: tabdata.c:816
void bn_tabdata_incr_mul3_scale(struct bn_tabdata *out, const struct bn_tabdata *in1, const struct bn_tabdata *in2, const struct bn_tabdata *in3, double scale)
double bn_tabdata_mul_area1(const struct bn_tabdata *in1, const struct bn_tabdata *in2)
Definition: tabdata.c:455
void bn_pr_table(const char *title, const struct bn_table *tabp)
Definition: tabdata.c:803
void bn_tabdata_join1(struct bn_tabdata *out, const struct bn_tabdata *in1, double scale, const struct bn_tabdata *in2)
fastf_t x[1]
array of nx+1 wavelengths, dynamically sized
Definition: tabdata.h:76
void bn_tabdata_mul3(struct bn_tabdata *out, const struct bn_tabdata *in1, const struct bn_tabdata *in2, const struct bn_tabdata *in3)
Definition: tabdata.c:175
fastf_t bn_table_lin_interp(const struct bn_tabdata *samp, double wl)
struct bn_tabdata * bn_tabdata_dup(const struct bn_tabdata *in)
Definition: tabdata.c:1041
double bn_tabdata_area1(const struct bn_tabdata *in)
Definition: tabdata.c:414
double fastf_t
Definition: defines.h:300
void bn_tabdata_join2(struct bn_tabdata *out, const struct bn_tabdata *in1, double scale2, const struct bn_tabdata *in2, double scale3, const struct bn_tabdata *in3)
#define BN_GET_TABLE(_table, _nx)
Definition: tabdata.h:84