ccgsl 2.7.2
C++wrappersforGnuScientificLibrary
wavelet.hpp
Go to the documentation of this file.
1/*
2 * $Id: wavelet.hpp 293 2012-12-17 20:27:36Z jdl3 $
3 * Copyright (C) 2012 John D Lamb
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or (at
8 * your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19
20#ifndef CCGSL_WAVELET_HPP
21#define CCGSL_WAVELET_HPP
22
23#include<new>
24#include<gsl/gsl_wavelet.h>
25
26namespace gsl {
30 class wavelet {
31 public:
35 typedef gsl_wavelet_type const* type;
40 ccgsl_pointer = 0;
41 count = 0; // initially nullptr will do
42 }
43 // Refines random access container
44 // Refines assignable
50 explicit wavelet( type T, size_t const k ){
51 ccgsl_pointer = gsl_wavelet_alloc( T, k );
52 // just plausibly we could allocate wavelet but not count
53 try { count = new size_t; } catch( std::bad_alloc& e ){
54 // try to tidy up before rethrowing
55 gsl_wavelet_free( ccgsl_pointer );
56 throw e;
57 }
58 *count = 1; // initially there is just one reference to ccgsl_pointer
59 }
66 explicit wavelet( gsl_wavelet* v ){
67 ccgsl_pointer = v;
68 // just plausibly we could fail to allocate count: no further action needed.
69 count = new size_t;
70 *count = 1; // initially there is just one reference to ccgsl_pointer
71 }
72 // copy constructor
78 count = v.count; if( count != 0 ) ++*count; }
79 // assignment operator
85 // first, possibly delete anything pointed to by this
86 if( count == 0 or --*count == 0 ){
87 if( ccgsl_pointer != 0 ) gsl_wavelet_free( ccgsl_pointer );
88 delete count;
89 } // Then copy
90 ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
91 }
92 // destructor
97 if( count == 0 or --*count == 0 ){
98 // could have allocated null pointer
99 if( ccgsl_pointer != 0 ) gsl_wavelet_free( ccgsl_pointer );
100 delete count;
101 }
102 }
103#ifdef __GXX_EXPERIMENTAL_CXX0X__
109 std::swap( count, v.count );
110 v.ccgsl_pointer = nullptr;
111 }
118 wavelet( std::move( v ) ).swap( *this );
119 return *this;
120 }
121#endif
122 // Refines equality comparable
123 // == operator
130 bool operator==( wavelet const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
131 // != operator
138 bool operator!=( wavelet const& v ) const { return not operator==( v ); }
139 // Refines forward container
140 // Refines less than comparable
141 // operator<
150 bool operator<( wavelet const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
151 // operator>
160 bool operator>( wavelet const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
161 // operator<=
170 bool operator<=( wavelet const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
171 // operator>=
180 bool operator>=( wavelet const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
185 bool empty() const { return ccgsl_pointer == 0; }
186 // swap() --- should work even if sizes don't match
192 void swap( wavelet& v ){
193 std::swap( ccgsl_pointer, v.ccgsl_pointer );
194 std::swap( count, v.count );
195 }
196 protected:
200 gsl_wavelet* ccgsl_pointer;
204 size_t* count;
205 public:
206 // shared reference functions
211 gsl_wavelet* get() const { return ccgsl_pointer; }
217 bool unique() const { return count != 0 and *count == 1; }
222 size_t use_count() const { return count == 0 ? 0 : *count; }
228#ifdef __GXX_EXPERIMENTAL_CXX0X__
229 explicit
230#endif
231 operator bool() const { return ccgsl_pointer != 0; }
236 std::string name() const { return gsl_wavelet_name( get() ); }
241 static type daubechies(){ return gsl_wavelet_daubechies; }
246 static type daubechies_centered(){ return gsl_wavelet_daubechies_centered; }
251 static type haar(){ return gsl_wavelet_haar; }
256 static type haar_centered(){ return gsl_wavelet_haar_centered; }
261 static type bspline(){ return gsl_wavelet_bspline; }
266 static type bspline_centered(){ return gsl_wavelet_bspline_centered; }
267
271 class workspace {
272 public:
277 ccgsl_pointer = 0;
278 count = 0; // initially nullptr will do
279 }
280 // Refines random access container
281 // Refines assignable
286 explicit workspace( size_t const n ){
287 ccgsl_pointer = gsl_wavelet_workspace_alloc( n );
288 // just plausibly we could allocate workspace but not count
289 try { count = new size_t; } catch( std::bad_alloc& e ){
290 // try to tidy up before rethrowing
291 gsl_wavelet_workspace_free( ccgsl_pointer );
292 throw e;
293 }
294 *count = 1; // initially there is just one reference to ccgsl_pointer
295 }
302 explicit workspace( gsl_wavelet_workspace* v ){
303 ccgsl_pointer = v;
304 // just plausibly we could fail to allocate count: no further action needed.
305 count = new size_t;
306 *count = 1; // initially there is just one reference to ccgsl_pointer
307 }
308 // copy constructor
314 count = v.count; if( count != 0 ) ++*count; }
315 // assignment operator
321 // first, possibly delete anything pointed to by this
322 if( count == 0 or --*count == 0 ){
323 if( ccgsl_pointer != 0 ) gsl_wavelet_workspace_free( ccgsl_pointer );
324 delete count;
325 } // Then copy
326 ccgsl_pointer = v.ccgsl_pointer; count = v.count; if( count != 0 ) ++*count; return *this;
327 }
328 // destructor
333 if( count == 0 or --*count == 0 ){
334 // could have allocated null pointer
335 if( ccgsl_pointer != 0 ) gsl_wavelet_workspace_free( ccgsl_pointer );
336 delete count;
337 }
338 }
339#ifdef __GXX_EXPERIMENTAL_CXX0X__
345 std::swap( count, v.count );
346 v.ccgsl_pointer = nullptr;
347 }
354 workspace( std::move( v ) ).swap( *this );
355 return *this;
356 }
357#endif
358 // Refines equality comparable
359 // == operator
366 bool operator==( workspace const& v ) const { return ccgsl_pointer == v.ccgsl_pointer; }
367 // != operator
374 bool operator!=( workspace const& v ) const { return not operator==( v ); }
375 // Refines forward container
376 // Refines less than comparable
377 // operator<
386 bool operator<( workspace const& v ) const { return ccgsl_pointer < v.ccgsl_pointer; }
387 // operator>
396 bool operator>( workspace const& v ) const { return ccgsl_pointer > v.ccgsl_pointer; }
397 // operator<=
406 bool operator<=( workspace const& v ) const { return ccgsl_pointer <= v.ccgsl_pointer; }
407 // operator>=
416 bool operator>=( workspace const& v ) const { return ccgsl_pointer >= v.ccgsl_pointer; }
421 bool empty() const { return ccgsl_pointer == 0; }
422 // swap() --- should work even if sizes don't match
428 void swap( workspace& v ){
429 std::swap( ccgsl_pointer, v.ccgsl_pointer );
430 std::swap( count, v.count );
431 }
432 private:
436 gsl_wavelet_workspace* ccgsl_pointer;
440 size_t* count;
441 public:
442 // shared reference functions
447 gsl_wavelet_workspace* get() const { return ccgsl_pointer; }
453 bool unique() const { return count != 0 and *count == 1; }
458 size_t use_count() const { return count == 0 ? 0 : *count; }
464#ifdef __GXX_EXPERIMENTAL_CXX0X__
465 explicit
466#endif
467 operator bool() const { return ccgsl_pointer != 0; }
468 };
469
474 inline gsl_wavelet_direction forward() const { return gsl_wavelet_forward; }
479 inline gsl_wavelet_direction backward() const { return gsl_wavelet_backward; }
480
481#ifndef DOXYGEN_SKIP
491 int transform( double* data, size_t stride, size_t n, gsl_wavelet_direction dir,
492 workspace& work ) const {
493 return gsl_wavelet_transform( get(), data, stride, n, dir, work.get() ); }
494
503 int transform_forward( double* data, size_t stride, size_t n, workspace& work ) const {
504 return gsl_wavelet_transform_forward( get(), data, stride, n, work.get() ); }
505
514 int transform_inverse( double* data, size_t stride, size_t n, workspace& work ) const {
515 return gsl_wavelet_transform_inverse( get(), data, stride, n, work.get() ); }
516#endif // DOXYGEN_SKIP
517
527 template<typename DATA>
528 int transform( DATA& data, size_t stride, gsl_wavelet_direction dir,
529 workspace& work ) const {
530 return gsl_wavelet_transform( get(), data.data(), stride, data.size() / stride, dir, work.get() ); }
531
540 template<typename DATA>
541 int transform_forward( DATA& data, size_t stride, workspace& work ) const {
542 return gsl_wavelet_transform_forward( get(), data.data(), stride, data.size() / stride, work.get() ); }
543
552 template<typename DATA>
553 int transform_inverse( DATA& data, size_t stride, workspace& work ) const {
554 return gsl_wavelet_transform_inverse( get(), data.data(), stride, data.size() / stride, work.get() ); }
555
564 template<typename DATA>
565 int transform( DATA& data, gsl_wavelet_direction dir,
566 workspace& work ) const {
567 return gsl_wavelet_transform( get(), data.data(), 1, data.size(), dir, work.get() ); }
568
576 template<typename DATA>
577 int transform_forward( DATA& data, workspace& work ) const {
578 return gsl_wavelet_transform_forward( get(), data.data(), 1, data.size(), work.get() ); }
579
587 template<typename DATA>
588 int transform_inverse( DATA& data, workspace& work ) const {
589 return gsl_wavelet_transform_inverse( get(), data.data(), 1, data.size(), work.get() ); }
590
591 };
592}
593#endif
Workspace for wavelets.
Definition: wavelet.hpp:271
workspace(size_t const n)
The default constructor creates a new workspace with n elements.
Definition: wavelet.hpp:286
bool operator<=(workspace const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:406
size_t use_count() const
Find how many workspace objects share this pointer.
Definition: wavelet.hpp:458
bool operator>=(workspace const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:416
~workspace()
The destructor only deletes the pointers if count reaches zero.
Definition: wavelet.hpp:332
workspace(gsl_wavelet_workspace *v)
Could construct from a gsl_wavelet_workspace.
Definition: wavelet.hpp:302
bool operator!=(workspace const &v) const
Two workspace are different if their elements are not identical.
Definition: wavelet.hpp:374
workspace(workspace const &v)
The copy constructor.
Definition: wavelet.hpp:313
workspace()
The default constructor is only really useful for assigning to.
Definition: wavelet.hpp:276
size_t * count
The shared reference count.
Definition: wavelet.hpp:440
workspace(workspace &&v)
Move constructor.
Definition: wavelet.hpp:344
bool operator<(workspace const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:386
gsl_wavelet_workspace * ccgsl_pointer
The shared pointer.
Definition: wavelet.hpp:436
workspace & operator=(workspace &&v)
Move operator.
Definition: wavelet.hpp:353
bool operator==(workspace const &v) const
Two workspace are identically equal if their elements are identical.
Definition: wavelet.hpp:366
bool empty() const
Find if the workspace is empty.
Definition: wavelet.hpp:421
bool operator>(workspace const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:396
workspace & operator=(workspace const &v)
The assignment operator.
Definition: wavelet.hpp:320
void swap(workspace &v)
Swap two workspace objects.
Definition: wavelet.hpp:428
gsl_wavelet_workspace * get() const
Get the gsl_wavelet_workspace.
Definition: wavelet.hpp:447
bool unique() const
Find if this is the only object sharing the gsl_wavelet_workspace.
Definition: wavelet.hpp:453
Wavelets in one dimension.
Definition: wavelet.hpp:30
bool unique() const
Find if this is the only object sharing the gsl_wavelet.
Definition: wavelet.hpp:217
gsl_wavelet_type const * type
Define gsl::wavelet::static type.
Definition: wavelet.hpp:35
wavelet & operator=(wavelet const &v)
The assignment operator.
Definition: wavelet.hpp:84
gsl_wavelet * get() const
Get the gsl_wavelet.
Definition: wavelet.hpp:211
wavelet(gsl_wavelet *v)
Could construct from a gsl_wavelet.
Definition: wavelet.hpp:66
static type daubechies_centered()
Wavelet static type.
Definition: wavelet.hpp:246
bool operator>=(wavelet const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:180
static type haar()
Wavelet static type.
Definition: wavelet.hpp:251
wavelet(wavelet const &v)
The copy constructor.
Definition: wavelet.hpp:77
wavelet & operator=(wavelet &&v)
Move operator.
Definition: wavelet.hpp:117
static type bspline_centered()
Wavelet static type.
Definition: wavelet.hpp:266
static type bspline()
Wavelet static type.
Definition: wavelet.hpp:261
void swap(wavelet &v)
Swap two wavelet objects.
Definition: wavelet.hpp:192
int transform(DATA &data, size_t stride, gsl_wavelet_direction dir, workspace &work) const
C++ version of gsl_wavelet_transform().
Definition: wavelet.hpp:528
bool operator<(wavelet const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:150
bool operator>(wavelet const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:160
bool operator!=(wavelet const &v) const
Two wavelet are different if their elements are not identical.
Definition: wavelet.hpp:138
size_t use_count() const
Find how many wavelet objects share this pointer.
Definition: wavelet.hpp:222
~wavelet()
The destructor only deletes the pointers if count reaches zero.
Definition: wavelet.hpp:96
size_t * count
The shared reference count.
Definition: wavelet.hpp:204
int transform_inverse(DATA &data, workspace &work) const
C++ version of gsl_wavelet_transform_inverse().
Definition: wavelet.hpp:588
std::string name() const
C++ version of gsl_wavelet_name().
Definition: wavelet.hpp:236
int transform_inverse(DATA &data, size_t stride, workspace &work) const
C++ version of gsl_wavelet_transform_inverse().
Definition: wavelet.hpp:553
wavelet(wavelet &&v)
Move constructor.
Definition: wavelet.hpp:108
bool operator<=(wavelet const &v) const
A container needs to define an ordering for sorting.
Definition: wavelet.hpp:170
int transform_forward(DATA &data, workspace &work) const
C++ version of gsl_wavelet_transform_forward().
Definition: wavelet.hpp:577
gsl_wavelet_direction forward() const
Access direction.
Definition: wavelet.hpp:474
int transform_forward(DATA &data, size_t stride, workspace &work) const
C++ version of gsl_wavelet_transform_forward().
Definition: wavelet.hpp:541
int transform(DATA &data, gsl_wavelet_direction dir, workspace &work) const
C++ version of gsl_wavelet_transform().
Definition: wavelet.hpp:565
static type daubechies()
Wavelet static type.
Definition: wavelet.hpp:241
bool empty() const
Find if the wavelet is empty.
Definition: wavelet.hpp:185
bool operator==(wavelet const &v) const
Two wavelet are identically equal if their elements are identical.
Definition: wavelet.hpp:130
wavelet(type T, size_t const k)
The default constructor creates a new wavelet with n elements.
Definition: wavelet.hpp:50
gsl_wavelet_direction backward() const
Access direction.
Definition: wavelet.hpp:479
static type haar_centered()
Wavelet static type.
Definition: wavelet.hpp:256
wavelet()
The default constructor is only really useful for assigning to.
Definition: wavelet.hpp:39
gsl_wavelet * ccgsl_pointer
The shared pointer.
Definition: wavelet.hpp:200
size_t n(workspace const &w)
C++ version of gsl_rstat_n().
Definition: rstat.hpp:299
The gsl package creates an interface to the GNU Scientific Library for C++.
Definition: blas.hpp:34