Tree: clang-format without the include sorting

author: Marcus Müller <mmueller@gnuradio.org> 2019-08-07 21:45:12 +0200
committer: Marcus Müller <marcus@hostalia.de> 2019-08-09 23:04:28 +0200
commit: f7bbf2c1d8d780294f3e016aff239ca35eb6516e (patch)
tree: e09ab6112e02b2215b2d59ac24d3d6ea2edac745 /gr-wavelet/lib
parent: 78431dc6941e3acc67c858277dfe4a0ed583643c (diff)
6 files changed, 217 insertions, 234 deletions
diff --git a/gr-wavelet/lib/squash_ff_impl.cc b/gr-wavelet/lib/squash_ff_impl.cc
index 26439edbb5..266bb0833d 100644
--- a/gr-wavelet/lib/squash_ff_impl.cc
+++ b/gr-wavelet/lib/squash_ff_impl.cc
@@ -32,67 +32,66 @@
 // produce output vector of ogrid.size y-values
 
 namespace gr {
-  namespace wavelet {
-
-    squash_ff::sptr squash_ff::make(const std::vector<float> &igrid,
-				    const std::vector<float> &ogrid)
-    {
-      return gnuradio::get_initial_sptr(new squash_ff_impl(igrid, ogrid));
-    }
-
-    squash_ff_impl::squash_ff_impl(const std::vector<float> &igrid,
-				   const std::vector<float> &ogrid)
-      : sync_block("squash_ff",
-		      io_signature::make(1, 1, sizeof(float) * igrid.size()),
-		      io_signature::make(1, 1, sizeof(float) * ogrid.size()))
-    {
-      d_inum  = igrid.size();
-      d_onum  = ogrid.size();
-      d_igrid = (double *) malloc(d_inum * sizeof(double));
-      d_iwork = (double *) malloc(d_inum * sizeof(double));
-      d_ogrid = (double *) malloc(d_onum * sizeof(double));
-      for (unsigned int i = 0; i < d_inum; i++)
-	d_igrid[i] = igrid[i];
-      for (unsigned int i = 0; i < d_onum; i++)
-	d_ogrid[i] = ogrid[i];
-
-      d_accel = gsl_interp_accel_alloc();
-      d_spline = gsl_spline_alloc(gsl_interp_cspline, d_inum);	// FIXME check w/ Frank
+namespace wavelet {
+
+squash_ff::sptr squash_ff::make(const std::vector<float>& igrid,
+                                const std::vector<float>& ogrid)
+{
+    return gnuradio::get_initial_sptr(new squash_ff_impl(igrid, ogrid));
+}
+
+squash_ff_impl::squash_ff_impl(const std::vector<float>& igrid,
+                               const std::vector<float>& ogrid)
+    : sync_block("squash_ff",
+                 io_signature::make(1, 1, sizeof(float) * igrid.size()),
+                 io_signature::make(1, 1, sizeof(float) * ogrid.size()))
+{
+    d_inum = igrid.size();
+    d_onum = ogrid.size();
+    d_igrid = (double*)malloc(d_inum * sizeof(double));
+    d_iwork = (double*)malloc(d_inum * sizeof(double));
+    d_ogrid = (double*)malloc(d_onum * sizeof(double));
+    for (unsigned int i = 0; i < d_inum; i++)
+        d_igrid[i] = igrid[i];
+    for (unsigned int i = 0; i < d_onum; i++)
+        d_ogrid[i] = ogrid[i];
+
+    d_accel = gsl_interp_accel_alloc();
+    d_spline = gsl_spline_alloc(gsl_interp_cspline, d_inum); // FIXME check w/ Frank
+}
+
+squash_ff_impl::~squash_ff_impl()
+{
+    free((char*)d_igrid);
+    free((char*)d_iwork);
+    free((char*)d_ogrid);
+    gsl_interp_accel_free(d_accel);
+    gsl_spline_free(d_spline);
+}
+
+int squash_ff_impl::work(int noutput_items,
+                         gr_vector_const_void_star& input_items,
+                         gr_vector_void_star& output_items)
+{
+    const float* in = (const float*)input_items[0];
+    float* out = (float*)output_items[0];
+
+    for (int count = 0; count < noutput_items; count++) {
+
+        for (unsigned int i = 0; i < d_inum; i++)
+            d_iwork[i] = in[i];
+
+        gsl_spline_init(d_spline, d_igrid, d_iwork, d_inum);
+
+        for (unsigned int i = 0; i < d_onum; i++)
+            out[i] = gsl_spline_eval(d_spline, d_ogrid[i], d_accel);
+
+        in += d_inum;
+        out += d_onum;
     }
 
-    squash_ff_impl::~squash_ff_impl()
-    {
-      free((char *) d_igrid);
-      free((char *) d_iwork);
-      free((char *) d_ogrid);
-      gsl_interp_accel_free(d_accel);
-      gsl_spline_free(d_spline);
-    }
-
-    int
-    squash_ff_impl::work(int noutput_items,
-			 gr_vector_const_void_star &input_items,
-			 gr_vector_void_star &output_items)
-    {
-      const float *in  = (const float *) input_items[0];
-      float       *out = (float *) output_items[0];
-
-      for (int count = 0; count < noutput_items; count++) {
-
-	for (unsigned int i = 0; i < d_inum; i++)
-	  d_iwork[i] = in[i];
-
-	gsl_spline_init(d_spline, d_igrid, d_iwork, d_inum);
-
-	for (unsigned int i = 0; i < d_onum; i++)
-	  out[i] = gsl_spline_eval(d_spline, d_ogrid[i], d_accel);
-
-	in  += d_inum;
-	out += d_onum;
-      }
-
-      return noutput_items;
-    }
+    return noutput_items;
+}
 
-  } /* namespace wavelet */
+} /* namespace wavelet */
 } /* namespace gr */
diff --git a/gr-wavelet/lib/squash_ff_impl.h b/gr-wavelet/lib/squash_ff_impl.h
index 933ee5288c..4a0b09f541 100644
--- a/gr-wavelet/lib/squash_ff_impl.h
+++ b/gr-wavelet/lib/squash_ff_impl.h
@@ -20,8 +20,8 @@
  * Boston, MA 02110-1301, USA.
  */
 
-#ifndef	INCLUDED_WAVELET_SQUASH_FF_IMPL_H
-#define	INCLUDED_WAVELET_SQUASH_FF_IMPL_H
+#ifndef INCLUDED_WAVELET_SQUASH_FF_IMPL_H
+#define INCLUDED_WAVELET_SQUASH_FF_IMPL_H
 
 #include <gnuradio/wavelet/api.h>
 #include <gnuradio/wavelet/squash_ff.h>
@@ -30,31 +30,30 @@
 #include <gsl/gsl_spline.h>
 
 namespace gr {
-  namespace wavelet {
+namespace wavelet {
 
-    class WAVELET_API squash_ff_impl : public squash_ff
-    {
-      size_t  d_inum;
-      size_t  d_onum;
-      double *d_igrid;
-      double *d_iwork;
-      double *d_ogrid;
+class WAVELET_API squash_ff_impl : public squash_ff
+{
+    size_t d_inum;
+    size_t d_onum;
+    double* d_igrid;
+    double* d_iwork;
+    double* d_ogrid;
 
-      gsl_interp_accel *d_accel;
-      gsl_spline       *d_spline;
+    gsl_interp_accel* d_accel;
+    gsl_spline* d_spline;
 
-    public:
-      squash_ff_impl(const std::vector<float> &igrid,
-		     const std::vector<float> &ogrid);
+public:
+    squash_ff_impl(const std::vector<float>& igrid, const std::vector<float>& ogrid);
 
-      ~squash_ff_impl();
+    ~squash_ff_impl();
 
-      int work(int noutput_items,
-	       gr_vector_const_void_star &input_items,
-	       gr_vector_void_star &output_items);
-    };
+    int work(int noutput_items,
+             gr_vector_const_void_star& input_items,
+             gr_vector_void_star& output_items);
+};
 
-  } /* namespace wavelet */
+} /* namespace wavelet */
 } /* namespace gr */
 
 #endif /* INCLUDED_WAVELET_WAVELET_FF_IMPL_H */
diff --git a/gr-wavelet/lib/wavelet_ff_impl.cc b/gr-wavelet/lib/wavelet_ff_impl.cc
index c2880e84e2..b78bef1caa 100644
--- a/gr-wavelet/lib/wavelet_ff_impl.cc
+++ b/gr-wavelet/lib/wavelet_ff_impl.cc
@@ -34,77 +34,64 @@
 // order is wavelet length, even, 2...20
 
 namespace gr {
-  namespace wavelet {
+namespace wavelet {
 
-    wavelet_ff::sptr wavelet_ff::make(int size,
-				      int order,
-				      bool forward)
-    {
-      return gnuradio::get_initial_sptr(new wavelet_ff_impl(size, order, forward));
-    }
+wavelet_ff::sptr wavelet_ff::make(int size, int order, bool forward)
+{
+    return gnuradio::get_initial_sptr(new wavelet_ff_impl(size, order, forward));
+}
 
-    wavelet_ff_impl::wavelet_ff_impl(int size,
-				     int order,
-				     bool forward)
-      : sync_block("wavelet_ff",
-		      io_signature::make(1, 1, size * sizeof(float)),
-		      io_signature::make(1, 1, size * sizeof(float))),
-	d_size(size),
-	d_order(order),
-	d_forward(forward)
-    {
-      d_wavelet = gsl_wavelet_alloc(gsl_wavelet_daubechies, d_order);
-      if (d_wavelet == NULL)
-	throw std::runtime_error("can't allocate wavelet");
-      d_workspace = gsl_wavelet_workspace_alloc(d_size);
-      if (d_workspace == NULL)
-	throw std::runtime_error("can't allocate wavelet workspace");
-      d_temp = (double *) malloc(d_size*sizeof(double));
-      if (d_workspace == NULL)
-	throw std::runtime_error("can't allocate wavelet double conversion temp");
-    }
+wavelet_ff_impl::wavelet_ff_impl(int size, int order, bool forward)
+    : sync_block("wavelet_ff",
+                 io_signature::make(1, 1, size * sizeof(float)),
+                 io_signature::make(1, 1, size * sizeof(float))),
+      d_size(size),
+      d_order(order),
+      d_forward(forward)
+{
+    d_wavelet = gsl_wavelet_alloc(gsl_wavelet_daubechies, d_order);
+    if (d_wavelet == NULL)
+        throw std::runtime_error("can't allocate wavelet");
+    d_workspace = gsl_wavelet_workspace_alloc(d_size);
+    if (d_workspace == NULL)
+        throw std::runtime_error("can't allocate wavelet workspace");
+    d_temp = (double*)malloc(d_size * sizeof(double));
+    if (d_workspace == NULL)
+        throw std::runtime_error("can't allocate wavelet double conversion temp");
+}
 
-    wavelet_ff_impl::~wavelet_ff_impl()
-    {
-      gsl_wavelet_free(d_wavelet);
-      gsl_wavelet_workspace_free(d_workspace);
-      free((char *) d_temp);
-    }
+wavelet_ff_impl::~wavelet_ff_impl()
+{
+    gsl_wavelet_free(d_wavelet);
+    gsl_wavelet_workspace_free(d_workspace);
+    free((char*)d_temp);
+}
 
-    int
-    wavelet_ff_impl::work(int noutput_items,
-			  gr_vector_const_void_star &input_items,
-			  gr_vector_void_star &output_items)
-    {
-      const float *in  = (const float *) input_items[0];
-      float       *out = (float *) output_items[0];
+int wavelet_ff_impl::work(int noutput_items,
+                          gr_vector_const_void_star& input_items,
+                          gr_vector_void_star& output_items)
+{
+    const float* in = (const float*)input_items[0];
+    float* out = (float*)output_items[0];
 
-      for (int count = 0; count < noutput_items; count++) {
-	for (int i = 0; i < d_size; i++)
-	  d_temp[i] = in[i];
+    for (int count = 0; count < noutput_items; count++) {
+        for (int i = 0; i < d_size; i++)
+            d_temp[i] = in[i];
 
-	if (d_forward)
-	  gsl_wavelet_transform_forward(d_wavelet,
-					d_temp,
-					1,
-					d_size,
-					d_workspace);
-	else
-	  gsl_wavelet_transform_inverse(d_wavelet,
-					d_temp,
-					1,
-					d_size,
-					d_workspace);
+        if (d_forward)
+            gsl_wavelet_transform_forward(d_wavelet, d_temp, 1, d_size, d_workspace);
+        else
+            gsl_wavelet_transform_inverse(d_wavelet, d_temp, 1, d_size, d_workspace);
 
-	for (int i = 0; i < d_size; i++)
-	  out[i] = d_temp[i];
+        for (int i = 0; i < d_size; i++)
+            out[i] = d_temp[i];
 
-	in  += d_size;
-	out += d_size;
-      }
-
-      return noutput_items;
+        in += d_size;
+        out += d_size;
     }
 
-  } /* namespace wavelet */
+    return noutput_items;
+}
+
+} /* namespace wavelet */
 } /* namespace gr */
diff --git a/gr-wavelet/lib/wavelet_ff_impl.h b/gr-wavelet/lib/wavelet_ff_impl.h
index b8d6500487..13a055798b 100644
--- a/gr-wavelet/lib/wavelet_ff_impl.h
+++ b/gr-wavelet/lib/wavelet_ff_impl.h
@@ -27,30 +27,28 @@
 #include <gsl/gsl_wavelet.h>
 
 namespace gr {
-  namespace wavelet {
-
-    class WAVELET_API wavelet_ff_impl : public wavelet_ff
-    {
-      int                    d_size;
-      int                    d_order;
-      bool		     d_forward;
-      gsl_wavelet           *d_wavelet;
-      gsl_wavelet_workspace *d_workspace;
-      double                *d_temp;
-
-    public:
-      wavelet_ff_impl(int size,
-		      int order,
-		      bool forward);
-
-      ~wavelet_ff_impl();
-
-      int work(int noutput_items,
-	       gr_vector_const_void_star &input_items,
-	       gr_vector_void_star &output_items);
-    };
-
-  } /* namespace wavelet */
+namespace wavelet {
+
+class WAVELET_API wavelet_ff_impl : public wavelet_ff
+{
+    int d_size;
+    int d_order;
+    bool d_forward;
+    gsl_wavelet* d_wavelet;
+    gsl_wavelet_workspace* d_workspace;
+    double* d_temp;
+
+public:
+    wavelet_ff_impl(int size, int order, bool forward);
+
+    ~wavelet_ff_impl();
+
+    int work(int noutput_items,
+             gr_vector_const_void_star& input_items,
+             gr_vector_void_star& output_items);
+};
+
+} /* namespace wavelet */
 } /* namespace gr */
 
 #endif /* INCLUDED_WAVELET_WAVELET_FF_IMPL_H */
diff --git a/gr-wavelet/lib/wvps_ff_impl.cc b/gr-wavelet/lib/wvps_ff_impl.cc
index 9512ce45f1..d428a8a8a1 100644
--- a/gr-wavelet/lib/wvps_ff_impl.cc
+++ b/gr-wavelet/lib/wvps_ff_impl.cc
@@ -29,75 +29,75 @@
 #include <string.h>
 
 namespace gr {
-  namespace wavelet {
-
-    static int
-    ceil_log2(int k)
-    {
-      int m = 0;
-      for (int n = k-1; n > 0; n >>= 1) m++;
-      return m;
-    }
+namespace wavelet {
 
-    wvps_ff::sptr wvps_ff::make(int ilen)
-    {
-      return gnuradio::get_initial_sptr(new wvps_ff_impl(ilen));
-    }
+static int ceil_log2(int k)
+{
+    int m = 0;
+    for (int n = k - 1; n > 0; n >>= 1)
+        m++;
+    return m;
+}
 
-    wvps_ff_impl::wvps_ff_impl(int ilen)
-      : sync_block("wvps_ff",
-		      io_signature::make(1, 1, sizeof(float) * ilen),
-		      io_signature::make(1, 1, sizeof(float) * ceil_log2(ilen))),
-	d_ilen(ilen), d_olen(ceil_log2(ilen))
-    {
-    }
+wvps_ff::sptr wvps_ff::make(int ilen)
+{
+    return gnuradio::get_initial_sptr(new wvps_ff_impl(ilen));
+}
 
-    // input vector assumed to be output from gsl wavelet computation
+wvps_ff_impl::wvps_ff_impl(int ilen)
+    : sync_block("wvps_ff",
+                 io_signature::make(1, 1, sizeof(float) * ilen),
+                 io_signature::make(1, 1, sizeof(float) * ceil_log2(ilen))),
+      d_ilen(ilen),
+      d_olen(ceil_log2(ilen))
+{
+}
 
-    int
-    wvps_ff_impl::work(int noutput_items,
-		       gr_vector_const_void_star &input_items,
-		       gr_vector_void_star &output_items)
-    {
-      const float *in  = (const float *) input_items[0];
-      float       *out = (float *) output_items[0];
+// input vector assumed to be output from gsl wavelet computation
 
-      for (int count = 0; count < noutput_items; count++) {
+int wvps_ff_impl::work(int noutput_items,
+                       gr_vector_const_void_star& input_items,
+                       gr_vector_void_star& output_items)
+{
+    const float* in = (const float*)input_items[0];
+    float* out = (float*)output_items[0];
 
-	// any power?
+    for (int count = 0; count < noutput_items; count++) {
 
-	if (in[0] == 0.0) {
-	  for (int i = 0; i < d_olen; i++)
-	    out[i] = 0.0;
+        // any power?
 
-	} else {
+        if (in[0] == 0.0) {
+            for (int i = 0; i < d_olen; i++)
+                out[i] = 0.0;
 
-	  // get power normalization from 0-th wavelet coefficient
+        } else {
 
-	  float scl = 1.0/(in[0]*in[0]);
-	  int k = 1;
+            // get power normalization from 0-th wavelet coefficient
 
-	  // sum powers over sequences of bins,
-	  // sequence lengths in increasing powers of 2
+            float scl = 1.0 / (in[0] * in[0]);
+            int k = 1;
 
-	  for (int e = 0; e < d_olen; e++) {
-	    int m = 01<<e;
-	    float sum = 0.0;
+            // sum powers over sequences of bins,
+            // sequence lengths in increasing powers of 2
 
-	    for (int l = 0; l < m; l++)
-	      sum += (in[k+l]*in[k+l]);
+            for (int e = 0; e < d_olen; e++) {
+                int m = 01 << e;
+                float sum = 0.0;
 
-	    out[e] = scl*sum;
-	    k += m;
-	  }
-	}
+                for (int l = 0; l < m; l++)
+                    sum += (in[k + l] * in[k + l]);
 
-	in  += d_ilen;
-	out += d_olen;
-      }
+                out[e] = scl * sum;
+                k += m;
+            }
+        }
 
-      return noutput_items;
+        in += d_ilen;
+        out += d_olen;
     }
 
-  } /* namespace wavelet */
+    return noutput_items;
+}
+
+} /* namespace wavelet */
 } /* namespace gr */
diff --git a/gr-wavelet/lib/wvps_ff_impl.h b/gr-wavelet/lib/wvps_ff_impl.h
index b9951f40a7..a42826e90b 100644
--- a/gr-wavelet/lib/wvps_ff_impl.h
+++ b/gr-wavelet/lib/wvps_ff_impl.h
@@ -26,22 +26,22 @@
 #include <gnuradio/wavelet/wvps_ff.h>
 
 namespace gr {
-  namespace wavelet {
+namespace wavelet {
 
-    class WAVELET_API wvps_ff_impl : public wvps_ff
-    {
-      int d_ilen;
-      int d_olen;
+class WAVELET_API wvps_ff_impl : public wvps_ff
+{
+    int d_ilen;
+    int d_olen;
 
-    public:
-      wvps_ff_impl(int ilen);
+public:
+    wvps_ff_impl(int ilen);
 
-      int work(int noutput_items,
-	       gr_vector_const_void_star &input_items,
-	       gr_vector_void_star &output_items);
-    };
+    int work(int noutput_items,
+             gr_vector_const_void_star& input_items,
+             gr_vector_void_star& output_items);
+};
 
-  } /* namespace wavelet */
-}/* namespace gr */
+} /* namespace wavelet */
+} /* namespace gr */
 
 #endif /* INCLUDED_WAVELET_WVPS_FF_IMPL_H */
author	Marcus Müller <mmueller@gnuradio.org>	2019-08-07 21:45:12 +0200
committer	Marcus Müller <marcus@hostalia.de>	2019-08-09 23:04:28 +0200
commit	f7bbf2c1d8d780294f3e016aff239ca35eb6516e (patch)
tree	e09ab6112e02b2215b2d59ac24d3d6ea2edac745 /gr-wavelet/lib
parent	78431dc6941e3acc67c858277dfe4a0ed583643c (diff)