LCOV - code coverage report
Current view: top level - src - vector.h (source / functions) Hit Total Coverage
Test: qucs-core-0.0.19 Code Coverage Lines: 3 3 100.0 %
Date: 2015-01-05 16:01:02 Functions: 3 3 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * vector.h - vector class definitions
       3                 :            :  *
       4                 :            :  * Copyright (C) 2003, 2004, 2005, 2006, 2007 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                 :            : #ifndef __VECTOR_H__
      27                 :            : #define __VECTOR_H__
      28                 :            : 
      29                 :            : #include <limits>
      30                 :            : 
      31                 :            : #include "consts.h"
      32                 :            : #include "precision.h"
      33                 :            : #include "complex.h"
      34                 :            : 
      35                 :            : #ifdef log2
      36                 :            : #undef log2
      37                 :            : #endif
      38                 :            : 
      39                 :            : namespace qucs {
      40                 :            : 
      41                 :            : class strlist;
      42                 :            : class vector;
      43                 :            : 
      44                 :            : qucs::vector linspace (nr_double_t, nr_double_t, int);
      45                 :            : qucs::vector logspace (nr_double_t, nr_double_t, int);
      46                 :            : qucs::vector runavg (qucs::vector, const int);
      47                 :            : qucs::vector runavg (const nr_complex_t, const int);
      48                 :            : 
      49                 :            : class vector : public object
      50                 :            : {
      51                 :            :  public:
      52                 :            :   vector ();
      53                 :            :   vector (const char *);
      54                 :            :   vector (int);
      55                 :            :   vector (int, nr_complex_t);
      56                 :            :   vector (const char *, int);
      57                 :            :   vector (const vector &);
      58                 :            :   const vector& operator = (const vector &);
      59                 :            :   ~vector ();
      60                 :            :   void add (nr_complex_t);
      61                 :            :   void add (vector *);
      62                 :            :   nr_complex_t get (int);
      63                 :            :   void set (nr_double_t, int);
      64                 :            :   void set (const nr_complex_t, int);
      65                 :            :   int getSize (void) const;
      66                 :            :   int checkSizes (vector, vector);
      67                 :       2436 :   int getRequested (void) { return requested; }
      68                 :       1310 :   void setRequested (int n) { requested = n; }
      69                 :            :   void reverse (void);
      70                 :            :   strlist * getDependencies (void);
      71                 :            :   void setDependencies (strlist *);
      72                 :            :   void setOrigin (char *);
      73                 :            :   char * getOrigin (void);
      74                 :            :   int contains (nr_complex_t, nr_double_t eps = std::numeric_limits<nr_double_t>::epsilon());
      75                 :            :   void sort (bool ascending = true);
      76                 :            :   void print (void);
      77                 :            : 
      78                 :            :   nr_double_t maximum  (void);
      79                 :            :   nr_double_t minimum  (void);
      80                 :            :   nr_double_t rms      (void);
      81                 :            :   nr_double_t variance (void);
      82                 :            :   nr_double_t stddev   (void);
      83                 :            : 
      84                 :            :   friend nr_complex_t sum     (vector);
      85                 :            :   friend nr_complex_t prod    (vector);
      86                 :            :   friend nr_complex_t avg     (vector);
      87                 :            :   friend vector  cumsum  (vector);
      88                 :            :   friend vector  cumprod (vector);
      89                 :            :   friend vector  cumavg  (vector);
      90                 :            :   friend vector  dbm     (vector, const nr_complex_t);
      91                 :            :   friend nr_complex_t integrate (vector v, const nr_complex_t);
      92                 :            :   friend nr_double_t integrate (vector v, const nr_double_t);
      93                 :            : 
      94                 :            :   // vector manipulations
      95                 :            :   friend vector real   (vector);  // the real part
      96                 :            :   friend vector imag   (vector);  // the imaginary part
      97                 :            :   friend vector conj   (vector);  // the complex conjugate
      98                 :            :   friend vector norm   (vector);  // the square of the magnitude
      99                 :            :   friend vector arg    (vector);  // the angle in the plane
     100                 :            :   friend vector dB     (vector);
     101                 :            :   friend vector log    (vector);
     102                 :            :   friend vector log2   (vector);
     103                 :            :   friend vector pow    (vector, const nr_complex_t);
     104                 :            :   friend vector pow    (vector, const nr_double_t);
     105                 :            :   friend vector pow    (const nr_complex_t, vector);
     106                 :            :   friend vector pow    (const nr_double_t, vector);
     107                 :            :   friend vector pow    (vector, vector);
     108                 :            :   friend vector ztor   (vector, nr_complex_t);
     109                 :            :   friend vector rtoz   (vector, nr_complex_t);
     110                 :            :   friend vector ytor   (vector, nr_complex_t);
     111                 :            :   friend vector rtoy   (vector, nr_complex_t);
     112                 :            :   friend vector diff   (vector, vector, int);
     113                 :            :   friend vector unwrap (vector, nr_double_t, nr_double_t);
     114                 :            : 
     115                 :            :   friend vector polar   (vector, const nr_complex_t);
     116                 :            :   friend vector polar   (const nr_complex_t, vector);
     117                 :            :   friend vector polar   (vector, vector);
     118                 :            :   friend vector atan2   (vector, const nr_double_t);
     119                 :            :   friend vector atan2   (const nr_double_t, vector);
     120                 :            :   friend vector atan2   (vector, vector);
     121                 :            :   friend vector dbm2w   (vector);
     122                 :            :   friend vector w2dbm   (vector);
     123                 :            :   friend vector xhypot  (vector, vector);
     124                 :            :   friend vector xhypot  (vector, const nr_complex_t);
     125                 :            :   friend vector xhypot  (vector, const nr_double_t);
     126                 :            :   friend vector xhypot  (const nr_complex_t, vector);
     127                 :            :   friend vector xhypot  (const nr_double_t, vector);
     128                 :            : 
     129                 :            :   // overloaded math functions
     130                 :            :   friend vector abs     (vector);
     131                 :            :   friend vector log10   (vector);
     132                 :            :   friend vector exp     (vector);
     133                 :            :   friend vector limexp  (vector);
     134                 :            :   friend vector sqrt    (vector);
     135                 :            :   friend vector sin     (vector);
     136                 :            :   friend vector asin    (vector);
     137                 :            :   friend vector cos     (vector);
     138                 :            :   friend vector acos    (vector);
     139                 :            :   friend vector tan     (vector);
     140                 :            :   friend vector atan    (vector);
     141                 :            :   friend vector cot     (vector);
     142                 :            :   friend vector acot    (vector);
     143                 :            :   friend vector sinh    (vector);
     144                 :            :   friend vector asinh   (vector);
     145                 :            :   friend vector cosh    (vector);
     146                 :            :   friend vector sech    (vector);
     147                 :            :   friend vector cosech  (vector);
     148                 :            :   friend vector acosh   (vector);
     149                 :            :   friend vector asech   (vector);
     150                 :            :   friend vector tanh    (vector);
     151                 :            :   friend vector atanh   (vector);
     152                 :            :   friend vector coth    (vector);
     153                 :            :   friend vector acoth   (vector);
     154                 :            :   friend vector signum  (vector);
     155                 :            :   friend vector sign    (vector);
     156                 :            :   friend vector sinc    (vector);
     157                 :            :   friend vector ceil    (vector);
     158                 :            :   friend vector floor   (vector);
     159                 :            :   friend vector fix     (vector);
     160                 :            :   friend vector round   (vector);
     161                 :            :   friend vector sqr     (vector);
     162                 :            :   friend vector step    (vector);
     163                 :            :   friend vector jn      (const int, vector);
     164                 :            :   friend vector yn      (const int, vector);
     165                 :            :   friend vector i0      (vector);
     166                 :            :   friend vector erf     (vector);
     167                 :            :   friend vector erfc    (vector);
     168                 :            :   friend vector erfinv  (vector);
     169                 :            :   friend vector erfcinv (vector);
     170                 :            : 
     171                 :            :   // operator functions
     172                 :            :   friend vector operator + (vector, vector);
     173                 :            :   friend vector operator + (vector, const nr_complex_t);
     174                 :            :   friend vector operator + (vector, const nr_double_t);
     175                 :            :   friend vector operator + (const nr_complex_t, vector);
     176                 :            :   friend vector operator + (const nr_double_t, vector);
     177                 :            :   friend vector operator - (vector, vector);
     178                 :            :   friend vector operator - (vector, const nr_complex_t);
     179                 :            :   friend vector operator - (vector, const nr_double_t);
     180                 :            :   friend vector operator - (const nr_complex_t, vector);
     181                 :            :   friend vector operator - (const nr_double_t, vector);
     182                 :            :   friend vector operator * (vector, vector);
     183                 :            :   friend vector operator * (vector, const nr_complex_t);
     184                 :            :   friend vector operator * (vector, const nr_double_t);
     185                 :            :   friend vector operator * (const nr_complex_t, vector);
     186                 :            :   friend vector operator * (const nr_double_t, vector);
     187                 :            :   friend vector operator / (vector, vector);
     188                 :            :   friend vector operator / (vector, const nr_complex_t);
     189                 :            :   friend vector operator / (vector, const nr_double_t);
     190                 :            :   friend vector operator / (const nr_complex_t, vector);
     191                 :            :   friend vector operator / (const nr_double_t, vector);
     192                 :            :   friend vector operator % (vector, vector);
     193                 :            :   friend vector operator % (vector, const nr_complex_t);
     194                 :            :   friend vector operator % (vector, const nr_double_t);
     195                 :            :   friend vector operator % (const nr_complex_t, vector);
     196                 :            :   friend vector operator % (const nr_double_t, vector);
     197                 :            : 
     198                 :            :   // comparisons
     199                 :            :   //  friend int      operator == (const vector *, const vector *);
     200                 :            :   //  friend int      operator != (const vector *, const vector *);
     201                 :            : 
     202                 :            :   // assignment operations
     203                 :            :   vector operator  - ();
     204                 :            :   vector operator  = (const nr_complex_t);
     205                 :            :   vector operator  = (const nr_double_t);
     206                 :            :   vector operator += (vector);
     207                 :            :   vector operator += (const nr_complex_t);
     208                 :            :   vector operator += (const nr_double_t);
     209                 :            :   vector operator -= (vector);
     210                 :            :   vector operator -= (const nr_complex_t);
     211                 :            :   vector operator -= (const nr_double_t);
     212                 :            :   vector operator *= (vector);
     213                 :            :   vector operator *= (const nr_complex_t);
     214                 :            :   vector operator *= (const nr_double_t);
     215                 :            :   vector operator /= (vector);
     216                 :            :   vector operator /= (const nr_complex_t);
     217                 :            :   vector operator /= (const nr_double_t);
     218                 :            : 
     219                 :            :   // easy accessor operators
     220                 :            :   nr_complex_t  operator () (int i) const { return data[i]; }
     221                 :     326490 :   nr_complex_t& operator () (int i) { return data[i]; }
     222                 :            : 
     223                 :            :  private:
     224                 :            :   int requested;
     225                 :            :   int size;
     226                 :            :   int capacity;
     227                 :            :   strlist * dependencies;
     228                 :            :   nr_complex_t * data;
     229                 :            :   char * origin;
     230                 :            : };
     231                 :            : 
     232                 :            : /* declarations of friend functions to make them available in the
     233                 :            :    qucs namespace without argument-dependent lookup, see
     234                 :            : 
     235                 :            :    http://stackoverflow.com/questions/7785886/access-friend-function-defined-in-class
     236                 :            : 
     237                 :            :    for more info
     238                 :            : */
     239                 :            : nr_complex_t sum     (vector);
     240                 :            : nr_complex_t prod    (vector);
     241                 :            : nr_complex_t avg     (vector);
     242                 :            : vector  cumsum  (vector);
     243                 :            : vector  cumprod (vector);
     244                 :            : vector  cumavg  (vector);
     245                 :            : vector  dbm     (vector, const nr_complex_t z = 50.0);
     246                 :            : nr_complex_t integrate (vector v, const nr_complex_t);
     247                 :            : nr_double_t integrate (vector v, const nr_double_t);
     248                 :            : vector real   (vector);  // the real part
     249                 :            : vector imag   (vector);  // the imaginary part
     250                 :            : vector conj   (vector);  // the complex conjugate
     251                 :            : vector norm   (vector);  // the square of the magnitude
     252                 :            : vector arg    (vector);  // the angle in the plane
     253                 :            : vector dB     (vector);
     254                 :            : vector log    (vector);
     255                 :            : vector log2   (vector);
     256                 :            : vector pow    (vector, const nr_complex_t);
     257                 :            : vector pow    (vector, const nr_double_t);
     258                 :            : vector pow    (const nr_complex_t, vector);
     259                 :            : vector pow    (const nr_double_t, vector);
     260                 :            : vector pow    (vector, vector);
     261                 :            : vector ztor   (vector, nr_complex_t zref = 50.0);
     262                 :            : vector rtoz   (vector, nr_complex_t zref = 50.0);
     263                 :            : vector ytor   (vector, nr_complex_t zref = 50.0);
     264                 :            : vector rtoy   (vector, nr_complex_t zref = 50.0);
     265                 :            : vector diff   (vector, vector, int n = 1);
     266                 :            : vector unwrap (vector, nr_double_t tol = M_PI, nr_double_t step = 2 * M_PI);
     267                 :            : vector polar   (vector, const nr_complex_t);
     268                 :            : vector polar   (const nr_complex_t, vector);
     269                 :            : vector polar   (vector, vector);
     270                 :            : vector atan2   (vector, const nr_double_t);
     271                 :            : vector atan2   (const nr_double_t, vector);
     272                 :            : vector atan2   (vector, vector);
     273                 :            : vector dbm2w   (vector);
     274                 :            : vector w2dbm   (vector);
     275                 :            : vector xhypot  (vector, vector);
     276                 :            : vector xhypot  (vector, const nr_complex_t);
     277                 :            : vector xhypot  (vector, const nr_double_t);
     278                 :            : vector xhypot  (const nr_complex_t, vector);
     279                 :            : vector xhypot  (const nr_double_t, vector);
     280                 :            : vector abs     (vector);
     281                 :            : vector log10   (vector);
     282                 :            : vector exp     (vector);
     283                 :            : vector limexp  (vector);
     284                 :            : vector sqrt    (vector);
     285                 :            : vector sin     (vector);
     286                 :            : vector asin    (vector);
     287                 :            : vector cos     (vector);
     288                 :            : vector acos    (vector);
     289                 :            : vector tan     (vector);
     290                 :            : vector atan    (vector);
     291                 :            : vector cot     (vector);
     292                 :            : vector acot    (vector);
     293                 :            : vector sinh    (vector);
     294                 :            : vector asinh   (vector);
     295                 :            : vector cosh    (vector);
     296                 :            : vector sech    (vector);
     297                 :            : vector cosech  (vector);
     298                 :            : vector acosh   (vector);
     299                 :            : vector asech   (vector);
     300                 :            : vector tanh    (vector);
     301                 :            : vector atanh   (vector);
     302                 :            : vector coth    (vector);
     303                 :            : vector acoth   (vector);
     304                 :            : vector signum  (vector);
     305                 :            : vector sign    (vector);
     306                 :            : vector sinc    (vector);
     307                 :            : vector ceil    (vector);
     308                 :            : vector floor   (vector);
     309                 :            : vector fix     (vector);
     310                 :            : vector round   (vector);
     311                 :            : vector sqr     (vector);
     312                 :            : vector step    (vector);
     313                 :            : vector jn      (const int, vector);
     314                 :            : vector yn      (const int, vector);
     315                 :            : vector i0      (vector);
     316                 :            : vector erf     (vector);
     317                 :            : vector erfc    (vector);
     318                 :            : vector erfinv  (vector);
     319                 :            : vector erfcinv (vector);
     320                 :            : 
     321                 :            : } // namespace qucs
     322                 :            : 
     323                 :            : #endif /* __VECTOR_H__ */

Generated by: LCOV version 1.11