noyes 0.6.1 → 0.8.0

data/README

@@ -2,8 +2,8 @@ Noyes is a signal processing library.  It currently has just enough signal
 processing to produce features suitable for speech recognition.
 
 Pronunciation:  Typically pronounced the same as 'noise'.  But "NO!... YES!" is
-considered acceptable if you yell it loudly enough or at least with sufficient
-conviction to make people think you have truly changed your mind.
+considered acceptable if you say it with sufficient conviction to make people
+think you have truly changed your mind.
 
 Noyes is a general purpose signal processing tool that is flexible enough for
 many purposes.  However, it exists because there is a need for low-latency high

data/VERSION

@@ -0,0 +1 @@
+0.8.0

data/bin/mock_noyes_server

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# vim: set filetype=ruby :
+ROOT = File.dirname(File.dirname(__FILE__))
+$: << "#{ROOT}/lib/common"
+
+require 'optparse'
+require 'ostruct'
+require 'mock_noyes_server'
+DEF_PORT = 24902
+options = OpenStruct.new
+options.port = DEF_PORT
+OptionParser.new do |opt|
+  opt.banner = 'Usage: mock_nserv [options]'
+  opt.on '-v', '--verbose', 'Output more information' do 
+    options[:verbose] = true
+  end
+  opt.on '-h', '--help', 'Display this screen' do
+    puts opt
+    exit
+  end
+  opt.on '-p', '--port [PORT]', "Port (Default is #{DEF_PORT})" do |port|
+    options.port = port
+  end
+end.parse!
+
+server = MockNoyesServer.new options
+server.run

data/bin/nrec

@@ -1,34 +1,84 @@
 #!/usr/bin/env ruby
 # vim: set filetype=ruby :
 ROOT = File.dirname(File.dirname(__FILE__))
+VERSION_FILE = "#{ROOT}/VERSION"
 $: << "#{ROOT}/lib" << "#{ROOT}/ship"
 
-require 'optparse'
-options = {}
-OptionParser.new do |opt|
-  opt.banner = 'Usage: nrec [options] file1 file2 ...'
-  opt.on '-v', '--verbose', 'Output more information' do 
-    options[:verbose] = true
+require 'trollop'
+
+options = Trollop::options do
+  version "Noyes #{IO.read(VERSION_FILE).strip} (c) 2010 Talkhouse"
+  banner 'Usage: nrec [options] file1 file2 ...'
+  opt :implementation, "ruby, c, or java", :default => 'ruby'
+  opt :address, "address", :default => '174.129.244.159'
+  opt :port, "port", :default => 2348
+  opt :bits, "bit depth", :default => 16
+  opt :frequency, "sampling frequency", :default => 16000
+  opt :payload, "mfcc, or pcm", :default => 'mfcc'
+  opt :verbose, "verbose", :default => false
+end
+
+if options[:bits] != 16 && options[:payload] == 'mfcc'
+  Trollop::die :bits, "must be 16 for mfcc"
+end
+
+if options[:payload] == 'mfcc' && ((options[:frequency] % 8000) != 0)
+  Trollop::die :frequency, "(#{options[:frequency]}) for mfcc must be divisible by 8000"
+end
+
+# Must set implementation specific library path before requiring libraries.
+case options[:implementation].to_sym
+when :fastc
+  if RUBY_PLATFORM == 'java'
+    puts "The Java implementation is not accessable from Ruby, only JRuby."
+    puts "You'll need to check your environment carefully.  If you've"
+    puts "installed this gem under both ruby and jruby and both are in"
+    puts "your current environment you may have created a conflict."
+    puts "You must make sure the Ruby path preceeds the JRuby path."
+    exit
   end
-  options[:implementation] = :ruby
-  opt.on '-j', '--java', 'Use java implementation' do
-    options[:implementation] = :java
+  puts "Using Fast C implementation" if options[:verbose]
+  require 'noyes_c'
+  include NoyesC
+  def send_incremental_features file, to_server, from_server, bits, freq
+    puts "bits and freq #{bits} #{freq}"
+    feature_maker = NoyesC::Fast8kMfcc.new
+    pcm = file2pcm file, bits, freq
+    to_server.write TMAGIC
+    to_server.write TSTART
+    pcm.each_slice 1230 do |data|
+      data >>= feature_maker
+      next unless data
+      to_server.write TCEPSTRA
+      to_server.write [data.size].pack('N')
+      print '.'
+      data.each {|cmn| to_server.write cmn.pack('g*')} 
+      to_server.flush
+    end
+    to_server.write TEND
+    to_server.write TBYE
+    to_server.flush
+    from_server.read
   end
-  opt.on( '-h', '--help', 'Display this screen' ) do
-    puts opt
+when :c
+  if RUBY_PLATFORM == 'java'
+    puts "The Java implementation is not accessable from Ruby, only JRuby."
+    puts "You'll need to check your environment carefully.  If you've"
+    puts "installed this gem under both ruby and jruby and both are in"
+    puts "your current environment you may have created a conflict."
+    puts "You must make sure the Ruby path preceeds the JRuby path."
     exit
   end
-end.parse!
-
-# Must set implementation specific library path before requiring libraries.
-case options[:implementation]
+  puts "Using C implementation" if options[:verbose]
+  require 'noyes_c'
+  include NoyesC
 when :java
   if RUBY_PLATFORM != 'java'
     puts "The Java implementation is not accessable from Ruby, only JRuby."
     puts "You'll need to check your environment carefully.  If you've"
     puts "installed this gem under both ruby and jruby and both are in"
     puts "your current environment you may have created a conflict."
-    puts "you must make sure the jruby path preceeds the ruby path."
+    puts "You must make sure the JRuby path preceeds the Ruby path."
     exit
   end
   puts "Using Java implementation" if options[:verbose]
@@ -48,14 +98,23 @@ when :ruby
 end
 require 'socket'
 
-def recognize file, node='174.129.244.159', port=2348
-  TCPSocket.open(node, port) do |client|
-    send_incremental_features file, client, client
+def recognize file, options
+  TCPSocket.open(options[:address], options[:port]) do |client|
+    bits, rate = options[:bits], options[:frequency]
+    if options[:pcm]
+      send_incremental_pcm file, client, client, bits, rate
+    else
+      send_incremental_features file, client, client, bits, rate
+    end
   end
 end
 
 ARGV.each do |file|
   puts "recognizing file #{file}" if options[:verbose]
-  result = recognize file
-  puts "\n#{result}"
+  result = recognize file, options
+  if options[:verbose]
+    puts "\n#{result}"
+  else
+    puts "\n#{result[:transcript]}"
+  end
 end

data/lib/c_impl/discrete_cosine_transform.c

@@ -0,0 +1,60 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cDiscreteCosineTransform;
+
+static void dct_free(void *p) {
+  free_dct(p);
+}
+
+static VALUE t_init(VALUE self, VALUE args) {
+  int len = RARRAY_LEN(args);
+  int rows=13,cols=32;
+  if (len > 0)
+     rows = NUM2INT(rb_ary_entry(args, 0));
+  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);
+  rb_iv_set(self, "@dct", dctv);
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix *M = v_2_nmatrix(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);
+  return result;
+}
+
+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);
+  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);
+  return result;
+}
+
+void Init_dct() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cDiscreteCosineTransform = rb_define_class_under(m_noyes_c,
+                        "DCT", rb_cObject);
+  rb_define_method(cDiscreteCosineTransform, "initialize", t_init, -2);
+  rb_define_method(cDiscreteCosineTransform, "<<", t_left_shift, 1);
+  rb_define_method(cDiscreteCosineTransform, "melcos", t_melcos, 0);
+  id_push = rb_intern("push");
+}

data/lib/c_impl/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile "noyes_c"

data/lib/c_impl/fast_8k_mfcc.c

@@ -0,0 +1,39 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cFast8kMfcc;
+
+static void fast_8k_mfcc_free(Fast8kMfcc *p) {
+  free_fast_8k_mfcc(p);
+}
+
+static VALUE t_init(VALUE self, VALUE args) {
+  Fast8kMfcc *s = new_fast_8k_mfcc();
+  VALUE fast_8k_mfcc = Data_Wrap_Struct(cFast8kMfcc, 0, fast_8k_mfcc_free, s);
+  rb_iv_set(self, "@fast_8k_mfcc", fast_8k_mfcc);
+
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix1 *M = v_2_nmatrix1(obj); 
+  VALUE fast_8k_mfcc = rb_iv_get(self, "@fast_8k_mfcc");
+  Fast8kMfcc *s;
+  Data_Get_Struct(fast_8k_mfcc, Fast8kMfcc, s);
+  NMatrix *N = fast_8k_mfcc_apply(s, M);
+  VALUE result = nmatrix_2_v(N);
+  free_nmatrix(N);
+  free_nmatrix1(M);
+  return result;
+}
+
+void Init_fast_8k_mfcc() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cFast8kMfcc = rb_define_class_under(m_noyes_c, "Fast8kMfcc", rb_cObject);
+  rb_define_method(cFast8kMfcc, "initialize", t_init, -2);
+  rb_define_method(cFast8kMfcc, "<<", t_left_shift, 1);
+  id_push = rb_intern("push");
+}

data/lib/c_impl/hamming_window.c

@@ -0,0 +1,41 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cHammingWindow;
+
+static void hamming_window_free(void *p) {
+  free_hamming_window(p);
+}
+static VALUE t_init(VALUE self, VALUE args) {
+  int len = RARRAY_LEN(args);
+  int winsz = 205;
+  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);
+  rb_iv_set(self, "@hw", hwv);
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix *M = v_2_nmatrix(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);
+  return result;
+}
+
+void Init_hamming_window() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  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/live_cmn.c

@@ -0,0 +1,49 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cLiveCMN;
+
+static void live_cmn_free(void *p) {
+  free_live_cmn(p);
+}
+
+static VALUE t_init(VALUE self, VALUE args) {
+  int dimensions=13, init_mean=45.0, window_size=100, shift=160;
+  int len = RARRAY_LEN(args);
+  if (len > 0)
+     dimensions = NUM2INT(rb_ary_entry(args, 0));
+  if (len > 1)
+     init_mean= NUM2INT(rb_ary_entry(args, 1));
+  if (len > 2)
+     window_size = NUM2INT(rb_ary_entry(args, 2));
+  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);
+  rb_iv_set(self, "@cmn", cmnv);
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix *M = v_2_nmatrix(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);
+  return result;
+}
+
+void Init_live_cmn() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  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/log_compressor.c

@@ -0,0 +1,43 @@
+#include "ruby.h"
+#include "noyes.h"
+#include "rnoyes.h"
+
+static int id_push;
+
+VALUE cLogCompressor;
+
+static void log_compressor_free(void *p) {
+  free_log_compressor(p);
+}
+
+static VALUE t_init(VALUE self, VALUE args) {
+  int len = RARRAY_LEN(args);
+  double log_zero = -0.00001;
+  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);
+  rb_iv_set(self, "@log_compressor", lcv);
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix *M = v_2_nmatrix(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);
+  return result;
+}
+
+void Init_log_compressor() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  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");
+}

data/lib/c_impl/mel_filter.c

@@ -0,0 +1,115 @@
+#include "noyes.h"
+#include "rnoyes.h"
+#include "math.h"
+
+static int id_push;
+
+VALUE cMelFilter;
+
+static void mel_filter_free(void *p) {
+  free_mel_filter(p);
+}
+
+static VALUE t_make_filter(VALUE self, VALUE(left), VALUE(center), VALUE(right), VALUE(init_freq), VALUE(delta)) {
+  NMatrix1 *d = make_filter(NUM2DBL(left), NUM2DBL(center),
+                NUM2DBL(right), NUM2DBL(init_freq), NUM2DBL(delta)); 
+  if (d) {
+    VALUE result = rb_ary_new2(2);
+    rb_ary_store(result, 0, INT2FIX(round(d->data[0])));
+    int i;
+    VALUE filt = rb_ary_new2(d->rows-1);
+    for (i=1;i<d->rows;++i) {
+      rb_ary_store(filt, i-1, rb_float_new(d->data[i]));
+    }
+    rb_ary_store(result, 1, filt);
+    free_nmatrix1(d);
+    return result;
+  }
+  return Qnil;
+}
+
+static VALUE t_to_mel(VALUE self, VALUE m) {
+  return rb_float_new(mel(NUM2DBL(m)));
+}
+
+static VALUE t_to_linear(VALUE self, VALUE f) {
+  return rb_float_new(melinv(NUM2DBL(f)));
+}
+
+static VALUE t_make_bank_parameters(VALUE self, VALUE srate, VALUE nfft,
+                                    VALUE nfilt, VALUE lowerf, VALUE upperf) {
+  NMatrix *d = make_bank_parameters(NUM2INT(srate), NUM2INT(nfft),
+                NUM2INT(nfilt), NUM2INT(lowerf), NUM2INT(upperf)); 
+  if (d) {
+    VALUE result = rb_ary_new2(d->rows);
+    int i,j;
+    for (i=0;i<d->rows;++i) {
+      VALUE row = rb_ary_new2(d->cols);
+      rb_ary_store(result, i, row);
+      for (j=0;j<d->cols;++j) {
+        rb_ary_store(row, j, rb_float_new(d->data[i][j]));
+      }
+    }
+    free_nmatrix(d);
+    return result;
+  }
+  return Qnil;
+}
+
+static VALUE t_init(VALUE self, VALUE args) {
+  int srate=8000, nfft=256, nfilt=32, lowerf=200, upperf=3700;
+  int len = RARRAY_LEN(args);
+  if (len > 0)
+     srate = NUM2INT(rb_ary_entry(args, 0));
+  if (len > 1)
+    nfft = NUM2INT(rb_ary_entry(args, 1));
+  if (len > 2)
+    nfilt = NUM2INT(rb_ary_entry(args, 2));
+  if (len > 3)
+    lowerf = NUM2INT(rb_ary_entry(args, 3));
+  if (len > 4)
+    upperf = NUM2INT(rb_ary_entry(args, 4));
+
+  MelFilter *s = new_mel_filter(srate, nfft, nfilt, lowerf, upperf);
+  VALUE mel_filter = Data_Wrap_Struct(cMelFilter, 0, mel_filter_free, s);
+  rb_iv_set(self, "@mel_filter", mel_filter);
+
+  return self;
+}
+
+static VALUE t_left_shift(VALUE self, VALUE obj) {
+  NMatrix *M = v_2_nmatrix(obj);
+  VALUE mel_filter = rb_iv_get(self, "@mel_filter");
+  MelFilter *s;
+  Data_Get_Struct(mel_filter, MelFilter, s);
+  NMatrix *d = mel_filter_apply(s, M);
+
+  if (d) {
+    VALUE result = rb_ary_new2(d->rows);
+    int i,j;
+    for (i=0;i<d->rows;++i) {
+      VALUE row = rb_ary_new2(d->cols);
+      rb_ary_store(result, i, row);
+      for (j=0;j<d->cols;++j) {
+        rb_ary_store(row, j, rb_float_new(d->data[i][j]));
+      }
+    }
+    free_nmatrix(d);
+    return result;
+  }
+  return Qnil;
+}
+
+
+void Init_mel_filter() {
+  VALUE m_noyes_c = rb_define_module("NoyesC");
+  cMelFilter = rb_define_class_under(m_noyes_c, "MelFilter", rb_cObject);
+  rb_define_method(cMelFilter, "initialize", t_init, -2);
+  rb_define_method(cMelFilter, "<<", t_left_shift, 1);
+  rb_define_module_function(cMelFilter, "make_bank_parameters", t_make_bank_parameters, 5);
+  rb_define_module_function(cMelFilter, "make_filter", t_make_filter, 5);
+  rb_define_module_function(cMelFilter, "to_linear", t_to_linear, 1);
+  rb_define_module_function(cMelFilter, "to_mel", t_to_mel, 1);
+  id_push = rb_intern("push");
+}
+

data/lib/c_impl/n_dft.c

@@ -0,0 +1,63 @@
+#include "noyes.h"
+#include "stdlib.h"
+#include "memory.h"
+#include "math.h"
+#include "stdio.h"
+
+NMatrix * dft(double * data, int datalen, int size) {
+    if (datalen> size) {
+        fprintf(stderr,"Size(%d) must be larger than data length(%d)", size, datalen);
+        return NULL;
+    }
+    NMatrix *M = new_nmatrix(2, size);
+    double * real = M->data[0];
+    double * imag = M->data[1];
+    int j=0,i;
+    for (i=0;i<size;++i) {
+      imag[i] = 0.0;
+      real[i] = 0.0;
+    }
+    memcpy(real, data, datalen * sizeof(double));
+
+    for (i=0;i<size;++i) {
+        if (i < j) {
+           double temp = real[j];
+           real[j] = real[i];
+           real[i] = temp;
+           temp = imag[j];
+           imag[j] = imag[i];
+           imag[i] = temp;
+        }
+        int m = size/2;
+        while (j>=m && m> 1) {
+            j -= m;
+            m /= 2;
+        }   
+        j+=m;
+     }
+     int k=1,m;
+     while (k < size) {
+         int incr = 2*k;
+         double mul_r = cos(M_PI/k);
+         double mul_i = sin(M_PI/k);
+         double w_r = 1;
+         double w_i = 0;
+         for (i=0;i<k;++i) {
+             for (m=i;m<size; m+=incr) {
+                 double tmp_r = w_r * real[m+k] - w_i * imag[m+k];
+                 double tmp_i = w_r * imag[m+k] + w_i * real[m+k]; 
+                 real[m+k] = real[m] - tmp_r; 
+                 imag[m+k] = imag[m] - tmp_i; 
+                 real[m] = real[m] + tmp_r;
+                 imag[m] = imag[m] + tmp_i;
+             } 
+             double tmp_r = w_r * mul_r - w_i * mul_i;
+             double tmp_i = w_r * mul_i + w_i * mul_r; 
+             w_r = tmp_r;
+             w_i = tmp_i;
+         }
+         k=incr;
+     }
+
+    return M;
+}

data/lib/c_impl/n_discrete_cosine_transform.c

@@ -0,0 +1,46 @@
+#include "noyes.h"
+#include "math.h"
+
+DiscreteCosineTransform * new_dct(int rows, int cols) {
+  DiscreteCosineTransform *dct = malloc(sizeof(DiscreteCosineTransform));
+  dct->melcos = malloc(rows *sizeof(double*));
+  dct->rows = rows;
+  dct->cols = cols;
+  int i,j;
+  for (i=0;i<rows;++i) {
+      double freq = M_PI * i / cols;
+      double * ldct = malloc(sizeof(double) * cols);
+      for (j=0;j<cols;++j) {
+          ldct[j] = cos(freq * (j + 0.5)) / rows;
+      }
+      dct->melcos[i] = ldct;
+  }
+  return dct;
+}
+
+void free_dct(DiscreteCosineTransform *dct) {
+  int i;
+  for (i=0;i<dct->rows;++i) {
+    free(dct->melcos[i]);
+  }
+  free(dct->melcos);
+  free(dct);
+}
+
+NMatrix * dct_apply(DiscreteCosineTransform *self, NMatrix *data) {
+  NMatrix *M = new_nmatrix(data->rows, self->rows);
+  int i,j,k;
+  for (i=0;i<M->rows;++i) {
+    for (j=0;j<M->cols;++j) {
+      M->data[i][j] = 0;
+    }
+  }
+  for (i=0;i<data->rows;++i) {
+      for (j=0;j<self->rows;++j) {
+          for (k=0;k<self->cols; ++k) {
+              M->data[i][j] += data->data[i][k] * self->melcos[j][k];
+          }
+      }
+  }
+  return M;
+}