Branch data Line data Source code
1 : : /*
2 : : * check_zvr.cpp - iterate a zvr file
3 : : *
4 : : * Copyright (C) 2006, 2007 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #if HAVE_CONFIG_H
26 : : # include <config.h>
27 : : #endif
28 : :
29 : : #include <stdio.h>
30 : : #include <stdlib.h>
31 : : #include <string.h>
32 : : #include <cmath>
33 : : #include <assert.h>
34 : : #include <float.h>
35 : : #include <ctype.h>
36 : :
37 : : #include "strlist.h"
38 : : #include "object.h"
39 : : #include "complex.h"
40 : : #include "vector.h"
41 : : #include "dataset.h"
42 : : #include "constants.h"
43 : : #include "check_zvr.h"
44 : :
45 : : using namespace qucs;
46 : :
47 : : // Global variables.
48 : : dataset * zvr_result = NULL;
49 : : struct zvr_data_t * zvr_root = NULL;
50 : :
51 : : // Creates a valid data vector description.
52 : 0 : static char * zvr_vector_txt (struct zvr_vector_t * vec) {
53 : 0 : int i, i1 = -1, i2 = -1, off = 0, len = strlen (vec->n1);
54 : : static char txt[64];
55 : : // strip off leading 're' or 'im'
56 [ # # ][ # # ]: 0 : if (strstr (vec->n1, "re") == vec->n1 ||
[ # # ]
57 : 0 : strstr (vec->n1, "im") == vec->n1 ||
58 : 0 : strstr (vec->n1, "db") == vec->n1) {
59 : 0 : off = 2;
60 : : }
61 : : // strip off leading 'mag' or 'ang'
62 [ # # ][ # # ]: 0 : else if (strstr (vec->n1, "mag") == vec->n1 ||
63 : 0 : strstr (vec->n1, "ang") == vec->n1) {
64 : 0 : off = 3;
65 : : }
66 [ # # ][ # # ]: 0 : for (i = off; i < len; i++) if (!isalpha (vec->n1[i])) break;
67 : : // get index 1
68 [ # # ]: 0 : if (i < len) {
69 [ # # ]: 0 : if (isdigit (vec->n1[i])) { i1 = vec->n1[i] - '0'; vec->n1[i] = '\0'; }
70 : : }
71 : : // get index 2
72 [ # # ]: 0 : if (++i < len) {
73 [ # # ]: 0 : if (isdigit (vec->n1[i])) { i2 = vec->n1[i] - '0'; vec->n1[i] = '\0'; }
74 : : }
75 : : // create vector description
76 [ # # ][ # # ]: 0 : if (i1 >= 0 && i2 >= 0) {
77 : 0 : sprintf (txt, "%s[%d,%d]", &vec->n1[off], i1, i2);
78 : : }
79 [ # # ]: 0 : else if (i1 >= 0) {
80 : 0 : sprintf (txt, "%s[%d]", &vec->n1[off], i1);
81 : : }
82 : : else {
83 : 0 : sprintf (txt, "%s", &vec->n1[off]);
84 : : }
85 : 0 : return txt;
86 : : }
87 : :
88 : : // The function free's the memory used by the ZVR checker.
89 : 0 : static void zvr_finalize (void) {
90 : : struct zvr_data_t * root, * next;
91 : : // go through each dataset
92 [ # # ]: 0 : for (root = zvr_root; root; root = next) {
93 : 0 : struct zvr_vector_t * vec = root->v;
94 : 0 : struct zvr_header_t * hdr = root->h;
95 : 0 : next = root->next;
96 : : // free each data line
97 [ # # ]: 0 : if (root->d) {
98 : : struct zvr_line_t * rl, * nl;
99 [ # # ]: 0 : for (rl = root->d; rl; rl = nl) {
100 : 0 : nl = rl->next;
101 : 0 : free (rl);
102 : : }
103 : : }
104 : : // free header
105 [ # # ]: 0 : if (hdr) {
106 [ # # ]: 0 : if (hdr->funit) free (hdr->funit);
107 [ # # ]: 0 : if (hdr->d_UNT) free (hdr->d_UNT);
108 [ # # ]: 0 : if (hdr->d_FMT) free (hdr->d_FMT);
109 [ # # ]: 0 : if (hdr->d_TYP) free (hdr->d_TYP);
110 : 0 : free (hdr);
111 : : }
112 : : // free data vector
113 [ # # ]: 0 : if (vec) {
114 [ # # ]: 0 : if (vec->nf) free (vec->nf);
115 [ # # ]: 0 : if (vec->n1) free (vec->n1);
116 [ # # ]: 0 : if (vec->n2) free (vec->n2);
117 : 0 : free (vec);
118 : : }
119 : : }
120 : 0 : zvr_root = NULL;
121 : 0 : }
122 : :
123 : : // Create a dependency string list.
124 : 0 : static strlist * zvr_create_dep (char * n) {
125 [ # # ]: 0 : strlist * dep = new strlist ();
126 : 0 : dep->add (n);
127 : 0 : return dep;
128 : : }
129 : :
130 : : // Handles the dependency vectors.
131 : 0 : static void zvr_check_dependencies (void) {
132 : 0 : vector * dep1 = zvr_result->getDependencies ();
133 : 0 : vector * depn = (vector *) dep1->getNext ();
134 : : bool equal;
135 : :
136 : : // check for differing dependency vectors
137 [ # # ]: 0 : for (equal = true; depn != NULL; depn = (vector *) depn->getNext ()) {
138 [ # # ]: 0 : if (depn->getSize () != dep1->getSize ()) {
139 : 0 : equal = false; // differs in size
140 : 0 : break;
141 : : } else {
142 [ # # ]: 0 : for (int i = 0; i < depn->getSize (); i++) {
143 [ # # ]: 0 : if (depn->get (i) != dep1->get (i)) {
144 : 0 : equal = false; // differs in content
145 : 0 : break;
146 : : }
147 : : }
148 : : }
149 : : }
150 : :
151 : : // all dependency vectors equal
152 [ # # ]: 0 : if (equal) {
153 : : vector * ndep;
154 : : // delete unnecessary vectors
155 [ # # ]: 0 : for (depn = (vector *) dep1->getNext (); depn != NULL; depn = ndep) {
156 : 0 : ndep = (vector *) depn->getNext ();
157 : 0 : zvr_result->delDependency (depn);
158 : : }
159 : : }
160 : : // at least one dependency vectors not equal
161 : : else {
162 : 0 : vector * depn = zvr_result->getDependencies ();
163 : 0 : vector * varn = zvr_result->getVariables ();
164 : 0 : char txt[64]; int i = 1;
165 : : // change name of dependency vectors as well as the dependency
166 : : // reference in the appropriate variable vectors
167 [ # # ][ # # ]: 0 : while (depn != NULL && varn != NULL) {
[ # # ]
168 : 0 : sprintf (txt, "%s.%d", depn->getName (), i);
169 [ # # ]: 0 : depn->setName (txt);
170 [ # # ][ # # ]: 0 : varn->setDependencies (zvr_create_dep (txt));
171 : 0 : depn = (vector *) depn->getNext ();
172 : 0 : varn = (vector *) varn->getNext ();
173 : 0 : i++;
174 : : }
175 : : }
176 : 0 : }
177 : :
178 : : // The function performs the data conversion if necessary.
179 : 0 : static void zvr_conversion (struct zvr_data_t * root) {
180 [ # # ]: 0 : for (; root != NULL; root = root->next) {
181 : 0 : struct zvr_vector_t * vec = root->v;
182 : 0 : struct zvr_header_t * hdr = root->h;
183 : 0 : vector * var = vec->vd; int n;
184 : : // magnitude in [dB] and angle in [degree]
185 [ # # ][ # # ]: 0 : if (!strcmp (hdr->d_FMT, "COMPLEX") && !strcmp (hdr->d_UNT, "dB")) {
186 [ # # ]: 0 : for (n = 0; n < var->getSize (); n++) {
187 : 0 : nr_double_t r = real (var->get (n));
188 : 0 : nr_double_t i = imag (var->get (n));
189 [ # # ]: 0 : var->set (std::polar (std::pow (10.0, r / 20.0), rad (i)), n);
190 : 0 : }
191 : : }
192 : : // magnitude in [dB]
193 [ # # ][ # # ]: 0 : else if (!strcmp (hdr->d_FMT, "MAGNITUDE") && !strcmp (hdr->d_UNT, "dB")) {
194 [ # # ]: 0 : for (n = 0; n < var->getSize (); n++) {
195 : 0 : nr_double_t r = real (var->get (n));
196 : 0 : var->set (std::pow (10.0, r / 20.0), n);
197 : 0 : }
198 : : }
199 : : // linear magnitude and angle in [degree]
200 [ # # ]: 0 : else if (!strcmp (hdr->d_FMT, "MA")) {
201 [ # # ]: 0 : for (n = 0; n < var->getSize (); n++) {
202 [ # # ]: 0 : nr_double_t r = real (var->get (n));
203 [ # # ]: 0 : nr_double_t i = imag (var->get (n));
204 [ # # ]: 0 : var->set (std::polar (r, rad (i)), n);
205 : : }
206 : : }
207 : : // magnitude in [dB] and angle in [degree]
208 [ # # ]: 0 : else if (!strcmp (hdr->d_FMT, "DB")) {
209 [ # # ]: 0 : for (n = 0; n < var->getSize (); n++) {
210 : 0 : nr_double_t r = real (var->get (n));
211 : 0 : nr_double_t i = imag (var->get (n));
212 [ # # ]: 0 : var->set (std::polar (std::pow (10.0, r / 20.0), rad (i)), n);
213 : : }
214 : : }
215 : : }
216 : 0 : }
217 : :
218 : : /* This function is the overall ZVR data checker. It returns zero on
219 : : success, non-zero otherwise. */
220 : 0 : int zvr_check (void) {
221 : 0 : int errors = 0;
222 : : struct zvr_data_t * root;
223 : :
224 : : // create a dataset
225 [ # # ]: 0 : zvr_result = new dataset ();
226 : :
227 : : // transfer ZVR tree data into the dataset
228 [ # # ]: 0 : for (root = zvr_root; root; root = root->next) {
229 : 0 : struct zvr_vector_t * vec = root->v;
230 : 0 : vec->vi->setName (vec->nf);
231 : 0 : vec->vd->setName (zvr_vector_txt (vec));
232 [ # # ]: 0 : for (struct zvr_line_t * line = root->d; line; line = line->next) {
233 [ # # ]: 0 : vec->vi->add (line->d);
234 [ # # ]: 0 : vec->vd->add (nr_complex_t (line->r, line->i));
235 : : }
236 : 0 : vec->vd->setDependencies (zvr_create_dep (vec->nf));
237 : 0 : zvr_result->appendDependency (vec->vi);
238 : 0 : zvr_result->appendVariable (vec->vd);
239 : : }
240 : :
241 : : // handle dependency vectors
242 : 0 : zvr_check_dependencies ();
243 : :
244 : : // perform data conversions
245 : 0 : zvr_conversion (zvr_root);
246 : :
247 : : // free temporary memory
248 : 0 : zvr_finalize ();
249 : 0 : zvr_root = NULL;
250 : :
251 [ # # ]: 0 : return errors ? -1 : 0;
252 : : }
253 : :
254 : : // Destroys data used by the ZVR checker.
255 : 0 : void zvr_destroy (void) {
256 [ # # ]: 0 : if (zvr_result != NULL) {
257 : : // delete associated dataset
258 [ # # ]: 0 : delete zvr_result;
259 : 0 : zvr_result = NULL;
260 : : }
261 [ # # ]: 0 : if (zvr_root != NULL) {
262 : 0 : zvr_finalize ();
263 : 0 : zvr_root = NULL;
264 : : }
265 : 0 : }
266 : :
267 : : // Initializes the ZVR checker.
268 : 0 : void zvr_init (void) {
269 : 0 : zvr_result = NULL;
270 : 0 : zvr_root = NULL;
271 : 0 : }
|
