Branch data Line data Source code
1 : : /*
2 : : * evaluate.cpp - the Qucs equation evaluator implementations
3 : : *
4 : : * Copyright (C) 2004-2011 Stefan Jahn <stefan@lkcc.org>
5 : : * Copyright (C) 2006 Gunther Kraut <gn.kraut@t-online.de>
6 : : *
7 : : * This is free software; you can redistribute it and/or modify
8 : : * it under the terms of the GNU General Public License as published by
9 : : * the Free Software Foundation; either version 2, or (at your option)
10 : : * any later version.
11 : : *
12 : : * This software is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : * GNU General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU General Public License
18 : : * along with this package; see the file COPYING. If not, write to
19 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 : : * Boston, MA 02110-1301, USA.
21 : : *
22 : : * $Id$
23 : : *
24 : : */
25 : :
26 : : #if HAVE_CONFIG_H
27 : : # include <config.h>
28 : : #endif
29 : :
30 : : #include <stdio.h>
31 : : #include <stdlib.h>
32 : : #include <string.h>
33 : : #include <ctype.h>
34 : : #include <cmath>
35 : :
36 : : #include "logging.h"
37 : : #include "complex.h"
38 : : #include "object.h"
39 : : #include "vector.h"
40 : : #include "matrix.h"
41 : : #include "poly.h"
42 : : #include "spline.h"
43 : : #include "fourier.h"
44 : : #include "receiver.h"
45 : : #include "constants.h"
46 : : #include "fspecial.h"
47 : : #include "circuit.h"
48 : : #include "range.h"
49 : : #include "equation.h"
50 : : #include "evaluate.h"
51 : : #include "exception.h"
52 : : #include "exceptionstack.h"
53 : : #include "strlist.h"
54 : :
55 : : using namespace qucs;
56 : : using namespace qucs::eqn;
57 : : using namespace qucs::fourier;
58 : : using namespace fspecial;
59 : :
60 : : // Short macros in order to obtain the correct constant value.
61 : : #define D(con) ((constant *) (con))->d
62 : : #define C(con) ((constant *) (con))->c
63 : : #define V(con) ((constant *) (con))->v
64 : : #define M(con) ((constant *) (con))->m
65 : : #define MV(con) ((constant *) (con))->mv
66 : : #define STR(con) ((constant *) (con))->s
67 : : #define CHR(con) ((constant *) (con))->chr
68 : : #define INT(con) ((int) D (con))
69 : : #define RNG(con) ((constant *) (con))->r
70 : : #define B(con) ((constant *) (con))->b
71 : :
72 : : #define A(a) ((assignment *) (a))
73 : : #define R(r) ((reference *) (r))
74 : :
75 : : // Argument macros.
76 : : #define _ARES(idx) args->getResult(idx)
77 : : #define _ARG(idx) args->get(idx)
78 : :
79 : : #define _D(var,idx) nr_double_t (var) = D (_ARES (idx));
80 : : #define _BO(var,idx) bool (var) = B (_ARES (idx));
81 : : #define _CX(var,idx) nr_complex_t * (var) = C (_ARES (idx));
82 : : #define _V(var,idx) qucs::vector * (var) = V (_ARES (idx));
83 : : #define _M(var,idx) matrix * (var) = M (_ARES (idx));
84 : : #define _MV(var,idx) matvec * (var) = MV (_ARES (idx));
85 : : #define _I(var,idx) int (var) = INT (_ARES (idx));
86 : : #define _R(var,idx) range * (var) = RNG (_ARES (idx));
87 : :
88 : : #define _ARR0(var) _R (var,0)
89 : : #define _ARR1(var) _R (var,1)
90 : : #define _ARR2(var) _R (var,2)
91 : : #define _ARI0(var) _I (var,0)
92 : : #define _ARI1(var) _I (var,1)
93 : : #define _ARI2(var) _I (var,2)
94 : : #define _ARD0(var) _D (var,0)
95 : : #define _ARD1(var) _D (var,1)
96 : : #define _ARD2(var) _D (var,2)
97 : : #define _ARB0(var) _BO (var,0)
98 : : #define _ARB1(var) _BO (var,1)
99 : : #define _ARB2(var) _BO (var,2)
100 : : #define _ARC0(var) _CX (var,0)
101 : : #define _ARC1(var) _CX (var,1)
102 : : #define _ARC2(var) _CX (var,2)
103 : : #define _ARM0(var) _M (var,0)
104 : : #define _ARM1(var) _M (var,1)
105 : : #define _ARM2(var) _M (var,2)
106 : : #define _ARV0(var) _V (var,0)
107 : : #define _ARV1(var) _V (var,1)
108 : : #define _ARV2(var) _V (var,2)
109 : : #define _ARMV0(var) _MV (var,0)
110 : : #define _ARMV1(var) _MV (var,1)
111 : : #define _ARMV2(var) _MV (var,2)
112 : :
113 : : // Return value definition macros.
114 : : #define _DEFD() constant * res = new constant (TAG_DOUBLE);
115 : : #define _DEFB() constant * res = new constant (TAG_BOOLEAN);
116 : : #define _DEFC() constant * res = new constant (TAG_COMPLEX);
117 : : #define _DEFV() constant * res = new constant (TAG_VECTOR);
118 : : #define _DEFM() constant * res = new constant (TAG_MATRIX);
119 : : #define _DEFMV() constant * res = new constant (TAG_MATVEC);
120 : : #define _DEFR() constant * res = new constant (TAG_RANGE);
121 : :
122 : : // Return value macros.
123 : : #define _RETD(var) res->d = (var); return res;
124 : : #define _RETD_QUCS(var) res->d = (qucs::var); return res;
125 : : #define _RETD_STD(var) res->d = (std::var); return res;
126 : : #define _RETD_SPECIAL(var) res->d = (fspecial::var); return res;
127 : : #define _RETB(var) res->b = (var); return res;
128 : : #define _RETC(var) res->c = new nr_complex_t (var); return res;
129 : : #define _RETV(var) res->v = new qucs::vector (var); return res;
130 : : #define _RETM(var) res->m = new matrix (var); return res;
131 : : #define _RETMV(var) res->mv = new matvec (var); return res;
132 : : #define _RETR(var) res->r = (var); return res;
133 : :
134 : : // Return value macros without arguments.
135 : : #define __RETC() res->c = new nr_complex_t (); return res;
136 : : #define __RETV() res->v = new qucs::vector (); return res;
137 : : #define __RETM() res->m = new matrix (); return res;
138 : : #define __RETMV() res->mv = new matvec (); return res;
139 : :
140 : : #define SOLVEE(idx) args->get(idx)->solvee
141 : :
142 : : // Throws a math exception.
143 : : #define THROW_MATH_EXCEPTION(txt) do { \
144 : : qucs::exception * e = new qucs::exception (EXCEPTION_MATH); \
145 : : e->setText (txt); throw_exception (e); } while (0)
146 : :
147 : : /* The QUCS_CONCAT macros create a new concatenated symbol for the
148 : : compiler in a portable way. It is essential to use these macros
149 : : like QUCS_CONCAT (a,b) and *not* like QUCS_CONCAT (a, b) or its
150 : : variants. */
151 : : #if defined (__STDC__) || defined (__cplusplus)
152 : : # define QUCS_CONCAT2(a, b) a##b
153 : : # define QUCS_CONCAT3(a, b, c) a##b##c
154 : : #else
155 : : # define QUCS_CONCAT2(a, b) a/* */b
156 : : # define QUCS_CONCAT3(a, b, c) a/* */b/* */c
157 : : #endif
158 : :
159 : : // The following macro is meant to be used for some simple functions.
160 : : #define MAKE_FUNC_DEFINITION_0(cfunc) \
161 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d) (constant * args) { \
162 : : _ARD0 (d); \
163 : : _DEFD (); \
164 : : _RETD (cfunc (d)); \
165 : : } \
166 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c) (constant * args) { \
167 : : _ARC0 (c); \
168 : : _DEFC (); \
169 : : _RETC (cfunc (*c)); \
170 : : } \
171 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
172 : : _ARV0 (v); \
173 : : _DEFV (); \
174 : : _RETV (cfunc (*v)); \
175 : : }
176 : :
177 : : // The following macro is meant to be used for some simple functions,
178 : : // which must explicitly use the double function from the std namespace
179 : : #define MAKE_FUNC_DEFINITION_0_STD(cfunc) \
180 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d) (constant * args) { \
181 : : _ARD0 (d); \
182 : : _DEFD (); \
183 : : _RETD_STD (cfunc (d)); \
184 : : } \
185 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c) (constant * args) { \
186 : : _ARC0 (c); \
187 : : _DEFC (); \
188 : : _RETC (cfunc (*c)); \
189 : : } \
190 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
191 : : _ARV0 (v); \
192 : : _DEFV (); \
193 : : _RETV (cfunc (*v)); \
194 : : }
195 : :
196 : : // The following macro is meant to be used for some simple functions,
197 : : // which must explicitly use the double function from the qucs namespace
198 : : #define MAKE_FUNC_DEFINITION_0_QUCS(cfunc) \
199 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d) (constant * args) { \
200 : : _ARD0 (d); \
201 : : _DEFD (); \
202 : : _RETD_QUCS (cfunc (d)); \
203 : : } \
204 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c) (constant * args) { \
205 : : _ARC0 (c); \
206 : : _DEFC (); \
207 : : _RETC (cfunc (*c)); \
208 : : } \
209 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
210 : : _ARV0 (v); \
211 : : _DEFV (); \
212 : : _RETV (cfunc (*v)); \
213 : : }
214 : :
215 : : // The following macro is meant to be used for some simple functions,
216 : : // which must explicitly use the double function from the fspecial namespace
217 : : #define MAKE_FUNC_DEFINITION_0_SPECIAL(cfunc) \
218 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d) (constant * args) { \
219 : : _ARD0 (d); \
220 : : _DEFD (); \
221 : : _RETD_SPECIAL (cfunc (d)); \
222 : : } \
223 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c) (constant * args) { \
224 : : _ARC0 (c); \
225 : : _DEFC (); \
226 : : _RETC (cfunc (*c)); \
227 : : } \
228 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
229 : : _ARV0 (v); \
230 : : _DEFV (); \
231 : : _RETV (cfunc (*v)); \
232 : : }
233 : :
234 : : #define MAKE_FUNC_DEFINITION_1(cfunc) \
235 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d) (constant * args) { \
236 : : _ARD0 (d); \
237 : : _DEFD (); \
238 : : _RETD (cfunc (d)); \
239 : : } \
240 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c) (constant * args) { \
241 : : _ARC0 (c); \
242 : : _DEFD (); \
243 : : res->d = cfunc (*c); return res; \
244 : : } \
245 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
246 : : _ARV0 (v); \
247 : : _DEFV (); \
248 : : _RETV (cfunc (*v)); \
249 : : } \
250 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_m) (constant * args) { \
251 : : _ARM0 (m); \
252 : : _DEFM (); \
253 : : _RETM (cfunc (*m)); \
254 : : } \
255 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_mv) (constant * args) {\
256 : : _ARMV0 (mv); \
257 : : _DEFMV (); \
258 : : _RETMV (cfunc (*mv)); \
259 : : }
260 : :
261 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (exp); // exponential function
[ # # ][ # # ]
[ # # ][ # # ]
262 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (limexp); // limited exponential function
[ # # ][ # # ]
[ # # ][ # # ]
263 [ + - ][ + - ]: 9 : MAKE_FUNC_DEFINITION_0 (sin); // sine
[ + - ][ # # ]
[ # # ][ # # ]
264 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (cos); // cosine
[ # # ][ # # ]
[ # # ][ # # ]
265 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (tan); // tangent
[ # # ][ # # ]
[ # # ][ # # ]
266 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (sinh); // sine hyperbolicus
[ # # ][ # # ]
[ # # ][ # # ]
267 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (cosh); // cosine hyperbolicus
[ # # ][ # # ]
[ # # ][ # # ]
268 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (tanh); // tangent hyperbolicus
[ # # ][ # # ]
[ # # ][ # # ]
269 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (coth); // cotangent hyperbolicus
[ # # ][ # # ]
[ # # ][ # # ]
270 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (sech); // secans hyperbolicus
[ # # ][ # # ]
[ # # ][ # # ]
271 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (cosech); // cosecans hyperbolicus
[ # # ][ # # ]
[ # # ][ # # ]
272 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (signum); // signum function
[ # # ][ # # ]
[ # # ][ # # ]
273 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (sign); // sign function
[ # # ][ # # ]
[ # # ][ # # ]
274 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (sinc); // sin(x)/x aka sinc function
[ # # ][ # # ]
[ # # ][ # # ]
275 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0 (sqr); // square value
[ # # ][ # # ]
[ # # ][ # # ]
276 : :
277 [ # # ][ # # ]: 1 : MAKE_FUNC_DEFINITION_1 (real); // real value
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ # # ]
[ # # ]
278 [ # # ][ # # ]: 1 : MAKE_FUNC_DEFINITION_1 (imag); // imaginary value
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ # # ]
[ # # ]
279 [ # # ][ # # ]: 26 : MAKE_FUNC_DEFINITION_1 (abs); // absolute value
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ # # ]
[ # # ]
280 : :
281 : : // ******************** unary plus *************************
282 : 0 : constant * evaluate::plus_d (constant * args) {
283 [ # # ]: 0 : _ARD0 (d1); _DEFD (); _RETD (d1);
284 : : }
285 : :
286 : 0 : constant * evaluate::plus_c (constant * args) {
287 [ # # ]: 0 : _ARC0 (c1); _DEFC (); _RETC (*c1);
288 : : }
289 : :
290 : 0 : constant * evaluate::plus_v (constant * args) {
291 [ # # ][ # # ]: 0 : _ARV0 (v1); _DEFV (); _RETV (*v1);
292 : : }
293 : :
294 : 0 : constant * evaluate::plus_m (constant * args) {
295 [ # # ][ # # ]: 0 : _ARM0 (m1); _DEFM (); _RETM (*m1);
296 : : }
297 : :
298 : 0 : constant * evaluate::plus_mv (constant * args) {
299 [ # # ][ # # ]: 0 : _ARMV0 (v1); _DEFMV (); _RETMV (*v1);
300 : : }
301 : :
302 : : // ****************** addition *****************************
303 : 101 : constant * evaluate::plus_d_d (constant * args) {
304 : 101 : _ARD0 (d1);
305 : 101 : _ARD1 (d2);
306 [ + - ]: 101 : _DEFD ();
307 : 101 : _RETD (d1 + d2);
308 : : }
309 : :
310 : 0 : constant * evaluate::plus_c_c (constant * args) {
311 : 0 : _ARC0 (c1);
312 : 0 : _ARC1 (c2);
313 [ # # ]: 0 : _DEFC ();
314 [ # # ]: 0 : _RETC (*c1 + *c2);
315 : : }
316 : :
317 : 0 : constant * evaluate::plus_c_d (constant * args) {
318 [ # # ]: 0 : _ARC0 (c1);
319 [ # # ]: 0 : _ARD1 (d2);
320 [ # # ][ # # ]: 0 : _DEFC ();
321 [ # # ]: 0 : _RETC (*c1 + d2);
322 : : }
323 : :
324 : 0 : constant * evaluate::plus_d_c (constant * args) {
325 [ # # ]: 0 : _ARD0 (d1);
326 [ # # ]: 0 : _ARC1 (c2);
327 [ # # ][ # # ]: 0 : _DEFC ();
328 [ # # ]: 0 : _RETC (d1 + *c2);
329 : : }
330 : :
331 : 1 : constant * evaluate::plus_v_d (constant * args) {
332 : 1 : _ARV0 (v1);
333 : 1 : _ARD1 (d2);
334 [ + - ]: 1 : _DEFV ();
335 [ + - ][ + - ]: 1 : _RETV (*v1 + d2);
336 : : }
337 : :
338 : 0 : constant * evaluate::plus_d_v (constant * args) {
339 : 0 : _ARD0 (d1);
340 : 0 : _ARV1 (v2);
341 [ # # ]: 0 : _DEFV ();
342 [ # # ][ # # ]: 0 : _RETV (d1 + *v2);
343 : : }
344 : :
345 : 0 : constant * evaluate::plus_v_c (constant * args) {
346 : 0 : _ARV0 (v1);
347 : 0 : _ARC1 (c2);
348 [ # # ]: 0 : _DEFV ();
349 [ # # ][ # # ]: 0 : _RETV (*v1 + *c2);
350 : : }
351 : :
352 : 0 : constant * evaluate::plus_c_v (constant * args) {
353 : 0 : _ARC0 (c1);
354 : 0 : _ARV1 (v2);
355 [ # # ]: 0 : _DEFV ();
356 [ # # ][ # # ]: 0 : _RETV (*v2 + *c1);
357 : : }
358 : :
359 : 2 : constant * evaluate::plus_v_v (constant * args) {
360 : 2 : _ARV0 (v1);
361 : 2 : _ARV1 (v2);
362 [ + - ]: 2 : _DEFV ();
363 [ + - ][ + - ]: 2 : _RETV (*v1 + *v2);
[ + - ][ + - ]
364 : : }
365 : :
366 : 0 : constant * evaluate::plus_m_m (constant * args) {
367 : 0 : _ARM0 (m1);
368 : 0 : _ARM1 (m2);
369 [ # # ]: 0 : _DEFM ();
370 [ # # ][ # # ]: 0 : _RETM (*m1 + *m2);
[ # # ][ # # ]
371 : : }
372 : :
373 : 0 : constant * evaluate::plus_mv_mv (constant * args) {
374 : 0 : _ARMV0 (v1);
375 : 0 : _ARMV1 (v2);
376 [ # # ]: 0 : _DEFMV ();
377 [ # # ][ # # ]: 0 : _RETMV (*v1 + *v2);
[ # # ][ # # ]
378 : : }
379 : :
380 : 0 : constant * evaluate::plus_mv_m (constant * args) {
381 : 0 : _ARMV0 (v1);
382 : 0 : _ARM1 (m2);
383 [ # # ]: 0 : _DEFMV ();
384 [ # # ][ # # ]: 0 : _RETMV (*v1 + *m2);
[ # # ][ # # ]
385 : : }
386 : :
387 : 0 : constant * evaluate::plus_m_mv (constant * args) {
388 : 0 : _ARM0 (m1);
389 : 0 : _ARMV1 (v2);
390 [ # # ]: 0 : _DEFMV ();
391 [ # # ][ # # ]: 0 : _RETMV (*m1 + *v2);
[ # # ][ # # ]
392 : : }
393 : :
394 : 0 : constant * evaluate::plus_m_d (constant * args) {
395 : 0 : _ARM0 (m1);
396 : 0 : _ARD1 (d2);
397 [ # # ]: 0 : _DEFM ();
398 [ # # ][ # # ]: 0 : _RETM (*m1 + d2);
399 : : }
400 : :
401 : 0 : constant * evaluate::plus_d_m (constant * args) {
402 : 0 : _ARD0 (d1);
403 : 0 : _ARM1 (m2);
404 [ # # ]: 0 : _DEFM ();
405 [ # # ][ # # ]: 0 : _RETM (d1 + *m2);
406 : : }
407 : :
408 : 0 : constant * evaluate::plus_m_c (constant * args) {
409 : 0 : _ARM0 (m1);
410 : 0 : _ARC1 (c2);
411 [ # # ]: 0 : _DEFM ();
412 [ # # ][ # # ]: 0 : _RETM (*m1 + *c2);
413 : : }
414 : :
415 : 0 : constant * evaluate::plus_c_m (constant * args) {
416 : 0 : _ARC0 (c1);
417 : 0 : _ARM1 (m2);
418 [ # # ]: 0 : _DEFM ();
419 [ # # ][ # # ]: 0 : _RETM (*c1 + *m2);
420 : : }
421 : :
422 : 0 : constant * evaluate::plus_mv_d (constant * args) {
423 : 0 : _ARMV0 (m1);
424 : 0 : _ARD1 (d2);
425 [ # # ]: 0 : _DEFMV ();
426 [ # # ][ # # ]: 0 : _RETMV (*m1 + d2);
427 : : }
428 : :
429 : 0 : constant * evaluate::plus_d_mv (constant * args) {
430 : 0 : _ARD0 (d1);
431 : 0 : _ARMV1 (m2);
432 [ # # ]: 0 : _DEFMV ();
433 [ # # ][ # # ]: 0 : _RETMV (d1 + *m2);
434 : : }
435 : :
436 : 0 : constant * evaluate::plus_mv_c (constant * args) {
437 : 0 : _ARMV0 (m1);
438 : 0 : _ARC1 (c2);
439 [ # # ]: 0 : _DEFMV ();
440 [ # # ][ # # ]: 0 : _RETMV (*m1 + *c2);
441 : : }
442 : :
443 : 0 : constant * evaluate::plus_c_mv (constant * args) {
444 : 0 : _ARC0 (c1);
445 : 0 : _ARMV1 (m2);
446 [ # # ]: 0 : _DEFMV ();
447 [ # # ][ # # ]: 0 : _RETMV (*c1 + *m2);
448 : : }
449 : :
450 : 0 : constant * evaluate::plus_mv_v (constant * args) {
451 : 0 : _ARMV0 (m1);
452 : 0 : _ARV1 (v2);
453 [ # # ]: 0 : _DEFMV ();
454 [ # # ][ # # ]: 0 : _RETMV (*m1 + *v2);
[ # # ][ # # ]
455 : : }
456 : :
457 : 0 : constant * evaluate::plus_v_mv (constant * args) {
458 : 0 : _ARV0 (v1);
459 : 0 : _ARMV1 (m2);
460 [ # # ]: 0 : _DEFMV ();
461 [ # # ][ # # ]: 0 : _RETMV (*v1 + *m2);
[ # # ][ # # ]
462 : : }
463 : :
464 : 0 : constant * evaluate::plus_s_s (constant * args) {
465 : 0 : char * s1 = STR (_ARES(0));
466 : 0 : char * s2 = STR (_ARES(1));
467 [ # # ]: 0 : constant * res = new constant (TAG_STRING);
468 : 0 : char * p = (char *) malloc (strlen (s1) + strlen (s2) + 1);
469 : 0 : strcpy (p, s1); strcat (p, s2);
470 : 0 : res->s = p;
471 : 0 : return res;
472 : : }
473 : :
474 : 0 : constant * evaluate::plus_c_s (constant * args) {
475 : 0 : char c1 = CHR (_ARES(0));
476 : 0 : char * s2 = STR (_ARES(1));
477 [ # # ]: 0 : constant * res = new constant (TAG_STRING);
478 : 0 : char * p = (char *) malloc (strlen (s2) + 2);
479 : 0 : p[0] = c1; strcpy (&p[1], s2);
480 : 0 : res->s = p;
481 : 0 : return res;
482 : : }
483 : :
484 : 0 : constant * evaluate::plus_s_c (constant * args) {
485 : 0 : char * s1 = STR (_ARES(0));
486 : 0 : char c2 = CHR (_ARES(1));
487 [ # # ]: 0 : constant * res = new constant (TAG_STRING);
488 : 0 : char * p = (char *) malloc (strlen (s1) + 2);
489 : 0 : strcpy (p, s1); p[strlen (s1)] = c2; p[strlen (s1) + 1] = '\0';
490 : 0 : res->s = p;
491 : 0 : return res;
492 : : }
493 : :
494 : : // ******************** unary minus ***************************
495 : 202 : constant * evaluate::minus_d (constant * args) {
496 [ + - ]: 202 : _ARD0 (d1); _DEFD (); _RETD (-d1);
497 : : }
498 : :
499 : 0 : constant * evaluate::minus_c (constant * args) {
500 [ # # ]: 0 : _ARC0 (c1); _DEFC (); _RETC (-*c1);
501 : : }
502 : :
503 : 10 : constant * evaluate::minus_v (constant * args) {
504 [ + - ][ + - ]: 10 : _ARV0 (v1); _DEFV (); _RETV (-*v1);
505 : : }
506 : :
507 : 0 : constant * evaluate::minus_m (constant * args) {
508 [ # # ][ # # ]: 0 : _ARM0 (m1); _DEFM (); _RETM (-*m1);
509 : : }
510 : :
511 : 0 : constant * evaluate::minus_mv (constant * args) {
512 [ # # ][ # # ]: 0 : _ARMV0 (v1); _DEFMV (); _RETMV (-*v1);
513 : : }
514 : :
515 : : // ****************** subtraction *****************************
516 : 107 : constant * evaluate::minus_d_d (constant * args) {
517 : 107 : _ARD0 (d1);
518 : 107 : _ARD1 (d2);
519 [ + - ]: 107 : _DEFD ();
520 : 107 : _RETD (d1 - d2);
521 : : }
522 : :
523 : 0 : constant * evaluate::minus_c_c (constant * args) {
524 : 0 : _ARC0 (c1);
525 : 0 : _ARC1 (c2);
526 [ # # ]: 0 : _DEFC ();
527 [ # # ]: 0 : _RETC (*c1 - *c2);
528 : : }
529 : :
530 : 0 : constant * evaluate::minus_c_d (constant * args) {
531 [ # # ]: 0 : _ARC0 (c1);
532 [ # # ]: 0 : _ARD1 (d2);
533 [ # # ][ # # ]: 0 : _DEFC ();
534 [ # # ]: 0 : _RETC (*c1 - d2);
535 : : }
536 : :
537 : 0 : constant * evaluate::minus_d_c (constant * args) {
538 [ # # ]: 0 : _ARD0 (d1);
539 [ # # ]: 0 : _ARC1 (c2);
540 [ # # ][ # # ]: 0 : _DEFC ();
541 [ # # ]: 0 : _RETC (d1 - *c2);
542 : : }
543 : :
544 : 14 : constant * evaluate::minus_v_d (constant * args) {
545 : 14 : _ARV0 (v1);
546 : 14 : _ARD1 (d2);
547 [ + - ]: 14 : _DEFV ();
548 [ + - ][ + - ]: 14 : _RETV (*v1 - d2);
549 : : }
550 : :
551 : 0 : constant * evaluate::minus_d_v (constant * args) {
552 : 0 : _ARD0 (d1);
553 : 0 : _ARV1 (v2);
554 [ # # ]: 0 : _DEFV ();
555 [ # # ][ # # ]: 0 : _RETV (d1 - *v2);
556 : : }
557 : :
558 : 0 : constant * evaluate::minus_v_c (constant * args) {
559 : 0 : _ARV0 (v1);
560 : 0 : _ARC1 (c2);
561 [ # # ]: 0 : _DEFV ();
562 [ # # ][ # # ]: 0 : _RETV (*v1 - *c2);
563 : : }
564 : :
565 : 0 : constant * evaluate::minus_c_v (constant * args) {
566 : 0 : _ARC0 (c1);
567 : 0 : _ARV1 (v2);
568 [ # # ]: 0 : _DEFV ();
569 [ # # ][ # # ]: 0 : _RETV (*c1 - *v2);
570 : : }
571 : :
572 : 18 : constant * evaluate::minus_v_v (constant * args) {
573 : 18 : _ARV0 (v1);
574 : 18 : _ARV1 (v2);
575 [ + - ]: 18 : _DEFV ();
576 [ + - ][ + - ]: 18 : _RETV (*v1 - *v2);
[ + - ][ + - ]
577 : : }
578 : :
579 : 0 : constant * evaluate::minus_m_m (constant * args) {
580 : 0 : _ARM0 (m1);
581 : 0 : _ARM1 (m2);
582 [ # # ]: 0 : _DEFM ();
583 [ # # ][ # # ]: 0 : _RETM (*m1 - *m2);
[ # # ][ # # ]
584 : : }
585 : :
586 : 0 : constant * evaluate::minus_mv_mv (constant * args) {
587 : 0 : _ARMV0 (v1);
588 : 0 : _ARMV1 (v2);
589 [ # # ]: 0 : _DEFMV ();
590 [ # # ][ # # ]: 0 : _RETMV (*v1 - *v2);
[ # # ][ # # ]
591 : : }
592 : :
593 : 0 : constant * evaluate::minus_mv_m (constant * args) {
594 : 0 : _ARMV0 (v1);
595 : 0 : _ARM1 (m2);
596 [ # # ]: 0 : _DEFMV ();
597 [ # # ][ # # ]: 0 : _RETMV (*v1 - *m2);
[ # # ][ # # ]
598 : : }
599 : :
600 : 0 : constant * evaluate::minus_m_mv (constant * args) {
601 : 0 : _ARM0 (m1);
602 : 0 : _ARMV1 (v2);
603 [ # # ]: 0 : _DEFMV ();
604 [ # # ][ # # ]: 0 : _RETMV (*m1 - *v2);
[ # # ][ # # ]
605 : : }
606 : :
607 : 0 : constant * evaluate::minus_m_d (constant * args) {
608 : 0 : _ARM0 (m1);
609 : 0 : _ARD1 (d2);
610 [ # # ]: 0 : _DEFM ();
611 [ # # ][ # # ]: 0 : _RETM (*m1 - d2);
612 : : }
613 : :
614 : 0 : constant * evaluate::minus_d_m (constant * args) {
615 : 0 : _ARD0 (d1);
616 : 0 : _ARM1 (m2);
617 [ # # ]: 0 : _DEFM ();
618 [ # # ][ # # ]: 0 : _RETM (d1 - *m2);
619 : : }
620 : :
621 : 0 : constant * evaluate::minus_m_c (constant * args) {
622 : 0 : _ARM0 (m1);
623 : 0 : _ARC1 (c2);
624 [ # # ]: 0 : _DEFM ();
625 [ # # ][ # # ]: 0 : _RETM (*m1 - *c2);
626 : : }
627 : :
628 : 0 : constant * evaluate::minus_c_m (constant * args) {
629 : 0 : _ARC0 (c1);
630 : 0 : _ARM1 (m2);
631 [ # # ]: 0 : _DEFM ();
632 [ # # ][ # # ]: 0 : _RETM (*c1 - *m2);
633 : : }
634 : :
635 : 0 : constant * evaluate::minus_mv_d (constant * args) {
636 : 0 : _ARMV0 (m1);
637 : 0 : _ARD1 (d2);
638 [ # # ]: 0 : _DEFMV ();
639 [ # # ][ # # ]: 0 : _RETMV (*m1 - d2);
640 : : }
641 : :
642 : 0 : constant * evaluate::minus_d_mv (constant * args) {
643 : 0 : _ARD0 (d1);
644 : 0 : _ARMV1 (m2);
645 [ # # ]: 0 : _DEFMV ();
646 [ # # ][ # # ]: 0 : _RETMV (d1 - *m2);
647 : : }
648 : :
649 : 0 : constant * evaluate::minus_mv_c (constant * args) {
650 : 0 : _ARMV0 (m1);
651 : 0 : _ARC1 (c2);
652 [ # # ]: 0 : _DEFMV ();
653 [ # # ][ # # ]: 0 : _RETMV (*m1 - *c2);
654 : : }
655 : :
656 : 0 : constant * evaluate::minus_c_mv (constant * args) {
657 : 0 : _ARC0 (c1);
658 : 0 : _ARMV1 (m2);
659 [ # # ]: 0 : _DEFMV ();
660 [ # # ][ # # ]: 0 : _RETMV (*c1 - *m2);
661 : : }
662 : :
663 : 0 : constant * evaluate::minus_mv_v (constant * args) {
664 : 0 : _ARMV0 (m1);
665 : 0 : _ARV1 (v2);
666 [ # # ]: 0 : _DEFMV ();
667 [ # # ][ # # ]: 0 : _RETMV (*m1 - *v2);
[ # # ][ # # ]
668 : : }
669 : :
670 : 0 : constant * evaluate::minus_v_mv (constant * args) {
671 : 0 : _ARV0 (v1);
672 : 0 : _ARMV1 (m2);
673 [ # # ]: 0 : _DEFMV ();
674 [ # # ][ # # ]: 0 : _RETMV (*v1 - *m2);
[ # # ][ # # ]
675 : : }
676 : :
677 : : // ****************** multiplication *************************
678 : 30 : constant * evaluate::times_d_d (constant * args) {
679 : 30 : _ARD0 (d1);
680 : 30 : _ARD1 (d2);
681 [ + - ]: 30 : _DEFD ();
682 : 30 : _RETD (d1 * d2);
683 : : }
684 : :
685 : 0 : constant * evaluate::times_c_c (constant * args) {
686 : 0 : _ARC0 (c1);
687 : 0 : _ARC1 (c2);
688 [ # # ]: 0 : _DEFC ();
689 [ # # ]: 0 : _RETC ((*c1) * (*c2));
690 : : }
691 : :
692 : 0 : constant * evaluate::times_c_d (constant * args) {
693 [ # # ]: 0 : _ARC0 (c1);
694 [ # # ]: 0 : _ARD1 (d2);
695 [ # # ][ # # ]: 0 : _DEFC ();
696 [ # # ]: 0 : _RETC ((*c1) * d2);
697 : : }
698 : :
699 : 7 : constant * evaluate::times_d_c (constant * args) {
700 [ + - ]: 7 : _ARD0 (d1);
701 [ + - ]: 7 : _ARC1 (c2);
702 [ + - ][ + - ]: 7 : _DEFC ();
703 [ + - ]: 7 : _RETC (d1 * (*c2));
704 : : }
705 : :
706 : 0 : constant * evaluate::times_v_d (constant * args) {
707 : 0 : _ARV0 (v1);
708 : 0 : _ARD1 (d2);
709 [ # # ]: 0 : _DEFV ();
710 [ # # ][ # # ]: 0 : _RETV (*v1 * d2);
711 : : return res;
712 : : }
713 : :
714 : 21 : constant * evaluate::times_d_v (constant * args) {
715 : 21 : _ARD0 (d1);
716 : 21 : _ARV1 (v2);
717 [ + - ]: 21 : _DEFV ();
718 [ + - ][ + - ]: 21 : _RETV (d1 * *v2);
719 : : }
720 : :
721 : 0 : constant * evaluate::times_v_c (constant * args) {
722 : 0 : _ARV0 (v1);
723 : 0 : _ARC1 (c2);
724 [ # # ]: 0 : _DEFV ();
725 [ # # ][ # # ]: 0 : _RETV (*v1 * *c2);
726 : : }
727 : :
728 : 0 : constant * evaluate::times_c_v (constant * args) {
729 : 0 : _ARC0 (c1);
730 : 0 : _ARV1 (v2);
731 [ # # ]: 0 : _DEFV ();
732 [ # # ][ # # ]: 0 : _RETV (*c1 * *v2);
733 : : }
734 : :
735 : 0 : constant * evaluate::times_v_v (constant * args) {
736 : 0 : _ARV0 (v1);
737 : 0 : _ARV1 (v2);
738 [ # # ]: 0 : _DEFV ();
739 [ # # ][ # # ]: 0 : _RETV (*v1 * *v2);
[ # # ][ # # ]
740 : : }
741 : :
742 : 0 : constant * evaluate::times_m_m (constant * args) {
743 : 0 : _ARM0 (m1);
744 : 0 : _ARM1 (m2);
745 [ # # ]: 0 : _DEFM ();
746 [ # # ]: 0 : if (m1->getCols () != m2->getRows ()) {
747 [ # # ]: 0 : THROW_MATH_EXCEPTION ("nonconformant arguments in matrix multiplication");
748 [ # # ]: 0 : res->m = new matrix (m1->getRows (), m2->getCols ());
749 : : } else {
750 [ # # ][ # # ]: 0 : res->m = new matrix (*m1 * *m2);
[ # # ][ # # ]
751 : : }
752 : 0 : return res;
753 : : }
754 : :
755 : 0 : constant * evaluate::times_m_c (constant * args) {
756 : 0 : _ARM0 (m1);
757 : 0 : _ARC1 (c2);
758 [ # # ]: 0 : _DEFM ();
759 [ # # ][ # # ]: 0 : _RETM (*m1 * *c2);
760 : : }
761 : :
762 : 0 : constant * evaluate::times_c_m (constant * args) {
763 : 0 : _ARC0 (c1);
764 : 0 : _ARM1 (m2);
765 [ # # ]: 0 : _DEFM ();
766 [ # # ][ # # ]: 0 : _RETM (*c1 * *m2);
767 : : }
768 : :
769 : 0 : constant * evaluate::times_m_d (constant * args) {
770 : 0 : _ARM0 (m1);
771 : 0 : _ARD1 (d2);
772 [ # # ]: 0 : _DEFM ();
773 [ # # ][ # # ]: 0 : _RETM (*m1 * d2);
774 : : }
775 : :
776 : 0 : constant * evaluate::times_d_m (constant * args) {
777 : 0 : _ARD0 (d1);
778 : 0 : _ARM1 (m2);
779 [ # # ]: 0 : _DEFM ();
780 [ # # ][ # # ]: 0 : _RETM (d1 * *m2);
781 : : }
782 : :
783 : 0 : constant * evaluate::times_mv_mv (constant * args) {
784 : 0 : _ARMV0 (v1);
785 : 0 : _ARMV1 (v2);
786 [ # # ]: 0 : _DEFMV ();
787 [ # # ]: 0 : if (v1->getCols () != v2->getRows ()) {
788 [ # # ]: 0 : THROW_MATH_EXCEPTION ("nonconformant arguments in matrix multiplication");
789 [ # # ]: 0 : res->mv = new matvec (v1->getSize (), v1->getRows (), v2->getCols ());
790 : : } else {
791 [ # # ][ # # ]: 0 : res->mv = new matvec (*v1 * *v2);
[ # # ][ # # ]
792 : : }
793 : 0 : return res;
794 : : }
795 : :
796 : 0 : constant * evaluate::times_mv_c (constant * args) {
797 : 0 : _ARMV0 (v1);
798 : 0 : _ARC1 (c2);
799 [ # # ]: 0 : _DEFMV ();
800 [ # # ][ # # ]: 0 : _RETMV (*v1 * *c2);
801 : : }
802 : :
803 : 0 : constant * evaluate::times_c_mv (constant * args) {
804 : 0 : _ARC0 (c1);
805 : 0 : _ARMV1 (v2);
806 [ # # ]: 0 : _DEFMV ();
807 [ # # ][ # # ]: 0 : _RETMV (*c1 * *v2);
808 : : }
809 : :
810 : 0 : constant * evaluate::times_mv_d (constant * args) {
811 : 0 : _ARMV0 (v1);
812 : 0 : _ARD1 (d2);
813 [ # # ]: 0 : _DEFMV ();
814 [ # # ][ # # ]: 0 : _RETMV (*v1 * d2);
815 : : }
816 : :
817 : 0 : constant * evaluate::times_d_mv (constant * args) {
818 : 0 : _ARD0 (d1);
819 : 0 : _ARMV1 (v2);
820 [ # # ]: 0 : _DEFMV ();
821 [ # # ][ # # ]: 0 : _RETMV (d1 * *v2);
822 : : }
823 : :
824 : 0 : constant * evaluate::times_mv_m (constant * args) {
825 : 0 : _ARMV0 (v1);
826 : 0 : _ARM1 (m2);
827 [ # # ]: 0 : _DEFMV ();
828 [ # # ]: 0 : if (v1->getCols () != m2->getRows ()) {
829 [ # # ]: 0 : THROW_MATH_EXCEPTION ("nonconformant arguments in matrix multiplication");
830 [ # # ]: 0 : res->mv = new matvec (v1->getSize (), v1->getRows (), m2->getCols ());
831 : : } else {
832 [ # # ][ # # ]: 0 : res->mv = new matvec (*v1 * *m2);
[ # # ][ # # ]
833 : : }
834 : 0 : return res;
835 : : }
836 : :
837 : 0 : constant * evaluate::times_m_mv (constant * args) {
838 : 0 : _ARM0 (m1);
839 : 0 : _ARMV1 (v2);
840 [ # # ]: 0 : _DEFMV ();
841 [ # # ]: 0 : if (m1->getCols () != v2->getRows ()) {
842 [ # # ]: 0 : THROW_MATH_EXCEPTION ("nonconformant arguments in matrix multiplication");
843 [ # # ]: 0 : res->mv = new matvec (v2->getSize (), m1->getRows (), v2->getCols ());
844 : : } else {
845 [ # # ][ # # ]: 0 : res->mv = new matvec (*m1 * *v2);
[ # # ][ # # ]
846 : : }
847 : 0 : return res;
848 : : }
849 : :
850 : 0 : constant * evaluate::times_mv_v (constant * args) {
851 : 0 : _ARMV0 (v1);
852 : 0 : _ARV1 (v2);
853 [ # # ]: 0 : _DEFMV ();
854 [ # # ][ # # ]: 0 : _RETMV (*v1 * *v2);
[ # # ][ # # ]
855 : : }
856 : :
857 : 0 : constant * evaluate::times_v_mv (constant * args) {
858 : 0 : _ARV0 (v1);
859 : 0 : _ARMV1 (v2);
860 [ # # ]: 0 : _DEFMV ();
861 [ # # ][ # # ]: 0 : _RETMV (*v1 * *v2);
[ # # ][ # # ]
862 : : }
863 : :
864 : : // ****************** division *************************
865 : 123 : constant * evaluate::over_d_d (constant * args) {
866 : 123 : _ARD0 (d1);
867 : 123 : _ARD1 (d2);
868 [ + - ]: 123 : _DEFD ();
869 [ - + ][ # # ]: 123 : if (d2 == 0.0) THROW_MATH_EXCEPTION ("division by zero");
870 : 123 : _RETD (d1 / d2);
871 : : }
872 : :
873 : 0 : constant * evaluate::over_c_c (constant * args) {
874 : 0 : _ARC0 (c1);
875 : 0 : _ARC1 (c2);
876 [ # # ]: 0 : _DEFC ();
877 [ # # ][ # # ]: 0 : if (*c2 == 0.0) THROW_MATH_EXCEPTION ("division by zero");
878 [ # # ]: 0 : _RETC (*c1 / *c2);
879 : : }
880 : :
881 : 0 : constant * evaluate::over_c_d (constant * args) {
882 [ # # ]: 0 : _ARC0 (c1);
883 [ # # ]: 0 : _ARD1 (d2);
884 [ # # ][ # # ]: 0 : _DEFC ();
885 [ # # ][ # # ]: 0 : if (d2 == 0.0) THROW_MATH_EXCEPTION ("division by zero");
[ # # ][ # # ]
[ # # ]
886 [ # # ]: 0 : _RETC (*c1 / d2);
887 : : }
888 : :
889 : 0 : constant * evaluate::over_d_c (constant * args) {
890 [ # # ]: 0 : _ARD0 (d1);
891 [ # # ]: 0 : _ARC1 (c2);
892 [ # # ][ # # ]: 0 : _DEFC ();
893 [ # # ][ # # ]: 0 : if (*c2 == 0.0) THROW_MATH_EXCEPTION ("division by zero");
[ # # ][ # # ]
[ # # ]
894 [ # # ][ # # ]: 0 : _RETC (d1 / *c2);
895 : : }
896 : :
897 : 0 : constant * evaluate::over_v_d (constant * args) {
898 : 0 : _ARV0 (v1);
899 : 0 : _ARD1 (d2);
900 [ # # ]: 0 : _DEFV ();
901 [ # # ][ # # ]: 0 : if (d2 == 0.0) THROW_MATH_EXCEPTION ("division by zero");
902 [ # # ][ # # ]: 0 : _RETV (*v1 / d2);
903 : : }
904 : :
905 : 0 : constant * evaluate::over_d_v (constant * args) {
906 : 0 : _ARD0 (d1);
907 : 0 : _ARV1 (v2);
908 [ # # ]: 0 : _DEFV ();
909 [ # # ][ # # ]: 0 : _RETV (d1 / *v2);
910 : : }
911 : :
912 : 3 : constant * evaluate::over_v_c (constant * args) {
913 : 3 : _ARV0 (v1);
914 : 3 : _ARC1 (c2);
915 [ + - ]: 3 : _DEFV ();
916 [ - + ][ # # ]: 3 : if (*c2 == 0.0) THROW_MATH_EXCEPTION ("division by zero");
917 [ + - ][ + - ]: 3 : _RETV (*v1 / *c2);
918 : : }
919 : :
920 : 0 : constant * evaluate::over_c_v (constant * args) {
921 : 0 : _ARC0 (c1);
922 : 0 : _ARV1 (v2);
923 [ # # ]: 0 : _DEFV ();
924 [ # # ][ # # ]: 0 : _RETV (*c1 / *v2);
925 : : }
926 : :
927 : 13 : constant * evaluate::over_v_v (constant * args) {
928 : 13 : _ARV0 (v1);
929 : 13 : _ARV1 (v2);
930 [ + - ]: 13 : _DEFV ();
931 [ + - ][ + - ]: 13 : _RETV (*v1 / *v2);
[ + - ][ + - ]
932 : : }
933 : :
934 : 0 : constant * evaluate::over_m_c (constant * args) {
935 : 0 : _ARM0 (m1);
936 : 0 : _ARC1 (c2);
937 [ # # ]: 0 : _DEFM ();
938 [ # # ][ # # ]: 0 : _RETM (*m1 / *c2);
939 : : }
940 : :
941 : 0 : constant * evaluate::over_m_d (constant * args) {
942 : 0 : _ARM0 (m1);
943 : 0 : _ARD1 (d2);
944 [ # # ]: 0 : _DEFM ();
945 [ # # ][ # # ]: 0 : _RETM (*m1 / d2);
946 : : }
947 : :
948 : 0 : constant * evaluate::over_mv_c (constant * args) {
949 : 0 : _ARMV0 (v1);
950 : 0 : _ARC1 (c2);
951 [ # # ]: 0 : _DEFMV ();
952 [ # # ][ # # ]: 0 : _RETMV (*v1 / *c2);
953 : : }
954 : :
955 : 0 : constant * evaluate::over_mv_d (constant * args) {
956 : 0 : _ARMV0 (v1);
957 : 0 : _ARD1 (d2);
958 [ # # ]: 0 : _DEFMV ();
959 [ # # ][ # # ]: 0 : _RETMV (*v1 / d2);
960 : : }
961 : :
962 : 0 : constant * evaluate::over_mv_v (constant * args) {
963 : 0 : _ARMV0 (v1);
964 : 0 : _ARV1 (v2);
965 [ # # ]: 0 : _DEFMV ();
966 [ # # ][ # # ]: 0 : _RETMV (*v1 / *v2);
[ # # ][ # # ]
967 : : }
968 : :
969 : : // ****************** modulo *************************
970 : 0 : constant * evaluate::modulo_d_d (constant * args) {
971 : 0 : _ARD0 (d1);
972 : 0 : _ARD1 (d2);
973 [ # # ]: 0 : _DEFD ();
974 : 0 : _RETD (std::fmod (d1, d2));
975 : : }
976 : :
977 : 0 : constant * evaluate::modulo_c_c (constant * args) {
978 : 0 : _ARC0 (c1);
979 : 0 : _ARC1 (c2);
980 [ # # ]: 0 : _DEFC ();
981 [ # # ]: 0 : _RETC ((*c1) % (*c2));
982 : : }
983 : :
984 : 0 : constant * evaluate::modulo_c_d (constant * args) {
985 : 0 : _ARC0 (c1);
986 : 0 : _ARD1 (d2);
987 [ # # ]: 0 : _DEFC ();
988 [ # # ]: 0 : _RETC ((*c1) % d2);
989 : : }
990 : :
991 : 0 : constant * evaluate::modulo_d_c (constant * args) {
992 : 0 : _ARD0 (d1);
993 : 0 : _ARC1 (c2);
994 [ # # ]: 0 : _DEFC ();
995 [ # # ]: 0 : _RETC (d1 % (*c2));
996 : : }
997 : :
998 : 0 : constant * evaluate::modulo_v_d (constant * args) {
999 : 0 : _ARV0 (v1);
1000 : 0 : _ARD1 (d2);
1001 [ # # ]: 0 : _DEFV ();
1002 [ # # ][ # # ]: 0 : _RETV (*v1 % d2);
1003 : : }
1004 : :
1005 : 0 : constant * evaluate::modulo_d_v (constant * args) {
1006 : 0 : _ARD0 (d1);
1007 : 0 : _ARV1 (v2);
1008 [ # # ]: 0 : _DEFV ();
1009 [ # # ][ # # ]: 0 : _RETV (d1 % *v2);
1010 : : }
1011 : :
1012 : 0 : constant * evaluate::modulo_v_c (constant * args) {
1013 : 0 : _ARV0 (v1);
1014 : 0 : _ARC1 (c2);
1015 [ # # ]: 0 : _DEFV ();
1016 [ # # ][ # # ]: 0 : _RETV (*v1 % *c2);
1017 : : }
1018 : :
1019 : 0 : constant * evaluate::modulo_c_v (constant * args) {
1020 : 0 : _ARC0 (c1);
1021 : 0 : _ARV1 (v2);
1022 [ # # ]: 0 : _DEFV ();
1023 [ # # ][ # # ]: 0 : _RETV (*c1 % *v2);
1024 : : }
1025 : :
1026 : 0 : constant * evaluate::modulo_v_v (constant * args) {
1027 : 0 : _ARV0 (v1);
1028 : 0 : _ARV1 (v2);
1029 [ # # ]: 0 : _DEFV ();
1030 [ # # ][ # # ]: 0 : _RETV (*v1 % *v2);
[ # # ][ # # ]
1031 : : }
1032 : :
1033 : : // ****************** power *************************
1034 : 0 : constant * evaluate::power_d_d (constant * args) {
1035 : 0 : _ARD0 (d1);
1036 : 0 : _ARD1 (d2);
1037 [ # # ]: 0 : _DEFD ();
1038 : 0 : _RETD (std::pow (d1, d2));
1039 : : }
1040 : :
1041 : 0 : constant * evaluate::power_c_c (constant * args) {
1042 : 0 : _ARC0 (c1);
1043 : 0 : _ARC1 (c2);
1044 [ # # ]: 0 : _DEFC ();
1045 : 0 : _RETC (std::pow (*c1, *c2));
1046 : : }
1047 : :
1048 : 0 : constant * evaluate::power_c_d (constant * args) {
1049 : 0 : _ARC0 (c1);
1050 : 0 : _ARD1 (d2);
1051 [ # # ]: 0 : _DEFC ();
1052 [ # # ]: 0 : _RETC (pow (*c1, d2));
1053 : : }
1054 : :
1055 : 0 : constant * evaluate::power_d_c (constant * args) {
1056 : 0 : _ARD0 (d1);
1057 : 0 : _ARC1 (c2);
1058 [ # # ]: 0 : _DEFC ();
1059 [ # # ]: 0 : _RETC (pow (d1, *c2));
1060 : : }
1061 : :
1062 : 0 : constant * evaluate::power_v_d (constant * args) {
1063 : 0 : _ARV0 (v1);
1064 : 0 : _ARD1 (d2);
1065 [ # # ]: 0 : _DEFV ();
1066 [ # # ][ # # ]: 0 : _RETV (pow (*v1, d2));
1067 : : }
1068 : :
1069 : 0 : constant * evaluate::power_d_v (constant * args) {
1070 : 0 : _ARD0 (d1);
1071 : 0 : _ARV1 (v2);
1072 [ # # ]: 0 : _DEFV ();
1073 [ # # ][ # # ]: 0 : _RETV (pow (d1, *v2));
1074 : : }
1075 : :
1076 : 0 : constant * evaluate::power_v_c (constant * args) {
1077 : 0 : _ARV0 (v1);
1078 : 0 : _ARC1 (c2);
1079 [ # # ]: 0 : _DEFV ();
1080 [ # # ][ # # ]: 0 : _RETV (pow (*v1, *c2));
1081 : : }
1082 : :
1083 : 0 : constant * evaluate::power_c_v (constant * args) {
1084 : 0 : _ARC0 (c1);
1085 : 0 : _ARV1 (v2);
1086 [ # # ]: 0 : _DEFV ();
1087 [ # # ][ # # ]: 0 : _RETV (pow (*c1, *v2));
1088 : : }
1089 : :
1090 : 0 : constant * evaluate::power_v_v (constant * args) {
1091 : 0 : _ARV0 (v1);
1092 : 0 : _ARV1 (v2);
1093 [ # # ]: 0 : _DEFV ();
1094 [ # # ][ # # ]: 0 : _RETV (pow (*v1, *v2));
[ # # ][ # # ]
1095 : : }
1096 : :
1097 : 0 : constant * evaluate::power_m_d (constant * args) {
1098 : 0 : _ARM0 (m1);
1099 : 0 : _ARI1 (i2);
1100 [ # # ]: 0 : _DEFM ();
1101 [ # # ][ # # ]: 0 : _RETM (pow (*m1, i2));
1102 : : }
1103 : :
1104 : 0 : constant * evaluate::power_m_c (constant * args) {
1105 : 0 : _ARM0 (m1);
1106 : 0 : _ARC1 (c2);
1107 [ # # ]: 0 : _DEFM ();
1108 [ # # ][ # # ]: 0 : _RETM (pow (*m1, (int) real (*c2)));
1109 : : }
1110 : :
1111 : 0 : constant * evaluate::power_mv_d (constant * args) {
1112 : 0 : _ARMV0 (m1);
1113 : 0 : _ARI1 (i2);
1114 [ # # ]: 0 : _DEFMV ();
1115 [ # # ][ # # ]: 0 : _RETMV (pow (*m1, i2));
1116 : : }
1117 : :
1118 : 0 : constant * evaluate::power_mv_c (constant * args) {
1119 : 0 : _ARMV0 (m1);
1120 : 0 : _ARC1 (c2);
1121 [ # # ]: 0 : _DEFMV ();
1122 [ # # ][ # # ]: 0 : _RETMV (pow (*m1, (int) real (*c2)));
1123 : : }
1124 : :
1125 : 0 : constant * evaluate::power_mv_v (constant * args) {
1126 : 0 : _ARMV0 (m1);
1127 : 0 : _ARV1 (v2);
1128 [ # # ]: 0 : _DEFMV ();
1129 [ # # ][ # # ]: 0 : _RETMV (pow (*m1, *v2));
[ # # ][ # # ]
1130 : : }
1131 : :
1132 : : // ****************** hypotenuse *************************
1133 : 0 : constant * evaluate::xhypot_d_d (constant * args) {
1134 : 0 : _ARD0 (d1);
1135 : 0 : _ARD1 (d2);
1136 [ # # ]: 0 : _DEFD ();
1137 : 0 : _RETD (xhypot (d1, d2));
1138 : : }
1139 : :
1140 : 0 : constant * evaluate::xhypot_c_c (constant * args) {
1141 : 0 : _ARC0 (c1);
1142 : 0 : _ARC1 (c2);
1143 [ # # ]: 0 : _DEFD ();
1144 : 0 : _RETD (xhypot (*c1, *c2));
1145 : : }
1146 : :
1147 : 0 : constant * evaluate::xhypot_c_d (constant * args) {
1148 : 0 : _ARC0 (c1);
1149 : 0 : _ARD1 (d2);
1150 [ # # ]: 0 : _DEFD ();
1151 : 0 : _RETD (xhypot (*c1, d2));
1152 : : }
1153 : :
1154 : 0 : constant * evaluate::xhypot_d_c (constant * args) {
1155 : 0 : _ARD0 (d1);
1156 : 0 : _ARC1 (c2);
1157 [ # # ]: 0 : _DEFD ();
1158 : 0 : _RETD (xhypot (d1, *c2));
1159 : : }
1160 : :
1161 : 0 : constant * evaluate::xhypot_v_d (constant * args) {
1162 : 0 : _ARV0 (v1);
1163 : 0 : _ARD1 (d2);
1164 [ # # ]: 0 : _DEFV ();
1165 [ # # ][ # # ]: 0 : _RETV (xhypot (*v1, d2));
1166 : : }
1167 : :
1168 : 0 : constant * evaluate::xhypot_d_v (constant * args) {
1169 : 0 : _ARD0 (d1);
1170 : 0 : _ARV1 (v2);
1171 [ # # ]: 0 : _DEFV ();
1172 [ # # ][ # # ]: 0 : _RETV (xhypot (d1, *v2));
1173 : : }
1174 : :
1175 : 0 : constant * evaluate::xhypot_v_c (constant * args) {
1176 : 0 : _ARV0 (v1);
1177 : 0 : _ARC1 (c2);
1178 [ # # ]: 0 : _DEFV ();
1179 [ # # ][ # # ]: 0 : _RETV (xhypot (*v1, *c2));
1180 : : }
1181 : :
1182 : 0 : constant * evaluate::xhypot_c_v (constant * args) {
1183 : 0 : _ARC0 (c1);
1184 : 0 : _ARV1 (v2);
1185 [ # # ]: 0 : _DEFV ();
1186 [ # # ][ # # ]: 0 : _RETV (xhypot (*c1, *v2));
1187 : : }
1188 : :
1189 : 0 : constant * evaluate::xhypot_v_v (constant * args) {
1190 : 0 : _ARV0 (v1);
1191 : 0 : _ARV1 (v2);
1192 [ # # ]: 0 : _DEFV ();
1193 [ # # ][ # # ]: 0 : _RETV (xhypot (*v1, *v2));
[ # # ][ # # ]
1194 : : }
1195 : :
1196 : : // ************** conjugate complex **********************
1197 : 0 : constant * evaluate::conj_d (constant * args) {
1198 : 0 : _ARD0 (d1);
1199 [ # # ]: 0 : _DEFD ();
1200 : 0 : _RETD (d1);
1201 : : }
1202 : :
1203 : 0 : constant * evaluate::conj_c (constant * args) {
1204 : 0 : _ARC0 (c1);
1205 [ # # ]: 0 : _DEFC ();
1206 : 0 : _RETC (conj (*c1));
1207 : : }
1208 : :
1209 : 0 : constant * evaluate::conj_v (constant * args) {
1210 : 0 : _ARV0 (v1);
1211 [ # # ]: 0 : _DEFV ();
1212 [ # # ][ # # ]: 0 : _RETV (conj (*v1));
1213 : : }
1214 : :
1215 : 0 : constant * evaluate::conj_m (constant * args) {
1216 : 0 : _ARM0 (m);
1217 [ # # ]: 0 : _DEFM ();
1218 [ # # ][ # # ]: 0 : _RETM (conj (*m));
1219 : : }
1220 : :
1221 : 0 : constant * evaluate::conj_mv (constant * args) {
1222 : 0 : _ARMV0 (mv);
1223 [ # # ]: 0 : _DEFMV ();
1224 [ # # ][ # # ]: 0 : _RETMV (conj (*mv));
1225 : : }
1226 : :
1227 : : // ********** square of absolute value *****************
1228 : 0 : constant * evaluate::norm_d (constant * args) {
1229 : 0 : _ARD0 (d1);
1230 [ # # ]: 0 : _DEFD ();
1231 : 0 : _RETD (d1 * d1);
1232 : : }
1233 : :
1234 : 0 : constant * evaluate::norm_c (constant * args) {
1235 : 0 : _ARC0 (c1);
1236 [ # # ]: 0 : _DEFD ();
1237 : 0 : _RETD (norm (*c1));
1238 : : }
1239 : :
1240 : 0 : constant * evaluate::norm_v (constant * args) {
1241 : 0 : _ARV0 (v1);
1242 [ # # ]: 0 : _DEFV ();
1243 [ # # ][ # # ]: 0 : _RETV (norm (*v1));
1244 : : }
1245 : :
1246 : : // ********** phase in degrees *****************
1247 : 0 : constant * evaluate::phase_d (constant * args) {
1248 : 0 : _ARD0 (d1);
1249 [ # # ]: 0 : _DEFD ();
1250 [ # # ]: 0 : _RETD (d1 < 0.0 ? 180.0 : 0.0);
1251 : : }
1252 : :
1253 : 0 : constant * evaluate::phase_c (constant * args) {
1254 : 0 : _ARC0 (c1);
1255 [ # # ]: 0 : _DEFD ();
1256 : 0 : _RETD (deg (arg (*c1)));
1257 : : }
1258 : :
1259 : 4 : constant * evaluate::phase_v (constant * args) {
1260 : 4 : _ARV0 (v1);
1261 [ + - ]: 4 : _DEFV ();
1262 [ + - ][ + - ]: 4 : _RETV (deg (arg (*v1)));
[ + - ][ + - ]
[ + - ][ + - ]
1263 : : }
1264 : :
1265 : 0 : constant * evaluate::phase_m (constant * args) {
1266 : 0 : _ARM0 (m1);
1267 [ # # ]: 0 : _DEFM ();
1268 [ # # ][ # # ]: 0 : _RETM (deg (arg (*m1)));
[ # # ][ # # ]
[ # # ][ # # ]
1269 : : }
1270 : :
1271 : 0 : constant * evaluate::phase_mv (constant * args) {
1272 : 0 : _ARMV0 (v1);
1273 [ # # ]: 0 : _DEFMV ();
1274 [ # # ][ # # ]: 0 : _RETMV (deg (arg (*v1)));
[ # # ][ # # ]
[ # # ][ # # ]
1275 : : }
1276 : :
1277 : : // ********** phase in radians *****************
1278 : 0 : constant * evaluate::arg_d (constant * args) {
1279 : 0 : _ARD0 (d1);
1280 [ # # ]: 0 : _DEFD ();
1281 [ # # ]: 0 : _RETD (d1 < 0.0 ? M_PI : 0.0);
1282 : : }
1283 : :
1284 : 0 : constant * evaluate::arg_c (constant * args) {
1285 : 0 : _ARC0 (c1);
1286 [ # # ]: 0 : _DEFD ();
1287 : 0 : _RETD (arg (*c1));
1288 : : }
1289 : :
1290 : 2 : constant * evaluate::arg_v (constant * args) {
1291 : 2 : _ARV0 (v1);
1292 [ + - ]: 2 : _DEFV ();
1293 [ + - ][ + - ]: 2 : _RETV (arg (*v1));
1294 : : }
1295 : :
1296 : 0 : constant * evaluate::arg_m (constant * args) {
1297 : 0 : _ARM0 (m1);
1298 [ # # ]: 0 : _DEFM ();
1299 [ # # ][ # # ]: 0 : _RETM (arg (*m1));
1300 : : }
1301 : :
1302 : 0 : constant * evaluate::arg_mv (constant * args) {
1303 : 0 : _ARMV0 (v1);
1304 [ # # ]: 0 : _DEFMV ();
1305 [ # # ][ # # ]: 0 : _RETMV (arg (*v1));
1306 : : }
1307 : :
1308 : : // ******* unwrap phase in radians ************
1309 : 2 : constant * evaluate::unwrap_v_1 (constant * args) {
1310 : 2 : _ARV0 (v1);
1311 [ + - ]: 2 : _DEFV ();
1312 [ + - ][ + - ]: 2 : _RETV (unwrap (*v1));
1313 : : }
1314 : :
1315 : 0 : constant * evaluate::unwrap_v_2 (constant * args) {
1316 : 0 : _ARV0 (v1);
1317 : 0 : _ARD1 (d2);
1318 [ # # ]: 0 : _DEFV ();
1319 [ # # ][ # # ]: 0 : _RETV (unwrap (*v1, fabs (d2)));
1320 : : }
1321 : :
1322 : 0 : constant * evaluate::unwrap_v_3 (constant * args) {
1323 : 0 : _ARV0 (v1);
1324 : 0 : _ARD1 (d2);
1325 : 0 : _ARD2 (d3);
1326 [ # # ]: 0 : _DEFV ();
1327 [ # # ][ # # ]: 0 : _RETV (unwrap (*v1, fabs (d2), fabs (d3)));
1328 : : }
1329 : :
1330 : : // ******** radian/degree conversion **********
1331 : 0 : constant * evaluate::deg2rad_d (constant * args) {
1332 : 0 : _ARD0 (d1);
1333 [ # # ]: 0 : _DEFD ();
1334 : 0 : _RETD (rad (d1));
1335 : : }
1336 : :
1337 : 0 : constant * evaluate::deg2rad_c (constant * args) {
1338 : 0 : _ARC0 (c1);
1339 [ # # ]: 0 : _DEFD ();
1340 : 0 : _RETD (rad (real (*c1)));
1341 : : }
1342 : :
1343 : 0 : constant * evaluate::deg2rad_v (constant * args) {
1344 : 0 : _ARV0 (v1);
1345 [ # # ]: 0 : _DEFV ();
1346 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
1347 [ # # ][ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) v->add (rad (real (v1->get (i))));
1348 : 0 : res->v = v;
1349 : 0 : return res;
1350 : : }
1351 : :
1352 : 0 : constant * evaluate::rad2deg_d (constant * args) {
1353 : 0 : _ARD0 (d1);
1354 [ # # ]: 0 : _DEFD ();
1355 : 0 : _RETD (deg (d1));
1356 : : }
1357 : :
1358 : 0 : constant * evaluate::rad2deg_c (constant * args) {
1359 : 0 : _ARC0 (c1);
1360 [ # # ]: 0 : _DEFD ();
1361 : 0 : _RETD (deg (real (*c1)));
1362 : : }
1363 : :
1364 : 0 : constant * evaluate::rad2deg_v (constant * args) {
1365 : 0 : _ARV0 (v1);
1366 [ # # ]: 0 : _DEFV ();
1367 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
1368 [ # # ][ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) v->add (deg (real (v1->get (i))));
1369 : 0 : res->v = v;
1370 : 0 : return res;
1371 : : }
1372 : :
1373 : : // ********** voltage decibel *****************
1374 : 0 : constant * evaluate::dB_d (constant * args) {
1375 : 0 : _ARD0 (d1);
1376 [ # # ]: 0 : _DEFD ();
1377 : 0 : _RETD (10.0 * std::log10 (std::fabs (d1)));
1378 : : }
1379 : :
1380 : 0 : constant * evaluate::dB_c (constant * args) {
1381 : 0 : _ARC0 (c1);
1382 [ # # ]: 0 : _DEFD ();
1383 : 0 : _RETD (dB (*c1));
1384 : : }
1385 : :
1386 : 32 : constant * evaluate::dB_v (constant * args) {
1387 : 32 : _ARV0 (v1);
1388 [ + - ]: 32 : _DEFV ();
1389 [ + - ][ + - ]: 32 : _RETV (dB (*v1));
1390 : : }
1391 : :
1392 : 0 : constant * evaluate::dB_m (constant * args) {
1393 : 0 : _ARM0 (m1);
1394 [ # # ]: 0 : _DEFM ();
1395 [ # # ][ # # ]: 0 : _RETM (dB (*m1));
1396 : : }
1397 : :
1398 : 0 : constant * evaluate::dB_mv (constant * args) {
1399 : 0 : _ARMV0 (v1);
1400 [ # # ]: 0 : _DEFMV ();
1401 [ # # ][ # # ]: 0 : _RETMV (dB (*v1));
1402 : : }
1403 : :
1404 : : // ********** square root *****************
1405 : 7 : constant * evaluate::sqrt_d (constant * args) {
1406 : 7 : _ARD0 (d1);
1407 [ + - ]: 7 : _DEFC ();
1408 [ - + ]: 7 : if (d1 < 0.0)
1409 : 0 : res->c = new nr_complex_t (0.0, std::sqrt (-d1));
1410 : : else
1411 : 7 : res->c = new nr_complex_t (std::sqrt (d1));
1412 : 7 : return res;
1413 : : }
1414 : :
1415 : 0 : constant * evaluate::sqrt_c (constant * args) {
1416 : 0 : _ARC0 (c1);
1417 [ # # ]: 0 : _DEFC ();
1418 : 0 : _RETC (std::sqrt (*c1));
1419 : : }
1420 : :
1421 : 0 : constant * evaluate::sqrt_v (constant * args) {
1422 : 0 : _ARV0 (v1);
1423 [ # # ]: 0 : _DEFV ();
1424 [ # # ][ # # ]: 0 : _RETV (sqrt (*v1));
1425 : : }
1426 : :
1427 : : // ********** natural logarithm *****************
1428 : 0 : constant * evaluate::ln_d (constant * args) {
1429 : 0 : _ARD0 (d1);
1430 [ # # ]: 0 : _DEFC ();
1431 [ # # ]: 0 : if (d1 < 0.0)
1432 : 0 : res->c = new nr_complex_t (std::log (-d1), M_PI);
1433 : : else
1434 : 0 : res->c = new nr_complex_t (std::log (d1));
1435 : 0 : return res;
1436 : : }
1437 : :
1438 : 0 : constant * evaluate::ln_c (constant * args) {
1439 : 0 : _ARC0 (c1);
1440 [ # # ]: 0 : _DEFC ();
1441 : 0 : _RETC (std::log (*c1));
1442 : : }
1443 : :
1444 : 0 : constant * evaluate::ln_v (constant * args) {
1445 : 0 : _ARV0 (v1);
1446 [ # # ]: 0 : _DEFV ();
1447 [ # # ][ # # ]: 0 : _RETV (log (*v1));
1448 : : }
1449 : :
1450 : : // ********** decimal logarithm *****************
1451 : 0 : constant * evaluate::log10_d (constant * args) {
1452 : 0 : _ARD0 (d1);
1453 [ # # ]: 0 : _DEFC ();
1454 [ # # ]: 0 : if (d1 < 0.0)
1455 : 0 : res->c = new nr_complex_t (std::log10 (-d1), M_PI * M_LOG10E);
1456 : : else
1457 : 0 : res->c = new nr_complex_t (std::log10 (d1));
1458 : 0 : return res;
1459 : : }
1460 : :
1461 : 0 : constant * evaluate::log10_c (constant * args) {
1462 : 0 : _ARC0 (c1);
1463 [ # # ]: 0 : _DEFC ();
1464 : 0 : _RETC (std::log10 (*c1));
1465 : : }
1466 : :
1467 : 2 : constant * evaluate::log10_v (constant * args) {
1468 : 2 : _ARV0 (v1);
1469 [ + - ]: 2 : _DEFV ();
1470 [ + - ][ + - ]: 2 : _RETV (log10 (*v1));
1471 : : }
1472 : :
1473 : : // ********** binary logarithm *****************
1474 : 0 : constant * evaluate::log2_d (constant * args) {
1475 : 0 : _ARD0 (d1);
1476 [ # # ]: 0 : _DEFC ();
1477 [ # # ]: 0 : if (d1 < 0.0)
1478 : 0 : res->c = new nr_complex_t (std::log (-d1) * M_LOG2E, M_PI * M_LOG2E);
1479 : : else
1480 : 0 : res->c = new nr_complex_t (std::log (d1) * M_LOG2E);
1481 : 0 : return res;
1482 : : }
1483 : :
1484 : 0 : constant * evaluate::log2_c (constant * args) {
1485 : 0 : _ARC0 (c1);
1486 [ # # ]: 0 : _DEFC ();
1487 [ # # ]: 0 : _RETC (qucs::log2 (*c1));
1488 : : }
1489 : :
1490 : 0 : constant * evaluate::log2_v (constant * args) {
1491 : 0 : _ARV0 (v1);
1492 [ # # ]: 0 : _DEFV ();
1493 [ # # ][ # # ]: 0 : _RETV (log2 (*v1));
1494 : : }
1495 : :
1496 : : // ************* arcus sine *********************
1497 : 0 : constant * evaluate::arcsin_d (constant * args) {
1498 : 0 : _ARD0 (d1);
1499 [ # # ]: 0 : _DEFD ();
1500 : 0 : _RETD (std::asin (d1));
1501 : : }
1502 : :
1503 : 0 : constant * evaluate::arcsin_c (constant * args) {
1504 : 0 : _ARC0 (c1);
1505 [ # # ]: 0 : _DEFC ();
1506 [ # # ]: 0 : _RETC (asin (*c1));
1507 : : }
1508 : :
1509 : 0 : constant * evaluate::arcsin_v (constant * args) {
1510 : 0 : _ARV0 (v1);
1511 [ # # ]: 0 : _DEFV ();
1512 [ # # ][ # # ]: 0 : _RETV (asin (*v1));
1513 : : }
1514 : :
1515 : : // ************* arcus cosine ******************
1516 : 0 : constant * evaluate::arccos_d (constant * args) {
1517 : 0 : _ARD0 (d1);
1518 [ # # ]: 0 : _DEFD ();
1519 : 0 : _RETD (std::acos (d1));
1520 : : }
1521 : :
1522 : 0 : constant * evaluate::arccos_c (constant * args) {
1523 : 0 : _ARC0 (c1);
1524 [ # # ]: 0 : _DEFC ();
1525 [ # # ]: 0 : _RETC (qucs::acos (*c1));
1526 : : }
1527 : :
1528 : 0 : constant * evaluate::arccos_v (constant * args) {
1529 : 0 : _ARV0 (v1);
1530 [ # # ]: 0 : _DEFV ();
1531 [ # # ][ # # ]: 0 : _RETV (acos (*v1));
1532 : : }
1533 : :
1534 : : // ************** arcus tangent ******************
1535 : 0 : constant * evaluate::arctan_d (constant * args) {
1536 : 0 : _ARD0 (d1);
1537 [ # # ]: 0 : _DEFD ();
1538 : 0 : _RETD (std::atan (d1));
1539 : : }
1540 : :
1541 : 0 : constant * evaluate::arctan_c (constant * args) {
1542 : 0 : _ARC0 (c1);
1543 [ # # ]: 0 : _DEFC ();
1544 [ # # ]: 0 : _RETC (qucs::atan (*c1));
1545 : : }
1546 : :
1547 : 0 : constant * evaluate::arctan_v (constant * args) {
1548 : 0 : _ARV0 (v1);
1549 [ # # ]: 0 : _DEFV ();
1550 [ # # ][ # # ]: 0 : _RETV (atan (*v1));
1551 : : }
1552 : :
1553 : : // *************** cotangent ********************
1554 : 0 : constant * evaluate::cot_d (constant * args) {
1555 : 0 : _ARD0 (d1);
1556 [ # # ]: 0 : _DEFD ();
1557 : 0 : _RETD (1.0 / std::tan (d1));
1558 : : }
1559 : :
1560 : 0 : constant * evaluate::cot_c (constant * args) {
1561 : 0 : _ARC0 (c1);
1562 [ # # ]: 0 : _DEFC ();
1563 [ # # ]: 0 : _RETC (qucs::cot (*c1));
1564 : : }
1565 : :
1566 : 0 : constant * evaluate::cot_v (constant * args) {
1567 : 0 : _ARV0 (v1);
1568 [ # # ]: 0 : _DEFV ();
1569 [ # # ][ # # ]: 0 : _RETV (cot (*v1));
1570 : : }
1571 : :
1572 : : // ************ arcus cotangent *****************
1573 : 0 : constant * evaluate::arccot_d (constant * args) {
1574 : 0 : _ARD0 (d1);
1575 [ # # ]: 0 : _DEFD ();
1576 : 0 : _RETD (M_PI_2 - std::atan (d1));
1577 : : }
1578 : :
1579 : 0 : constant * evaluate::arccot_c (constant * args) {
1580 : 0 : _ARC0 (c1);
1581 [ # # ]: 0 : _DEFC ();
1582 [ # # ]: 0 : _RETC (qucs::acot (*c1));
1583 : : }
1584 : :
1585 : 0 : constant * evaluate::arccot_v (constant * args) {
1586 : 0 : _ARV0 (v1);
1587 [ # # ]: 0 : _DEFV ();
1588 [ # # ][ # # ]: 0 : _RETV (acot (*v1));
1589 : : }
1590 : :
1591 : : // ***************** secans *********************
1592 : 0 : constant * evaluate::sec_d (constant * args) {
1593 : 0 : _ARD0 (d1);
1594 [ # # ]: 0 : _DEFD ();
1595 : 0 : _RETD (1.0 / std::cos (d1));
1596 : : }
1597 : :
1598 : 0 : constant * evaluate::sec_c (constant * args) {
1599 : 0 : _ARC0 (c1);
1600 [ # # ]: 0 : _DEFC ();
1601 [ # # ][ # # ]: 0 : _RETC (1.0 / std::cos (*c1));
1602 : : }
1603 : :
1604 : 0 : constant * evaluate::sec_v (constant * args) {
1605 : 0 : _ARV0 (v1);
1606 [ # # ]: 0 : _DEFV ();
1607 [ # # ][ # # ]: 0 : _RETV (1.0 / qucs::cos (*v1));
[ # # ][ # # ]
1608 : : }
1609 : :
1610 : : // *************** arcus secans *******************
1611 : 0 : constant * evaluate::arcsec_d (constant * args) {
1612 : 0 : _ARD0 (d1);
1613 [ # # ]: 0 : _DEFD ();
1614 : 0 : _RETD (std::acos (1.0 / d1));
1615 : : }
1616 : :
1617 : 0 : constant * evaluate::arcsec_c (constant * args) {
1618 : 0 : _ARC0 (c1);
1619 [ # # ]: 0 : _DEFC ();
1620 [ # # ][ # # ]: 0 : _RETC (acos (1.0 / *c1));
[ # # ]
1621 : : }
1622 : :
1623 : 0 : constant * evaluate::arcsec_v (constant * args) {
1624 : 0 : _ARV0 (v1);
1625 [ # # ]: 0 : _DEFV ();
1626 [ # # ][ # # ]: 0 : _RETV (acos (1.0 / *v1));
[ # # ][ # # ]
1627 : : }
1628 : :
1629 : : // ***************** cosecans *********************
1630 : 0 : constant * evaluate::cosec_d (constant * args) {
1631 : 0 : _ARD0 (d1);
1632 [ # # ]: 0 : _DEFD ();
1633 : 0 : _RETD (1.0 / sin (d1));
1634 : : }
1635 : :
1636 : 0 : constant * evaluate::cosec_c (constant * args) {
1637 : 0 : _ARC0 (c1);
1638 [ # # ]: 0 : _DEFC ();
1639 [ # # ][ # # ]: 0 : _RETC (1.0 / sin (*c1));
[ # # ]
1640 : : }
1641 : :
1642 : 0 : constant * evaluate::cosec_v (constant * args) {
1643 : 0 : _ARV0 (v1);
1644 [ # # ]: 0 : _DEFV ();
1645 [ # # ][ # # ]: 0 : _RETV (1.0 / sin (*v1));
[ # # ][ # # ]
1646 : : }
1647 : :
1648 : : // ************* arcus cosecans *******************
1649 : 0 : constant * evaluate::arccosec_d (constant * args) {
1650 : 0 : _ARD0 (d1);
1651 [ # # ]: 0 : _DEFD ();
1652 : 0 : _RETD (std::asin (1.0 / d1));
1653 : : }
1654 : :
1655 : 0 : constant * evaluate::arccosec_c (constant * args) {
1656 : 0 : _ARC0 (c1);
1657 [ # # ]: 0 : _DEFC ();
1658 [ # # ][ # # ]: 0 : _RETC (asin (1.0 / *c1));
[ # # ]
1659 : : }
1660 : :
1661 : 0 : constant * evaluate::arccosec_v (constant * args) {
1662 : 0 : _ARV0 (v1);
1663 [ # # ]: 0 : _DEFV ();
1664 [ # # ][ # # ]: 0 : _RETV (asin (1.0 / *v1));
[ # # ][ # # ]
1665 : : }
1666 : :
1667 : : // ********** area sine hyperbolicus **************
1668 : 0 : constant * evaluate::arsinh_d (constant * args) {
1669 : 0 : _ARD0 (d1);
1670 [ # # ]: 0 : _DEFD ();
1671 : 0 : _RETD (log (d1 + sqrt (d1 * d1 + 1)));
1672 : : }
1673 : :
1674 : 0 : constant * evaluate::arsinh_c (constant * args) {
1675 : 0 : _ARC0 (c1);
1676 [ # # ]: 0 : _DEFC ();
1677 [ # # ]: 0 : _RETC (asinh (*c1));
1678 : : }
1679 : :
1680 : 0 : constant * evaluate::arsinh_v (constant * args) {
1681 : 0 : _ARV0 (v1);
1682 [ # # ]: 0 : _DEFV ();
1683 [ # # ][ # # ]: 0 : _RETV (asinh (*v1));
1684 : : }
1685 : :
1686 : : // ********** area cosecans hyperbolicus **************
1687 : 0 : constant * evaluate::arcosech_d (constant * args) {
1688 : 0 : _ARD0 (d1);
1689 [ # # ]: 0 : _DEFD ();
1690 : 0 : d1 = 1 / d1;
1691 : 0 : _RETD (log (d1 + sqrt (d1 * d1 + 1)));
1692 : : }
1693 : :
1694 : 0 : constant * evaluate::arcosech_c (constant * args) {
1695 : 0 : _ARC0 (c1);
1696 [ # # ]: 0 : _DEFC ();
1697 [ # # ][ # # ]: 0 : _RETC (asinh (1.0 / *c1));
[ # # ]
1698 : : }
1699 : :
1700 : 0 : constant * evaluate::arcosech_v (constant * args) {
1701 : 0 : _ARV0 (v1);
1702 [ # # ]: 0 : _DEFV ();
1703 [ # # ][ # # ]: 0 : _RETV (asinh (1 / *v1));
[ # # ][ # # ]
1704 : : }
1705 : :
1706 : : // ********* area cosine hyperbolicus ************
1707 : 0 : constant * evaluate::arcosh_d (constant * args) {
1708 : 0 : _ARD0 (d1);
1709 [ # # ]: 0 : _DEFC ();
1710 [ # # ][ # # ]: 0 : _RETC (acosh (nr_complex_t (d1)));
1711 : : }
1712 : :
1713 : 0 : constant * evaluate::arcosh_c (constant * args) {
1714 : 0 : _ARC0 (c1);
1715 [ # # ]: 0 : _DEFC ();
1716 [ # # ]: 0 : _RETC (acosh (*c1));
1717 : : }
1718 : :
1719 : 0 : constant * evaluate::arcosh_v (constant * args) {
1720 : 0 : _ARV0 (v1);
1721 [ # # ]: 0 : _DEFV ();
1722 [ # # ][ # # ]: 0 : _RETV (acosh (*v1));
1723 : : }
1724 : :
1725 : : // ********* area secans hyperbolicus ***********
1726 : 0 : constant * evaluate::arsech_d (constant * args) {
1727 : 0 : _ARD0 (d1);
1728 [ # # ]: 0 : _DEFC ();
1729 [ # # ][ # # ]: 0 : _RETC (asech (nr_complex_t (d1)));
1730 : : }
1731 : :
1732 : 0 : constant * evaluate::arsech_c (constant * args) {
1733 : 0 : _ARC0 (c1);
1734 [ # # ]: 0 : _DEFC ();
1735 [ # # ]: 0 : _RETC (asech (*c1));
1736 : : }
1737 : :
1738 : 0 : constant * evaluate::arsech_v (constant * args) {
1739 : 0 : _ARV0 (v1);
1740 [ # # ]: 0 : _DEFV ();
1741 [ # # ][ # # ]: 0 : _RETV (asech (*v1));
1742 : : }
1743 : :
1744 : : // ******* area tangent hyperbolicus **********
1745 : 0 : constant * evaluate::artanh_d (constant * args) {
1746 : 0 : _ARD0 (d1);
1747 [ # # ]: 0 : _DEFD ();
1748 : 0 : _RETD (0.5 * log ((1.0 + d1) / (1.0 - d1)));
1749 : : }
1750 : :
1751 : 0 : constant * evaluate::artanh_c (constant * args) {
1752 : 0 : _ARC0 (c1);
1753 [ # # ]: 0 : _DEFC ();
1754 [ # # ]: 0 : _RETC (atanh (*c1));
1755 : : }
1756 : :
1757 : 0 : constant * evaluate::artanh_v (constant * args) {
1758 : 0 : _ARV0 (v1);
1759 [ # # ]: 0 : _DEFV ();
1760 [ # # ][ # # ]: 0 : _RETV (atanh (*v1));
1761 : : }
1762 : :
1763 : : // ******* area cotangent hyperbolicus **********
1764 : 0 : constant * evaluate::arcoth_d (constant * args) {
1765 : 0 : _ARD0 (d1);
1766 [ # # ]: 0 : _DEFD ();
1767 : 0 : _RETD (0.5 * std::log ((d1 + 1.0) / (d1 - 1.0)));
1768 : : }
1769 : :
1770 : 0 : constant * evaluate::arcoth_c (constant * args) {
1771 : 0 : _ARC0 (c1);
1772 [ # # ]: 0 : _DEFC ();
1773 [ # # ]: 0 : _RETC (qucs::acoth (*c1));
1774 : : }
1775 : :
1776 : 0 : constant * evaluate::arcoth_v (constant * args) {
1777 : 0 : _ARV0 (v1);
1778 [ # # ]: 0 : _DEFV ();
1779 [ # # ][ # # ]: 0 : _RETV (qucs::acoth (*v1));
1780 : : }
1781 : :
1782 : : // This is the rtoz, ztor, ytor, rtoy helper macro.
1783 : : #define MAKE_FUNC_DEFINITION_2(cfunc) \
1784 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d) (constant * args) { \
1785 : : _ARD0 (d); \
1786 : : _DEFD (); \
1787 : : _RETD (real (cfunc (nr_complex_t (d, 0)))); \
1788 : : } \
1789 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d_d) (constant * args) { \
1790 : : _ARD0 (d); \
1791 : : _ARD1 (z); \
1792 : : _DEFD (); \
1793 : : _RETD (real (cfunc (nr_complex_t (d, 0), z))); \
1794 : : } \
1795 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_d_c) (constant * args) { \
1796 : : _ARD0 (d); \
1797 : : _ARC1 (z); \
1798 : : _DEFC (); \
1799 : : _RETC (cfunc (nr_complex_t (d, 0), *z)); \
1800 : : } \
1801 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c) (constant * args) { \
1802 : : _ARC0 (c); \
1803 : : _DEFC (); \
1804 : : _RETC (cfunc (*c)); \
1805 : : } \
1806 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c_d) (constant * args) { \
1807 : : _ARC0 (c); \
1808 : : _ARD1 (z); \
1809 : : _DEFC (); \
1810 : : _RETC (cfunc (*c, z)); \
1811 : : } \
1812 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_c_c) (constant * args) { \
1813 : : _ARC0 (c); \
1814 : : _ARC1 (z); \
1815 : : _DEFC (); \
1816 : : _RETC (cfunc (*c, *z)); \
1817 : : } \
1818 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
1819 : : _ARV0 (v); \
1820 : : _DEFV (); \
1821 : : _RETV (cfunc (*v)); \
1822 : : } \
1823 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v_d) (constant * args) { \
1824 : : _ARV0 (v); \
1825 : : _ARD1 (z); \
1826 : : _DEFV (); \
1827 : : _RETV (cfunc (*v, z)); \
1828 : : } \
1829 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v_c) (constant * args) { \
1830 : : _ARV0 (v); \
1831 : : _ARC1 (z); \
1832 : : _DEFV (); \
1833 : : _RETV (cfunc (*v, *z)); \
1834 : : } \
1835 : :
1836 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_2 (ztor);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1837 [ # # ][ # # ]: 3 : MAKE_FUNC_DEFINITION_2 (rtoz);
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1838 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_2 (ytor);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1839 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_2 (rtoy);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1840 : :
1841 : : // ** convert reflexion coefficient to standing wave ratio **
1842 : 0 : constant * evaluate::rtoswr_d (constant * args) {
1843 : 0 : _ARD0 (d1);
1844 [ # # ]: 0 : _DEFD ();
1845 : 0 : _RETD ((1 + fabs (d1)) / (1 - fabs (d1)));
1846 : : }
1847 : :
1848 : 0 : constant * evaluate::rtoswr_c (constant * args) {
1849 : 0 : _ARC0 (c1);
1850 [ # # ]: 0 : _DEFD ();
1851 : 0 : _RETD ((1 + abs (*c1)) / (1 - abs (*c1)));
1852 : : }
1853 : :
1854 : 0 : constant * evaluate::rtoswr_v (constant * args) {
1855 : 0 : _ARV0 (v1);
1856 [ # # ]: 0 : _DEFV ();
1857 [ # # ]: 0 : res->v = new qucs::vector (v1->getSize ());
1858 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++)
1859 [ # # ][ # # ]: 0 : res->v->set ((1 + abs (v1->get (i))) / (1 - abs (v1->get (i))), i);
1860 : 0 : return res;
1861 : : }
1862 : :
1863 : : // ** differentiate vector with respect to another vector **
1864 : 2 : constant * evaluate::diff_v_2 (constant * args) {
1865 : 2 : _ARV0 (v1);
1866 : 2 : _ARV1 (v2);
1867 [ + - ]: 2 : _DEFV ();
1868 [ + - ][ + - ]: 2 : _RETV (diff (*v1, *v2));
[ + - ][ + - ]
1869 : : }
1870 : :
1871 : 0 : constant * evaluate::diff_v_3 (constant * args) {
1872 : 0 : _ARV0 (v1);
1873 : 0 : _ARV1 (v2);
1874 : 0 : _ARI2 (i3);
1875 [ # # ]: 0 : _DEFV ();
1876 [ # # ][ # # ]: 0 : _RETV (diff (*v1, *v2, i3));
[ # # ][ # # ]
1877 : : }
1878 : :
1879 : : // ***************** maximum *******************
1880 : 0 : constant * evaluate::max_d (constant * args) {
1881 : 0 : _ARD0 (d1);
1882 [ # # ]: 0 : _DEFD ();
1883 : 0 : _RETD (d1);
1884 : : }
1885 : :
1886 : 0 : constant * evaluate::max_c (constant * args) {
1887 : 0 : _ARC0 (c1);
1888 [ # # ]: 0 : _DEFD ();
1889 [ # # ]: 0 : if (fabs (arg (*c1)) < M_PI_2)
1890 : 0 : res->d = abs (*c1);
1891 : : else
1892 : 0 : res->d = -abs (*c1);
1893 : 0 : return res;
1894 : : }
1895 : :
1896 : 0 : constant * evaluate::max_v (constant * args) {
1897 : 0 : _ARV0 (v1);
1898 [ # # ]: 0 : _DEFD ();
1899 : 0 : _RETD (v1->maximum ());
1900 : : }
1901 : :
1902 : 0 : constant * evaluate::max_d_d (constant * args) {
1903 : 0 : _ARD0 (d1);
1904 : 0 : _ARD1 (d2);
1905 [ # # ]: 0 : _DEFD ();
1906 [ # # ]: 0 : _RETD (MAX (d1, d2));
1907 : : }
1908 : :
1909 : 0 : constant * evaluate::max_d_c (constant * args) {
1910 [ # # ]: 0 : _ARD0 (d1);
1911 [ # # ]: 0 : _ARC1 (c2);
1912 [ # # ][ # # ]: 0 : _DEFC ();
1913 : 0 : nr_double_t a = d1;
1914 [ # # ]: 0 : nr_double_t b = fabs (arg (*c2)) < M_PI_2 ? abs (*c2) : -abs (*c2);
1915 [ # # ]: 0 : nr_complex_t r = a > b ? d1 : *c2;
1916 [ # # ]: 0 : _RETC (r);
1917 : : }
1918 : :
1919 : 0 : constant * evaluate::max_c_c (constant * args) {
1920 [ # # ]: 0 : _ARC0 (c1);
1921 [ # # ]: 0 : _ARC1 (c2);
1922 [ # # ][ # # ]: 0 : _DEFC ();
1923 [ # # ]: 0 : nr_double_t a = fabs (arg (*c1)) < M_PI_2 ? abs (*c1) : -abs (*c1);
1924 [ # # ]: 0 : nr_double_t b = fabs (arg (*c2)) < M_PI_2 ? abs (*c2) : -abs (*c2);
1925 [ # # ]: 0 : nr_complex_t r = a > b ? *c1 : *c2;
1926 [ # # ]: 0 : _RETC (r);
1927 : : }
1928 : :
1929 : 0 : constant * evaluate::max_c_d (constant * args) {
1930 [ # # ]: 0 : _ARC0 (c1);
1931 [ # # ]: 0 : _ARD1 (d2);
1932 [ # # ][ # # ]: 0 : _DEFC ();
1933 [ # # ]: 0 : nr_double_t a = fabs (arg (*c1)) < M_PI_2 ? abs (*c1) : -abs (*c1);
1934 : 0 : nr_double_t b = d2;
1935 [ # # ]: 0 : nr_complex_t r = a > b ? *c1 : d2;
1936 [ # # ]: 0 : _RETC (r);
1937 : : }
1938 : :
1939 : : // ***************** minimum *******************
1940 : 0 : constant * evaluate::min_d (constant * args) {
1941 : 0 : _ARD0 (d1);
1942 [ # # ]: 0 : _DEFD ();
1943 : 0 : _RETD (d1);
1944 : : }
1945 : :
1946 : 0 : constant * evaluate::min_c (constant * args) {
1947 : 0 : _ARC0 (c1);
1948 [ # # ]: 0 : _DEFD ();
1949 [ # # ]: 0 : if (fabs (arg (*c1)) < M_PI_2)
1950 : 0 : res->d = abs (*c1);
1951 : : else
1952 : 0 : res->d = -abs (*c1);
1953 : 0 : return res;
1954 : : }
1955 : :
1956 : 0 : constant * evaluate::min_v (constant * args) {
1957 : 0 : _ARV0 (v1);
1958 [ # # ]: 0 : _DEFD ();
1959 : 0 : _RETD (v1->minimum ());
1960 : : }
1961 : :
1962 : 0 : constant * evaluate::min_d_d (constant * args) {
1963 : 0 : _ARD0 (d1);
1964 : 0 : _ARD1 (d2);
1965 [ # # ]: 0 : _DEFD ();
1966 [ # # ]: 0 : _RETD (MIN (d1, d2));
1967 : : }
1968 : :
1969 : 0 : constant * evaluate::min_d_c (constant * args) {
1970 [ # # ]: 0 : _ARD0 (d1);
1971 [ # # ]: 0 : _ARC1 (c2);
1972 [ # # ][ # # ]: 0 : _DEFC ();
1973 : 0 : nr_double_t a = d1;
1974 [ # # ]: 0 : nr_double_t b = fabs (arg (*c2)) < M_PI_2 ? abs (*c2) : -abs (*c2);
1975 [ # # ]: 0 : nr_complex_t r = a < b ? d1 : *c2;
1976 [ # # ]: 0 : _RETC (r);
1977 : : }
1978 : :
1979 : 0 : constant * evaluate::min_c_c (constant * args) {
1980 [ # # ]: 0 : _ARC0 (c1);
1981 [ # # ]: 0 : _ARC1 (c2);
1982 [ # # ][ # # ]: 0 : _DEFC ();
1983 [ # # ]: 0 : nr_double_t a = fabs (arg (*c1)) < M_PI_2 ? abs (*c1) : -abs (*c1);
1984 [ # # ]: 0 : nr_double_t b = fabs (arg (*c2)) < M_PI_2 ? abs (*c2) : -abs (*c2);
1985 [ # # ]: 0 : nr_complex_t r = a < b ? *c1 : *c2;
1986 [ # # ]: 0 : _RETC (r);
1987 : : }
1988 : :
1989 : 0 : constant * evaluate::min_c_d (constant * args) {
1990 [ # # ]: 0 : _ARC0 (c1);
1991 [ # # ]: 0 : _ARD1 (d2);
1992 [ # # ][ # # ]: 0 : _DEFC ();
1993 [ # # ]: 0 : nr_double_t a = fabs (arg (*c1)) < M_PI_2 ? abs (*c1) : -abs (*c1);
1994 : 0 : nr_double_t b = d2;
1995 [ # # ]: 0 : nr_complex_t r = a < b ? *c1 : d2;
1996 [ # # ]: 0 : _RETC (r);
1997 : : }
1998 : :
1999 : : // ******************** sum **********************
2000 : 0 : constant * evaluate::sum_d (constant * args) {
2001 : 0 : _ARD0 (d1);
2002 [ # # ]: 0 : _DEFD ();
2003 : 0 : _RETD (d1);
2004 : : }
2005 : :
2006 : 0 : constant * evaluate::sum_c (constant * args) {
2007 : 0 : _ARC0 (c1);
2008 [ # # ]: 0 : _DEFC ();
2009 : 0 : _RETC (*c1);
2010 : : }
2011 : :
2012 : 0 : constant * evaluate::sum_v (constant * args) {
2013 : 0 : _ARV0 (v1);
2014 [ # # ]: 0 : _DEFC ();
2015 [ # # ][ # # ]: 0 : _RETC (sum (*v1));
2016 : : }
2017 : :
2018 : : // ****************** product ********************
2019 : 0 : constant * evaluate::prod_d (constant * args) {
2020 : 0 : _ARD0 (d1);
2021 [ # # ]: 0 : _DEFD ();
2022 : 0 : _RETD (d1);
2023 : : }
2024 : :
2025 : 0 : constant * evaluate::prod_c (constant * args) {
2026 : 0 : _ARC0 (c1);
2027 [ # # ]: 0 : _DEFC ();
2028 : 0 : _RETC (*c1);
2029 : : }
2030 : :
2031 : 0 : constant * evaluate::prod_v (constant * args) {
2032 : 0 : _ARV0 (v1);
2033 [ # # ]: 0 : _DEFC ();
2034 [ # # ][ # # ]: 0 : _RETC (prod (*v1));
2035 : : }
2036 : :
2037 : : // ******************* average *********************
2038 : 0 : constant * evaluate::avg_d (constant * args) {
2039 : 0 : _ARD0 (d1);
2040 [ # # ]: 0 : _DEFD ();
2041 : 0 : _RETD (d1);
2042 : : }
2043 : :
2044 : 0 : constant * evaluate::avg_c (constant * args) {
2045 : 0 : _ARC0 (c1);
2046 [ # # ]: 0 : _DEFC ();
2047 : 0 : _RETC (*c1);
2048 : : }
2049 : :
2050 : 0 : constant * evaluate::avg_v (constant * args) {
2051 : 0 : _ARV0 (v1);
2052 [ # # ]: 0 : _DEFC ();
2053 [ # # ][ # # ]: 0 : _RETC (avg (*v1));
2054 : : }
2055 : :
2056 : : // ******************* lengths *********************
2057 : 0 : constant * evaluate::length_d (constant *) {
2058 [ # # ]: 0 : _DEFD ();
2059 : 0 : _RETD (1);
2060 : : }
2061 : :
2062 : 0 : constant * evaluate::length_c (constant *) {
2063 [ # # ]: 0 : _DEFD ();
2064 : 0 : _RETD (1);
2065 : : }
2066 : :
2067 : 0 : constant * evaluate::length_v (constant * args) {
2068 : 0 : _ARV0 (v1);
2069 [ # # ]: 0 : _DEFD ();
2070 : 0 : _RETD (v1->getSize ());
2071 : : }
2072 : :
2073 : 0 : constant * evaluate::length_m (constant *) {
2074 [ # # ]: 0 : _DEFD ();
2075 : 0 : _RETD (1);
2076 : : }
2077 : :
2078 : 0 : constant * evaluate::length_mv (constant * args) {
2079 : 0 : _ARV0 (mv);
2080 [ # # ]: 0 : _DEFD ();
2081 : 0 : _RETD (mv->getSize ());
2082 : : }
2083 : :
2084 : : // ***************** array indices *****************
2085 : 26 : constant * evaluate::index_mv_2 (constant * args) {
2086 : 26 : _ARMV0 (mv);
2087 : 26 : _ARI1 (r);
2088 : 26 : _ARI2 (c);
2089 [ + - ]: 26 : _DEFV ();
2090 [ + - ][ + - ]: 26 : if (r < 1 || r > mv->getRows () || c < 1 || c > mv->getCols ()) {
[ + - ][ - + ]
[ - + ]
2091 : : char txt[256];
2092 : : sprintf (txt, "matvec indices [%d,%d] out of bounds [1-%d,1-%d]",
2093 : 0 : r, c, mv->getRows (), mv->getCols ());
2094 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2095 [ # # ][ # # ]: 0 : res->v = new qucs::vector (mv->getSize ());
2096 : : } else {
2097 [ + - ]: 26 : res->v = new qucs::vector (mv->get (r - 1, c - 1));
2098 : : }
2099 : 26 : return res;
2100 : : }
2101 : :
2102 : 0 : constant * evaluate::index_mv_1 (constant * args) {
2103 : 0 : _ARMV0 (mv);
2104 : 0 : _ARI1 (i);
2105 [ # # ]: 0 : _DEFM ();
2106 [ # # ][ # # ]: 0 : if (i < 1 || i > mv->getSize ()) {
[ # # ]
2107 : : char txt[256];
2108 : 0 : sprintf (txt, "matvec index [%d] out of bounds [1-%d]", i, mv->getSize ());
2109 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2110 [ # # ][ # # ]: 0 : res->m = new matrix (mv->getRows (), mv->getCols ());
2111 : : } else {
2112 [ # # ]: 0 : res->m = new matrix (mv->get (i - 1));
2113 : : }
2114 : 0 : return res;
2115 : : }
2116 : :
2117 : : /* Little helper macros for the following functionality. */
2118 : : #define EQUATION_HAS_DEPS(v,n) \
2119 : : ((v)->getDataDependencies() != NULL && \
2120 : : (v)->getDataDependencies()->length() >= n)
2121 : : #define EQUATION_DEPS(v) \
2122 : : ((v)->getDataDependencies() ? (v)->getDataDependencies()->length() : 1)
2123 : :
2124 : : /* This following function is used to get a subset of data entries
2125 : : from a data vector with certain data dependencies. */
2126 : 0 : void evaluate::extract_vector (constant * args, int idx, int &skip, int &size,
2127 : : constant * res) {
2128 : 0 : _ARV0 (v);
2129 : 0 : int i = INT (_ARES (idx));
2130 : 0 : int type = _ARG(idx)->getType ();
2131 : : qucs::vector * vres;
2132 : 0 : strlist * deps = _ARES(0)->getDataDependencies ();
2133 [ # # ]: 0 : int didx = (deps ? deps->length () : 0) - idx;
2134 : 0 : int dsize = SOLVEE(0)->getDependencySize (deps, idx);
2135 : :
2136 : : // all of the data vector
2137 [ # # ]: 0 : if (type == TAG_RANGE) {
2138 [ # # ]: 0 : if (dsize > 1) {
2139 : : // dependent vectors: only ':' possible
2140 [ # # ]: 0 : vres = new qucs::vector (*(res->v));
2141 [ # # ]: 0 : skip *= deps ? SOLVEE(0)->getDataSize (deps->get (didx - 1)) : 1;
2142 [ # # ]: 0 : size *= deps ? SOLVEE(0)->getDataSize (deps->get (didx)) : 1;
2143 : : }
2144 : : else {
2145 : : // independent vectors
2146 : 0 : range * r = RNG (_ARES (idx));
2147 : : int i, n, k;
2148 : 0 : int len = res->v->getSize ();
2149 : 0 : i = (int) r->lo ();
2150 [ # # ][ # # ]: 0 : if (i < 0 || i >= len) {
2151 : : char txt[256];
2152 : 0 : sprintf (txt, "vector index %d out of bounds [%d,%d]", i, 0, len - 1);
2153 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2154 : : }
2155 : 0 : i = (int) r->hi ();
2156 [ # # ][ # # ]: 0 : if (i < 0 || i >= len) {
2157 : : char txt[256];
2158 : 0 : sprintf (txt, "vector index %d out of bounds [%d,%d]", i, 0, len - 1);
2159 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2160 : : }
2161 : 0 : size = 0;
2162 [ # # ][ # # ]: 0 : for (n = 0; n < len; n++) if (r->inside (n)) size++;
2163 [ # # ]: 0 : vres = new qucs::vector (size);
2164 [ # # ]: 0 : for (k = 0, n = 0; n < len; n++) {
2165 [ # # ]: 0 : if (r->inside (n))
2166 : 0 : vres->set (res->v->get (n), k++);
2167 : : }
2168 : : }
2169 : : }
2170 : : // a subset
2171 : : else {
2172 [ # # ]: 0 : vres = new qucs::vector (dsize * size);
2173 [ # # ]: 0 : int len = deps ? SOLVEE(0)->getDataSize (deps->get (didx)) : v->getSize ();
2174 [ # # ][ # # ]: 0 : if (i < 0 || i >= len) {
2175 : : char txt[256];
2176 : : sprintf (txt, "vector index %d (%d) out of bounds [%d,%d]",
2177 : 0 : idx, i, 0, len - 1);
2178 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2179 : : } else {
2180 : : int k, n;
2181 [ # # ]: 0 : for (n = k = 0; k < dsize * size; n += skip, k++) {
2182 : 0 : vres->set (res->v->get (dsize * i + n), k);
2183 : : }
2184 : : }
2185 [ # # ][ # # ]: 0 : if (deps && didx >= 0) {
2186 : 0 : res->addDropDependencies (deps->get (didx));
2187 : : }
2188 : : }
2189 [ # # ][ # # ]: 0 : if (res->v != NULL) delete res->v;
2190 : 0 : res->v = vres;
2191 : 0 : }
2192 : :
2193 : 0 : constant * evaluate::index_v_1 (constant * args) {
2194 [ # # ]: 0 : _ARV0 (v);
2195 [ # # ][ # # ]: 0 : _DEFV ();
2196 : 0 : int skip = 1, size = 1;
2197 [ # # ][ # # ]: 0 : res->v = new qucs::vector (*v);
2198 [ # # ]: 0 : extract_vector (args, 1, skip, size, res);
2199 : 0 : return res;
2200 : : }
2201 : :
2202 : 0 : constant * evaluate::index_v_2 (constant * args) {
2203 [ # # ]: 0 : _ARV0 (v);
2204 [ # # ][ # # ]: 0 : _DEFV ();
2205 : 0 : int skip = 1, size = 1;
2206 [ # # ][ # # ]: 0 : res->v = new qucs::vector (*v);
2207 [ # # ][ # # ]: 0 : if (!EQUATION_HAS_DEPS (_ARES(0), 2)) {
[ # # ][ # # ]
[ # # ][ # # ]
2208 : : char txt[256];
2209 : : sprintf (txt, "invalid number of vector indices (%d > %d)", 2,
2210 [ # # ][ # # ]: 0 : EQUATION_DEPS (_ARES(0)));
[ # # ][ # # ]
2211 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2212 : 0 : return res;
2213 : : }
2214 [ # # ]: 0 : extract_vector (args, 1, skip, size, res);
2215 [ # # ]: 0 : extract_vector (args, 2, skip, size, res);
2216 : 0 : return res;
2217 : : }
2218 : :
2219 : 0 : constant * evaluate::index_m_2 (constant * args) {
2220 : 0 : _ARM0 (m);
2221 : 0 : _ARI1 (r);
2222 : 0 : _ARI2 (c);
2223 [ # # ]: 0 : _DEFC ();
2224 [ # # ][ # # ]: 0 : if (r < 1 || r > m->getRows () || c < 1 || c > m->getCols ()) {
[ # # ][ # # ]
[ # # ]
2225 : : char txt[256];
2226 : : sprintf (txt, "matrix indices [%d,%d] out of bounds [1-%d,1-%d]",
2227 : 0 : r, c, m->getRows (), m->getCols ());
2228 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION (txt);
[ # # ][ # # ]
2229 [ # # ]: 0 : res->c = new nr_complex_t ();
2230 : : } else {
2231 [ # # ]: 0 : res->c = new nr_complex_t (m->get (r - 1, c - 1));
2232 : : }
2233 : 0 : return res;
2234 : : }
2235 : :
2236 : 0 : constant * evaluate::index_s_1 (constant * args) {
2237 : 0 : char * s = STR (_ARES(0));
2238 : 0 : _ARI1 (i);
2239 [ # # ]: 0 : constant * res = new constant (TAG_CHAR);
2240 [ # # ][ # # ]: 0 : res->chr = (i >= 0 && i < (int) strlen (s)) ? s[i] : ' ';
2241 : 0 : return res;
2242 : : }
2243 : :
2244 : : // Interpolator helper macro without number of points given.
2245 : : #define INTERPOL_HELPER() \
2246 : : constant * arg = new constant (TAG_DOUBLE); \
2247 : : arg->d = 64; \
2248 : : arg->solvee = args->getResult(0)->solvee; \
2249 : : arg->evaluate (); \
2250 : : args->append (arg);
2251 : :
2252 : : // ***************** interpolation *****************
2253 : 0 : constant * evaluate::interpolate_v_v (constant * args) {
2254 [ # # ]: 0 : INTERPOL_HELPER();
2255 : 0 : return interpolate_v_v_d (args);
2256 : : }
2257 : :
2258 : 0 : constant * evaluate::interpolate_v_v_d (constant * args) {
2259 [ # # ]: 0 : _ARV0 (v1);
2260 [ # # ]: 0 : _ARV1 (v2);
2261 [ # # ]: 0 : _ARI2 (n);
2262 [ # # ][ # # ]: 0 : _DEFV ();
2263 [ # # ][ # # ]: 0 : if (v1->getSize () < 3) {
2264 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("interpolate: number of datapoints must be greater "
[ # # ][ # # ]
2265 : : "than 2");
2266 [ # # ][ # # ]: 0 : res->v = new qucs::vector ();
2267 : 0 : return res;
2268 : : }
2269 [ # # ][ # # ]: 0 : nr_double_t last = real (v2->get (v2->getSize () - 1));
2270 [ # # ]: 0 : nr_double_t first = real (v2->get (0));
2271 [ # # ][ # # ]: 0 : constant * arg = new constant (TAG_VECTOR);
2272 [ # # ][ # # ]: 0 : arg->v = new qucs::vector (qucs::linspace (first, last, n));
2273 [ # # ]: 0 : arg->solvee = args->getResult(0)->solvee;
2274 [ # # ]: 0 : arg->evaluate ();
2275 [ # # ][ # # ]: 0 : qucs::vector * val = new qucs::vector (n);
2276 [ # # ]: 0 : spline spl (SPLINE_BC_NATURAL);
2277 [ # # ][ # # ]: 0 : spl.vectors (*v1, *v2);
[ # # ][ # # ]
[ # # ]
2278 [ # # ]: 0 : spl.construct ();
2279 [ # # ][ # # ]: 0 : for (int k = 0; k < arg->v->getSize (); k++) {
2280 [ # # ][ # # ]: 0 : val->set (spl.evaluate (real (arg->v->get (k))).f0, k);
[ # # ]
2281 : : }
2282 : 0 : res->v = val;
2283 [ # # ][ # # ]: 0 : node * gen = SOLVEE(0)->addGeneratedEquation (arg->v, "Interpolate");
2284 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2285 : 0 : res->dropdeps = 1;
2286 [ # # ][ # # ]: 0 : delete arg;
2287 [ # # ]: 0 : return res;
2288 : : }
2289 : :
2290 : : // ***************** fourier transformations *****************
2291 : : #define FOURIER_HELPER_1(efunc,cfunc,isign,dep) \
2292 : : constant * evaluate:: QUCS_CONCAT2 (efunc,_v_v) (constant * args) { \
2293 : : _ARV0 (v); \
2294 : : _ARV1 (t); \
2295 : : _DEFV (); \
2296 : : qucs::vector * val = new qucs::vector (QUCS_CONCAT2 (cfunc,_1d) (*v)); \
2297 : : int k = val->getSize (); \
2298 : : *val = isign > 0 ? *val / k : *val * k; \
2299 : : res->v = val; \
2300 : : int n = t->getSize (); \
2301 : : if (k != n) { \
2302 : : THROW_MATH_EXCEPTION ("nonconformant vector lengths"); \
2303 : : return res; } \
2304 : : nr_double_t last = real (t->get (n - 1)); \
2305 : : nr_double_t first = real (t->get (0)); \
2306 : : nr_double_t delta = (last - first) / (n - 1); \
2307 : : constant * arg = new constant (TAG_VECTOR); \
2308 : : arg->v = new qucs::vector (qucs::linspace (0, 1.0 / delta, n)); \
2309 : : arg->solvee = args->getResult(0)->solvee; \
2310 : : arg->evaluate (); \
2311 : : node * gen = SOLVEE(0)->addGeneratedEquation (arg->v, dep); \
2312 : : res->addPrepDependencies (A(gen)->result); \
2313 : : res->dropdeps = 1; \
2314 : : args->append (arg); \
2315 : : return res; \
2316 : : }
2317 : :
2318 : : #define FOURIER_HELPER_2(cfunc) \
2319 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_v) (constant * args) { \
2320 : : _ARV0 (v); \
2321 : : _DEFV (); \
2322 : : qucs::vector * val = new qucs::vector (QUCS_CONCAT2 (cfunc,_1d) (*v)); \
2323 : : res->v = val; \
2324 : : res->dropdeps = 1; \
2325 : : return res; \
2326 : : }
2327 : :
2328 [ + - ][ + - ]: 3 : FOURIER_HELPER_1 (time2freq,dft,1,"Frequency");
[ + - ][ + - ]
[ + - ][ + - ]
[ - + ][ # # ]
[ + - ][ + - ]
2329 [ # # ][ # # ]: 0 : FOURIER_HELPER_1 (freq2time,idft,-1,"Time");
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2330 [ # # ][ # # ]: 0 : FOURIER_HELPER_2 (fft);
[ # # ]
2331 [ # # ][ # # ]: 0 : FOURIER_HELPER_2 (ifft);
[ # # ]
2332 [ # # ][ # # ]: 0 : FOURIER_HELPER_2 (dft);
[ # # ]
2333 [ # # ][ # # ]: 0 : FOURIER_HELPER_2 (idft);
[ # # ]
2334 : :
2335 : : // Shuffles values of FFT arounds.
2336 : 0 : constant * evaluate::fftshift_v (constant * args) {
2337 : 0 : _ARV0 (v);
2338 [ # # ]: 0 : _DEFV ();
2339 [ # # ][ # # ]: 0 : res->v = new qucs::vector (fftshift (*v));
2340 : 0 : return res;
2341 : : }
2342 : :
2343 : : // This is the stoz, ztos, ytos, stoy helper macro.
2344 : : #define MAKE_FUNC_DEFINITION_3(cfunc) \
2345 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_m) (constant * args) { \
2346 : : _ARM0 (m); \
2347 : : _DEFM (); \
2348 : : _RETM (cfunc (*m)); \
2349 : : } \
2350 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_m_d) (constant * args) { \
2351 : : _ARM0 (m); \
2352 : : _ARD1 (z); \
2353 : : _DEFM (); \
2354 : : _RETM (cfunc (*m, nr_complex_t (z, 0))); \
2355 : : } \
2356 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_m_c) (constant * args) { \
2357 : : _ARM0 (m); \
2358 : : _ARC1 (z); \
2359 : : _DEFM (); \
2360 : : _RETM (cfunc (*m, *z)); \
2361 : : } \
2362 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_m_v) (constant * args) { \
2363 : : _ARM0 (m); \
2364 : : _ARV1 (z); \
2365 : : _DEFM (); \
2366 : : _RETM (cfunc (*m, *z)); \
2367 : : } \
2368 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_mv) (constant * args) { \
2369 : : _ARMV0 (m); \
2370 : : _DEFMV (); \
2371 : : _RETMV (cfunc (*m)); \
2372 : : } \
2373 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_mv_d) (constant * args) { \
2374 : : _ARMV0 (m); \
2375 : : _ARD1 (z); \
2376 : : _DEFMV (); \
2377 : : _RETMV (cfunc (*m, nr_complex_t (z, 0))); \
2378 : : } \
2379 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_mv_c) (constant * args) { \
2380 : : _ARMV0 (m); \
2381 : : _ARC1 (z); \
2382 : : _DEFMV (); \
2383 : : _RETMV (cfunc (*m, *z)); \
2384 : : } \
2385 : : constant * evaluate:: QUCS_CONCAT2 (cfunc,_mv_v) (constant * args) { \
2386 : : _ARMV0 (m); \
2387 : : _ARV1 (z); \
2388 : : _DEFMV (); \
2389 : : _RETMV (cfunc (*m, *z)); \
2390 : : } \
2391 : :
2392 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_3 (stoy);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2393 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_3 (ytos);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2394 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_3 (stoz);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2395 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_3 (ztos);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2396 : :
2397 : : // ***************** matrix conversions *****************
2398 : 0 : constant * evaluate::ytoz_m (constant * args) {
2399 : 0 : _ARM0 (m);
2400 [ # # ]: 0 : _DEFM ();
2401 [ # # ][ # # ]: 0 : _RETM (ytoz (*m));
2402 : : }
2403 : :
2404 : 0 : constant * evaluate::ytoz_mv (constant * args) {
2405 : 0 : _ARMV0 (mv);
2406 [ # # ]: 0 : _DEFMV ();
2407 [ # # ][ # # ]: 0 : _RETMV (ytoz (*mv));
2408 : : }
2409 : :
2410 : 0 : constant * evaluate::ztoy_m (constant * args) {
2411 : 0 : _ARM0 (m);
2412 [ # # ]: 0 : _DEFM ();
2413 [ # # ][ # # ]: 0 : _RETM (ztoy (*m));
2414 : : }
2415 : :
2416 : 0 : constant * evaluate::ztoy_mv (constant * args) {
2417 : 0 : _ARMV0 (mv);
2418 [ # # ]: 0 : _DEFMV ();
2419 [ # # ][ # # ]: 0 : _RETMV (ztoy (*mv));
2420 : : }
2421 : :
2422 : : // These are stos() helpers.
2423 : : #define _CHKM(m) /* check square matrix */ \
2424 : : if (m->getCols () != m->getRows ()) { \
2425 : : THROW_MATH_EXCEPTION ("stos: not a square matrix"); \
2426 : : res->m = new matrix (m->getRows (), m->getCols ()); \
2427 : : return res; }
2428 : : #define _CHKMV(mv) /* check square matrix vector */ \
2429 : : if (mv->getCols () != mv->getRows ()) { \
2430 : : THROW_MATH_EXCEPTION ("stos: not a square matrix"); \
2431 : : res->mv = new matvec (mv->getSize (), mv->getRows (), mv->getCols ()); \
2432 : : return res; }
2433 : : #define _CHKMA(m,cond) \
2434 : : if (!(cond)) { \
2435 : : THROW_MATH_EXCEPTION ("stos: nonconformant arguments"); \
2436 : : res->m = new matrix (m->getRows (), m->getCols ()); \
2437 : : return res; }
2438 : : #define _CHKMVA(mv,cond) \
2439 : : if (!(cond)) { \
2440 : : THROW_MATH_EXCEPTION ("stos: nonconformant arguments"); \
2441 : : res->mv = new matvec (mv->getSize (), mv->getRows (), mv->getCols ()); \
2442 : : return res; }
2443 : :
2444 : : // Function -- MATRIX stos (MATRIX, DOUBLE)
2445 : 0 : constant * evaluate::stos_m_d (constant * args) {
2446 [ # # ]: 0 : _ARM0 (m); _ARD1 (zref); _DEFM ();
2447 [ # # ][ # # ]: 0 : _CHKM (m);
[ # # ]
2448 [ # # ][ # # ]: 0 : _RETM (stos (*m, zref));
2449 : : }
2450 : :
2451 : : // Function -- MATRIX stos (MATRIX, COMPLEX)
2452 : 0 : constant * evaluate::stos_m_c (constant * args) {
2453 [ # # ]: 0 : _ARM0 (m); _ARC1 (zref); _DEFM ();
2454 [ # # ][ # # ]: 0 : _CHKM (m);
[ # # ]
2455 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref));
2456 : : }
2457 : :
2458 : : // Function -- MATRIX stos (MATRIX, DOUBLE, DOUBLE)
2459 : 0 : constant * evaluate::stos_m_d_d (constant * args) {
2460 [ # # ]: 0 : _ARM0 (m); _ARD1 (zref); _ARD2 (z0); _DEFM ();
2461 [ # # ][ # # ]: 0 : _CHKM (m);
[ # # ]
2462 [ # # ][ # # ]: 0 : _RETM (stos (*m, zref, z0));
2463 : : }
2464 : :
2465 : : // Function -- MATRIX stos (MATRIX, DOUBLE, COMPLEX)
2466 : 0 : constant * evaluate::stos_m_d_c (constant * args) {
2467 [ # # ]: 0 : _ARM0 (m); _ARD1 (zref); _ARC2 (z0); _DEFM ();
2468 [ # # ][ # # ]: 0 : _CHKM (m);
[ # # ]
2469 [ # # ][ # # ]: 0 : _RETM (stos (*m, nr_complex_t (zref, 0), *z0));
2470 : : }
2471 : :
2472 : : // Function -- MATRIX stos (MATRIX, COMPLEX, DOUBLE)
2473 : 0 : constant * evaluate::stos_m_c_d (constant * args) {
2474 [ # # ]: 0 : _ARM0 (m); _ARC1 (zref); _ARD2 (z0); _DEFM ();
2475 [ # # ][ # # ]: 0 : _CHKM (m);
[ # # ]
2476 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref, nr_complex_t (z0, 0)));
2477 : : }
2478 : :
2479 : : // Function -- MATRIX stos (MATRIX, COMPLEX, COMPLEX)
2480 : 0 : constant * evaluate::stos_m_c_c (constant * args) {
2481 [ # # ]: 0 : _ARM0 (m); _ARC1 (zref); _ARC2 (z0); _DEFM ();
2482 [ # # ][ # # ]: 0 : _CHKM (m);
[ # # ]
2483 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref, *z0));
2484 : : }
2485 : :
2486 : : // Function -- MATRIX stos (MATRIX, VECTOR)
2487 : 0 : constant * evaluate::stos_m_v (constant * args) {
2488 [ # # ]: 0 : _ARM0 (m); _ARV1 (zref); _DEFM ();
2489 [ # # ][ # # ]: 0 : _CHKM (m); _CHKMA (m, m->getRows () == zref->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2490 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref));
[ # # ][ # # ]
2491 : : }
2492 : :
2493 : : // Function -- MATRIX stos (MATRIX, VECTOR, DOUBLE)
2494 : 0 : constant * evaluate::stos_m_v_d (constant * args) {
2495 [ # # ]: 0 : _ARM0 (m); _ARV1 (zref); _ARD2 (z0); _DEFM ();
2496 [ # # ][ # # ]: 0 : _CHKM (m); _CHKMA (m, m->getRows () == zref->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2497 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref, nr_complex_t (z0, 0)));
[ # # ][ # # ]
2498 : : }
2499 : :
2500 : : // Function -- MATRIX stos (MATRIX, VECTOR, COMPLEX)
2501 : 0 : constant * evaluate::stos_m_v_c (constant * args) {
2502 [ # # ]: 0 : _ARM0 (m); _ARV1 (zref); _ARC2 (z0); _DEFM ();
2503 [ # # ][ # # ]: 0 : _CHKM (m); _CHKMA (m, m->getRows () == zref->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2504 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref, *z0));
[ # # ][ # # ]
2505 : : }
2506 : :
2507 : : // Function -- MATRIX stos (MATRIX, DOUBLE, VECTOR)
2508 : 0 : constant * evaluate::stos_m_d_v (constant * args) {
2509 [ # # ]: 0 : _ARM0 (m); _ARD1 (zref); _ARV2 (z0); _DEFM ();
2510 [ # # ][ # # ]: 0 : _CHKM (m); _CHKMA (m, m->getRows () == z0->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2511 [ # # ][ # # ]: 0 : _RETM (stos (*m, nr_complex_t (zref, 0), *z0));
[ # # ][ # # ]
2512 : : }
2513 : :
2514 : : // Function -- MATRIX stos (MATRIX, COMPLEX, VECTOR)
2515 : 0 : constant * evaluate::stos_m_c_v (constant * args) {
2516 [ # # ]: 0 : _ARM0 (m); _ARC1 (zref); _ARV2 (z0); _DEFM ();
2517 [ # # ][ # # ]: 0 : _CHKM (m); _CHKMA (m, m->getRows () == z0->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2518 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref, *z0));
[ # # ][ # # ]
2519 : : }
2520 : :
2521 : : // Function -- MATRIX stos (MATRIX, VECTOR, VECTOR)
2522 : 0 : constant * evaluate::stos_m_v_v (constant * args) {
2523 [ # # ]: 0 : _ARM0 (m); _ARV1 (zref); _ARV2 (z0); _DEFM ();
2524 [ # # ][ # # ]: 0 : _CHKM (m); _CHKMA (m, m->getRows () == z0->getSize () &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2525 : : m->getRows () == zref->getSize ());
2526 [ # # ][ # # ]: 0 : _RETM (stos (*m, *zref, *z0));
[ # # ][ # # ]
[ # # ][ # # ]
2527 : : }
2528 : :
2529 : : // Function -- MATVEC stos (MATVEC, DOUBLE)
2530 : 0 : constant * evaluate::stos_mv_d (constant * args) {
2531 [ # # ]: 0 : _ARMV0 (mv); _ARD1 (zref); _DEFMV ();
2532 [ # # ][ # # ]: 0 : _CHKMV (mv);
[ # # ]
2533 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, zref));
2534 : : }
2535 : :
2536 : : // Function -- MATVEC stos (MATVEC, COMPLEX)
2537 : 0 : constant * evaluate::stos_mv_c (constant * args) {
2538 [ # # ]: 0 : _ARMV0 (mv); _ARC1 (zref); _DEFMV ();
2539 [ # # ][ # # ]: 0 : _CHKMV (mv);
[ # # ]
2540 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref));
2541 : : }
2542 : :
2543 : : // Function -- MATVEC stos (MATVEC, DOUBLE, DOUBLE)
2544 : 0 : constant * evaluate::stos_mv_d_d (constant * args) {
2545 [ # # ]: 0 : _ARMV0 (mv); _ARD1 (zref); _ARD2 (z0); _DEFMV ();
2546 [ # # ][ # # ]: 0 : _CHKMV (mv);
[ # # ]
2547 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, zref, z0));
2548 : : }
2549 : :
2550 : : // Function -- MATVEC stos (MATVEC, DOUBLE, COMPLEX)
2551 : 0 : constant * evaluate::stos_mv_d_c (constant * args) {
2552 [ # # ]: 0 : _ARMV0 (mv); _ARD1 (zref); _ARC2 (z0); _DEFMV ();
2553 [ # # ][ # # ]: 0 : _CHKMV (mv);
[ # # ]
2554 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, nr_complex_t (zref, 0), *z0));
2555 : : }
2556 : :
2557 : : // Function -- MATVEC stos (MATVEC, COMPLEX, DOUBLE)
2558 : 0 : constant * evaluate::stos_mv_c_d (constant * args) {
2559 [ # # ]: 0 : _ARMV0 (mv); _ARC1 (zref); _ARD2 (z0); _DEFMV ();
2560 [ # # ][ # # ]: 0 : _CHKMV (mv);
[ # # ]
2561 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref, nr_complex_t (z0, 0)));
2562 : : }
2563 : :
2564 : : // Function -- MATVEC stos (MATVEC, COMPLEX, COMPLEX)
2565 : 0 : constant * evaluate::stos_mv_c_c (constant * args) {
2566 [ # # ]: 0 : _ARMV0 (mv); _ARC1 (zref); _ARC2 (z0); _DEFMV ();
2567 [ # # ][ # # ]: 0 : _CHKMV (mv);
[ # # ]
2568 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref, *z0));
2569 : : }
2570 : :
2571 : : // Function -- MATVEC stos (MATVEC, VECTOR)
2572 : 0 : constant * evaluate::stos_mv_v (constant * args) {
2573 [ # # ]: 0 : _ARMV0 (mv); _ARV1 (zref); _DEFMV ();
2574 [ # # ][ # # ]: 0 : _CHKMV (mv); _CHKMVA (mv, mv->getRows () == zref->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2575 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref));
[ # # ][ # # ]
2576 : : }
2577 : :
2578 : : // Function -- MATVEC stos (MATVEC, VECTOR, DOUBLE)
2579 : 0 : constant * evaluate::stos_mv_v_d (constant * args) {
2580 [ # # ]: 0 : _ARMV0 (mv); _ARV1 (zref); _ARD2 (z0); _DEFMV ();
2581 [ # # ][ # # ]: 0 : _CHKMV (mv); _CHKMVA (mv, mv->getRows () == zref->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2582 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref, nr_complex_t (z0, 0)));
[ # # ][ # # ]
2583 : : }
2584 : :
2585 : : // Function -- MATVEC stos (MATVEC, VECTOR, COMPLEX)
2586 : 0 : constant * evaluate::stos_mv_v_c (constant * args) {
2587 [ # # ]: 0 : _ARMV0 (mv); _ARV1 (zref); _ARC2 (z0); _DEFMV ();
2588 [ # # ][ # # ]: 0 : _CHKMV (mv); _CHKMVA (mv, mv->getRows () == zref->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2589 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref, *z0));
[ # # ][ # # ]
2590 : : }
2591 : :
2592 : : // Function -- MATVEC stos (MATVEC, DOUBLE, VECTOR)
2593 : 0 : constant * evaluate::stos_mv_d_v (constant * args) {
2594 [ # # ]: 0 : _ARMV0 (mv); _ARD1 (zref); _ARV2 (z0); _DEFMV ();
2595 [ # # ][ # # ]: 0 : _CHKMV (mv); _CHKMVA (mv, mv->getRows () == z0->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2596 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, nr_complex_t (zref, 0), *z0));
[ # # ][ # # ]
2597 : : }
2598 : :
2599 : : // Function -- MATVEC stos (MATVEC, COMPLEX, VECTOR)
2600 : 0 : constant * evaluate::stos_mv_c_v (constant * args) {
2601 [ # # ]: 0 : _ARMV0 (mv); _ARC1 (zref); _ARV2 (z0); _DEFMV ();
2602 [ # # ][ # # ]: 0 : _CHKMV (mv); _CHKMVA (mv, mv->getRows () == z0->getSize ());
[ # # ][ # # ]
[ # # ][ # # ]
2603 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref, *z0));
[ # # ][ # # ]
2604 : : }
2605 : :
2606 : : // Function -- MATVEC stos (MATVEC, VECTOR, VECTOR)
2607 : 0 : constant * evaluate::stos_mv_v_v (constant * args) {
2608 [ # # ]: 0 : _ARMV0 (mv); _ARV1 (zref); _ARV2 (z0); _DEFMV ();
2609 [ # # ][ # # ]: 0 : _CHKMV (mv); _CHKMVA (mv, mv->getRows () == z0->getSize () &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2610 : : mv->getRows () == zref->getSize ());
2611 [ # # ][ # # ]: 0 : _RETMV (stos (*mv, *zref, *z0));
[ # # ][ # # ]
[ # # ][ # # ]
2612 : : }
2613 : :
2614 : 0 : constant * evaluate::twoport_m (constant * args) {
2615 : 0 : _ARM0 (m);
2616 : 0 : char f = CHR (_ARES(1));
2617 : 0 : char t = CHR (_ARES(2));
2618 [ # # ]: 0 : _DEFM ();
2619 [ # # ][ # # ]: 0 : if (m->getRows () < 2 || m->getCols () < 2) {
[ # # ]
2620 [ # # ]: 0 : THROW_MATH_EXCEPTION ("invalid matrix dimensions for twoport "
2621 : : "transformation");
2622 [ # # ]: 0 : _RETM (*m);
2623 : : }
2624 [ # # ][ # # ]: 0 : _RETM (twoport (*m, toupper (f), toupper (t)));
[ # # ][ # # ]
2625 : : }
2626 : :
2627 : 0 : constant * evaluate::twoport_mv (constant * args) {
2628 : 0 : _ARMV0 (mv);
2629 : 0 : char f = CHR (_ARES(1));
2630 : 0 : char t = CHR (_ARES(2));
2631 [ # # ]: 0 : _DEFMV ();
2632 [ # # ][ # # ]: 0 : if (mv->getRows () < 2 || mv->getCols () < 2) {
[ # # ]
2633 [ # # ]: 0 : THROW_MATH_EXCEPTION ("invalid matrix dimensions for twoport "
2634 : : "transformation");
2635 [ # # ]: 0 : _RETMV (*mv);
2636 : : }
2637 [ # # ][ # # ]: 0 : _RETMV (twoport (*mv, toupper (f), toupper (t)));
[ # # ][ # # ]
2638 : : }
2639 : :
2640 : 0 : constant * evaluate::inverse_m (constant * args) {
2641 : 0 : _ARM0 (m);
2642 [ # # ]: 0 : _DEFM ();
2643 [ # # ][ # # ]: 0 : _RETM (inverse (*m));
2644 : : }
2645 : :
2646 : 0 : constant * evaluate::inverse_mv (constant * args) {
2647 : 0 : _ARMV0 (mv);
2648 [ # # ]: 0 : _DEFMV ();
2649 [ # # ][ # # ]: 0 : _RETMV (inverse (*mv));
2650 : : }
2651 : :
2652 : 0 : constant * evaluate::transpose_m (constant * args) {
2653 : 0 : _ARM0 (m);
2654 [ # # ]: 0 : _DEFM ();
2655 [ # # ][ # # ]: 0 : _RETM (transpose (*m));
2656 : : }
2657 : :
2658 : 0 : constant * evaluate::transpose_mv (constant * args) {
2659 : 0 : _ARMV0 (mv);
2660 [ # # ]: 0 : _DEFMV ();
2661 [ # # ][ # # ]: 0 : _RETMV (transpose (*mv));
2662 : : }
2663 : :
2664 : 0 : constant * evaluate::det_m (constant * args) {
2665 : 0 : _ARM0 (m);
2666 [ # # ]: 0 : _DEFC ();
2667 [ # # ][ # # ]: 0 : _RETC (det (*m));
2668 : : }
2669 : :
2670 : 0 : constant * evaluate::det_mv (constant * args) {
2671 : 0 : _ARMV0 (mv);
2672 [ # # ]: 0 : _DEFV ();
2673 [ # # ][ # # ]: 0 : _RETV (det (*mv));
2674 : : }
2675 : :
2676 : 0 : constant * evaluate::eye_m (constant * args) {
2677 : 0 : _ARI0 (i);
2678 [ # # ]: 0 : _DEFM ();
2679 [ # # ]: 0 : _RETM (eye (i));
2680 : : }
2681 : :
2682 : 0 : constant * evaluate::adjoint_m (constant * args) {
2683 : 0 : _ARM0 (m);
2684 [ # # ]: 0 : _DEFM ();
2685 [ # # ][ # # ]: 0 : _RETM (adjoint (*m));
2686 : : }
2687 : :
2688 : 0 : constant * evaluate::adjoint_mv (constant * args) {
2689 : 0 : _ARMV0 (mv);
2690 [ # # ]: 0 : _DEFMV ();
2691 [ # # ][ # # ]: 0 : _RETMV (adjoint (*mv));
2692 : : }
2693 : :
2694 : : // ***************** s-parameter stability factors *****************
2695 : 0 : constant * evaluate::rollet_m (constant * args) {
2696 : 0 : _ARM0 (m);
2697 [ # # ]: 0 : _DEFD ();
2698 [ # # ]: 0 : _RETD (rollet (*m));
2699 : : }
2700 : :
2701 : 0 : constant * evaluate::rollet_mv (constant * args) {
2702 : 0 : _ARMV0 (mv);
2703 [ # # ]: 0 : _DEFV ();
2704 [ # # ][ # # ]: 0 : _RETV (rollet (*mv));
2705 : : }
2706 : :
2707 : 0 : constant * evaluate::mu1_m (constant * args) {
2708 : 0 : _ARM0 (m);
2709 [ # # ]: 0 : _DEFD ();
2710 : : nr_double_t k;
2711 : 0 : k = (1 - norm (m->get (0, 0))) /
2712 [ # # ][ # # ]: 0 : (abs (m->get (1, 1) - conj (m->get (0, 0)) * det (*m)) +
[ # # ][ # # ]
[ # # ]
2713 [ # # ][ # # ]: 0 : abs (m->get (0, 1) * m->get (1, 0)));
[ # # ]
2714 : 0 : _RETD (k);
2715 : : }
2716 : :
2717 : 0 : constant * evaluate::mu1_mv (constant * args) {
2718 [ # # ]: 0 : _ARMV0 (mv);
2719 [ # # ][ # # ]: 0 : _DEFV ();
2720 [ # # ]: 0 : qucs::vector k;
2721 : : k = (1 - norm (mv->get (0, 0))) /
2722 : : (abs (mv->get (1, 1) - conj (mv->get (0, 0)) * det (*mv)) +
2723 [ # # ][ # # ]: 0 : abs (mv->get (0, 1) * mv->get (1, 0)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2724 [ # # ][ # # ]: 0 : _RETV (k);
[ # # ]
2725 : : }
2726 : :
2727 : 0 : constant * evaluate::mu2_m (constant * args) {
2728 : 0 : _ARM0 (m);
2729 [ # # ]: 0 : _DEFD ();
2730 : : nr_double_t k;
2731 : 0 : k = (1 - norm (m->get (1, 1))) /
2732 [ # # ][ # # ]: 0 : (abs (m->get (0, 0) - conj (m->get (1, 1)) * det (*m)) +
[ # # ][ # # ]
[ # # ]
2733 [ # # ][ # # ]: 0 : abs (m->get (0, 1) * m->get (1, 0)));
[ # # ]
2734 : 0 : _RETD (k);
2735 : : }
2736 : :
2737 : 0 : constant * evaluate::mu2_mv (constant * args) {
2738 [ # # ]: 0 : _ARMV0 (mv);
2739 [ # # ][ # # ]: 0 : _DEFV ();
2740 [ # # ]: 0 : qucs::vector k;
2741 : : k = (1 - norm (mv->get (1, 1))) /
2742 : : (abs (mv->get (0, 0) - conj (mv->get (1, 1)) * det (*mv)) +
2743 [ # # ][ # # ]: 0 : abs (mv->get (0, 1) * mv->get (1, 0)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2744 [ # # ][ # # ]: 0 : _RETV (k);
[ # # ]
2745 : : }
2746 : :
2747 : 0 : constant * evaluate::b1_m (constant * args) {
2748 : 0 : _ARM0 (m);
2749 [ # # ]: 0 : _DEFD ();
2750 [ # # ]: 0 : _RETD (b1 (*m));
2751 : : }
2752 : :
2753 : 0 : constant * evaluate::b1_mv (constant * args) {
2754 : 0 : _ARMV0 (mv);
2755 [ # # ]: 0 : _DEFV ();
2756 [ # # ][ # # ]: 0 : _RETV (b1 (*mv));
2757 : : }
2758 : :
2759 : : // ***************** vector creation *****************
2760 : 0 : constant * evaluate::linspace (constant * args) {
2761 : 0 : _ARD0 (start);
2762 : 0 : _ARD1 (stop);
2763 : 0 : _ARI2 (points);
2764 [ # # ]: 0 : _DEFV ();
2765 [ # # ]: 0 : if (points < 2) {
2766 [ # # ]: 0 : THROW_MATH_EXCEPTION ("linspace: number of points must be greater than 1");
2767 [ # # ]: 0 : res->v = new qucs::vector ();
2768 : 0 : return res;
2769 : : }
2770 [ # # ]: 0 : _RETV (qucs::linspace (start, stop, points));
2771 : : }
2772 : :
2773 : 0 : constant * evaluate::logspace (constant * args) {
2774 : 0 : _ARD0 (start);
2775 : 0 : _ARD1 (stop);
2776 : 0 : _ARI2 (points);
2777 [ # # ]: 0 : _DEFV ();
2778 [ # # ]: 0 : if (points < 2) {
2779 [ # # ]: 0 : THROW_MATH_EXCEPTION ("logspace: number of points must be greater than 1");
2780 [ # # ]: 0 : res->v = new qucs::vector ();
2781 : 0 : return res;
2782 : : }
2783 [ # # ]: 0 : if (start * stop <= 0) {
2784 [ # # ]: 0 : THROW_MATH_EXCEPTION ("logspace: invalid start/stop values");
2785 [ # # ]: 0 : res->v = new qucs::vector (points);
2786 : 0 : return res;
2787 : : }
2788 [ # # ]: 0 : _RETV (qucs::logspace (start, stop, points));
2789 : : }
2790 : :
2791 : : // Circle helper macro with a number of points given.
2792 : : #define CIRCLE_HELPER_D(argi) \
2793 : : int n = INT (args->getResult (argi)); \
2794 : : if (n < 2) { \
2795 : : THROW_MATH_EXCEPTION ("Circle: number of points must be greater than 1"); \
2796 : : _DEFV (); \
2797 : : res->v = new qucs::vector (); \
2798 : : return res; \
2799 : : } \
2800 : : constant * arg = new constant (TAG_VECTOR); \
2801 : : arg->v = new qucs::vector (qucs::linspace (0, 360, n)); \
2802 : : arg->solvee = args->getResult(0)->solvee; \
2803 : : arg->evaluate (); \
2804 : : delete args->get(argi); \
2805 : : args->get((argi)-1)->setNext (NULL); \
2806 : : args->append (arg);
2807 : :
2808 : : // Circle helper macro with no additional argument given.
2809 : : #define CIRCLE_HELPER_A() \
2810 : : constant * arg = new constant (TAG_VECTOR); \
2811 : : arg->v = new qucs::vector (qucs::linspace (0, 360, 64)); \
2812 : : arg->solvee = args->getResult(0)->solvee; \
2813 : : arg->evaluate (); \
2814 : : args->append (arg);
2815 : :
2816 : : // ***************** s-parameter noise circles *****************
2817 : 0 : constant * evaluate::noise_circle_d_v (constant * args) {
2818 [ # # ]: 0 : qucs::vector * Sopt = V (_ARES(0));
2819 [ # # ]: 0 : qucs::vector * Fmin = V (_ARES(1));
2820 [ # # ]: 0 : qucs::vector * Rn = V (_ARES(2));
2821 [ # # ]: 0 : nr_double_t F = D (_ARES(3));
2822 [ # # ]: 0 : qucs::vector * arc = V (_ARES(4));
2823 : :
2824 [ # # ][ # # ]: 0 : _DEFV ();
2825 [ # # ][ # # ]: 0 : qucs::vector N = circuit::z0 / 4 / *Rn * (F - *Fmin) * norm (1 + *Sopt);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2826 [ # # ][ # # ]: 0 : qucs::vector R = sqrt (N * N + N * (1 - norm (*Sopt))) / (1 + N);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2827 [ # # ][ # # ]: 0 : qucs::vector C = *Sopt / (1 + N);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2828 [ # # ][ # # ]: 0 : qucs::vector * circle = new qucs::vector (C.getSize () * arc->getSize ());
[ # # ][ # # ]
2829 : 0 : int i, a, j; nr_complex_t v;
2830 [ # # ][ # # ]: 0 : for (i = 0, j = 0; i < C.getSize (); i++) {
2831 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++, j++) {
2832 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2833 [ # # ]: 0 : circle->set (v, j);
2834 : : }
2835 : : }
2836 : :
2837 [ # # ][ # # ]: 0 : node * gen = SOLVEE(4)->addGeneratedEquation (arc, "Arcs");
2838 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2839 : 0 : res->v = circle;
2840 [ # # ][ # # ]: 0 : return res;
[ # # ]
2841 : : }
2842 : :
2843 : 0 : constant * evaluate::noise_circle_d_d (constant * args) {
2844 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (4);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2845 : 0 : return noise_circle_d_v (args);
2846 : : }
2847 : :
2848 : 0 : constant * evaluate::noise_circle_d (constant * args) {
2849 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
2850 : 0 : return noise_circle_d_v (args);
2851 : : }
2852 : :
2853 : 0 : constant * evaluate::noise_circle_v_v (constant * args) {
2854 [ # # ]: 0 : qucs::vector * Sopt = V (_ARES(0));
2855 [ # # ]: 0 : qucs::vector * Fmin = V (_ARES(1));
2856 [ # # ]: 0 : qucs::vector * Rn = V (_ARES(2));
2857 [ # # ]: 0 : qucs::vector * F = V (_ARES(3));
2858 [ # # ]: 0 : :: vector * arc = V (_ARES(4));
2859 : :
2860 [ # # ][ # # ]: 0 : _DEFV ();
2861 : : qucs::vector * circle =
2862 [ # # ][ # # ]: 0 : new qucs::vector (Sopt->getSize () * arc->getSize () * F->getSize ());
[ # # ][ # # ]
[ # # ]
2863 [ # # ][ # # ]: 0 : int i, a, j, f; nr_complex_t v; qucs::vector N, R, C;
[ # # ]
2864 [ # # ][ # # ]: 0 : for (f = 0; f < F->getSize (); f++) {
2865 [ # # ][ # # ]: 0 : N = circuit::z0 / 4 / *Rn * (F->get (f) - *Fmin) * norm (1 + *Sopt);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2866 [ # # ][ # # ]: 0 : R = sqrt (N * N + N * (1 - norm (*Sopt))) / (1 + N);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2867 [ # # ][ # # ]: 0 : C = *Sopt / (1 + N);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2868 [ # # ][ # # ]: 0 : for (i = 0; i < C.getSize (); i++) {
2869 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++) {
2870 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2871 [ # # ][ # # ]: 0 : j = i * F->getSize () * arc->getSize () + f * arc->getSize () + a;
[ # # ]
2872 [ # # ]: 0 : circle->set (v, j);
2873 : : }
2874 : : }
2875 : : }
2876 : :
2877 : : node * gen;
2878 [ # # ][ # # ]: 0 : gen = SOLVEE(3)->addGeneratedEquation (F, "NF");
2879 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2880 [ # # ][ # # ]: 0 : gen = SOLVEE(4)->addGeneratedEquation (arc, "Arcs");
2881 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2882 : :
2883 : 0 : res->v = circle;
2884 [ # # ][ # # ]: 0 : return res;
[ # # ]
2885 : : }
2886 : :
2887 : 0 : constant * evaluate::noise_circle_v_d (constant * args) {
2888 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (4);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2889 : 0 : return noise_circle_v_v (args);
2890 : : }
2891 : :
2892 : 0 : constant * evaluate::noise_circle_v (constant * args) {
2893 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
2894 : 0 : return noise_circle_v_v (args);
2895 : : }
2896 : :
2897 : : // ***************** s-parameter stability circles *****************
2898 : 0 : constant * evaluate::stab_circle_l_v (constant * args) {
2899 [ # # ]: 0 : _ARMV0 (S);
2900 [ # # ]: 0 : _ARV1 (arc);
2901 [ # # ][ # # ]: 0 : _DEFV ();
2902 [ # # ][ # # ]: 0 : qucs::vector D = norm (S->get (1, 1)) - norm (det (*S));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2903 [ # # ][ # # ]: 0 : qucs::vector C = (conj (S->get (1, 1)) - S->get (0, 0) * conj (det (*S))) / D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2904 [ # # ][ # # ]: 0 : qucs::vector R = abs (S->get (0, 1)) * abs (S->get (1, 0)) / D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2905 [ # # ][ # # ]: 0 : qucs::vector * circle = new qucs::vector (S->getSize () * arc->getSize ());
[ # # ]
2906 : 0 : int a, d, i; nr_complex_t v;
2907 [ # # ]: 0 : for (i = 0, d = 0; i < S->getSize (); i++) {
2908 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++, d++) {
2909 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2910 [ # # ]: 0 : circle->set (v, d);
2911 : : }
2912 : : }
2913 [ # # ][ # # ]: 0 : node * gen = SOLVEE(1)->addGeneratedEquation (arc, "Arcs");
2914 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2915 : 0 : res->v = circle;
2916 [ # # ][ # # ]: 0 : return res;
[ # # ]
2917 : : }
2918 : :
2919 : 0 : constant * evaluate::stab_circle_l_d (constant * args) {
2920 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (1);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2921 : 0 : return stab_circle_l_v (args);
2922 : : }
2923 : :
2924 : 0 : constant * evaluate::stab_circle_l (constant * args) {
2925 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
2926 : 0 : return stab_circle_l_v (args);
2927 : : }
2928 : :
2929 : 0 : constant * evaluate::stab_circle_s_v (constant * args) {
2930 [ # # ]: 0 : _ARMV0 (S);
2931 [ # # ]: 0 : _ARV1 (arc);
2932 [ # # ][ # # ]: 0 : _DEFV ();
2933 [ # # ][ # # ]: 0 : qucs::vector D = norm (S->get (0, 0)) - norm (det (*S));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2934 [ # # ][ # # ]: 0 : qucs::vector C = (conj (S->get (0, 0)) - S->get (1, 1) * conj (det (*S))) / D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2935 [ # # ][ # # ]: 0 : qucs::vector R = abs (S->get (0, 1)) * abs (S->get (1, 0)) / D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2936 [ # # ][ # # ]: 0 : qucs::vector * circle = new qucs::vector (S->getSize () * arc->getSize ());
[ # # ]
2937 : 0 : int a, d, i; nr_complex_t v;
2938 [ # # ]: 0 : for (i = 0, d = 0; i < S->getSize (); i++) {
2939 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++, d++) {
2940 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2941 [ # # ]: 0 : circle->set (v, d);
2942 : : }
2943 : : }
2944 [ # # ][ # # ]: 0 : node * gen = SOLVEE(1)->addGeneratedEquation (arc, "Arcs");
2945 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2946 : 0 : res->v = circle;
2947 [ # # ][ # # ]: 0 : return res;
[ # # ]
2948 : : }
2949 : :
2950 : 0 : constant * evaluate::stab_circle_s_d (constant * args) {
2951 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (1);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2952 : 0 : return stab_circle_s_v (args);
2953 : : }
2954 : :
2955 : 0 : constant * evaluate::stab_circle_s (constant * args) {
2956 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
2957 : 0 : return stab_circle_s_v (args);
2958 : : }
2959 : :
2960 : : // ***************** s-parameter gain circles *****************
2961 : 0 : constant * evaluate::ga_circle_d_v (constant * args) {
2962 [ # # ]: 0 : _ARMV0 (S);
2963 [ # # ]: 0 : _ARD1 (G);
2964 [ # # ]: 0 : _ARV2 (arc);
2965 [ # # ][ # # ]: 0 : _DEFV ();
2966 [ # # ][ # # ]: 0 : qucs::vector g, D, c, s, k, C, R, d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2967 [ # # ][ # # ]: 0 : D = det (*S);
[ # # ][ # # ]
[ # # ]
2968 [ # # ][ # # ]: 0 : c = S->get (0, 0) - conj (S->get (1, 1)) * D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2969 [ # # ][ # # ]: 0 : k = rollet (*S);
[ # # ][ # # ]
[ # # ]
2970 [ # # ][ # # ]: 0 : s = S->get (0, 1) * S->get (1, 0);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2971 [ # # ][ # # ]: 0 : g = G / norm (S->get (1, 0));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2972 [ # # ][ # # ]: 0 : d = 1 + g * (norm (S->get (0, 0)) - norm (D));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2973 [ # # ][ # # ]: 0 : C = g * conj (c) / d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2974 [ # # ][ # # ]: 0 : R = sqrt (1 - 2 * k * g * abs (s) + g * g * norm (s)) / abs (d);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2975 : :
2976 [ # # ][ # # ]: 0 : qucs::vector * circle = new qucs::vector (S->getSize () * arc->getSize ());
[ # # ]
2977 : 0 : int i, a, j; nr_complex_t v;
2978 [ # # ][ # # ]: 0 : for (i = 0, j = 0; i < C.getSize (); i++) {
2979 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++, j++) {
2980 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2981 [ # # ]: 0 : circle->set (v, j);
2982 : : }
2983 : : }
2984 : :
2985 [ # # ][ # # ]: 0 : node * gen = SOLVEE(2)->addGeneratedEquation (arc, "Arcs");
2986 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
2987 : 0 : res->v = circle;
2988 [ # # ][ # # ]: 0 : return res;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
2989 : : }
2990 : :
2991 : 0 : constant * evaluate::ga_circle_d_d (constant * args) {
2992 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (2);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
2993 : 0 : return ga_circle_d_v (args);
2994 : : }
2995 : :
2996 : 0 : constant * evaluate::ga_circle_d (constant * args) {
2997 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
2998 : 0 : return ga_circle_d_v (args);
2999 : : }
3000 : :
3001 : 0 : constant * evaluate::ga_circle_v_v (constant * args) {
3002 [ # # ]: 0 : _ARMV0 (S);
3003 [ # # ]: 0 : _ARV1 (G);
3004 [ # # ]: 0 : _ARV2 (arc);
3005 [ # # ][ # # ]: 0 : _DEFV ();
3006 : : qucs::vector * circle =
3007 [ # # ][ # # ]: 0 : new qucs::vector (S->getSize () * arc->getSize () * G->getSize ());
[ # # ][ # # ]
3008 [ # # ][ # # ]: 0 : int i, a, j, f; nr_complex_t v; qucs::vector g, D, c, s, k, R, C, d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3009 [ # # ][ # # ]: 0 : D = det (*S);
[ # # ][ # # ]
[ # # ]
3010 [ # # ][ # # ]: 0 : c = S->get (0, 0) - conj (S->get (1, 1)) * D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3011 [ # # ][ # # ]: 0 : k = rollet (*S);
[ # # ][ # # ]
[ # # ]
3012 [ # # ][ # # ]: 0 : s = S->get (0, 1) * S->get (1, 0);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3013 [ # # ][ # # ]: 0 : for (f = 0; f < G->getSize (); f++) {
3014 [ # # ][ # # ]: 0 : g = G->get (f) / norm (S->get (1, 0));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3015 [ # # ][ # # ]: 0 : d = 1 + g * (norm (S->get (0, 0)) - norm (D));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3016 [ # # ][ # # ]: 0 : C = g * conj (c) / d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3017 [ # # ][ # # ]: 0 : R = sqrt (1 - 2 * k * g * abs (s) + g * g * norm (s)) / abs (d);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3018 [ # # ][ # # ]: 0 : for (i = 0; i < C.getSize (); i++) {
3019 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++) {
3020 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3021 [ # # ][ # # ]: 0 : j = i * G->getSize () * arc->getSize () + f * arc->getSize () + a;
[ # # ]
3022 [ # # ]: 0 : circle->set (v, j);
3023 : : }
3024 : : }
3025 : : }
3026 : :
3027 : : node * gen;
3028 [ # # ][ # # ]: 0 : gen = SOLVEE(1)->addGeneratedEquation (G, "Ga");
3029 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
3030 [ # # ][ # # ]: 0 : gen = SOLVEE(2)->addGeneratedEquation (arc, "Arcs");
3031 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
3032 : 0 : res->v = circle;
3033 [ # # ][ # # ]: 0 : return res;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3034 : : }
3035 : :
3036 : 0 : constant * evaluate::ga_circle_v_d (constant * args) {
3037 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (2);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3038 : 0 : return ga_circle_v_v (args);
3039 : : }
3040 : :
3041 : 0 : constant * evaluate::ga_circle_v (constant * args) {
3042 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
3043 : 0 : return ga_circle_v_v (args);
3044 : : }
3045 : :
3046 : 0 : constant * evaluate::gp_circle_d_v (constant * args) {
3047 [ # # ]: 0 : _ARMV0 (S);
3048 [ # # ]: 0 : _ARD1 (G);
3049 [ # # ]: 0 : _ARV2 (arc);
3050 [ # # ][ # # ]: 0 : _DEFV ();
3051 [ # # ][ # # ]: 0 : qucs::vector g, D, c, s, k, C, R, d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3052 [ # # ][ # # ]: 0 : D = det (*S);
[ # # ][ # # ]
[ # # ]
3053 [ # # ][ # # ]: 0 : c = S->get (1, 1) - conj (S->get (0, 0)) * D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3054 [ # # ][ # # ]: 0 : k = rollet (*S);
[ # # ][ # # ]
[ # # ]
3055 [ # # ][ # # ]: 0 : s = S->get (0, 1) * S->get (1, 0);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3056 [ # # ][ # # ]: 0 : g = G / norm (S->get (1, 0));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3057 [ # # ][ # # ]: 0 : d = 1 + g * (norm (S->get (1, 1)) - norm (D));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3058 [ # # ][ # # ]: 0 : C = g * conj (c) / d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3059 [ # # ][ # # ]: 0 : R = sqrt (1 - 2 * k * g * abs (s) + g * g * norm (s)) / abs (d);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3060 : :
3061 [ # # ][ # # ]: 0 : qucs::vector * circle = new qucs::vector (S->getSize () * arc->getSize ());
[ # # ]
3062 : 0 : int i, a, j; nr_complex_t v;
3063 [ # # ][ # # ]: 0 : for (i = 0, j = 0; i < C.getSize (); i++) {
3064 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++, j++) {
3065 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3066 [ # # ]: 0 : circle->set (v, j);
3067 : : }
3068 : : }
3069 : :
3070 [ # # ][ # # ]: 0 : node * gen = SOLVEE(2)->addGeneratedEquation (arc, "Arcs");
3071 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
3072 : 0 : res->v = circle;
3073 [ # # ][ # # ]: 0 : return res;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3074 : : }
3075 : :
3076 : 0 : constant * evaluate::gp_circle_d_d (constant * args) {
3077 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (2);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3078 : 0 : return gp_circle_d_v (args);
3079 : : }
3080 : :
3081 : 0 : constant * evaluate::gp_circle_d (constant * args) {
3082 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
3083 : 0 : return gp_circle_d_v (args);
3084 : : }
3085 : :
3086 : 0 : constant * evaluate::gp_circle_v_v (constant * args) {
3087 [ # # ]: 0 : _ARMV0 (S);
3088 [ # # ]: 0 : _ARV1 (G);
3089 [ # # ]: 0 : _ARV2 (arc);
3090 [ # # ][ # # ]: 0 : _DEFV ();
3091 : : qucs::vector * circle =
3092 [ # # ][ # # ]: 0 : new qucs::vector (S->getSize () * arc->getSize () * G->getSize ());
[ # # ][ # # ]
3093 [ # # ][ # # ]: 0 : int i, a, j, f; nr_complex_t v; qucs::vector g, D, c, s, k, R, C, d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3094 [ # # ][ # # ]: 0 : D = det (*S);
[ # # ][ # # ]
[ # # ]
3095 [ # # ][ # # ]: 0 : c = S->get (1, 1) - conj (S->get (0, 0)) * D;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3096 [ # # ][ # # ]: 0 : k = rollet (*S);
[ # # ][ # # ]
[ # # ]
3097 [ # # ][ # # ]: 0 : s = S->get (0, 1) * S->get (1, 0);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3098 [ # # ][ # # ]: 0 : for (f = 0; f < G->getSize (); f++) {
3099 [ # # ][ # # ]: 0 : g = G->get (f) / norm (S->get (1, 0));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3100 [ # # ][ # # ]: 0 : d = 1 + g * (norm (S->get (1, 1)) - norm (D));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3101 [ # # ][ # # ]: 0 : C = g * conj (c) / d;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3102 [ # # ][ # # ]: 0 : R = sqrt (1 - 2 * k * g * abs (s) + g * g * norm (s)) / abs (d);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3103 [ # # ][ # # ]: 0 : for (i = 0; i < C.getSize (); i++) {
3104 [ # # ][ # # ]: 0 : for (a = 0; a < arc->getSize (); a++) {
3105 [ # # ][ # # ]: 0 : v = C.get (i) + R.get (i) * exp (nr_complex_t (0, 1) * rad (arc->get (a)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3106 [ # # ][ # # ]: 0 : j = i * G->getSize () * arc->getSize () + f * arc->getSize () + a;
[ # # ]
3107 [ # # ]: 0 : circle->set (v, j);
3108 : : }
3109 : : }
3110 : : }
3111 : :
3112 : : node * gen;
3113 [ # # ][ # # ]: 0 : gen = SOLVEE(1)->addGeneratedEquation (G, "Gp");
3114 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
3115 [ # # ][ # # ]: 0 : gen = SOLVEE(2)->addGeneratedEquation (arc, "Arcs");
3116 [ # # ]: 0 : res->addPrepDependencies (A(gen)->result);
3117 : 0 : res->v = circle;
3118 [ # # ][ # # ]: 0 : return res;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3119 : : }
3120 : :
3121 : 0 : constant * evaluate::gp_circle_v_d (constant * args) {
3122 [ # # ][ # # ]: 0 : CIRCLE_HELPER_D (2);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3123 : 0 : return gp_circle_v_v (args);
3124 : : }
3125 : :
3126 : 0 : constant * evaluate::gp_circle_v (constant * args) {
3127 [ # # ][ # # ]: 0 : CIRCLE_HELPER_A ();
3128 : 0 : return gp_circle_v_v (args);
3129 : : }
3130 : :
3131 : : // ***************** versus vectors *****************
3132 : 2 : constant * evaluate::plot_vs_v (constant * args) {
3133 : 2 : _ARV0 (v);
3134 [ + - ]: 2 : _DEFV ();
3135 : 2 : int i = 1;
3136 [ + + ]: 4 : for (node * arg = args->getNext (); arg != NULL; arg = arg->getNext ()) {
3137 : 2 : node * gen = arg->solvee->addGeneratedEquation (V (_ARES (i)), "Versus");
3138 : 2 : res->addPrepDependencies (A(gen)->result);
3139 : 2 : i++;
3140 : : }
3141 : 2 : res->dropdeps = 1;
3142 [ + - ]: 2 : _RETV (*v);
3143 : : }
3144 : :
3145 : 0 : constant * evaluate::plot_vs_mv (constant * args) {
3146 : 0 : _ARMV0 (mv);
3147 [ # # ]: 0 : _DEFMV ();
3148 : 0 : int i = 1;
3149 [ # # ]: 0 : for (node * arg = args->getNext (); arg != NULL; arg = arg->getNext ()) {
3150 : 0 : node * gen = arg->solvee->addGeneratedEquation (V (_ARES (i)), "Versus");
3151 : 0 : res->addPrepDependencies (A(gen)->result);
3152 : 0 : i++;
3153 : : }
3154 : 0 : res->dropdeps = 1;
3155 [ # # ]: 0 : _RETMV (*mv);
3156 : : }
3157 : :
3158 : : // ***************** find x-value for given y-value *****************
3159 : 0 : constant * evaluate::xvalue_d (constant * args) {
3160 [ # # ]: 0 : _ARV0 (v);
3161 [ # # ]: 0 : _ARD1 (d);
3162 [ # # ][ # # ]: 0 : _DEFC ();
3163 [ # # ][ # # ]: 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3164 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ][ # # ]
3165 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
[ # # ][ # # ]
3166 [ # # ]: 0 : _RETC (0.0);
3167 : : }
3168 [ # # ][ # # ]: 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
[ # # ]
3169 : : int idx, i;
3170 : 0 : nr_double_t t, diff = std::numeric_limits<nr_double_t>::max();
3171 [ # # ][ # # ]: 0 : for (idx = i = 0; i < v->getSize (); i++) {
3172 [ # # ]: 0 : t = abs (v->get (i) - d);
3173 [ # # ]: 0 : if (t < diff) {
3174 : 0 : idx = i;
3175 : 0 : diff = t;
3176 : : }
3177 : : }
3178 [ # # ][ # # ]: 0 : _RETC (indep->get (idx));
3179 : : }
3180 : :
3181 : 0 : constant * evaluate::xvalue_c (constant * args) {
3182 : 0 : _ARV0 (v);
3183 : 0 : _ARC1 (c);
3184 [ # # ]: 0 : _DEFC ();
3185 : 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3186 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ]
3187 [ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
3188 : 0 : _RETC (0.0);
3189 : : }
3190 : 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
3191 : : int idx, i;
3192 : 0 : nr_double_t t, diff = std::numeric_limits<nr_double_t>::max();
3193 [ # # ]: 0 : for (idx = i = 0; i < v->getSize (); i++) {
3194 [ # # ]: 0 : t = abs (v->get (i) - *c);
3195 [ # # ]: 0 : if (t < diff) {
3196 : 0 : idx = i;
3197 : 0 : diff = t;
3198 : : }
3199 : : }
3200 [ # # ]: 0 : _RETC (indep->get (idx));
3201 : : }
3202 : :
3203 : : // ***************** find y-value for given x-value *****************
3204 : 0 : constant * evaluate::yvalue_d (constant * args) {
3205 [ # # ]: 0 : _ARV0 (v);
3206 [ # # ]: 0 : _ARD1 (d);
3207 [ # # ][ # # ]: 0 : _DEFC ();
3208 [ # # ][ # # ]: 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3209 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ][ # # ]
3210 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
[ # # ][ # # ]
3211 [ # # ]: 0 : _RETC (0.0);
3212 : : }
3213 [ # # ][ # # ]: 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
[ # # ]
3214 : : int idx, i;
3215 : 0 : nr_double_t t, diff = std::numeric_limits<nr_double_t>::max();
3216 [ # # ][ # # ]: 0 : for (idx = i = 0; i < indep->getSize (); i++) {
3217 [ # # ]: 0 : t = abs (indep->get (i) - d);
3218 [ # # ]: 0 : if (t < diff) {
3219 : 0 : idx = i;
3220 : 0 : diff = t;
3221 : : }
3222 : : }
3223 [ # # ][ # # ]: 0 : _RETC (v->get (idx));
3224 : : }
3225 : :
3226 : 0 : constant * evaluate::yvalue_c (constant * args) {
3227 : 0 : _ARV0 (v);
3228 : 0 : _ARC1 (c);
3229 [ # # ]: 0 : _DEFC ();
3230 : 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3231 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ]
3232 [ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
3233 : 0 : _RETC (0.0);
3234 : : }
3235 : 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
3236 : : int idx, i;
3237 : 0 : nr_double_t t, diff = std::numeric_limits<nr_double_t>::max();
3238 [ # # ]: 0 : for (idx = i = 0; i < indep->getSize (); i++) {
3239 [ # # ]: 0 : t = abs (indep->get (i) - *c);
3240 [ # # ]: 0 : if (t < diff) {
3241 : 0 : idx = i;
3242 : 0 : diff = t;
3243 : : }
3244 : : }
3245 [ # # ]: 0 : _RETC (v->get (idx));
3246 : : }
3247 : :
3248 : : // ***************** min, max, avg using range specification *****************
3249 : 0 : constant * evaluate::max_r (constant * args) {
3250 [ # # ]: 0 : _ARV0 (v);
3251 [ # # ]: 0 : _ARR1 (r);
3252 [ # # ][ # # ]: 0 : _DEFD ();
3253 [ # # ][ # # ]: 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3254 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ][ # # ]
3255 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
[ # # ][ # # ]
3256 : 0 : _RETD (0.0);
3257 : : }
3258 [ # # ][ # # ]: 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
[ # # ]
3259 : 0 : nr_complex_t c;
3260 : 0 : nr_double_t d, M = -std::numeric_limits<nr_double_t>::max();
3261 [ # # ][ # # ]: 0 : for (int i = 0; i < indep->getSize (); i++) {
3262 [ # # ][ # # ]: 0 : if (r->inside (real (indep->get (i)))) {
[ # # ]
3263 [ # # ]: 0 : c = v->get (i);
3264 [ # # ]: 0 : d = fabs (arg (c)) < M_PI_2 ? abs (c) : -abs (c);
3265 [ # # ]: 0 : if (d > M) M = d;
3266 : : }
3267 : : }
3268 : 0 : _RETD (M);
3269 : : }
3270 : :
3271 : 0 : constant * evaluate::min_r (constant * args) {
3272 [ # # ]: 0 : _ARV0 (v);
3273 [ # # ]: 0 : _ARR1 (r);
3274 [ # # ][ # # ]: 0 : _DEFD ();
3275 [ # # ][ # # ]: 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3276 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ][ # # ]
3277 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
[ # # ][ # # ]
3278 : 0 : _RETD (0.0);
3279 : : }
3280 [ # # ][ # # ]: 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
[ # # ]
3281 : 0 : nr_complex_t c;
3282 : 0 : nr_double_t d, M = +std::numeric_limits<nr_double_t>::max();
3283 [ # # ][ # # ]: 0 : for (int i = 0; i < indep->getSize (); i++) {
3284 [ # # ][ # # ]: 0 : if (r->inside (real (indep->get (i)))) {
[ # # ]
3285 [ # # ]: 0 : c = v->get (i);
3286 [ # # ]: 0 : d = fabs (arg (c)) < M_PI_2 ? abs (c) : -abs (c);
3287 [ # # ]: 0 : if (d < M) M = d;
3288 : : }
3289 : : }
3290 : 0 : _RETD (M);
3291 : : }
3292 : :
3293 : 0 : constant * evaluate::avg_r (constant * args) {
3294 [ # # ]: 0 : _ARV0 (v);
3295 [ # # ]: 0 : _ARR1 (r);
3296 [ # # ][ # # ]: 0 : _DEFC ();
3297 [ # # ][ # # ]: 0 : strlist * deps = _ARG(0)->collectDataDependencies ();
3298 [ # # ][ # # ]: 0 : if (!deps || deps->length () != 1) {
[ # # ][ # # ]
3299 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("not an appropriate dependent data vector");
[ # # ][ # # ]
3300 [ # # ]: 0 : _RETC (0.0);
3301 : : }
3302 [ # # ][ # # ]: 0 : qucs::vector * indep = SOLVEE(0)->getDataVector (deps->get (0));
[ # # ]
3303 : 0 : nr_complex_t c = 0.0;
3304 : : int i, k;
3305 [ # # ][ # # ]: 0 : for (k = i = 0; i < indep->getSize (); i++) {
3306 [ # # ][ # # ]: 0 : if (r->inside (real (indep->get (i)))) {
[ # # ]
3307 [ # # ]: 0 : c += v->get (i);
3308 : 0 : k++;
3309 : : }
3310 : : }
3311 [ # # ]: 0 : _RETC (c / (nr_double_t) k);
3312 : : }
3313 : :
3314 : : // *************** range functionality *****************
3315 : 0 : constant * evaluate::range_d_d (constant * args) {
3316 : 0 : _ARD0 (d1);
3317 : 0 : _ARD1 (d2);
3318 [ # # ]: 0 : _DEFR ();
3319 [ # # ]: 0 : _RETR (new range ('[', d1, d2, ']'));
3320 : : }
3321 : :
3322 : 0 : constant * evaluate::range_c_d (constant * args) {
3323 : 0 : _ARD1 (d2);
3324 [ # # ]: 0 : _DEFR ();
3325 [ # # ]: 0 : _RETR (new range ('.', d2 - 1, d2, ']'));
3326 : : }
3327 : :
3328 : 0 : constant * evaluate::range_d_c (constant * args) {
3329 : 0 : _ARD0 (d1);
3330 [ # # ]: 0 : _DEFR ();
3331 [ # # ]: 0 : _RETR (new range ('[', d1, d1 + 1, '.'));
3332 : : }
3333 : :
3334 : 0 : constant * evaluate::range_c_c (constant *) {
3335 [ # # ]: 0 : _DEFR ();
3336 [ # # ]: 0 : _RETR (new range ('.', 0, 0, '.'));
3337 : : }
3338 : :
3339 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_STD (ceil); // ceil double->integer conversion
[ # # ][ # # ]
[ # # ][ # # ]
3340 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_STD (floor); // floor double->integer conversion
[ # # ][ # # ]
[ # # ][ # # ]
3341 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (fix); // fix double->integer conversion
[ # # ][ # # ]
[ # # ][ # # ]
3342 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (step); // step function
[ # # ][ # # ]
[ # # ][ # # ]
3343 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_QUCS (round); // round function
[ # # ][ # # ]
[ # # ][ # # ]
3344 : : //#ifndef HAVE_ERF
3345 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_SPECIAL (erf); // error function
[ # # ][ # # ]
[ # # ][ # # ]
3346 : : //#else
3347 : : //MAKE_FUNC_DEFINITION_0_STD (erf); // error function
3348 : : //#endif
3349 : : //#ifndef HAVE_ERFC
3350 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_SPECIAL (erfc); // complementary error function
[ # # ][ # # ]
[ # # ][ # # ]
3351 : : //#else
3352 : : //MAKE_FUNC_DEFINITION_0_STD (erfc); // complementary error function
3353 : : //#endif
3354 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_SPECIAL (erfinv); // inverse of error function
[ # # ][ # # ]
[ # # ][ # # ]
3355 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_SPECIAL (erfcinv); // inverse of complementary error function
[ # # ][ # # ]
[ # # ][ # # ]
3356 [ # # ][ # # ]: 0 : MAKE_FUNC_DEFINITION_0_SPECIAL (i0); // modified bessel zero order
[ # # ][ # # ]
[ # # ][ # # ]
3357 : :
3358 : : // ******************* cumulative sum *********************
3359 : 0 : constant * evaluate::cumsum_d (constant * args) {
3360 : 0 : _ARD0 (d1);
3361 [ # # ]: 0 : _DEFD ();
3362 : 0 : _RETD (d1);
3363 : : }
3364 : :
3365 : 0 : constant * evaluate::cumsum_c (constant * args) {
3366 : 0 : _ARC0 (c1);
3367 [ # # ]: 0 : _DEFC ();
3368 : 0 : _RETC (*c1);
3369 : : }
3370 : :
3371 : 0 : constant * evaluate::cumsum_v (constant * args) {
3372 : 0 : _ARV0 (v1);
3373 [ # # ]: 0 : _DEFV ();
3374 [ # # ][ # # ]: 0 : _RETV (cumsum (*v1));
3375 : : }
3376 : :
3377 : : // **************** cumulative average ******************
3378 : 0 : constant * evaluate::cumavg_d (constant * args) {
3379 : 0 : _ARD0 (d1);
3380 [ # # ]: 0 : _DEFD ();
3381 : 0 : _RETD (d1);
3382 : : }
3383 : :
3384 : 0 : constant * evaluate::cumavg_c (constant * args) {
3385 : 0 : _ARC0 (c1);
3386 [ # # ]: 0 : _DEFC ();
3387 : 0 : _RETC (*c1);
3388 : : }
3389 : :
3390 : 0 : constant * evaluate::cumavg_v (constant * args) {
3391 : 0 : _ARV0 (v1);
3392 [ # # ]: 0 : _DEFV ();
3393 [ # # ][ # # ]: 0 : _RETV (cumavg (*v1));
3394 : : }
3395 : :
3396 : : // ******************* cumulative product *********************
3397 : 0 : constant * evaluate::cumprod_d (constant * args) {
3398 : 0 : _ARD0 (d1);
3399 [ # # ]: 0 : _DEFD ();
3400 : 0 : _RETD (d1);
3401 : : }
3402 : :
3403 : 0 : constant * evaluate::cumprod_c (constant * args) {
3404 : 0 : _ARC0 (c1);
3405 [ # # ]: 0 : _DEFC ();
3406 : 0 : _RETC (*c1);
3407 : : }
3408 : :
3409 : 0 : constant * evaluate::cumprod_v (constant * args) {
3410 : 0 : _ARV0 (v1);
3411 [ # # ]: 0 : _DEFV ();
3412 [ # # ][ # # ]: 0 : _RETV (cumprod (*v1));
3413 : : }
3414 : :
3415 : : // ******************* rms *********************
3416 : 0 : constant * evaluate::rms_d (constant * args) {
3417 : 0 : _ARD0 (d1);
3418 [ # # ]: 0 : _DEFD ();
3419 : 0 : _RETD (fabs (d1));
3420 : : }
3421 : :
3422 : 0 : constant * evaluate::rms_c (constant * args) {
3423 : 0 : _ARC0 (c1);
3424 [ # # ]: 0 : _DEFD ();
3425 : 0 : _RETD (abs (*c1));
3426 : : }
3427 : :
3428 : 0 : constant * evaluate::rms_v (constant * args) {
3429 : 0 : _ARV0 (v1);
3430 [ # # ]: 0 : _DEFD ();
3431 : 0 : _RETD (v1->rms ());
3432 : : }
3433 : :
3434 : : // ******************* variance *********************
3435 : 0 : constant * evaluate::variance_d (constant *) {
3436 [ # # ]: 0 : _DEFD ();
3437 : 0 : _RETD (0);
3438 : : }
3439 : :
3440 : 0 : constant * evaluate::variance_c (constant *) {
3441 [ # # ]: 0 : _DEFD ();
3442 : 0 : _RETD (0);
3443 : : }
3444 : :
3445 : 0 : constant * evaluate::variance_v (constant * args) {
3446 : 0 : _ARV0 (v1);
3447 [ # # ]: 0 : _DEFD ();
3448 : 0 : _RETD (v1->variance ());
3449 : : }
3450 : :
3451 : : // ******************* stddev *********************
3452 : 0 : constant * evaluate::stddev_d (constant *) {
3453 [ # # ]: 0 : _DEFD ();
3454 : 0 : _RETD (0);
3455 : : }
3456 : :
3457 : 0 : constant * evaluate::stddev_c (constant *) {
3458 [ # # ]: 0 : _DEFD ();
3459 : 0 : _RETD (0);
3460 : : }
3461 : :
3462 : 0 : constant * evaluate::stddev_v (constant * args) {
3463 : 0 : _ARV0 (v1);
3464 [ # # ]: 0 : _DEFD ();
3465 : 0 : _RETD (v1->stddev ());
3466 : : }
3467 : :
3468 : : // ********* jn (bessel function of 1st kind, nth order) ***********
3469 : 0 : constant * evaluate::jn_d_d (constant * args) {
3470 : 0 : _ARI0 (n);
3471 : 0 : _ARD1 (x);
3472 [ # # ]: 0 : _DEFD ();
3473 : 0 : _RETD (::jn (n, x));
3474 : : }
3475 : :
3476 : 0 : constant * evaluate::jn_d_c (constant * args) {
3477 : 0 : _ARI0 (n);
3478 : 0 : _ARC1 (x);
3479 [ # # ]: 0 : _DEFC ();
3480 [ # # ]: 0 : _RETC (jn (n, *x));
3481 : : }
3482 : :
3483 : 0 : constant * evaluate::jn_d_v (constant * args) {
3484 : 0 : _ARI0 (n);
3485 : 0 : _ARV1 (x);
3486 [ # # ]: 0 : _DEFV ();
3487 [ # # ][ # # ]: 0 : _RETV (jn (n, *x));
3488 : : }
3489 : :
3490 : : // ********* yn (bessel function of 2nd kind, nth order) ***********
3491 : 0 : constant * evaluate::yn_d_d (constant * args) {
3492 : 0 : _ARI0 (n);
3493 : 0 : _ARD1 (x);
3494 [ # # ]: 0 : _DEFD ();
3495 : 0 : _RETD (::yn (n, x));
3496 : : }
3497 : :
3498 : 0 : constant * evaluate::yn_d_c (constant * args) {
3499 : 0 : _ARI0 (n);
3500 : 0 : _ARC1 (x);
3501 [ # # ]: 0 : _DEFC ();
3502 [ # # ]: 0 : _RETC (yn (n, *x));
3503 : : }
3504 : :
3505 : 0 : constant * evaluate::yn_d_v (constant * args) {
3506 : 0 : _ARI0 (n);
3507 : 0 : _ARV1 (x);
3508 [ # # ]: 0 : _DEFV ();
3509 [ # # ][ # # ]: 0 : _RETV (yn (n, *x));
3510 : : }
3511 : :
3512 : : // ***************** sqr *****************
3513 : 0 : constant * evaluate::sqr_m (constant * args) {
3514 : 0 : _ARM0 (m1);
3515 [ # # ]: 0 : _DEFM ();
3516 [ # # ][ # # ]: 0 : _RETM (qucs::sqr (*m1));
3517 : : }
3518 : :
3519 : 0 : constant * evaluate::sqr_mv (constant * args) {
3520 : 0 : _ARMV0 (m1);
3521 [ # # ]: 0 : _DEFMV ();
3522 [ # # ][ # # ]: 0 : _RETMV (qucs::sqr (*m1));
3523 : : }
3524 : :
3525 : : // ******************* polar *********************
3526 : 0 : constant * evaluate::polar_d_d (constant * args) {
3527 [ # # ]: 0 : _ARD0 (a);
3528 [ # # ]: 0 : _ARD1 (p);
3529 [ # # ][ # # ]: 0 : _DEFC ();
3530 [ # # ]: 0 : _RETC (std::polar (a, rad (p)));
3531 : : }
3532 : :
3533 : 0 : constant * evaluate::polar_c_d (constant * args) {
3534 : 0 : _ARC0 (a);
3535 : 0 : _ARD1 (p);
3536 [ # # ]: 0 : _DEFC ();
3537 [ # # ][ # # ]: 0 : _RETC (qucs::polar (*a, nr_complex_t (rad (p), 0)));
3538 : : }
3539 : :
3540 : 0 : constant * evaluate::polar_d_c (constant * args) {
3541 : 0 : _ARD0 (a);
3542 : 0 : _ARC1 (p);
3543 [ # # ]: 0 : _DEFC ();
3544 [ # # ][ # # ]: 0 : _RETC (qucs::polar (nr_complex_t (a, 0), rad (*p)));
3545 : : }
3546 : :
3547 : 0 : constant * evaluate::polar_c_c (constant * args) {
3548 : 0 : _ARC0 (a);
3549 : 0 : _ARC1 (p);
3550 [ # # ]: 0 : _DEFC ();
3551 [ # # ][ # # ]: 0 : _RETC (qucs::polar (*a, rad (*p)));
3552 : : }
3553 : :
3554 : 0 : constant * evaluate::polar_d_v (constant * args) {
3555 : 0 : _ARD0 (a);
3556 : 0 : _ARV1 (v);
3557 [ # # ]: 0 : _DEFV ();
3558 [ # # ][ # # ]: 0 : _RETV (polar (nr_complex_t (a, 0), rad (*v)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3559 : : }
3560 : :
3561 : 0 : constant * evaluate::polar_c_v (constant * args) {
3562 : 0 : _ARC0 (a);
3563 : 0 : _ARV1 (v);
3564 [ # # ]: 0 : _DEFV ();
3565 [ # # ][ # # ]: 0 : _RETV (polar (*a, rad (*v)));
[ # # ][ # # ]
[ # # ][ # # ]
3566 : : }
3567 : :
3568 : 0 : constant * evaluate::polar_v_d (constant * args) {
3569 : 0 : _ARV0 (v);
3570 : 0 : _ARD1 (p);
3571 [ # # ]: 0 : _DEFV ();
3572 [ # # ][ # # ]: 0 : _RETV (polar (*v, nr_complex_t (rad (p), 0)));
3573 : : }
3574 : :
3575 : 0 : constant * evaluate::polar_v_c (constant * args) {
3576 : 0 : _ARV0 (v);
3577 : 0 : _ARC1 (p);
3578 [ # # ]: 0 : _DEFV ();
3579 [ # # ][ # # ]: 0 : _RETV (polar (*v, rad (*p)));
3580 : : }
3581 : :
3582 : 0 : constant * evaluate::polar_v_v (constant * args) {
3583 : 0 : _ARV0 (a);
3584 : 0 : _ARV1 (p);
3585 [ # # ]: 0 : _DEFV ();
3586 [ # # ][ # # ]: 0 : _RETV (polar (*a, rad (*p)));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
3587 : : }
3588 : :
3589 : : // ******************* arctan2 *********************
3590 : 0 : constant * evaluate::arctan2_d_d (constant * args) {
3591 : 0 : _ARD0 (y);
3592 : 0 : _ARD1 (x);
3593 [ # # ]: 0 : _DEFD ();
3594 [ # # ][ # # ]: 0 : if ((x == 0) && (y == 0)) {
3595 [ # # ]: 0 : THROW_MATH_EXCEPTION ("arctan2: not defined for (0,0)");
3596 : 0 : _RETD (-M_PI / 2);
3597 : : }
3598 : 0 : _RETD (std::atan2 (y, x));
3599 : : }
3600 : :
3601 : 0 : constant * evaluate::arctan2_d_v (constant * args) {
3602 : 0 : _ARD0 (y);
3603 : 0 : _ARV1 (x);
3604 [ # # ]: 0 : _DEFV ();
3605 [ # # ][ # # ]: 0 : _RETV (atan2 (y, *x));
3606 : : }
3607 : :
3608 : 0 : constant * evaluate::arctan2_v_d (constant * args) {
3609 : 0 : _ARV0 (y);
3610 : 0 : _ARD1 (x);
3611 [ # # ]: 0 : _DEFV ();
3612 [ # # ][ # # ]: 0 : _RETV (atan2 (*y, x));
3613 : : }
3614 : :
3615 : 0 : constant * evaluate::arctan2_v_v (constant * args) {
3616 : 0 : _ARV0 (y);
3617 : 0 : _ARV1 (x);
3618 [ # # ]: 0 : _DEFV ();
3619 [ # # ][ # # ]: 0 : _RETV (atan2 (*y, *x));
[ # # ][ # # ]
3620 : : }
3621 : :
3622 : : // ******************* dbm2w *********************
3623 : 0 : constant * evaluate::dbm2w_d (constant * args) {
3624 : 0 : _ARD0 (d1);
3625 [ # # ]: 0 : _DEFD ();
3626 : 0 : _RETD (0.001 * std::pow (10.0, d1 / 10.0));
3627 : : }
3628 : :
3629 : 0 : constant * evaluate::dbm2w_c (constant * args) {
3630 : 0 : _ARC0 (c1);
3631 [ # # ]: 0 : _DEFC ();
3632 [ # # ][ # # ]: 0 : _RETC (0.001 * pow (10.0, *c1 / 10.0));
3633 : : }
3634 : :
3635 : 0 : constant * evaluate::dbm2w_v (constant * args) {
3636 : 0 : _ARV0 (v1);
3637 [ # # ]: 0 : _DEFV ();
3638 [ # # ][ # # ]: 0 : _RETV (dbm2w (*v1));
3639 : : }
3640 : :
3641 : : // ******************* w2dbm *********************
3642 : 0 : constant * evaluate::w2dbm_d (constant * args) {
3643 : 0 : _ARD0 (d1);
3644 [ # # ]: 0 : _DEFD ();
3645 : 0 : _RETD (10.0 * std::log10 (d1 / 0.001));
3646 : : }
3647 : :
3648 : 0 : constant * evaluate::w2dbm_c (constant * args) {
3649 : 0 : _ARC0 (c1);
3650 [ # # ]: 0 : _DEFC ();
3651 [ # # ][ # # ]: 0 : _RETC (10.0 * log10 (*c1 / 0.001));
3652 : : }
3653 : :
3654 : 0 : constant * evaluate::w2dbm_v (constant * args) {
3655 : 0 : _ARV0 (v1);
3656 [ # # ]: 0 : _DEFV ();
3657 [ # # ][ # # ]: 0 : _RETV (w2dbm (*v1));
3658 : : }
3659 : :
3660 : : // ********** integrate *****************
3661 : 0 : constant * evaluate::integrate_d_d (constant * args) {
3662 : 0 : _ARD0 (data);
3663 : 0 : _ARD1 (incr);
3664 [ # # ]: 0 : _DEFD ();
3665 : 0 : _RETD (data * incr);
3666 : : }
3667 : :
3668 : 0 : constant * evaluate::integrate_c_c (constant * args) {
3669 : 0 : _ARC0 (data);
3670 : 0 : _ARC1 (incr);
3671 [ # # ]: 0 : _DEFC ();
3672 [ # # ]: 0 : _RETC (*data * *incr);
3673 : : }
3674 : :
3675 : 0 : constant * evaluate::integrate_v_d (constant * args) {
3676 : 0 : _ARV0 (data);
3677 : 0 : _ARD1 (incr);
3678 [ # # ]: 0 : _DEFD ();
3679 [ # # ]: 0 : _RETD (integrate (*data, incr));
3680 : : }
3681 : :
3682 : 0 : constant * evaluate::integrate_v_c (constant * args) {
3683 : 0 : _ARV0 (data);
3684 : 0 : _ARC1 (incr);
3685 [ # # ]: 0 : _DEFC ();
3686 [ # # ][ # # ]: 0 : _RETC (integrate (*data, *incr));
3687 : : }
3688 : :
3689 : : // ******************* dbm *********************
3690 : 0 : constant * evaluate::dbm_d (constant * args) {
3691 : 0 : _ARD0 (d1);
3692 [ # # ]: 0 : _DEFD ();
3693 : 0 : _RETD (10.0 * std::log10 (norm (d1) / circuit::z0 / 0.001));
3694 : : }
3695 : :
3696 : 0 : constant * evaluate::dbm_d_d (constant * args) {
3697 : 0 : _ARD0 (d1);
3698 : 0 : _ARD1 (z);
3699 [ # # ]: 0 : _DEFD ();
3700 : 0 : _RETD (10.0 * std::log10 (norm (d1) / z / 0.001));
3701 : : }
3702 : :
3703 : 0 : constant * evaluate::dbm_c (constant * args) {
3704 : 0 : _ARC0 (c1);
3705 [ # # ]: 0 : _DEFC ();
3706 : 0 : _RETC (10.0 * log10 (norm (*c1) / circuit::z0 / 0.001));
3707 : : }
3708 : :
3709 : 0 : constant * evaluate::dbm_c_d (constant * args) {
3710 : 0 : _ARC0 (c1);
3711 : 0 : _ARD1 (z);
3712 [ # # ]: 0 : _DEFC ();
3713 : 0 : _RETC (10.0 * log10 (norm (*c1) / z / 0.001));
3714 : : }
3715 : :
3716 : 0 : constant * evaluate::dbm_v (constant * args) {
3717 : 0 : _ARV0 (v1);
3718 [ # # ]: 0 : _DEFV ();
3719 [ # # ][ # # ]: 0 : _RETV (dbm (*v1));
3720 : : }
3721 : :
3722 : 0 : constant * evaluate::dbm_v_d (constant * args) {
3723 : 0 : _ARV0 (v1);
3724 : 0 : _ARD1 (z);
3725 [ # # ]: 0 : _DEFV ();
3726 [ # # ][ # # ]: 0 : _RETV (dbm (*v1, z));
3727 : : }
3728 : :
3729 : 0 : constant * evaluate::dbm_d_c (constant * args) {
3730 : 0 : _ARD0 (d1);
3731 : 0 : _ARC1 (z);
3732 [ # # ]: 0 : _DEFC ();
3733 [ # # ][ # # ]: 0 : _RETC (10.0 * log10 (norm (d1) / conj (*z) / 0.001));
[ # # ][ # # ]
3734 : : }
3735 : :
3736 : 0 : constant * evaluate::dbm_c_c (constant * args) {
3737 : 0 : _ARC0 (c1);
3738 : 0 : _ARC1 (z);
3739 [ # # ]: 0 : _DEFC ();
3740 [ # # ][ # # ]: 0 : _RETC (10.0 * log10 (norm (*c1) / conj (*z) / 0.001));
[ # # ][ # # ]
3741 : : }
3742 : :
3743 : 0 : constant * evaluate::dbm_v_c (constant * args) {
3744 : 0 : _ARV0 (v1);
3745 : 0 : _ARC1 (z);
3746 [ # # ]: 0 : _DEFV ();
3747 [ # # ][ # # ]: 0 : _RETV (dbm (*v1, *z));
3748 : : }
3749 : :
3750 : : // ************** running average ****************
3751 : 0 : constant * evaluate::runavg_d_d (constant * args) {
3752 : 0 : _ARD0 (x);
3753 : 0 : _ARI1 (n);
3754 [ # # ]: 0 : _DEFV ();
3755 [ # # ]: 0 : if (n < 1) {
3756 [ # # ]: 0 : THROW_MATH_EXCEPTION ("runavg: number n to be averaged over must be "
3757 : : "larger or equal 1");
3758 [ # # ]: 0 : __RETV ();
3759 : : }
3760 [ # # ][ # # ]: 0 : _RETV (runavg (nr_complex_t (x, 0), n));
3761 : : }
3762 : :
3763 : 0 : constant * evaluate::runavg_c_d (constant * args) {
3764 : 0 : _ARC0 (x);
3765 : 0 : _ARI1 (n);
3766 [ # # ]: 0 : _DEFV ();
3767 [ # # ]: 0 : if (n < 1) {
3768 [ # # ]: 0 : THROW_MATH_EXCEPTION ("runavg: number n to be averaged over must be "
3769 : : "larger or equal 1");
3770 [ # # ]: 0 : __RETV ();
3771 : : }
3772 [ # # ]: 0 : _RETV (runavg (*x, n));
3773 : : }
3774 : :
3775 : 0 : constant * evaluate::runavg_v_d (constant * args) {
3776 : 0 : _ARV0 (x);
3777 : 0 : _ARI1 (n);
3778 [ # # ]: 0 : _DEFV ();
3779 [ # # ][ # # ]: 0 : if (n < 1 || n > x->getSize ()) {
[ # # ]
3780 [ # # ]: 0 : THROW_MATH_EXCEPTION ("runavg: number n to be averaged over must be "
3781 : : "larger or equal 1 and less or equal than the "
3782 : : "number of vector elements");
3783 [ # # ]: 0 : __RETV ();
3784 : : }
3785 [ # # ][ # # ]: 0 : _RETV (runavg (*x, n));
3786 : : }
3787 : :
3788 : : // ********************* thermal voltage **********************
3789 : 0 : constant * evaluate::vt_d (constant * args) {
3790 : 0 : _ARD0 (d1);
3791 [ # # ]: 0 : _DEFD ();
3792 : 0 : _RETD (d1 * kBoverQ);
3793 : : }
3794 : :
3795 : 0 : constant * evaluate::vt_c (constant * args) {
3796 : 0 : _ARC0 (c1);
3797 [ # # ]: 0 : _DEFC ();
3798 [ # # ]: 0 : _RETC (*c1 * kBoverQ);
3799 : : }
3800 : :
3801 : 0 : constant * evaluate::vt_v (constant * args) {
3802 : 0 : _ARV0 (v1);
3803 [ # # ]: 0 : _DEFV ();
3804 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
3805 [ # # ][ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) v->add (v1->get (i) * kBoverQ);
[ # # ]
3806 : 0 : res->v = v;
3807 : 0 : return res;
3808 : : }
3809 : :
3810 : : // ************** Kaiser-Bessel derived window ****************
3811 : 0 : constant * evaluate::kbd_d_d (constant * args) {
3812 [ # # ]: 0 : _ARD0 (alpha);
3813 [ # # ]: 0 : _ARI1 (size);
3814 [ # # ][ # # ]: 0 : _DEFV ();
3815 : : int i;
3816 : 0 : nr_double_t sval = 0.0;
3817 [ # # ]: 0 : if (size <= 0) {
3818 [ # # ][ # # ]: 0 : THROW_MATH_EXCEPTION ("kbd: vector length must be greater than zero");
[ # # ][ # # ]
3819 [ # # ][ # # ]: 0 : __RETV ();
3820 : : }
3821 [ # # ]: 0 : qucs::vector v (size);
3822 [ # # ]: 0 : for (i = 0; i < size / 2; i++) {
3823 [ # # ][ # # ]: 0 : sval += fspecial::i0 (M_PI * alpha * std::sqrt (1.0 - sqr (4.0 * i / size - 1.0)));
3824 : 0 : v (i) = sval;
3825 : : }
3826 : : // need to add one more value to the normalization factor at size/2
3827 [ # # ][ # # ]: 0 : sval += fspecial::i0 (M_PI * alpha * std::sqrt (1.0 - sqr (4.0 * (size / 2) / size - 1.0)));
3828 : : // normalize the window and fill in the righthand side of the window
3829 [ # # ]: 0 : for (i = 0; i < size / 2; i++) {
3830 : 0 : v (i) = std::sqrt (v (i) / sval);
3831 : 0 : v (size - 1 - i) = v (i);
3832 : : }
3833 [ # # ][ # # ]: 0 : _RETV (v);
[ # # ]
3834 : : }
3835 : :
3836 : 0 : constant * evaluate::kbd_d (constant * args) {
3837 [ # # ]: 0 : constant * arg = new constant (TAG_DOUBLE);
3838 : 0 : arg->d = 64;
3839 : 0 : arg->solvee = args->getResult(0)->solvee;
3840 : 0 : arg->evaluate ();
3841 : 0 : args->append (arg);
3842 : 0 : return kbd_d_d (args);
3843 : : }
3844 : :
3845 : : // ***************** if-then-else operation ****************
3846 : 0 : constant * evaluate::ifthenelse_d_d (constant * args) {
3847 : 0 : _ARB0 (cond);
3848 : 0 : _ARD1 (d1);
3849 : 0 : _ARD2 (d2);
3850 [ # # ]: 0 : _DEFD ();
3851 [ # # ]: 0 : _RETD (cond ? d1 : d2);
3852 : : }
3853 : :
3854 : 0 : constant * evaluate::ifthenelse_b_b (constant * args) {
3855 : 0 : _ARB0 (cond);
3856 : 0 : _ARB1 (b1);
3857 : 0 : _ARB2 (b2);
3858 [ # # ]: 0 : _DEFB ();
3859 [ # # ]: 0 : _RETB (cond ? b1 : b2);
3860 : : }
3861 : :
3862 : 0 : constant * evaluate::ifthenelse_d_b (constant * args) {
3863 : 0 : _ARB0 (cond);
3864 : 0 : _ARD1 (d1);
3865 : 0 : _ARB2 (b2);
3866 [ # # ]: 0 : _DEFD ();
3867 [ # # ][ # # ]: 0 : _RETD (cond ? d1 : (b2 ? 1.0 : 0.0));
3868 : : }
3869 : :
3870 : 0 : constant * evaluate::ifthenelse_b_d (constant * args) {
3871 : 0 : _ARB0 (cond);
3872 : 0 : _ARB1 (b1);
3873 : 0 : _ARD2 (d2);
3874 [ # # ]: 0 : _DEFD ();
3875 [ # # ][ # # ]: 0 : _RETD (cond ? (b1 ? 1.0 : 0.0) : d2);
3876 : : }
3877 : :
3878 : 0 : constant * evaluate::ifthenelse_c_c (constant * args) {
3879 [ # # ]: 0 : _ARB0 (cond);
3880 [ # # ]: 0 : int t1 = _ARG(1)->getType ();
3881 [ # # ]: 0 : int t2 = _ARG(2)->getType ();
3882 : 0 : nr_complex_t c1, c2;
3883 [ # # ]: 0 : if (t1 == TAG_DOUBLE)
3884 [ # # ]: 0 : c1 = D(_ARES(1));
3885 [ # # ]: 0 : else if (t1 == TAG_COMPLEX)
3886 [ # # ]: 0 : c1 = *C(_ARES(1));
3887 : : else
3888 [ # # ][ # # ]: 0 : c1 = B(_ARES(1)) ? 1.0 : 0.0;
3889 [ # # ]: 0 : if (t2 == TAG_DOUBLE)
3890 [ # # ]: 0 : c2 = D(_ARES(2));
3891 [ # # ]: 0 : else if (t2 == TAG_COMPLEX)
3892 [ # # ]: 0 : c2 = *C(_ARES(2));
3893 : : else
3894 [ # # ][ # # ]: 0 : c2 = B(_ARES(2)) ? 1.0 : 0.0;
3895 [ # # ][ # # ]: 0 : _DEFC ();
3896 [ # # ][ # # ]: 0 : _RETC (cond ? c1 : c2);
3897 : : }
3898 : :
3899 : 0 : constant * evaluate::ifthenelse_m_m (constant * args) {
3900 [ # # ]: 0 : _ARB0 (cond);
3901 [ # # ]: 0 : int t1 = _ARG(1)->getType ();
3902 [ # # ]: 0 : int t2 = _ARG(2)->getType ();
3903 [ # # ][ # # ]: 0 : matrix m1, m2;
3904 [ # # # # : 0 : switch (t1) {
# ]
3905 : : case TAG_DOUBLE:
3906 [ # # ][ # # ]: 0 : m1 = matrix (1); m1 (1,1) = D(_ARES(1)); break;
[ # # ][ # # ]
3907 : : case TAG_COMPLEX:
3908 [ # # ][ # # ]: 0 : m1 = matrix (1); m1 (1,1) = *C(_ARES(1)); break;
[ # # ][ # # ]
3909 : : case TAG_BOOLEAN:
3910 [ # # ][ # # ]: 0 : m1 = matrix (1); m1 (1,1) = B(_ARES(1)) ? 1.0 : 0.0; break;
[ # # ][ # # ]
[ # # ]
3911 : : case TAG_MATRIX:
3912 [ # # ][ # # ]: 0 : m1 = *M(_ARES(1)); break;
3913 : : }
3914 [ # # # # : 0 : switch (t2) {
# ]
3915 : : case TAG_DOUBLE:
3916 [ # # ][ # # ]: 0 : m2 = matrix (1); m2 (0,0) = D(_ARES(2)); break;
[ # # ][ # # ]
3917 : : case TAG_COMPLEX:
3918 [ # # ][ # # ]: 0 : m2 = matrix (1); m2 (0,0) = *C(_ARES(2)); break;
[ # # ][ # # ]
3919 : : case TAG_BOOLEAN:
3920 [ # # ][ # # ]: 0 : m2 = matrix (1); m2 (0,0) = B(_ARES(2)) ? 1.0 : 0.0; break;
[ # # ][ # # ]
[ # # ]
3921 : : case TAG_MATRIX:
3922 [ # # ][ # # ]: 0 : m2 = *M(_ARES(2)); break;
3923 : : }
3924 [ # # ][ # # ]: 0 : _DEFM ();
3925 [ # # ][ # # ]: 0 : _RETM (cond ? m1 : m2);
[ # # ][ # # ]
[ # # ]
3926 : : }
3927 : :
3928 : 0 : constant * evaluate::ifthenelse_v_v (constant * args) {
3929 [ # # ]: 0 : _ARB0 (cond);
3930 [ # # ]: 0 : int t1 = _ARG(1)->getType ();
3931 [ # # ]: 0 : int t2 = _ARG(2)->getType ();
3932 [ # # ][ # # ]: 0 : qucs::vector v1, v2;
3933 [ # # # # : 0 : switch (t1) {
# ]
3934 : : case TAG_DOUBLE:
3935 [ # # ][ # # ]: 0 : v1 = qucs::vector (1); v1 (0) = D(_ARES(1)); break;
[ # # ][ # # ]
3936 : : case TAG_COMPLEX:
3937 [ # # ][ # # ]: 0 : v1 = qucs::vector (1); v1 (0) = *C(_ARES(1)); break;
[ # # ][ # # ]
3938 : : case TAG_BOOLEAN:
3939 [ # # ][ # # ]: 0 : v1 = qucs::vector (1); v1 (0) = B(_ARES(1)) ? 1.0 : 0.0; break;
[ # # ][ # # ]
[ # # ]
3940 : : case TAG_VECTOR:
3941 [ # # ][ # # ]: 0 : v1 = *V(_ARES(1)); break;
3942 : : }
3943 [ # # # # : 0 : switch (t2) {
# ]
3944 : : case TAG_DOUBLE:
3945 [ # # ][ # # ]: 0 : v2 = qucs::vector (1); v2 (0) = D(_ARES(2)); break;
[ # # ][ # # ]
3946 : : case TAG_COMPLEX:
3947 [ # # ][ # # ]: 0 : v2 = qucs::vector (1); v2 (0) = *C(_ARES(2)); break;
[ # # ][ # # ]
3948 : : case TAG_BOOLEAN:
3949 [ # # ][ # # ]: 0 : v2 = qucs::vector (1); v2 (0) = B(_ARES(2)) ? 1.0 : 0.0; break;
[ # # ][ # # ]
[ # # ]
3950 : : case TAG_VECTOR:
3951 [ # # ][ # # ]: 0 : v2 = *V(_ARES(2)); break;
3952 : : }
3953 [ # # ][ # # ]: 0 : _DEFV ();
3954 [ # # ][ # # ]: 0 : _RETV (cond ? v1 : v2);
[ # # ][ # # ]
[ # # ]
3955 : : }
3956 : :
3957 : 0 : constant * evaluate::ifthenelse_v_v_v (constant * args) {
3958 [ # # ]: 0 : _ARV0 (cond);
3959 [ # # ]: 0 : int t1 = _ARG(1)->getType ();
3960 [ # # ]: 0 : int t2 = _ARG(2)->getType ();
3961 [ # # ][ # # ]: 0 : qucs::vector v1, v2;
3962 [ # # # # : 0 : switch (t1) {
# ]
3963 : : case TAG_DOUBLE:
3964 [ # # ][ # # ]: 0 : v1 = qucs::vector (1); v1 (0) = D(_ARES(1)); break;
[ # # ][ # # ]
3965 : : case TAG_COMPLEX:
3966 [ # # ][ # # ]: 0 : v1 = qucs::vector (1); v1 (0) = *C(_ARES(1)); break;
[ # # ][ # # ]
3967 : : case TAG_BOOLEAN:
3968 [ # # ][ # # ]: 0 : v1 = qucs::vector (1); v1 (0) = B(_ARES(1)) ? 1.0 : 0.0; break;
[ # # ][ # # ]
[ # # ]
3969 : : case TAG_VECTOR:
3970 [ # # ][ # # ]: 0 : v1 = *V(_ARES(1)); break;
3971 : : }
3972 [ # # # # : 0 : switch (t2) {
# ]
3973 : : case TAG_DOUBLE:
3974 [ # # ][ # # ]: 0 : v2 = qucs::vector (1); v2 (0) = D(_ARES(2)); break;
[ # # ][ # # ]
3975 : : case TAG_COMPLEX:
3976 [ # # ][ # # ]: 0 : v2 = qucs::vector (1); v2 (0) = *C(_ARES(2)); break;
[ # # ][ # # ]
3977 : : case TAG_BOOLEAN:
3978 [ # # ][ # # ]: 0 : v2 = qucs::vector (1); v2 (0) = B(_ARES(2)) ? 1.0 : 0.0; break;
[ # # ][ # # ]
[ # # ]
3979 : : case TAG_VECTOR:
3980 [ # # ][ # # ]: 0 : v2 = *V(_ARES(2)); break;
3981 : : }
3982 [ # # ][ # # ]: 0 : _DEFV ();
3983 : : int i, a, b;
3984 [ # # ][ # # ]: 0 : qucs::vector * v = new qucs::vector ();
3985 [ # # ][ # # ]: 0 : for (a = b = i = 0; i < cond->getSize (); i++) {
3986 [ # # ][ # # ]: 0 : v->add (cond->get (i) != 0.0 ? v1 (a) : v2 (b));
[ # # ]
3987 : 0 : a++;
3988 : 0 : b++;
3989 [ # # ][ # # ]: 0 : if (a >= v1.getSize ()) a = 0;
3990 [ # # ][ # # ]: 0 : if (b >= v2.getSize ()) b = 0;
3991 : : }
3992 : 0 : res->v = v;
3993 [ # # ][ # # ]: 0 : return res;
3994 : : }
3995 : :
3996 : : // ************************** less *************************
3997 : 0 : constant * evaluate::less_d_d (constant * args) {
3998 : 0 : _ARD0 (d0);
3999 : 0 : _ARD1 (d1);
4000 [ # # ]: 0 : _DEFB ();
4001 : 0 : _RETB (d0 < d1);
4002 : : }
4003 : :
4004 : 0 : constant * evaluate::less_d_c (constant * args) {
4005 : 0 : _ARD0 (d0);
4006 : 0 : _ARC1 (c1);
4007 [ # # ]: 0 : _DEFB ();
4008 [ # # ]: 0 : _RETB (d0 < *c1);
4009 : : }
4010 : :
4011 : 0 : constant * evaluate::less_d_v (constant * args) {
4012 : 0 : _ARD0 (d0);
4013 : 0 : _ARV1 (v1);
4014 [ # # ]: 0 : _DEFV ();
4015 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4016 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4017 [ # # ][ # # ]: 0 : v->add (d0 < v1->get (i) ? 1.0 : 0.0);
[ # # ]
4018 : : }
4019 : 0 : res->v = v;
4020 : 0 : return res;
4021 : : }
4022 : :
4023 : 0 : constant * evaluate::less_c_d (constant * args) {
4024 : 0 : _ARC0 (c0);
4025 : 0 : _ARD1 (d1);
4026 [ # # ]: 0 : _DEFB ();
4027 [ # # ]: 0 : _RETB (*c0 < d1);
4028 : : }
4029 : :
4030 : 0 : constant * evaluate::less_c_c (constant * args) {
4031 : 0 : _ARC0 (c0);
4032 : 0 : _ARC1 (c1);
4033 [ # # ]: 0 : _DEFB ();
4034 : 0 : _RETB (*c0 < *c1);
4035 : : }
4036 : :
4037 : 0 : constant * evaluate::less_c_v (constant * args) {
4038 : 0 : _ARC0 (c0);
4039 : 0 : _ARV1 (v1);
4040 [ # # ]: 0 : _DEFV ();
4041 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4042 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4043 [ # # ][ # # ]: 0 : v->add (*c0 < v1->get (i) ? 1.0 : 0.0);
4044 : : }
4045 : 0 : res->v = v;
4046 : 0 : return res;
4047 : : }
4048 : :
4049 : 21 : constant * evaluate::less_v_d (constant * args) {
4050 : 21 : _ARV0 (v0);
4051 : 21 : _ARD1 (d1);
4052 [ + - ]: 21 : _DEFV ();
4053 [ + - ]: 21 : qucs::vector * v = new qucs::vector ();
4054 [ + + ]: 36363 : for (int i = 0; i < v0->getSize (); i++) {
4055 [ + - ][ + - ]: 36342 : v->add (real (v0->get (i)) < d1 ? 1.0 : 0.0);
4056 : : }
4057 : 21 : res->v = v;
4058 : 21 : return res;
4059 : : }
4060 : :
4061 : 0 : constant * evaluate::less_v_c (constant * args) {
4062 : 0 : _ARV0 (v0);
4063 : 0 : _ARC1 (c1);
4064 [ # # ]: 0 : _DEFV ();
4065 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4066 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4067 [ # # ][ # # ]: 0 : v->add (v0->get (i) < *c1 ? 1.0 : 0.0);
4068 : : }
4069 : 0 : res->v = v;
4070 : 0 : return res;
4071 : : }
4072 : :
4073 : 0 : constant * evaluate::less_v_v (constant * args) {
4074 : 0 : _ARV0 (v0);
4075 : 0 : _ARV1 (v1);
4076 [ # # ]: 0 : _DEFV ();
4077 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4078 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4079 [ # # ][ # # ]: 0 : v->add (v0->get (i) < v1->get (i) ? 1.0 : 0.0);
4080 : : }
4081 : 0 : res->v = v;
4082 : 0 : return res;
4083 : : }
4084 : :
4085 : : // ************************* greater ***********************
4086 : 0 : constant * evaluate::greater_d_d (constant * args) {
4087 : 0 : _ARD0 (d0);
4088 : 0 : _ARD1 (d1);
4089 [ # # ]: 0 : _DEFB ();
4090 : 0 : _RETB (d0 > d1);
4091 : : }
4092 : :
4093 : 0 : constant * evaluate::greater_d_c (constant * args) {
4094 : 0 : _ARD0 (d0);
4095 : 0 : _ARC1 (c1);
4096 [ # # ]: 0 : _DEFB ();
4097 [ # # ]: 0 : _RETB (d0 > *c1);
4098 : : }
4099 : :
4100 : 0 : constant * evaluate::greater_d_v (constant * args) {
4101 : 0 : _ARD0 (d0);
4102 : 0 : _ARV1 (v1);
4103 [ # # ]: 0 : _DEFV ();
4104 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4105 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4106 [ # # ][ # # ]: 0 : v->add (d0 > real (v1->get (i)) ? 1.0 : 0.0);
4107 : : }
4108 : 0 : res->v = v;
4109 : 0 : return res;
4110 : : }
4111 : :
4112 : 0 : constant * evaluate::greater_c_d (constant * args) {
4113 : 0 : _ARC0 (c0);
4114 : 0 : _ARD1 (d1);
4115 [ # # ]: 0 : _DEFB ();
4116 [ # # ]: 0 : _RETB (*c0 > d1);
4117 : : }
4118 : :
4119 : 0 : constant * evaluate::greater_c_c (constant * args) {
4120 : 0 : _ARC0 (c0);
4121 : 0 : _ARC1 (c1);
4122 [ # # ]: 0 : _DEFB ();
4123 : 0 : _RETB (*c0 > *c1);
4124 : : }
4125 : :
4126 : 0 : constant * evaluate::greater_c_v (constant * args) {
4127 : 0 : _ARC0 (c0);
4128 : 0 : _ARV1 (v1);
4129 [ # # ]: 0 : _DEFV ();
4130 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4131 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4132 [ # # ][ # # ]: 0 : v->add (*c0 > v1->get (i) ? 1.0 : 0.0);
4133 : : }
4134 : 0 : res->v = v;
4135 : 0 : return res;
4136 : : }
4137 : :
4138 : 0 : constant * evaluate::greater_v_d (constant * args) {
4139 : 0 : _ARV0 (v0);
4140 : 0 : _ARD1 (d1);
4141 [ # # ]: 0 : _DEFV ();
4142 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4143 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4144 [ # # ][ # # ]: 0 : v->add (real (v0->get (i)) > d1 ? 1.0 : 0.0);
4145 : : }
4146 : 0 : res->v = v;
4147 : 0 : return res;
4148 : : }
4149 : :
4150 : 0 : constant * evaluate::greater_v_c (constant * args) {
4151 : 0 : _ARV0 (v0);
4152 : 0 : _ARC1 (c1);
4153 [ # # ]: 0 : _DEFV ();
4154 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4155 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4156 [ # # ][ # # ]: 0 : v->add (v0->get (i) > *c1 ? 1.0 : 0.0);
4157 : : }
4158 : 0 : res->v = v;
4159 : 0 : return res;
4160 : : }
4161 : :
4162 : 0 : constant * evaluate::greater_v_v (constant * args) {
4163 : 0 : _ARV0 (v0);
4164 : 0 : _ARV1 (v1);
4165 [ # # ]: 0 : _DEFV ();
4166 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4167 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4168 [ # # ][ # # ]: 0 : v->add (v0->get (i) > v1->get (i) ? 1.0 : 0.0);
4169 : : }
4170 : 0 : res->v = v;
4171 : 0 : return res;
4172 : : }
4173 : :
4174 : : // ********************** less or equal ********************
4175 : 0 : constant * evaluate::lessorequal_d_d (constant * args) {
4176 : 0 : _ARD0 (d0);
4177 : 0 : _ARD1 (d1);
4178 [ # # ]: 0 : _DEFB ();
4179 : 0 : _RETB (d0 <= d1);
4180 : : }
4181 : :
4182 : 0 : constant * evaluate::lessorequal_d_c (constant * args) {
4183 : 0 : _ARD0 (d0);
4184 : 0 : _ARC1 (c1);
4185 [ # # ]: 0 : _DEFB ();
4186 [ # # ]: 0 : _RETB (d0 <= *c1);
4187 : : }
4188 : :
4189 : 0 : constant * evaluate::lessorequal_d_v (constant * args) {
4190 : 0 : _ARD0 (d0);
4191 : 0 : _ARV1 (v1);
4192 [ # # ]: 0 : _DEFV ();
4193 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4194 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4195 [ # # ][ # # ]: 0 : v->add (d0 <= real (v1->get (i)) ? 1.0 : 0.0);
4196 : : }
4197 : 0 : res->v = v;
4198 : 0 : return res;
4199 : : }
4200 : :
4201 : 0 : constant * evaluate::lessorequal_c_d (constant * args) {
4202 : 0 : _ARC0 (c0);
4203 : 0 : _ARD1 (d1);
4204 [ # # ]: 0 : _DEFB ();
4205 [ # # ]: 0 : _RETB (*c0 <= d1);
4206 : : }
4207 : :
4208 : 0 : constant * evaluate::lessorequal_c_c (constant * args) {
4209 : 0 : _ARC0 (c0);
4210 : 0 : _ARC1 (c1);
4211 [ # # ]: 0 : _DEFB ();
4212 : 0 : _RETB (*c0 <= *c1);
4213 : : }
4214 : :
4215 : 0 : constant * evaluate::lessorequal_c_v (constant * args) {
4216 : 0 : _ARC0 (c0);
4217 : 0 : _ARV1 (v1);
4218 [ # # ]: 0 : _DEFV ();
4219 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4220 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4221 [ # # ][ # # ]: 0 : v->add (*c0 <= v1->get (i) ? 1.0 : 0.0);
4222 : : }
4223 : 0 : res->v = v;
4224 : 0 : return res;
4225 : : }
4226 : :
4227 : 0 : constant * evaluate::lessorequal_v_d (constant * args) {
4228 : 0 : _ARV0 (v0);
4229 : 0 : _ARD1 (d1);
4230 [ # # ]: 0 : _DEFV ();
4231 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4232 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4233 [ # # ][ # # ]: 0 : v->add (real (v0->get (i)) <= d1 ? 1.0 : 0.0);
4234 : : }
4235 : 0 : res->v = v;
4236 : 0 : return res;
4237 : : }
4238 : :
4239 : 0 : constant * evaluate::lessorequal_v_c (constant * args) {
4240 : 0 : _ARV0 (v0);
4241 : 0 : _ARC1 (c1);
4242 [ # # ]: 0 : _DEFV ();
4243 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4244 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4245 [ # # ][ # # ]: 0 : v->add (v0->get (i) <= *c1 ? 1.0 : 0.0);
4246 : : }
4247 : 0 : res->v = v;
4248 : 0 : return res;
4249 : : }
4250 : :
4251 : 0 : constant * evaluate::lessorequal_v_v (constant * args) {
4252 : 0 : _ARV0 (v0);
4253 : 0 : _ARV1 (v1);
4254 [ # # ]: 0 : _DEFV ();
4255 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4256 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4257 [ # # ][ # # ]: 0 : v->add (v0->get (i) <= v1->get (i) ? 1.0 : 0.0);
4258 : : }
4259 : 0 : res->v = v;
4260 : 0 : return res;
4261 : : }
4262 : :
4263 : : // ********************* greater or equal ******************
4264 : 0 : constant * evaluate::greaterorequal_d_d (constant * args) {
4265 : 0 : _ARD0 (d0);
4266 : 0 : _ARD1 (d1);
4267 [ # # ]: 0 : _DEFB ();
4268 : 0 : _RETB (d0 >= d1);
4269 : : }
4270 : :
4271 : 0 : constant * evaluate::greaterorequal_d_c (constant * args) {
4272 : 0 : _ARD0 (d0);
4273 : 0 : _ARC1 (c1);
4274 [ # # ]: 0 : _DEFB ();
4275 [ # # ]: 0 : _RETB (d0 >= *c1);
4276 : : }
4277 : :
4278 : 0 : constant * evaluate::greaterorequal_d_v (constant * args) {
4279 : 0 : _ARD0 (d0);
4280 : 0 : _ARV1 (v1);
4281 [ # # ]: 0 : _DEFV ();
4282 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4283 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4284 [ # # ][ # # ]: 0 : v->add (d0 >= real (v1->get (i)) ? 1.0 : 0.0);
4285 : : }
4286 : 0 : res->v = v;
4287 : 0 : return res;
4288 : : }
4289 : :
4290 : 0 : constant * evaluate::greaterorequal_c_d (constant * args) {
4291 : 0 : _ARC0 (c0);
4292 : 0 : _ARD1 (d1);
4293 [ # # ]: 0 : _DEFB ();
4294 [ # # ]: 0 : _RETB (*c0 >= d1);
4295 : : }
4296 : :
4297 : 0 : constant * evaluate::greaterorequal_c_c (constant * args) {
4298 : 0 : _ARC0 (c0);
4299 : 0 : _ARC1 (c1);
4300 [ # # ]: 0 : _DEFB ();
4301 : 0 : _RETB (*c0 >= *c1);
4302 : : }
4303 : :
4304 : 0 : constant * evaluate::greaterorequal_c_v (constant * args) {
4305 : 0 : _ARC0 (c0);
4306 : 0 : _ARV1 (v1);
4307 [ # # ]: 0 : _DEFV ();
4308 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4309 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4310 [ # # ][ # # ]: 0 : v->add (*c0 >= v1->get (i) ? 1.0 : 0.0);
4311 : : }
4312 : 0 : res->v = v;
4313 : 0 : return res;
4314 : : }
4315 : :
4316 : 0 : constant * evaluate::greaterorequal_v_d (constant * args) {
4317 : 0 : _ARV0 (v0);
4318 : 0 : _ARD1 (d1);
4319 [ # # ]: 0 : _DEFV ();
4320 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4321 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4322 [ # # ][ # # ]: 0 : v->add (real (v0->get (i)) >= d1 ? 1.0 : 0.0);
4323 : : }
4324 : 0 : res->v = v;
4325 : 0 : return res;
4326 : : }
4327 : :
4328 : 0 : constant * evaluate::greaterorequal_v_c (constant * args) {
4329 : 0 : _ARV0 (v0);
4330 : 0 : _ARC1 (c1);
4331 [ # # ]: 0 : _DEFV ();
4332 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4333 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4334 [ # # ][ # # ]: 0 : v->add (v0->get (i) >= *c1 ? 1.0 : 0.0);
4335 : : }
4336 : 0 : res->v = v;
4337 : 0 : return res;
4338 : : }
4339 : :
4340 : 0 : constant * evaluate::greaterorequal_v_v (constant * args) {
4341 : 0 : _ARV0 (v0);
4342 : 0 : _ARV1 (v1);
4343 [ # # ]: 0 : _DEFV ();
4344 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4345 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4346 [ # # ][ # # ]: 0 : v->add (v0->get (i) >= v1->get (i) ? 1.0 : 0.0);
4347 : : }
4348 : 0 : res->v = v;
4349 : 0 : return res;
4350 : : }
4351 : :
4352 : : // ************************** equal ************************
4353 : 0 : constant * evaluate::equal_d_d (constant * args) {
4354 : 0 : _ARD0 (d0);
4355 : 0 : _ARD1 (d1);
4356 [ # # ]: 0 : _DEFB ();
4357 : 0 : _RETB (d0 == d1);
4358 : : }
4359 : :
4360 : 0 : constant * evaluate::equal_d_c (constant * args) {
4361 [ # # ]: 0 : _ARD0 (d0);
4362 [ # # ]: 0 : _ARC1 (c1);
4363 [ # # ][ # # ]: 0 : _DEFB ();
4364 : 0 : _RETB (d0 == *c1);
4365 : : }
4366 : :
4367 : 0 : constant * evaluate::equal_d_v (constant * args) {
4368 : 0 : _ARD0 (d0);
4369 : 0 : _ARV1 (v1);
4370 [ # # ]: 0 : _DEFV ();
4371 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4372 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4373 [ # # ][ # # ]: 0 : v->add (d0 == real (v1->get (i)) ? 1.0 : 0.0);
4374 : : }
4375 : 0 : res->v = v;
4376 : 0 : return res;
4377 : : }
4378 : :
4379 : 0 : constant * evaluate::equal_c_d (constant * args) {
4380 [ # # ]: 0 : _ARC0 (c0);
4381 [ # # ]: 0 : _ARD1 (d1);
4382 [ # # ][ # # ]: 0 : _DEFB ();
4383 : 0 : _RETB (*c0 == d1);
4384 : : }
4385 : :
4386 : 0 : constant * evaluate::equal_c_c (constant * args) {
4387 : 0 : _ARC0 (c0);
4388 : 0 : _ARC1 (c1);
4389 [ # # ]: 0 : _DEFB ();
4390 : 0 : _RETB (*c0 == *c1);
4391 : : }
4392 : :
4393 : 0 : constant * evaluate::equal_c_v (constant * args) {
4394 : 0 : _ARC0 (c0);
4395 : 0 : _ARV1 (v1);
4396 [ # # ]: 0 : _DEFV ();
4397 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4398 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4399 [ # # ][ # # ]: 0 : v->add (*c0 == v1->get (i) ? 1.0 : 0.0);
4400 : : }
4401 : 0 : res->v = v;
4402 : 0 : return res;
4403 : : }
4404 : :
4405 : 0 : constant * evaluate::equal_v_d (constant * args) {
4406 : 0 : _ARV0 (v0);
4407 : 0 : _ARD1 (d1);
4408 [ # # ]: 0 : _DEFV ();
4409 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4410 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4411 [ # # ][ # # ]: 0 : v->add (real (v0->get (i)) == d1 ? 1.0 : 0.0);
4412 : : }
4413 : 0 : res->v = v;
4414 : 0 : return res;
4415 : : }
4416 : :
4417 : 0 : constant * evaluate::equal_v_c (constant * args) {
4418 : 0 : _ARV0 (v0);
4419 : 0 : _ARC1 (c1);
4420 [ # # ]: 0 : _DEFV ();
4421 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4422 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4423 [ # # ][ # # ]: 0 : v->add (v0->get (i) == *c1 ? 1.0 : 0.0);
4424 : : }
4425 : 0 : res->v = v;
4426 : 0 : return res;
4427 : : }
4428 : :
4429 : 0 : constant * evaluate::equal_v_v (constant * args) {
4430 : 0 : _ARV0 (v0);
4431 : 0 : _ARV1 (v1);
4432 [ # # ]: 0 : _DEFV ();
4433 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4434 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4435 [ # # ][ # # ]: 0 : v->add (v0->get (i) == v1->get (i) ? 1.0 : 0.0);
4436 : : }
4437 : 0 : res->v = v;
4438 : 0 : return res;
4439 : : }
4440 : :
4441 : 0 : constant * evaluate::equal_b_b (constant * args) {
4442 : 0 : _ARB0 (b0);
4443 : 0 : _ARB1 (b1);
4444 [ # # ]: 0 : _DEFB ();
4445 : 0 : _RETB (b0 == b1);
4446 : : }
4447 : :
4448 : : // ************************ not equal **********************
4449 : 0 : constant * evaluate::notequal_d_d (constant * args) {
4450 : 0 : _ARD0 (d0);
4451 : 0 : _ARD1 (d1);
4452 [ # # ]: 0 : _DEFB ();
4453 : 0 : _RETB (d0 != d1);
4454 : : }
4455 : :
4456 : 0 : constant * evaluate::notequal_d_c (constant * args) {
4457 [ # # ]: 0 : _ARD0 (d0);
4458 [ # # ]: 0 : _ARC1 (c1);
4459 [ # # ][ # # ]: 0 : _DEFB ();
4460 : 0 : _RETB (d0 != *c1);
4461 : : }
4462 : :
4463 : 0 : constant * evaluate::notequal_d_v (constant * args) {
4464 : 0 : _ARD0 (d0);
4465 : 0 : _ARV1 (v1);
4466 [ # # ]: 0 : _DEFV ();
4467 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4468 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4469 [ # # ][ # # ]: 0 : v->add (d0 != real (v1->get (i)) ? 1.0 : 0.0);
4470 : : }
4471 : 0 : res->v = v;
4472 : 0 : return res;
4473 : : }
4474 : :
4475 : 0 : constant * evaluate::notequal_c_d (constant * args) {
4476 [ # # ]: 0 : _ARC0 (c0);
4477 [ # # ]: 0 : _ARD1 (d1);
4478 [ # # ][ # # ]: 0 : _DEFB ();
4479 : 0 : _RETB (*c0 != d1);
4480 : : }
4481 : :
4482 : 0 : constant * evaluate::notequal_c_c (constant * args) {
4483 : 0 : _ARC0 (c0);
4484 : 0 : _ARC1 (c1);
4485 [ # # ]: 0 : _DEFB ();
4486 : 0 : _RETB (*c0 != *c1);
4487 : : }
4488 : :
4489 : 0 : constant * evaluate::notequal_c_v (constant * args) {
4490 : 0 : _ARC0 (c0);
4491 : 0 : _ARV1 (v1);
4492 [ # # ]: 0 : _DEFV ();
4493 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4494 [ # # ]: 0 : for (int i = 0; i < v1->getSize (); i++) {
4495 [ # # ][ # # ]: 0 : v->add (*c0 != v1->get (i) ? 1.0 : 0.0);
4496 : : }
4497 : 0 : res->v = v;
4498 : 0 : return res;
4499 : : }
4500 : :
4501 : 0 : constant * evaluate::notequal_v_d (constant * args) {
4502 : 0 : _ARV0 (v0);
4503 : 0 : _ARD1 (d1);
4504 [ # # ]: 0 : _DEFV ();
4505 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4506 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4507 [ # # ][ # # ]: 0 : v->add (real (v0->get (i)) != d1 ? 1.0 : 0.0);
4508 : : }
4509 : 0 : res->v = v;
4510 : 0 : return res;
4511 : : }
4512 : :
4513 : 0 : constant * evaluate::notequal_v_c (constant * args) {
4514 : 0 : _ARV0 (v0);
4515 : 0 : _ARC1 (c1);
4516 [ # # ]: 0 : _DEFV ();
4517 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4518 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4519 [ # # ][ # # ]: 0 : v->add (v0->get (i) != *c1 ? 1.0 : 0.0);
4520 : : }
4521 : 0 : res->v = v;
4522 : 0 : return res;
4523 : : }
4524 : :
4525 : 0 : constant * evaluate::notequal_v_v (constant * args) {
4526 : 0 : _ARV0 (v0);
4527 : 0 : _ARV1 (v1);
4528 [ # # ]: 0 : _DEFV ();
4529 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4530 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4531 [ # # ][ # # ]: 0 : v->add (v0->get (i) != v1->get (i) ? 1.0 : 0.0);
4532 : : }
4533 : 0 : res->v = v;
4534 : 0 : return res;
4535 : : }
4536 : :
4537 : 0 : constant * evaluate::notequal_b_b (constant * args) {
4538 : 0 : _ARB0 (b0);
4539 : 0 : _ARB1 (b1);
4540 [ # # ]: 0 : _DEFB ();
4541 : 0 : _RETB (b0 != b1);
4542 : : }
4543 : :
4544 : : // *************************** not *************************
4545 : 0 : constant * evaluate::not_b (constant * args) {
4546 : 0 : _ARB0 (b0);
4547 [ # # ]: 0 : _DEFB ();
4548 : 0 : _RETB (!b0);
4549 : : }
4550 : :
4551 : : // *************************** or **************************
4552 : 0 : constant * evaluate::or_b_b (constant * args) {
4553 : 0 : _ARB0 (b0);
4554 : 0 : _ARB1 (b1);
4555 [ # # ]: 0 : _DEFB ();
4556 [ # # ][ # # ]: 0 : _RETB (b0 || b1);
4557 : : }
4558 : :
4559 : : // ************************** and **************************
4560 : 0 : constant * evaluate::and_b_b (constant * args) {
4561 : 0 : _ARB0 (b0);
4562 : 0 : _ARB1 (b1);
4563 [ # # ]: 0 : _DEFB ();
4564 [ # # ][ # # ]: 0 : _RETB (b0 && b1);
4565 : : }
4566 : :
4567 : : // ******************* random numbers **********************
4568 : 0 : constant * evaluate::rand (constant *) {
4569 [ # # ]: 0 : _DEFD ();
4570 : 0 : _RETD (((nr_double_t) ::rand ()) / (nr_double_t) RAND_MAX);
4571 : : }
4572 : :
4573 : 0 : constant * evaluate::srand_d (constant * args) {
4574 : : static int done = 0;
4575 : 0 : _ARD0 (d0);
4576 [ # # ]: 0 : _DEFD ();
4577 [ # # ]: 0 : if (!done) {
4578 : 0 : unsigned int i0 = (unsigned int) d0;
4579 : 0 : ::srand (i0);
4580 : 0 : done = 1;
4581 : 0 : _RETD (1.0);
4582 : : } else {
4583 : 0 : _RETD (0.0);
4584 : : }
4585 : : }
4586 : :
4587 : :
4588 : : // ******************* assert test *************************
4589 : 0 : constant * evaluate::assert_b(constant *args)
4590 : : {
4591 : 0 : _ARB0(b0);
4592 [ # # ]: 0 : if(!b0) {
4593 [ # # ]: 0 : THROW_MATH_EXCEPTION ("assert failled");
4594 : 0 : abort();
4595 : : }
4596 [ # # ]: 0 : _DEFB ();
4597 : 0 : _RETB(true);
4598 : : }
4599 : :
4600 : :
4601 : 0 : constant * evaluate::assert_d(constant *args)
4602 : : {
4603 : 0 : _ARD0(d0);
4604 [ # # ]: 0 : if(d0 == 0.0) {
4605 [ # # ]: 0 : THROW_MATH_EXCEPTION ("assert failled");
4606 : 0 : abort();
4607 : : }
4608 [ # # ]: 0 : _DEFB ();
4609 : 0 : _RETB(true);
4610 : : }
4611 : :
4612 : :
4613 : 21 : constant * evaluate::assert_v (constant * args) {
4614 : 21 : _ARV0 (v0);
4615 [ + + ]: 36363 : for (int i = 0; i < v0->getSize (); i++) {
4616 [ + - ][ - + ]: 36342 : if( v0->get(i) == 0.0 ) {
4617 [ # # ]: 0 : THROW_MATH_EXCEPTION ("assert failled");
4618 : 0 : abort();
4619 : : }
4620 : : }
4621 [ + - ]: 21 : _DEFB ();
4622 : 21 : _RETB(true);
4623 : : }
4624 : :
4625 : :
4626 : 0 : constant * evaluate::bugon_b(constant *args)
4627 : : {
4628 : 0 : _ARB0(b0);
4629 [ # # ]: 0 : if(b0) {
4630 [ # # ]: 0 : THROW_MATH_EXCEPTION ("bugon failled");
4631 : 0 : abort();
4632 : : }
4633 [ # # ]: 0 : _DEFB ();
4634 : 0 : _RETB(true);
4635 : : }
4636 : :
4637 : :
4638 : 0 : constant * evaluate::bugon_d(constant *args)
4639 : : {
4640 : 0 : _ARD0(d0);
4641 [ # # ]: 0 : if(d0 != 0.0) {
4642 [ # # ]: 0 : THROW_MATH_EXCEPTION ("bugon failled");
4643 : 0 : abort();
4644 : : }
4645 [ # # ]: 0 : _DEFB ();
4646 : 0 : _RETB(true);
4647 : : }
4648 : :
4649 : :
4650 : 0 : constant * evaluate::bugon_v (constant * args) {
4651 : 0 : _ARV0 (v0);
4652 [ # # ]: 0 : for (int i = 0; i < v0->getSize (); i++) {
4653 [ # # ][ # # ]: 0 : if( v0->get(i) != 0.0 ) {
4654 [ # # ]: 0 : THROW_MATH_EXCEPTION ("bugon failled");
4655 : 0 : abort();
4656 : : }
4657 : : }
4658 [ # # ]: 0 : _DEFB ();
4659 : 0 : _RETB(true);
4660 : : }
4661 : :
4662 : :
4663 : : // ******************* immediate vectors *******************
4664 : 0 : constant * evaluate::vector_x (constant * args) {
4665 [ # # ]: 0 : _DEFV ();
4666 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4667 [ # # ]: 0 : for (node * arg = args; arg != NULL; arg = arg->getNext ()) {
4668 : 0 : constant * c = arg->getResult ();
4669 [ # # # # : 0 : switch (arg->getType ()) {
# ]
4670 : : case TAG_COMPLEX:
4671 : 0 : v->add (*(c->c)); break;
4672 : : case TAG_DOUBLE:
4673 [ # # ]: 0 : v->add (c->d); break;
4674 : : case TAG_BOOLEAN:
4675 [ # # ][ # # ]: 0 : v->add (c->b ? 1.0 : 0.0); break;
4676 : : case TAG_VECTOR:
4677 : 0 : v->add (c->v); break;
4678 : : default:
4679 [ # # ]: 0 : v->add (0.0); break;
4680 : : }
4681 : : }
4682 : 0 : res->v = v;
4683 : 0 : return res;
4684 : : }
4685 : :
4686 : : // ******************* immediate matrices ******************
4687 : 0 : constant * evaluate::matrix_x (constant * args) {
4688 [ # # ]: 0 : _DEFM ();
4689 : : /* create temporary list of vectors */
4690 : 0 : qucs::vector * va = NULL;
4691 [ # # ]: 0 : qucs::vector * v = new qucs::vector ();
4692 : 0 : va = v;
4693 [ # # ]: 0 : for (node * arg = args; arg != NULL; arg = arg->getNext ()) {
4694 : 0 : constant * c = arg->getResult ();
4695 [ # # # # : 0 : switch (arg->getType ()) {
# # ]
4696 : : case TAG_COMPLEX:
4697 : 0 : v->add (*(c->c)); break;
4698 : : case TAG_DOUBLE:
4699 [ # # ]: 0 : v->add (c->d); break;
4700 : : case TAG_BOOLEAN:
4701 [ # # ][ # # ]: 0 : v->add (c->b ? 1.0 : 0.0); break;
4702 : : case TAG_VECTOR:
4703 : 0 : v->add (c->v); break;
4704 : : case TAG_CHAR:
4705 [ # # ]: 0 : if (c->chr == ';') {
4706 : : /* append new vector, i.e. a new matrix row */
4707 [ # # ]: 0 : qucs::vector * vn = new qucs::vector ();
4708 : 0 : v->setNext (vn);
4709 : 0 : v = vn;
4710 : : }
4711 [ # # ]: 0 : else v->add (0.0);
4712 : 0 : break;
4713 : : default:
4714 [ # # ]: 0 : v->add (0.0); break;
4715 : : }
4716 : : }
4717 : : /* determine matrix dimensions and create it */
4718 : : int r, c;
4719 [ # # ]: 0 : for (r = 0, c = 0, v = va; v != NULL; v = (::vector *) v->getNext (), r++) {
4720 [ # # ]: 0 : if (c < v->getSize ()) c = v->getSize ();
4721 : : }
4722 [ # # ]: 0 : matrix * m = new matrix (r, c);
4723 : : /* fill in matrix entries and delete temporary vector list */
4724 : 0 : qucs::vector * vn = NULL;
4725 [ # # ]: 0 : for (r = 0, v = va; v != NULL; v = vn, r++) {
4726 [ # # ]: 0 : for (c = 0; c < v->getSize (); c++) {
4727 : 0 : m->set (r, c, v->get (c));
4728 : : }
4729 : 0 : vn = (::vector *) v->getNext ();
4730 [ # # ]: 0 : delete v;
4731 : : }
4732 : : /* return result matrix */
4733 : 0 : res->m = m;
4734 : 0 : return res;
4735 : : }
4736 : :
4737 : : // ********************** EMI receiver *********************
4738 : 0 : constant * evaluate::receiver_v_v (constant * args) {
4739 : 0 : _ARV0 (da);
4740 : 0 : _ARV1 (dt);
4741 [ # # ]: 0 : _DEFV ();
4742 : :
4743 : : // run receiver functionality
4744 : : qucs::vector * ed;
4745 [ # # ]: 0 : if (_ARG(2)) {
4746 : 0 : _ARI2 (len);
4747 : 0 : ed = emi::receiver (da, dt, len);
4748 : : }
4749 : : else {
4750 : 0 : ed = emi::receiver (da, dt);
4751 : : }
4752 : :
4753 : : // create two vectors for spectrum and frequency
4754 : 0 : int rlen = ed->getSize ();
4755 [ # # ]: 0 : qucs::vector * rvec = new qucs::vector (rlen);
4756 [ # # ]: 0 : qucs::vector * rfeq = new qucs::vector (rlen);
4757 [ # # ]: 0 : for (int i = 0; i < rlen; i++) {
4758 : 0 : (*rvec)(i) = real (ed->get (i));
4759 : 0 : (*rfeq)(i) = imag (ed->get (i));
4760 : : }
4761 [ # # ]: 0 : delete ed;
4762 : :
4763 : : // put results back into equation solver
4764 : 0 : node * gen = SOLVEE(0)->addGeneratedEquation (rfeq, "Frequency");
4765 : 0 : res->addPrepDependencies (A(gen)->result);
4766 : 0 : res->dropdeps = 1;
4767 : 0 : res->v = rvec;
4768 : 0 : return res;
4769 : : }
4770 : :
4771 : : // Include the application array.
4772 : : #include "applications.h"
4773 : :
|
