Branch data Line data Source code
1 : : /*
2 : : * sweep.cpp - variable sweep class implementation
3 : : *
4 : : * Copyright (C) 2004, 2005, 2008 Stefan Jahn <stefan@lkcc.org>
5 : : *
6 : : * This is free software; you can redistribute it and/or modify
7 : : * it under the terms of the GNU General Public License as published by
8 : : * the Free Software Foundation; either version 2, or (at your option)
9 : : * any later version.
10 : : *
11 : : * This software is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : * GNU General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU General Public License
17 : : * along with this package; see the file COPYING. If not, write to
18 : : * the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
19 : : * Boston, MA 02110-1301, USA.
20 : : *
21 : : * $Id$
22 : : *
23 : : */
24 : :
25 : : #if HAVE_CONFIG_H
26 : : # include <config.h>
27 : : #endif
28 : :
29 : : #include <stdio.h>
30 : : #include <stdlib.h>
31 : : #include <string.h>
32 : : #include <cmath>
33 : : #include <assert.h>
34 : :
35 : : #include "object.h"
36 : : #include "complex.h"
37 : : #include "vector.h"
38 : : #include "sweep.h"
39 : :
40 : : namespace qucs {
41 : :
42 : : // Constructor creates an unnamed instance of the sweep class.
43 : 0 : sweep::sweep () : object () {
44 : 0 : type = SWEEP_UNKNOWN;
45 : 0 : data = NULL;
46 : 0 : size = 0;
47 : 0 : txt = NULL;
48 : 0 : counter = 0;
49 : 0 : }
50 : :
51 : : // Constructor creates a named instance of the sweep class.
52 : 160 : sweep::sweep (const char * n) : object (n) {
53 : 160 : type = SWEEP_UNKNOWN;
54 : 160 : data = NULL;
55 : 160 : size = 0;
56 : 160 : txt = NULL;
57 : 160 : counter = 0;
58 : 160 : }
59 : :
60 : : // Destructor deletes the sweep class object.
61 : 160 : sweep::~sweep () {
62 [ # # ][ + - ]: 160 : if (data) free (data);
63 [ # # ][ - + ]: 160 : if (txt) free (txt);
64 [ # # ][ - + ]: 160 : }
65 : :
66 : : /* The copy constructor creates a new instance of the sweep class
67 : : based on the given sweep object. */
68 : 0 : sweep::sweep (sweep & s) : object (s) {
69 : 0 : type = s.type;
70 : 0 : size = s.size;
71 : 0 : counter = s.counter;
72 : 0 : data = (nr_double_t *) malloc (sizeof (nr_double_t) * size);
73 [ # # # # ]: 0 : if (s.data)
74 : 0 : memcpy (data, s.data, sizeof (nr_double_t) * size);
75 : : else
76 : 0 : memset (data, 0, sizeof (nr_double_t) * size);
77 : 0 : }
78 : :
79 : : // The function returns the value at the given position.
80 : 59 : nr_double_t sweep::get (int idx) {
81 [ + - ][ + - ]: 59 : assert (idx >= 0 && idx < size && data != NULL);
[ - + ][ - + ]
82 : 59 : return data[idx];
83 : : }
84 : :
85 : : // The function sets the given value at the given position.
86 : 66645 : void sweep::set (int idx, nr_double_t val) {
87 [ + - ][ + - ]: 66645 : assert (idx >= 0 && idx < size && data != NULL);
[ - + ][ - + ]
88 : 66645 : data[idx] = val;
89 : 66645 : }
90 : :
91 : : /* This function modifies the current size of the sweep. If the the
92 : : new number of points is larger than the current one it zeroes the
93 : : new elements. */
94 : 160 : void sweep::setSize (int points) {
95 [ - + ]: 160 : assert (points > 0);
96 [ - + ]: 160 : if (data != NULL) {
97 : 0 : data = (nr_double_t *) realloc (data, sizeof (nr_double_t) * points);
98 [ # # ]: 0 : if (points > size)
99 : 0 : memset (&data[size], 0, sizeof (nr_double_t) * (points - size));
100 : : }
101 : : else {
102 : 160 : data = (nr_double_t *) malloc (sizeof (nr_double_t) * points);
103 : 160 : memset (data, 0, sizeof (nr_double_t) * points);
104 : : }
105 : 160 : size = points;
106 : 160 : counter = 0;
107 : 160 : }
108 : :
109 : : // The function creates a string representation of the sweep definition.
110 : 0 : char * sweep::toString (void) {
111 [ # # ]: 0 : if (txt) free (txt);
112 [ # # ][ # # ]: 0 : if (data == NULL || size == 0) return (char *) "";
113 : 0 : int len = 3 + size - 1;
114 : 0 : txt = (char *) malloc (len);
115 : 0 : strcpy (txt, "[");
116 [ # # ]: 0 : for (int i = 0; i < size; i++) {
117 : : static char str[256]; // enough for a real number
118 : 0 : sprintf (str, "%g", (double) get (i));
119 : 0 : txt = (char *) realloc (txt, len += strlen (str));
120 : 0 : strcat (txt, str);
121 [ # # ]: 0 : if (i != size - 1) strcat (txt, ";");
122 : : }
123 : 0 : strcat (txt, "]");
124 : 0 : return txt;
125 : : }
126 : :
127 : : /* The following function reverses the values order inside the sweep
128 : : definition. */
129 : 0 : void sweep::reverse (void) {
130 [ # # ][ # # ]: 0 : if (data != NULL && size > 0) {
131 : 0 : nr_double_t * buf = (nr_double_t *) malloc (sizeof (nr_double_t) * size);
132 [ # # ]: 0 : for (int i = 0; i < size; i++) buf[i] = data[size - 1 - i];
133 : 0 : free (data);
134 : 0 : data = buf;
135 : : }
136 : 0 : }
137 : :
138 : : /* The function returns the current sweep value and afterwards steps
139 : : one value forward. It wraps around at the end of sweep. */
140 : 78302 : nr_double_t sweep::next (void) {
141 : 78302 : nr_double_t res = data[counter];
142 [ + + ]: 78302 : if (++counter >= size) counter = 0;
143 [ - + ]: 78302 : if (size == 1)
144 : 0 : return parent->getPropertyDouble ("Values");
145 : 78302 : return res;
146 : : }
147 : :
148 : : /* This function returns the sweep value before the current value and
149 : : thereby steps one value back. It wraps around at the beginning of
150 : : the sweep. */
151 : 0 : nr_double_t sweep::prev (void) {
152 [ # # ]: 0 : if (--counter < 0) counter = size - 1;
153 : 0 : return data[counter];
154 : : }
155 : :
156 : : // Constructor creates an unnamed instance of the linsweep class.
157 : 0 : linsweep::linsweep () : sweep () {
158 : 0 : type = SWEEP_LINEAR;
159 : 0 : }
160 : :
161 : : // Constructor creates a named instance of the linsweep class.
162 : 131 : linsweep::linsweep (const char * n) : sweep (n) {
163 : 131 : type = SWEEP_LINEAR;
164 : 131 : }
165 : :
166 : : /* This function creates a linear stepped vector of values starting at
167 : : the given start value, ending with the given stop value and
168 : : containing points elements. */
169 : 131 : void linsweep::create (nr_double_t start, nr_double_t stop, int points) {
170 [ + - ]: 131 : vector v = linspace (start, stop, points);
171 [ + - ]: 131 : setSize (points);
172 [ + - ][ + - ]: 59355 : for (int i = 0; i < points; i++) set (i, real (v.get (i)));
[ + + ][ + - ]
173 : 131 : }
174 : :
175 : : // Destructor deletes the linsweep class object.
176 : 131 : linsweep::~linsweep () {
177 [ - + ][ # # ]: 262 : }
178 : :
179 : : // Constructor creates an unnamed instance of the logsweep class.
180 : 0 : logsweep::logsweep () : sweep () {
181 : 0 : type = SWEEP_LOGARITHMIC;
182 : 0 : }
183 : :
184 : : // Constructor creates a named instance of the logsweep class.
185 : 25 : logsweep::logsweep (const char * n) : sweep (n) {
186 : 25 : type = SWEEP_LOGARITHMIC;
187 : 25 : }
188 : :
189 : : /* This function creates a logarithmic stepped vector of values
190 : : starting at the given start value, ending with the given stop value
191 : : and containing points elements. */
192 : 25 : void logsweep::create (nr_double_t start, nr_double_t stop, int points) {
193 [ + - ]: 25 : vector v = logspace (start, stop, points);
194 [ + - ]: 25 : setSize (points);
195 [ + - ][ + - ]: 7430 : for (int i = 0; i < points; i++) set (i, real (v.get (i)));
[ + + ][ + - ]
196 : 25 : }
197 : :
198 : : // Destructor deletes the logsweep class object.
199 : 25 : logsweep::~logsweep () {
200 [ - + ][ # # ]: 50 : }
201 : :
202 : : // Constructor creates an unnamed instance of the consweep class.
203 : 0 : consweep::consweep () : sweep () {
204 : 0 : type = SWEEP_CONSTANT;
205 : 0 : }
206 : :
207 : : // Constructor creates a named instance of the consweep class.
208 : 0 : consweep::consweep (const char * n) : sweep (n) {
209 : 0 : type = SWEEP_CONSTANT;
210 : 0 : }
211 : :
212 : : /* This function creates a constant value in a sweep containing one
213 : : element only. */
214 : 0 : void consweep::create (nr_double_t val) {
215 : 0 : setSize (1);
216 : 0 : set (0, val);
217 : 0 : }
218 : :
219 : : // Destructor deletes the consweep class object.
220 : 0 : consweep::~consweep () {
221 [ # # ][ # # ]: 0 : }
222 : :
223 : : // Constructor creates an unnamed instance of the lstsweep class.
224 : 0 : lstsweep::lstsweep () : sweep () {
225 : 0 : type = SWEEP_LIST;
226 : 0 : }
227 : :
228 : : // Constructor creates a named instance of the lstsweep class.
229 : 4 : lstsweep::lstsweep (const char * n) : sweep (n) {
230 : 4 : type = SWEEP_LIST;
231 : 4 : }
232 : :
233 : : /* This function creates arbitrary values in a sweep containing points
234 : : elements. The actual values must be assigned using the set()
235 : : function. */
236 : 4 : void lstsweep::create (int points) {
237 : 4 : setSize (points);
238 : 4 : }
239 : :
240 : : // Destructor deletes the lstsweep class object.
241 : 4 : lstsweep::~lstsweep () {
242 [ - + ][ # # ]: 8 : }
243 : :
244 : : } // namespace qucs
|
