noyes 0.9.2 → 1.0.0

data/lib/{c_impl/noyes.h → cext/c_noyes.h}

@@ -11,27 +11,28 @@ typedef struct {
   double **data;
   int rows;
   int cols;
-} NMatrix;
+} Cmat;
 
 typedef struct {
   double ***data;
   int rows;
   int cols;
   int z;
-} NMatrix3;
+} Cmat3;
 
 typedef struct {
   double *data;
   int rows;
-} NMatrix1;
+} Carr;
 
-NMatrix *new_nmatrix(int rows, int cols);
-void free_nmatrix(NMatrix *);
+Cmat *cmat_new(int rows, int cols);
+void cmat_free(Cmat *);
 
-NMatrix1 *new_nmatrix1(int rows);
-void free_nmatrix1(NMatrix1 *);
-NMatrix1 ** nmatrix_2_nmatrix1s(NMatrix *M);
-NMatrix * nmatrix1_2_nmatrix(NMatrix1 **array, int size);
+Carr *carr_new(int rows);
+void carr_free(Carr *);
+Carr ** mat2arrs(Cmat *M);
+Cmat * arrs2mat(Carr **array, int size);
+Carr *cmat_flatten(Cmat *M);
 
 // Preemphasizer
 typedef struct {
@@ -40,8 +41,8 @@ typedef struct {
 } Preemphasizer;
 
 Preemphasizer * new_preemphasizer(double factor);
-void free_preemphasizer(Preemphasizer *self);
-NMatrix1 *preemphasizer_apply(Preemphasizer *self, NMatrix1 *data);
+void preemphasizer_free(Preemphasizer *self);
+Carr *preemphasizer_apply(Preemphasizer *self, Carr *data);
 
 // Segmenter
 typedef struct {
@@ -52,8 +53,8 @@ typedef struct {
 } Segmenter;
 
 Segmenter * new_segmenter(int winsz, int winshift);
-void free_segmenter(Segmenter *s);
-NMatrix * segmenter_apply(Segmenter* self, NMatrix1 *data);
+void segmenter_free(Segmenter *s);
+Cmat * segmenter_apply(Segmenter* self, Carr *data);
 
 // Hamming Window
 typedef struct {
@@ -61,9 +62,9 @@ typedef struct {
   size_t buflen;
 } HammingWindow;
 
-HammingWindow * new_hamming_window(int window_size);
-void free_hamming_window(HammingWindow *s);
-NMatrix * hamming_window_apply(HammingWindow* self, NMatrix *data);
+HammingWindow * hamming_window_new(int window_size);
+void hamming_window_free(HammingWindow *s);
+Cmat * hamming_window_apply(HammingWindow* self, Cmat *data);
 
 // Power spectrum
 typedef struct {
@@ -71,9 +72,9 @@ typedef struct {
 } PowerSpectrum;
 
 PowerSpectrum * new_power_spectrum(int nfft);
-void free_power_spectrum(PowerSpectrum *);
-NMatrix *power_spectrum_apply(PowerSpectrum *self, NMatrix *data);
-NMatrix * dft(double * data, int datalen, int size);
+void power_spectrum_free(PowerSpectrum *);
+Cmat *power_spectrum_apply(PowerSpectrum *self, Cmat *data);
+Cmat * dft(double * data, int datalen, int size);
 
 // Mel Filter
 typedef struct {
@@ -85,11 +86,11 @@ typedef struct {
 
 MelFilter * new_mel_filter(int srate, int nfft, int nfilt, int lowerf,
                                                             int upperf);
-void free_mel_filter(MelFilter* mf);
-NMatrix *make_bank_parameters(double srate, int nfft, int nfilt,
+void mel_filter_free(MelFilter* mf);
+Cmat *make_bank_parameters(double srate, int nfft, int nfilt,
                                       double lowerf, double upperf); 
-NMatrix * mel_filter_apply(MelFilter* self, NMatrix * power_spectrum);
-NMatrix1 * make_filter(double left, double center, double right,
+Cmat * mel_filter_apply(MelFilter* self, Cmat * power_spectrum);
+Carr * make_filter(double left, double center, double right,
                                double initFreq, double delta);
 double melinv(double m);
 double mel(double m);
@@ -99,9 +100,9 @@ typedef struct {
   double log_zero;
 } LogCompressor;
 
-LogCompressor * new_log_compressor(double log_zero);
-void free_log_compressor(LogCompressor *lc);
-NMatrix * log_compressor_apply(LogCompressor *self, NMatrix *data);
+LogCompressor * log_compressor_new(double log_zero);
+void log_compressor_free(LogCompressor *lc);
+Cmat * log_compressor_apply(LogCompressor *self, Cmat *data);
 
 // Discrete Cosine Transform
 typedef struct {
@@ -110,9 +111,9 @@ typedef struct {
   double **melcos;
 } DiscreteCosineTransform;
 
-DiscreteCosineTransform * new_dct(int order, int ncol);
-void free_dct(DiscreteCosineTransform *dct);
-NMatrix * dct_apply(DiscreteCosineTransform *self, NMatrix *data);
+DiscreteCosineTransform * dct_new(int order, int ncol);
+void dct_free(DiscreteCosineTransform *dct);
+Cmat * dct_apply(DiscreteCosineTransform *self, Cmat *data);
 
 typedef struct {
   double * sums;
@@ -124,9 +125,9 @@ typedef struct {
   int shift;
 } LiveCMN;
 
-LiveCMN * new_live_cmn(int dimensions, double init_mean, int window_size, int shift);
-void free_live_cmn(LiveCMN *lcmn);
-NMatrix *live_cmn_apply(LiveCMN *self, NMatrix *data);
+LiveCMN * live_cmn_new(int dimensions, double init_mean, int window_size, int shift);
+void live_cmn_free(LiveCMN *lcmn);
+Cmat *live_cmn_apply(LiveCMN *self, Cmat *data);
 
 // Silence removal with BentCentMarker and SpeechTrimmer
 typedef struct {
@@ -138,12 +139,14 @@ typedef struct {
   double threshold;
 } BentCentMarker;
 
-BentCentMarker * new_bent_cent_marker();
-void free_bent_cent_marker(BentCentMarker *self);
-double bent_cent_marker_log_rms(BentCentMarker *self, NMatrix1 *data);
-int bent_cent_marker_apply(BentCentMarker *self, NMatrix1 *data);
+BentCentMarker * bent_cent_marker_new(double threshold, double adjustment,
+                                      double average_number, double background,
+                                      double level, double min_signal);
+void bent_cent_marker_free(BentCentMarker *self);
+double bent_cent_marker_log_rms(BentCentMarker *self, Carr *data);
+int bent_cent_marker_apply(BentCentMarker *self, Carr *data);
 
-#include "n_array_list.h"
+#include "c_array_list.h"
 
 typedef struct {
   int leader;
@@ -155,16 +158,16 @@ typedef struct {
   int ecs;
   BentCentMarker *bcm;
   Segmenter *seg;
-  NList *queue;
+  Clist *queue;
   int eos_reached;
 } SpeechTrimmer;
 
-SpeechTrimmer * new_speech_trimmer();
-void free_speech_trimmer(SpeechTrimmer *self);
-void speech_trimmer_enqueue(SpeechTrimmer *self, NMatrix1* pcm);
-NMatrix1 * speech_trimmer_dequeue(SpeechTrimmer *self);
+SpeechTrimmer * new_speech_trimmer(int frequency, double threshold);
+void speech_trimmer_free(SpeechTrimmer *self);
+void speech_trimmer_enqueue(SpeechTrimmer *self, Carr* pcm);
+Carr * speech_trimmer_dequeue(SpeechTrimmer *self);
 int speech_trimmer_eos(SpeechTrimmer *self);
-NMatrix * speech_trimmer_apply(SpeechTrimmer *self, NMatrix1* pcm);
+Cmat * speech_trimmer_apply(SpeechTrimmer *self, Carr* pcm);
 
 // Fast 8k mfcc
 // This strings together all the algorithms necessary to make mfcc's from an 8k
@@ -178,11 +181,11 @@ typedef struct {
   LogCompressor *log;
   DiscreteCosineTransform *dct;
   LiveCMN *cmn;
-} Fast8kMfcc;
+} Mfcc16x8;
 
-Fast8kMfcc* new_fast_8k_mfcc();
-void free_fast_8k_mfcc(Fast8kMfcc *self);
-NMatrix *fast_8k_mfcc_apply(Fast8kMfcc *self, NMatrix1 *data);
+Mfcc16x8* mfcc_16x8_new();
+void mfcc_16x8_free(Mfcc16x8 *self);
+Cmat *mfcc_16x8_apply(Mfcc16x8 *self, Carr *data);
 
 #ifdef __cplusplus
 }

data/lib/{c_impl/n_power_spec.c → cext/c_power_spec.c}

@@ -1,4 +1,4 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "stdlib.h"
 #include "math.h"
 
@@ -9,19 +9,19 @@ PowerSpectrum * new_power_spectrum(int nfft) {
   return ps;
 }
 
-void free_power_spectrum(PowerSpectrum * self) {
+void power_spectrum_free(PowerSpectrum * self) {
   free(self);
 }
 
-NMatrix *power_spectrum_apply(PowerSpectrum *self, NMatrix *data) {
-  NMatrix *ps = new_nmatrix(data->rows, self->n_uniq_fft_points);
+Cmat *power_spectrum_apply(PowerSpectrum *self, Cmat *data) {
+  Cmat *ps = cmat_new(data->rows, self->n_uniq_fft_points);
   int i,j;
   for (i=0;i<data->rows;++i) {
-      NMatrix * ffts = dft(data->data[i], data->cols, self->nfft);
+      Cmat * ffts = dft(data->data[i], data->cols, self->nfft);
       for (j=0;j<self->n_uniq_fft_points;++j) {
           ps->data[i][j] = pow(ffts->data[0][j],2) + pow(ffts->data[1][j],2);
       }
-      free_nmatrix(ffts);
+      cmat_free(ffts);
   } 
   return ps;
 }

data/lib/{c_impl/n_preemphasis.c → cext/c_preemphasis.c}

@@ -1,4 +1,4 @@
-#include "noyes.h"
+#include "c_noyes.h"
 
 Preemphasizer * new_preemphasizer(double factor) {
   Preemphasizer *self = malloc(sizeof(Preemphasizer));
@@ -7,12 +7,12 @@ Preemphasizer * new_preemphasizer(double factor) {
   return self;
 }
 
-void free_preemphasizer(Preemphasizer *self) {
+void preemphasizer_free(Preemphasizer *self) {
   free(self);
 }
 
-NMatrix1 *preemphasizer_apply(Preemphasizer *self, NMatrix1 *data) {
-    NMatrix1 *res = new_nmatrix1(data->rows);
+Carr *preemphasizer_apply(Preemphasizer *self, Carr *data) {
+    Carr *res = carr_new(data->rows);
     double current_prior = self->prior;
     self->prior = data->data[data->rows-1];
     int i;

data/lib/{c_impl/n_segmenter.c → cext/c_segmenter.c}

@@ -1,4 +1,4 @@
-#include "noyes.h"
+#include "c_noyes.h"
 #include "memory.h"
 
 Segmenter * new_segmenter(int winsz, int winshift) {
@@ -10,7 +10,7 @@ Segmenter * new_segmenter(int winsz, int winshift) {
   return s;
 };
 
-void free_segmenter(Segmenter *s) {
+void segmenter_free(Segmenter *s) {
   if (s->buf) {
     free(s->buf);
   }
@@ -18,7 +18,9 @@ void free_segmenter(Segmenter *s) {
   free(s);
 }
 
-NMatrix * segmenter_apply(Segmenter* self, NMatrix1 *data) {
+#define MIN_SEGMENTS 3
+
+Cmat * segmenter_apply(Segmenter* self, Carr *data) {
   double * combo;
   int combolen = 0;
   if (self->buf != NULL) {
@@ -31,23 +33,27 @@ NMatrix * segmenter_apply(Segmenter* self, NMatrix1 *data) {
       combolen = data->rows;
       memcpy(combo, data->data, combolen * sizeof(double));
   }
-  if (combolen < self->winsz + self->winshift * 5) {
+  if (combolen < self->winsz + self->winshift * MIN_SEGMENTS ) {
       self->buf = realloc(self->buf, combolen * sizeof(double));
       memcpy(self->buf, combo, combolen*sizeof(double));
       self->buflen = combolen;
       return NULL;
   } else {
-      self->buf = NULL;
+      if (self->buf != NULL) {
+        free(self->buf);
+        self->buf = NULL;
+      }
   }
-  NMatrix *M = new_nmatrix((combolen - self->winsz)/ self->winshift+1, self->winsz);
+
+  int nseg = 1 + (combolen - self->winsz - (combolen - self->winsz)
+                  % self->winshift) / self->winshift;
+  Cmat *M = cmat_new(nseg, self->winsz);
   int i = 0;
-  int j=0;
-  while (i+self->winsz <= combolen) {
-    memcpy(M->data[j++], combo + i, self->winsz * sizeof(double));
-    i+=self->winshift;
+  for (i=0;i<M->rows;++i) {
+    memcpy(M->data[i], combo + i*self->winshift, self->winsz * sizeof(double));
   }
   
-  int bufsize = combolen- i;
+  int bufsize = combolen - M->rows * self->winshift;
   if (bufsize > 0) {
       // Copy the tail end of combo into buf.
       self->buf = realloc(self->buf, bufsize * sizeof(double));

data/lib/cext/c_speech_trimmer.c

@@ -0,0 +1,126 @@
+#include "c_noyes.h"
+#undef TRUE
+#define TRUE 1
+#undef FALSE
+#define FALSE 0
+
+SpeechTrimmer * new_speech_trimmer(int frequency, double threshold) {
+  SpeechTrimmer *self = malloc(sizeof(SpeechTrimmer));
+  self->leader = 5;
+  self->trailer = 5;
+  self->speech_started = FALSE;
+  self->bcm = bent_cent_marker_new(threshold, 0.003, 1.0, 100.0, 0.0, 0.0);
+  self->false_count = 0;
+  self->true_count = 0;
+  self->queue = clist_new();
+  self->eos_reached = FALSE;
+  self->scs = 20;
+  self->ecs = 50;
+  self->seg = new_segmenter(frequency/100, frequency/100);
+  return self;
+}
+
+void speech_trimmer_free(SpeechTrimmer *self) {
+  bent_cent_marker_free(self->bcm);
+  segmenter_free(self->seg);
+
+  int i;
+  for (i=0; i<clist_size(self->queue); ++i)
+    carr_free(clist_get(self->queue, i));
+  clist_free(self->queue);
+
+  free(self);
+}
+
+Cmat * speech_trimmer_apply(SpeechTrimmer *self, Carr* pcm) {
+  if (self->eos_reached)
+    return NULL;
+
+  Cmat *segment_matrix = segmenter_apply(self->seg, pcm);
+  if (segment_matrix == NULL)
+	  return NULL;
+
+  Clist *speech_segments = clist_new();
+  int centisecond_count = segment_matrix->rows;
+  Carr **segments = mat2arrs(segment_matrix);
+  int speech_count = 0, i;
+  for (i=0; i<centisecond_count ;++i) {
+    speech_trimmer_enqueue(self, segments[i]);
+    Carr *centispeech = speech_trimmer_dequeue(self);
+    while (centispeech != NULL) {
+      clist_add(speech_segments, centispeech);
+      speech_count++;
+      centispeech = speech_trimmer_dequeue(self);
+    }
+    if (speech_trimmer_eos(self)) {
+      for (i+=1;i<centisecond_count; ++i)
+        carr_free(segments[i]);
+      break;
+    }
+  }
+  free(segments);
+
+  if (speech_trimmer_eos(self) && speech_count == 0) {
+    for (i=0; i<clist_size(speech_segments); ++i)
+      carr_free(clist_get(speech_segments, i));
+
+    clist_free(speech_segments);
+    return NULL;
+  }
+
+  Cmat *result = arrs2mat((Carr**)speech_segments->data, speech_count);
+  free(speech_segments);
+  return result;
+}
+
+void speech_trimmer_enqueue(SpeechTrimmer *self, Carr* pcm) {
+  if (self->eos_reached) {
+    carr_free(pcm);
+    return;
+  }
+  clist_add(self->queue, pcm);
+  if (bent_cent_marker_apply(self->bcm, pcm)) {
+    self->false_count = 0;
+    self->true_count += 1;
+  } else {
+    self->false_count += 1;
+    self->true_count = 0;
+  }
+  if (self->speech_started) {
+    if (self->false_count == self->ecs) {
+      self->eos_reached = TRUE;
+      int new_size = clist_size(self->queue) - self->ecs + self->trailer;
+      int i;
+      for (i=new_size; i<clist_size(self->queue); ++i)
+        carr_free(clist_get(self->queue, i));
+
+      clist_remove(self->queue, new_size, clist_size(self->queue));
+    }
+  } else if (self->true_count > self->scs) {
+    if (self->leader + self->scs < clist_size(self->queue)) {
+      int start = clist_size(self->queue) - self->leader - self->scs - 1;
+      int i;
+      for (i=0; i<start; ++i)
+        carr_free(clist_get(self->queue, i));
+
+      clist_remove(self->queue, 0, start);
+    }
+    self->speech_started = TRUE;
+  }
+}
+
+Carr * speech_trimmer_dequeue(SpeechTrimmer *self) {
+  if (clist_size(self->queue) == 0)
+    return NULL;
+  if (self->eos_reached || (self->speech_started &&
+    clist_size(self->queue) > self->ecs)) {
+    Carr * N = clist_get(self->queue, 0);
+    clist_remove(self->queue, 0, 1);
+    return N;
+  }
+  return NULL;
+}
+
+int speech_trimmer_eos(SpeechTrimmer *self) {
+  return self->eos_reached;
+}

data/lib/{c_impl → cext}/discrete_cosine_transform.c

@@ -1,13 +1,11 @@
 #include "ruby.h"
-#include "noyes.h"
-#include "rnoyes.h"
-
-static int id_push;
+#include "c_noyes.h"
+#include "r_noyes.h"
 
 VALUE cDiscreteCosineTransform;
 
-static void dct_free(void *p) {
-  free_dct(p);
+static void _dct_free(void *p) {
+  dct_free(p);
 }
 
 static VALUE t_init(VALUE self, VALUE args) {
@@ -18,20 +16,21 @@ static VALUE t_init(VALUE self, VALUE args) {
   if (len > 1)
      cols = NUM2INT(rb_ary_entry(args, 1));
 
-  DiscreteCosineTransform *dct = new_dct(rows,cols);
-  VALUE dctv = Data_Wrap_Struct(cDiscreteCosineTransform, 0, dct_free, dct);
+  DiscreteCosineTransform *dct = dct_new(rows,cols);
+  VALUE dctv = Data_Wrap_Struct(cDiscreteCosineTransform, 0, _dct_free, dct);
   rb_iv_set(self, "@dct", dctv);
   return self;
 }
 
 static VALUE t_left_shift(VALUE self, VALUE obj) {
-  NMatrix *M = v_2_nmatrix(obj);
+  Cmat *M = r2cmat(obj);
   DiscreteCosineTransform *dct;
   VALUE dctv = rb_iv_get(self, "@dct");
   Data_Get_Struct(dctv, DiscreteCosineTransform, dct);
-  NMatrix *N = dct_apply(dct, M);
-  VALUE result = nmatrix_2_v(N);
-  free_nmatrix(N);
+  Cmat *N = dct_apply(dct, M);
+  VALUE result = cmat2r(N);
+  cmat_free(N);
+  cmat_free(M);
   return result;
 }
 
@@ -39,19 +38,19 @@ static VALUE t_melcos(VALUE self) {
   DiscreteCosineTransform *dct;
   VALUE dctv = rb_iv_get(self, "@dct");
   Data_Get_Struct(dctv, DiscreteCosineTransform, dct);
-  NMatrix *N = new_nmatrix(dct->rows, dct->cols);
+  Cmat *N = cmat_new(dct->rows, dct->cols);
   int i;
   for (i=0;i<dct->rows;++i) {
     memcpy(N->data[i],dct->melcos[i], dct->cols * sizeof(double));
   }
-  VALUE result = nmatrix_2_v(N);
-  free_nmatrix(N);
+  VALUE result = cmat2r(N);
+  cmat_free(N);
   return result;
 }
 
 static VALUE t_dft(VALUE classmod, VALUE data, VALUE size) {
-  NMatrix1 *M = v_2_nmatrix1(data);
-  NMatrix *R = dft(M->data, M->rows, FIX2INT(size));
+  Carr *M = r2carr(data);
+  Cmat *R = dft(M->data, M->rows, FIX2INT(size));
   VALUE result = rb_ary_new2(R->cols);
   int i;
   for (i=0;i<R->cols;++i) {
@@ -59,8 +58,8 @@ static VALUE t_dft(VALUE classmod, VALUE data, VALUE size) {
     VALUE imag = rb_float_new(R->data[1][i]);
     rb_ary_store(result, i, rb_complex_new(real, imag));
   }
-  free_nmatrix1(M);
-  free_nmatrix(R);
+  carr_free(M);
+  cmat_free(R);
   return result;
 }
 
@@ -72,5 +71,4 @@ void Init_dct() {
   rb_define_method(cDiscreteCosineTransform, "<<", t_left_shift, 1);
   rb_define_method(cDiscreteCosineTransform, "melcos", t_melcos, 0);
   rb_define_module_function(m_noyes_c, "dft", t_dft, 2);
-  id_push = rb_intern("push");
 }

data/lib/{c_impl → cext}/hamming_window.c

@@ -1,13 +1,11 @@
 #include "ruby.h"
-#include "noyes.h"
-#include "rnoyes.h"
-
-static int id_push;
+#include "c_noyes.h"
+#include "r_noyes.h"
 
 VALUE cHammingWindow;
 
-static void hamming_window_free(void *p) {
-  free_hamming_window(p);
+static void _hamming_window_free(void *p) {
+  hamming_window_free(p);
 }
 static VALUE t_init(VALUE self, VALUE args) {
   int len = RARRAY_LEN(args);
@@ -15,20 +13,21 @@ static VALUE t_init(VALUE self, VALUE args) {
   if (len > 0) {
      winsz = NUM2INT(rb_ary_entry(args, 0));
   }
-  HammingWindow *hw = new_hamming_window(winsz);
-  VALUE hwv = Data_Wrap_Struct(cHammingWindow, 0, hamming_window_free, hw);
+  HammingWindow *hw = hamming_window_new(winsz);
+  VALUE hwv = Data_Wrap_Struct(cHammingWindow, 0, _hamming_window_free, hw);
   rb_iv_set(self, "@hw", hwv);
   return self;
 }
 
 static VALUE t_left_shift(VALUE self, VALUE obj) {
-  NMatrix *M = v_2_nmatrix(obj);
+  Cmat *M = r2cmat(obj);
   HammingWindow *hw;
   VALUE hwv = rb_iv_get(self, "@hw");
   Data_Get_Struct(hwv, HammingWindow, hw);
-  NMatrix *N = hamming_window_apply(hw, M);
-  VALUE result = nmatrix_2_v(N);
-  free_nmatrix(N);
+  Cmat *N = hamming_window_apply(hw, M);
+  VALUE result = cmat2r(N);
+  cmat_free(N);
+  cmat_free(M);
   return result;
 }
 
@@ -37,5 +36,4 @@ void Init_hamming_window() {
   cHammingWindow = rb_define_class_under(m_noyes_c, "HammingWindow", rb_cObject);
   rb_define_method(cHammingWindow, "initialize", t_init, -2);
   rb_define_method(cHammingWindow, "<<", t_left_shift, 1);
-  id_push = rb_intern("push");
 }

data/lib/{c_impl → cext}/live_cmn.c

@@ -1,13 +1,11 @@
 #include "ruby.h"
-#include "noyes.h"
-#include "rnoyes.h"
-
-static int id_push;
+#include "c_noyes.h"
+#include "r_noyes.h"
 
 VALUE cLiveCMN;
 
-static void live_cmn_free(void *p) {
-  free_live_cmn(p);
+static void _live_cmn_free(void *p) {
+  live_cmn_free(p);
 }
 
 static VALUE t_init(VALUE self, VALUE args) {
@@ -22,20 +20,21 @@ static VALUE t_init(VALUE self, VALUE args) {
   if (len > 3)
      shift = NUM2INT(rb_ary_entry(args, 3));
 
-  LiveCMN *cmn = new_live_cmn(dimensions, init_mean, window_size, shift);
-  VALUE cmnv = Data_Wrap_Struct(cLiveCMN, 0, live_cmn_free, cmn);
+  LiveCMN *cmn = live_cmn_new(dimensions, init_mean, window_size, shift);
+  VALUE cmnv = Data_Wrap_Struct(cLiveCMN, 0, _live_cmn_free, cmn);
   rb_iv_set(self, "@cmn", cmnv);
   return self;
 }
 
 static VALUE t_left_shift(VALUE self, VALUE obj) {
-  NMatrix *M = v_2_nmatrix(obj);
+  Cmat *M = r2cmat(obj);
   LiveCMN *cmn;
   VALUE cmnv = rb_iv_get(self, "@cmn");
   Data_Get_Struct(cmnv, LiveCMN, cmn);
-  NMatrix *N = live_cmn_apply(cmn, M);
-  VALUE result = nmatrix_2_v(N);
-  free_nmatrix(N);
+  Cmat *N = live_cmn_apply(cmn, M);
+  VALUE result = cmat2r(N);
+  cmat_free(N);
+  cmat_free(M);
   return result;
 }
 
@@ -44,6 +43,4 @@ void Init_live_cmn() {
   cLiveCMN = rb_define_class_under(m_noyes_c, "LiveCMN", rb_cObject);
   rb_define_method(cLiveCMN, "initialize", t_init, -2);
   rb_define_method(cLiveCMN, "<<", t_left_shift, 1);
-  id_push = rb_intern("push");
 }
-

data/lib/{c_impl → cext}/log_compressor.c

@@ -1,13 +1,11 @@
 #include "ruby.h"
-#include "noyes.h"
-#include "rnoyes.h"
-
-static int id_push;
+#include "c_noyes.h"
+#include "r_noyes.h"
 
 VALUE cLogCompressor;
 
-static void log_compressor_free(void *p) {
-  free_log_compressor(p);
+static void _log_compressor_free(void *p) {
+  log_compressor_free(p);
 }
 
 static VALUE t_init(VALUE self, VALUE args) {
@@ -16,21 +14,21 @@ static VALUE t_init(VALUE self, VALUE args) {
   if (len > 0) {
      log_zero = NUM2DBL(rb_ary_entry(args, 0));
   }
-  LogCompressor *lc = new_log_compressor(log_zero);
-  VALUE lcv = Data_Wrap_Struct(cLogCompressor, 0, log_compressor_free, lc);
+  LogCompressor *lc = log_compressor_new(log_zero);
+  VALUE lcv = Data_Wrap_Struct(cLogCompressor, 0, _log_compressor_free, lc);
   rb_iv_set(self, "@log_compressor", lcv);
   return self;
 }
 
 static VALUE t_left_shift(VALUE self, VALUE obj) {
-  NMatrix *M = v_2_nmatrix(obj);
+  Cmat *M = r2cmat(obj);
   LogCompressor *lc;
   VALUE lcv = rb_iv_get(self, "@log_compressor");
   Data_Get_Struct(lcv, LogCompressor, lc);
-  NMatrix *N = log_compressor_apply(lc, M);
-  VALUE result = nmatrix_2_v(N);
-  free_nmatrix(N);
-  free_nmatrix(M);
+  Cmat *N = log_compressor_apply(lc, M);
+  VALUE result = cmat2r(N);
+  cmat_free(N);
+  cmat_free(M);
   return result;
 }
 
@@ -39,5 +37,4 @@ void Init_log_compressor() {
   cLogCompressor = rb_define_class_under(m_noyes_c, "LogCompressor", rb_cObject);
   rb_define_method(cLogCompressor, "initialize", t_init, -2);
   rb_define_method(cLogCompressor, "<<", t_left_shift, 1);
-  id_push = rb_intern("push");
 }