libStatGen Software 1
Loading...
Searching...
No Matches
MathVector.h
1/*
2 * Copyright (C) 2010 Regents of the University of Michigan
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18#ifndef __MATHVECTOR_H__
19#define __MATHVECTOR_H__
20
21#include "StringBasics.h"
22
23#include <stdio.h>
24#include <assert.h>
25
26class Matrix;
27
28class Vector
29{
30public:
31 int dim, size;
32 double * data;
33 String label;
34
35 Vector()
36 {
37 Init();
38 }
39 Vector(Vector & v)
40 {
41 Init();
42 Copy(v);
43 }
44 Vector(int d)
45 {
46 Init();
47 Dimension(d);
48 }
49 Vector(const char * text)
50 {
51 Init();
52 label = text;
53 }
54 Vector(const char * text, int d)
55 {
56 Init();
57 label = text;
58 Dimension(d);
59 }
60 Vector(const char * text, Vector & v)
61 {
62 Init();
63 label = text;
64 Copy(v);
65 }
66
67 ~Vector();
68
69 void Dimension(int d);
70 void Dimension(int d, double value);
71
72 void GrowTo(int d)
73 {
74 Dimension(d > dim ? d : dim);
75 }
76 void GrowTo(int d, double value)
77 {
78 Dimension(d > dim ? d : dim, value);
79 }
80
81 int Length() const
82 {
83 return dim;
84 }
85
86 void SetLabel(const char * text)
87 {
88 label = text;
89 }
90
91 void Zero();
92 void Set(double k);
93 void Set(Vector & v)
94 {
95 Copy(v);
96 };
97 void SetMultiple(double k, Vector & v);
98
99 void Negate();
100 void Add(double n);
101 void Multiply(double k);
102
103 double InnerProduct(Vector & v);
104 void Copy(const Vector & v);
105 void Add(Vector & v);
106 void AddMultiple(double k, Vector & v);
107 void Subtract(Vector & v);
108
109 void Product(Matrix & m, Vector & v);
110
111 double & operator [](int n)
112 {
113 assert(n < dim);
114 return data[n];
115 }
116 double operator [](int n) const
117 {
118 assert(n < dim);
119 return data[n];
120 }
121
122 double operator [](double fraction)
123 {
124 return data[(int)(dim * fraction)];
125 }
126 double & operator [](double fraction) const
127 {
128 return data[(int)(dim * fraction)];
129 }
130
131 Vector & operator = (const Vector & v);
132 bool operator == (const Vector & v) const;
133 bool operator != (const Vector & v) const
134 {
135 return !(*this == v);
136 }
137
138 void Swap(int i, int j)
139 {
140 double swap = data[i];
141 data[i] = data[j];
142 data[j] = swap;
143 }
144 void Swap(Vector & rhs);
145
146 Vector & operator *= (double rhs)
147 {
148 Multiply(rhs);
149 return *this;
150 }
151 Vector & operator += (double rhs)
152 {
153 Add(rhs);
154 return *this;
155 }
156 Vector & operator -= (double rhs)
157 {
158 return *this += -rhs;
159 }
160 Vector & operator /= (double rhs)
161 {
162 return *this *= 1/rhs;
163 }
164
165 Vector & operator += (Vector & rhs)
166 {
167 Add(rhs);
168 return * this;
169 }
170 Vector & operator -= (Vector & rhs)
171 {
172 Subtract(rhs);
173 return * this;
174 }
175
176 void DeleteDimension(int n);
177 void Delete(int n)
178 {
179 DeleteDimension(n);
180 }
181 void Insert(int n, double value);
182
183 // Calculates average and variance
184 void AveVar(double & ave, double & var) const;
185 double Average() const;
186 double Var() const;
187 double StandardDeviation() const;
188
189 double Average(double returnIfNull);
190 double Var(double returnIfNull);
191 double StandardDeviation(double returnIfNull);
192
193 // Common descriptive functions
194 double Sum() const;
195 double SumSquares() const;
196 double Product() const;
197
198 // Find extreme values
199 double Min() const;
200 double Max() const;
201
202 // Return the number of elements in a subset
203 int CountIfGreater(double treshold) const;
204 int CountIfGreaterOrEqual(double treshold) const;
205
206 // Append another vector to the end
207 void Stack(const Vector & v);
208
209 void Print(int maxDim = -1)
210 {
211 Print(stdout, maxDim);
212 }
213 void Print(FILE * output, int maxDim = -1);
214
215 // Routines for creating and searching through sorted vectors
216 void Sort();
217 void Reverse();
218 void Sort(Vector & freeRider);
219 int BinarySearch(double value);
220 int FastFind(double value)
221 {
222 return BinarySearch(value);
223 }
224
225 // Remove consecutive duplicate elements from vector
226 void RemoveDuplicates();
227
228 // Query first and last elements
229 //
230
231 double & First()
232 {
233 return data[0];
234 }
235 double & Last()
236 {
237 return data[dim - 1];
238 }
239
240 // Routines for using a vector as a stack of doubles
241 //
242
243 void Clear()
244 {
245 dim = 0;
246 }
247 void Push(double value);
248 double Pop()
249 {
250 return data[--dim];
251 }
252 double Peek() const
253 {
254 return data[dim-1];
255 }
256
257 // This routine adds items to a sorted list
258 //
259
260 void InsertInSortedList(int item);
261
262 static int alloc;
263
264 bool isAscending();
265 bool isDescending();
266
267 // Routines for dealing with vectors that include missing data
268 //
269
270 int SafeCount() const;
271 double SafeMin() const;
272 double SafeMax() const;
273
274private:
275 static int CompareDouble(const double * a, const double * b);
276 void Init();
277};
278
279
280
282// Wrapper for multi-dimensional functions
283// so that they can be used as parameters
284// and keep private data
285{
286private:
287 double(*f)(Vector &);
288
289public:
290 // Constructors
291 VectorFunc();
292 VectorFunc(double(*func)(Vector &));
293
294 // Virtual destructor ensures that dynamic objects are
295 // handled correctly
296 virtual ~VectorFunc() { }
297
298 virtual double Evaluate(Vector & v);
299
300 // Calculate derivatives along each direction. Delta is a guess value
301 // for the initial stepsize in numerical derivation
302 virtual void Derivative(Vector & point, Vector & d, double delta = 1.0);
303
304 // Minimum function value found while evaluating derivative
305 // and its location...
306 double dfmin;
307 Vector dpmin;
308};
309
310#endif
311
312
313