ruby-esvidi 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03766101e6f4fa0d77d72a2c30aa1f56170b5632
+  data.tar.gz: 24265d2eb3e6ec16464ec5927ce162c2b04a7a7f
+SHA512:
+  metadata.gz: 3ed34234dc9d2ff57e2c7dcc5e5d1c8da7df7f94b5cbd8bfc1f77e3a186840c7c75cf18ae29870a5816bf7bae3ec59167488d2e6cab6cf8f89ccffaeba464cb6
+  data.tar.gz: fc0100467875e5da37526471adfaa8bc332ffdbc10f9c0b34b069f506ef7aa5662a342919743dbd4975c6c021df8827d0329483a4cd7d512ce797999c0e53d96

data/LICENSE

@@ -0,0 +1,2 @@
+Public Domain
+

data/README.md

@@ -0,0 +1,38 @@
+Fork from [willcannings/Ruby-SVD](https://github.com/willcannings/Ruby-SVD) to fix some bugs.
+
+Ruby SVD
+========
+Singular Value Decomposition for Ruby with no dependency on GSL or LAPACK.
+
+About
+-----
+Ruby SVD provides an interface to the Numerical Recipies C implementation of an SVD matrix decomposer. It also includes an extension to the native Ruby Matrix class with a simple LSA
+method (decomposes the matrix, transposes matrix V, diagonalises the S array into a matrix, then removes all but the two leading terms in S to compress the original matrix to two dimensions).
+
+Sample Usage
+------------
+```ruby
+require 'ruby-svd'
+
+tdm = SVDMatrix.new(4, 2)
+tdm.set_row(0, [1,0])
+tdm.set_row(1, [1,0])
+tdm.set_row(2, [0,1])
+tdm.set_row(3, [0,1])
+
+puts "== Term document matrix:"
+p tdm
+
+puts "\n== Decomposing matrix:"
+lsa = LSA.new(tdm)
+p lsa
+
+puts "\n== Classifying new column vector: [1, 0.5, 0, 0.5]"
+puts "Format is [column, similarity]"
+ranks = lsa.classify_vector([1,0.5,0,0.5])
+p ranks
+
+sorted_ranks = ranks.sort_by(&:last).reverse
+puts "\n== Vector most similar to column #{sorted_ranks.first[0]}"
+p tdm.column(sorted_ranks.first[0])
+```

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+# file: extconf.rb
+require 'mkmf'
+create_makefile('svd')

data/ext/nrutil.h

@@ -0,0 +1,376 @@
+/* nrutil.h */
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+#define NR_END 1
+#define FREE_ARG char*
+
+
+#ifndef _NR_UTILS_H_
+#define _NR_UTILS_H_
+
+static float sqrarg;
+#define SQR(a) ((sqrarg = (a)) == 0.0 ? 0.0 : sqrarg*sqrarg)
+
+static double dsqrarg;
+#define DSQR(a) ((dsqrarg = (a)) == 0.0 ? 0.0 : dsqrarg*dsqrarg)
+
+static double dmaxarg1, dmaxarg2;
+#define DMAX(a, b) (dmaxarg1 = (a), dmaxarg2 = (b), (dmaxarg1) > (dmaxarg2) ? (dmaxarg1) : (dmaxarg2))
+
+static double dminarg1, dminarg2;
+#define DMIN(a, b) (dminarg1 = (a), dminarg2 = (b), (dminarg1) < (dminarg2) ? (dminarg1) : (dminarg2))
+
+static float maxarg1, maxarg2;
+#define FMAX(a, b) (maxarg1 = (a), maxarg2 = (b), (maxarg1) > (maxarg2) ? (maxarg1) : (maxarg2))
+
+static float minarg1, minarg2;
+#define FMIN(a, b) (minarg1 = (a), minarg2 = (b), (minarg1) < (minarg2) ? (minarg1) : (minarg2))
+
+static long lmaxarg1, lmaxarg2;
+#define LMAX(a, b) (lmaxarg1 = (a), lmaxarg2 = (b), (lmaxarg1) > (lmaxarg2) ? (lmaxarg1) : (lmaxarg2))
+
+static long lminarg1, lminarg2;
+#define LMIN(a, b) (lminarg1 = (a), lminarg2 = (b), (lminarg1) < (lminarg2) ? (lminarg1) : (lminarg2))
+
+static int imaxarg1, imaxarg2;
+#define IMAX(a, b) (imaxarg1 = (a), imaxarg2 = (b), (imaxarg1) > (imaxarg2) ? (imaxarg1) : (imaxarg2))
+
+static int iminarg1, iminarg2;
+#define IMIN(a, b) (iminarg1 = (a), iminarg2 = (b), (iminarg1) < (iminarg2) ? (iminarg1) : (iminarg2))
+     
+#define SIGN(a, b) ((b) >= 0.0 ? fabs(a) : -fabs(a))
+     
+
+/* prototype declaration */
+
+#if defined(__STDC__) || defined(ANSI) || defined(NRANSI) /* ANSI */
+
+void nrerror(char error_test[]);
+float *vector(long nl, long nh);
+int *ivector(long nl, long nh);
+unsigned char *cvector(long nl, long nh);
+unsigned long *lvector(long nl, long nh);
+double *dvector(long nl, long nh);
+float **matrix(long nrl, long nrh, long ncl, long nch);
+double  **dmatrix(long nrl, long nrh, long ncl, long nch);
+int **imatrix(long nrl, long nrh, long ncl, long nch);
+float **submatrix(float **a, long oldrl, long oldrh, 
+		  long oldcl, long oldch, long newrl, long newcl);
+float **convert_matrix(float *a, long nrl, long nrh, long ncl, long nch);
+float ***f3tensor(long nrl, long nrh, long ncl, long nch, 
+		  long ndl, long ndh);
+void free_vector(float *v, long nl, long nh);
+void free_ivector(int *v, long nl, long nh);
+void free_cvector(unsigned char *v, long nl, long nh);
+void free_lvector(unsigned long *v, long nl, long nh);
+void free_dvector(double *v, long nl, long nh);
+void free_matrix(float **m, long nrl, long nrh, long ncl, long nch);
+void free_dmatrix(double **m, long nrl, long nrh, long ncl, long nch);
+void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch);
+void free_submatrix(float **b, long nrl, long nrh, long ncl, long nch);
+void free_convert_matrix(float **b, long nrl, long nrh, 
+			 long ncl, long nch);
+void free_f3tensor(float ***t, long nrl, long nrh, long ncl, long nch, 
+		   long ndl, long ndh);
+
+#else /* ANSI */
+/* traditional -K&R */
+
+void nrerror();
+float *vector();
+
+#endif /* ANSI */
+
+#endif /* _NR_UTILS_H_ */
+
+
+/* function definition */
+
+
+void nrerror(char error_text[])
+     /* Numerical Recipes standard error handler */
+{
+  fprintf(stderr, "Numerical Recipes run-time error...\n");
+  fprintf(stderr, "%s\n",error_text);
+  fprintf(stderr, "...now exiting to system...\n");
+  exit(1);
+}
+
+float *vector(long nl, long nh)
+     /* allocate a float vector with subscript range v[nl..nr] */
+{
+  float *v;
+  
+  v = (float *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(float)));
+  if (!v) nrerror("allocation failure in vector()");
+  return v - nl + NR_END;
+}
+
+int *ivector(long nl, long nh)
+     /* allocate an int vector with subscript range v[nl..nr] */
+{
+  int *v;
+  
+  v = (int *)malloc((size_t)((nh - nl + 1 + NR_END)*sizeof(int)));
+  if (!v) nrerror("allocation failure in ivector()");
+  return v - nl + NR_END;
+}
+
+unsigned char *cvector(long nl, long nh)
+     /* allocate an unsigned char vector with subscript range v[nl..nr] */
+{
+  unsigned char *v;
+  
+  v = (unsigned char *)malloc((size_t)((nh - nl + 1 + NR_END)
+				       * sizeof(unsigned char)));
+  if (!v) nrerror("allocation failure in cvector()");
+  return v - nl + NR_END;
+}
+
+unsigned long *lvector(long nl, long nh)
+     /* allocate an unsigned long vector with subscript range v[nl..nr] */
+{
+  unsigned long *v;
+  
+  v = (unsigned long *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(long)));
+  if (!v) nrerror("allocation failure in lvector()");
+  return v - nl + NR_END;
+}
+
+double *dvector(long nl, long nh)
+     /* allocate a double vector with subscript range v[nl..nr] */
+{
+  double *v;
+  
+  v = (double *)malloc((size_t)((nh - nl + 1 + NR_END) * sizeof(double)));
+  if (!v) nrerror("allocation failure in dvector()");
+  return v - nl + NR_END;
+}
+
+float **matrix(long nrl, long nrh, long ncl, long nch)
+     /* allocate a float matrix with subscript range m[nrl..nrh][ncl, nch] */
+{
+  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
+  float **m;
+  
+  /* allocate pointers to rows */
+  m = (float **)malloc((size_t)((nrow + NR_END) * sizeof(float *)));
+  if (!m) nrerror("allocation failure 1 in matrix()");
+  m += NR_END;
+  m -= nrl;
+  
+  /* allocate rows and set pointers to them */
+  m[nrl] = (float *)malloc((size_t)((nrow * ncol + NR_END) * sizeof(float)));
+  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
+  m[nrl] += NR_END;
+  m[nrl] -= ncl;
+  
+  for (i = nrl + 1; i <= nrh; i++) m[i] = m[i-1] + ncol;
+  
+  /* return pointer to array of pointers to rows */
+  return m;
+}
+
+double **dmatrix(long nrl, long nrh, long ncl, long nch)
+     /* allocate a double matrix with subscript range m[nrl..nrh][ncl, nch] */
+{
+  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
+  double **m;
+  
+  /* allocate pointers to rows */
+  m = (double **)malloc((size_t)((nrow + NR_END) * sizeof(double *)));
+  if (!m) nrerror("allocation failure 1 in matrix()");
+  m += NR_END;
+  m -= nrl;
+  
+  /* allocate rows and set pointers to them */
+  m[nrl] = (double *)malloc((size_t)((nrow * ncol + NR_END) * sizeof(double)));
+  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
+  m[nrl] += NR_END;
+  m[nrl] -= ncl;
+  
+  for (i = nrl + 1; i <= nrh; i++) m[i] = m[i-1] + ncol;
+  
+  /* return pointer to array of pointers to rows */
+  return m;
+}
+
+int **imatrix(long nrl, long nrh, long ncl, long nch)
+     /* allocate an int matrix with subscript range m[nrl..nrh][ncl, nch] */
+{
+  long i, nrow = nrh - nrl + 1, ncol = nch - ncl + 1;
+  int **m;
+  
+  /* allocate pointers to rows */
+  m = (int **)malloc((size_t)((nrow + NR_END) * sizeof(int *)));
+  if (!m) nrerror("allocation failure 1 in matrix()");
+  m += NR_END;
+  m -= nrl;
+  
+  /* allocate rows and set pointers to them */
+  m[nrl] = (int *)malloc((size_t)((nrow * ncol + NR_END) * sizeof(int)));
+  if (!m[nrl]) nrerror("allocation failure 2 in matrix()");
+  m[nrl] += NR_END;
+  m[nrl] -= ncl;
+  
+  for (i = nrl + 1; i <= nrh; i++) m[i] = m[i-1] + ncol;
+  
+  /* return pointer to array of pointers to rows */
+  return m;
+}
+
+float **submatrix(float **a, long oldrl, long oldrh, long oldcl, long oldch,
+		  long newrl, long newcl)
+     /* point a submatrix [newrl..][newcl..] 
+	to a[oldrl..oldrh][oldcl..oldch] */
+     
+{
+  long i, j, nrow = oldrh - oldrl + 1, ncol = oldcl - newcl;
+  float **m;
+  
+  /* allocate array of pointers to rows */
+  m = (float **)malloc((size_t)((nrow + NR_END) * sizeof(float *)));
+  if (!m) nrerror("allocation failure in submatrix()");
+  m += NR_END;
+  m -= newrl;
+  
+  /* set pointers to rows */
+  for (i = oldrl, j = newrl; i <= oldrh; i++, j++) m[j] = a[i] + ncol;
+  
+  /* return pointer to array of pointers to rows */
+  return m;
+}
+
+float **convert_matrix(float *a, long nrl, long nrh, long ncl, long nch)
+     /* allocate a float matrix m[nrl..nrh][ncl..nch] that points to the matrix
+	declared in the standard C manner as a[nrow][ncol], 
+	where nrow = nrh - nrl + 1 and ncol = nch - ncl + 1. The routine should
+	be called with the address &a[0][0] as the first argument. */
+{
+  long i, j, nrow = nrh -nrl + 1, ncol = nch - ncl + 1;
+  float **m;
+  
+  /* allocate pointers to rows */
+  m = (float **)malloc((size_t)((nrow + NR_END) * sizeof(float *)));
+  if (!m) nrerror("allocation failure in convert_matrix()");
+  m += NR_END;
+  m -= nrl;
+  
+  /* set pointers to rows */
+  m[nrl] = a - ncl;
+  for (i = 1, j = nrl + 1; i < nrow; i++, j++) m[j] = m[j - 1] + ncol;
+  
+  /* return pointer to array of pointers to rows */
+  return m;
+}
+
+float ***f3tensor(long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
+     /* allocate a float 3tensor with range t[nrl..nrh][ncl..nch][ndl..ndh] */
+{
+  long i, j, nrow = nrh - nrl + 1, ncol = nch - ncl + 1, ndep = ndh - ndl + 1;
+  float ***t;
+  
+  /* allocate pointers to pointers to rows */
+  t = (float ***)malloc((size_t)((nrow + NR_END) * sizeof(float **)));
+  if (!t) nrerror("allocation failure 1 in f3tensor()");
+  t += NR_END;
+  t -= nrl;
+  
+  /* allocate pointers to rows and set pointers to them */
+  t[nrl] = (float **)malloc((size_t)((nrow * ncol + NR_END) 
+				     * sizeof(float *)));
+  if (!t[nrl]) nrerror("allocation failure 2 in f3tensor()");
+  t[nrl] += NR_END;
+  t[nrl] -= ncl;
+  
+  /* allocate rows and set pointers to them */
+  t[nrl][ncl] = (float *)malloc((size_t)((nrow * ncol * ndep + NR_END) 
+					 * sizeof(float)));
+  if (!t[nrl][ncl]) nrerror("allocation failure 3 in f3tensor()");
+  t[nrl][ncl] += NR_END;
+  t[nrl][ncl] -= ndl;
+  
+  for (j = ncl + 1; j <= nch; j++) t[nrl][j] = t[nrl][j - 1] + ndep;
+  for (i = nrl + 1; i <= nrh; i++) {
+    t[i] = t[i - 1] + ncol;
+    t[i][ncl] = t[i - 1][ncl] + ncol * ndep;
+    for ( j = ncl + 1; j <= nch; j++) t[i][j] = t[i][j - 1] + ndep;
+  }
+  
+  /* return pointer to array of pointers to rows */
+  return t;
+}
+
+void free_vector(float *v, long nl, long nh)
+     /* free a float vector allocated with vector() */
+{
+  free((FREE_ARG)(v + nl - NR_END));
+}
+
+void free_ivector(int *v, long nl, long nh)
+     /* free an int vector allocated with ivector() */
+{
+  free((FREE_ARG)(v + nl - NR_END));
+}
+
+void free_cvector(unsigned char *v, long nl, long nh)
+     /* free an unsigned char vector allocated with cvector() */
+{
+  free((FREE_ARG)(v + nl - NR_END));
+}
+
+void free_lvector(unsigned long *v, long nl, long nh)
+     /* free an unsigned long vector allocated with lvector() */
+{
+  free((FREE_ARG)(v + nl - NR_END));
+}
+
+void free_dvector(double *v, long nl, long nh)
+     /* free a double vector allocated with dvector() */
+{
+  free((FREE_ARG)(v + nl - NR_END));
+}
+
+void free_matrix(float **m, long nrl, long nrh, long ncl, long nch)
+     /* free a float matrix allocated by matrix() */
+{
+  free((FREE_ARG)(m[nrl] + ncl - NR_END));
+  free((FREE_ARG)(m + nrl - NR_END));
+}
+
+void free_dmatrix(double **m, long nrl, long nrh, long ncl, long nch)
+     /* free a double matrix allocated by dmatrix() */
+{
+  free((FREE_ARG)(m[nrl] + ncl - NR_END));
+  free((FREE_ARG)(m + nrl - NR_END));
+}
+
+void free_imatrix(int **m, long nrl, long nrh, long ncl, long nch)
+     /* free an int matrix allocated by imatrix() */
+{
+  free((FREE_ARG)(m[nrl] + ncl - NR_END));
+  free((FREE_ARG)(m + nrl - NR_END));
+}
+
+void free_submatirx(float **b, long nrl, long nrh, long ncl, long nch)
+     /* free a submatirx allocated by submatirx() */
+{
+  free((FREE_ARG)(b + nrl - NR_END));
+}
+
+void free_convert_matirx(float **b, long nrl, long nrh, long ncl, long nch)
+     /* free a matirx allocated by convert_matirx() */
+{
+  free((FREE_ARG)(b + nrl - NR_END));
+}
+
+void free_f3tensor(float ***t, long nrl, long nrh, long ncl, long nch,
+		   long ndl, long ndh)
+     /* free a float f3tensor allocated by f3tensor() */
+{
+  free((FREE_ARG)(t[nrl][ncl] + ndl - NR_END));
+  free((FREE_ARG)(t[nrl] + ncl - NR_END));
+  free((FREE_ARG)(t + nrl - NR_END));
+}
+

data/ext/svd.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <ruby.h>
+#include "svd.h"
+
+VALUE decompose(VALUE module, VALUE matrix_ruby, VALUE m_ruby, VALUE n_ruby) {
+	int m = NUM2INT(m_ruby);
+	int n = NUM2INT(n_ruby);
+	float **u = matrix(1, m, 1, n);
+	float **v = matrix(1, m, 1, n);
+	float *w = vector(1, n);
+	VALUE *matrix_values = RARRAY_PTR(matrix_ruby);
+	int offset = 0;
+	int i, j;
+	
+	/* output arrays */
+	VALUE u_output = rb_ary_new();
+	VALUE v_output = rb_ary_new();
+	VALUE w_output = rb_ary_new();
+	VALUE output = rb_ary_new();
+	
+	/* precondition */
+	if((m*n) != RARRAY_LEN(matrix_ruby)) {
+		rb_raise(rb_eRangeError, "Size of the array is not equal to m * n");
+		return;
+	}
+	
+	/* convert to u matrix */
+	for(i = 1; i <= m; i++) {
+		for(j = 1; j <= n; j++) {
+			offset = ((i-1)*n) + (j-1);
+			u[i][j] = (float) NUM2DBL(matrix_values[offset]);
+		}
+	}
+
+	/* perform SVD */
+	svdcmp(u, m, n, w, v);
+	
+	/* create w output array */
+	for(i = 1; i <= n; i++)
+		rb_ary_push(w_output, rb_float_new(w[i]));
+	
+	/* create u arrays */
+	for(i = 1; i <= m; i++) {
+		for(j = 1; j <= n; j++) {
+			rb_ary_push(u_output, rb_float_new(u[i][j]));
+		}
+	}
+	
+	/* create v arrays */
+	for(i = 1; i <= n; i++) {
+		for(j = 1; j <= n; j++) {
+			rb_ary_push(v_output, rb_float_new(v[i][j]));
+		}
+	}
+	
+	rb_ary_push(output, u_output);
+	rb_ary_push(output, w_output);
+	rb_ary_push(output, v_output);
+	return output;
+}
+
+void Init_svd()
+{
+	VALUE module = rb_define_module("SVD");
+	rb_define_module_function(module, "decompose", decompose, 3);
+}		

data/ext/svd.h

@@ -0,0 +1,194 @@
+/* svd.h */
+/* Singular Value Decomposition for solving linear algebraic equations */
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include "nrutil.h"
+
+float pythag(float a, float b)
+{
+	float absa,absb;
+	absa=fabs(a);
+	absb=fabs(b);
+	if (absa > absb) return absa*sqrt(1.0+SQR(absb/absa));
+	else return (absb == 0.0 ? 0.0 : absb*sqrt(1.0+SQR(absa/absb)));
+}
+
+void svdcmp(float **a, int m, int n, float w[], float **v)
+{
+	float pythag(float a, float b);
+	int flag,i,its,j,jj,k,l,nm;
+	float anorm,c,f,g,h,s,scale,x,y,z,*rv1;
+
+	rv1=vector(1,n);
+	g=scale=anorm=0.0;
+	for (i=1;i<=n;i++) {
+		l=i+1;
+		rv1[i]=scale*g;
+		g=s=scale=0.0;
+		if (i <= m) {
+			for (k=i;k<=m;k++) scale += fabs(a[k][i]);
+			if (scale) {
+				for (k=i;k<=m;k++) {
+					a[k][i] /= scale;
+					s += a[k][i]*a[k][i];
+				}
+				f=a[i][i];
+				g = -SIGN(sqrt(s),f);
+				h=f*g-s;
+				a[i][i]=f-g;
+				for (j=l;j<=n;j++) {
+					for (s=0.0,k=i;k<=m;k++) s += a[k][i]*a[k][j];
+					f=s/h;
+					for (k=i;k<=m;k++) a[k][j] += f*a[k][i];
+				}
+				for (k=i;k<=m;k++) a[k][i] *= scale;
+			}
+		}
+		w[i]=scale *g;
+		g=s=scale=0.0;
+		if (i <= m && i != n) {
+			for (k=l;k<=n;k++) scale += fabs(a[i][k]);
+			if (scale) {
+				for (k=l;k<=n;k++) {
+					a[i][k] /= scale;
+					s += a[i][k]*a[i][k];
+				}
+				f=a[i][l];
+				g = -SIGN(sqrt(s),f);
+				h=f*g-s;
+				a[i][l]=f-g;
+				for (k=l;k<=n;k++) rv1[k]=a[i][k]/h;
+				for (j=l;j<=m;j++) {
+					for (s=0.0,k=l;k<=n;k++) s += a[j][k]*a[i][k];
+					for (k=l;k<=n;k++) a[j][k] += s*rv1[k];
+				}
+				for (k=l;k<=n;k++) a[i][k] *= scale;
+			}
+		}
+		anorm=FMAX(anorm,(fabs(w[i])+fabs(rv1[i])));
+	}
+	for (i=n;i>=1;i--) {
+		if (i < n) {
+			if (g) {
+				for (j=l;j<=n;j++)
+					v[j][i]=(a[i][j]/a[i][l])/g;
+				for (j=l;j<=n;j++) {
+					for (s=0.0,k=l;k<=n;k++) s += a[i][k]*v[k][j];
+					for (k=l;k<=n;k++) v[k][j] += s*v[k][i];
+				}
+			}
+			for (j=l;j<=n;j++) v[i][j]=v[j][i]=0.0;
+		}
+		v[i][i]=1.0;
+		g=rv1[i];
+		l=i;
+	}
+	for (i=IMIN(m,n);i>=1;i--) {
+		l=i+1;
+		g=w[i];
+		for (j=l;j<=n;j++) a[i][j]=0.0;
+		if (g) {
+			g=1.0/g;
+			for (j=l;j<=n;j++) {
+				for (s=0.0,k=l;k<=m;k++) s += a[k][i]*a[k][j];
+				f=(s/a[i][i])*g;
+				for (k=i;k<=m;k++) a[k][j] += f*a[k][i];
+			}
+			for (j=i;j<=m;j++) a[j][i] *= g;
+		} else for (j=i;j<=m;j++) a[j][i]=0.0;
+		++a[i][i];
+	}
+	for (k=n;k>=1;k--) {
+		for (its=1;its<=30;its++) {
+			flag=1;
+			for (l=k;l>=1;l--) {
+				nm=l-1;
+				if ((float)(fabs(rv1[l])+anorm) == anorm) {
+					flag=0;
+					break;
+				}
+				if ((float)(fabs(w[nm])+anorm) == anorm) break;
+			}
+			if (flag) {
+				c=0.0;
+				s=1.0;
+				for (i=l;i<=k;i++) {
+					f=s*rv1[i];
+					rv1[i]=c*rv1[i];
+					if ((float)(fabs(f)+anorm) == anorm) break;
+					g=w[i];
+					h=pythag(f,g);
+					w[i]=h;
+					h=1.0/h;
+					c=g*h;
+					s = -f*h;
+					for (j=1;j<=m;j++) {
+						y=a[j][nm];
+						z=a[j][i];
+						a[j][nm]=y*c+z*s;
+						a[j][i]=z*c-y*s;
+					}
+				}
+			}
+			z=w[k];
+			if (l == k) {
+				if (z < 0.0) {
+					w[k] = -z;
+					for (j=1;j<=n;j++) v[j][k] = -v[j][k];
+				}
+				break;
+			}
+			if (its == 30) nrerror("no convergence in 30 svdcmp iterations");
+			x=w[l];
+			nm=k-1;
+			y=w[nm];
+			g=rv1[nm];
+			h=rv1[k];
+			f=((y-z)*(y+z)+(g-h)*(g+h))/(2.0*h*y);
+			g=pythag(f,1.0);
+			f=((x-z)*(x+z)+h*((y/(f+SIGN(g,f)))-h))/x;
+			c=s=1.0;
+			for (j=l;j<=nm;j++) {
+				i=j+1;
+				g=rv1[i];
+				y=w[i];
+				h=s*g;
+				g=c*g;
+				z=pythag(f,h);
+				rv1[j]=z;
+				c=f/z;
+				s=h/z;
+				f=x*c+g*s;
+				g = g*c-x*s;
+				h=y*s;
+				y *= c;
+				for (jj=1;jj<=n;jj++) {
+					x=v[jj][j];
+					z=v[jj][i];
+					v[jj][j]=x*c+z*s;
+					v[jj][i]=z*c-x*s;
+				}
+				z=pythag(f,h);
+				w[j]=z;
+				if (z) {
+					z=1.0/z;
+					c=f*z;
+					s=h*z;
+				}
+				f=c*g+s*y;
+				x=c*y-s*g;
+				for (jj=1;jj<=m;jj++) {
+					y=a[jj][j];
+					z=a[jj][i];
+					a[jj][j]=y*c+z*s;
+					a[jj][i]=z*c-y*s;
+				}
+			}
+			rv1[l]=0.0;
+			rv1[k]=f;
+			w[k]=x;
+		}
+	}
+	free_vector(rv1,1,n);
+}

data/lib/lsa.rb

@@ -0,0 +1,43 @@
+require 'svd_matrix'
+
+class LSA
+  attr_accessor :u, :s, :v
+
+  def initialize(matrix)
+    @u, @s, @v = matrix.decompose(2)
+  end
+  
+  def inspect
+    "U:\n#{@u.inspect}\n\nS:\n#{@s.inspect}\n\nV:\n#{@v.inspect}"
+  end
+  
+  # Return a distance (cosine similarity) between a new vector,
+  # and all the clusters (columns) used in the original matrix.
+  # Returns a sorted list of indexes and distances,
+  def classify_vector(values)
+    raise "Unsupported vector length" unless values.size == @u.row_size || values.size == @v.row_size
+    vector = Matrix.row_vector(values)
+    mult_matrix = (values.size == @u.row_size ? @u : @v)
+    comp_matrix = (values.size == @u.row_size ? @v : @u)
+    
+    position = vector * Matrix[*mult_matrix] * @s.inverse
+    x = position[0,0]
+    y = position[0,1]
+    results = []
+    
+    comp_matrix.row_size.times do |index|
+      results << [index, cosine_similarity(x, y, comp_matrix[index, 0], comp_matrix[index, 1])]
+    end
+    
+    results.sort {|a, b| b[1] <=> a[1]}
+  end
+  
+  # Determines the cosine similarity between two 2D points
+  def cosine_similarity(x1, y1, x2, y2)
+    dp = (x1 * x2) + (y1 * y2)
+    mag1 = Math.sqrt((x1 ** 2) + (y1 ** 2))
+    mag2 = Math.sqrt((x2 ** 2) + (y2 ** 2))
+    return 0 if mag1 == 0 || mag2 == 0
+    return (dp / (mag1 * mag2))
+  end
+end

data/lib/ruby-esvidi.rb

@@ -0,0 +1,3 @@
+require 'svd'
+require 'svd_matrix'
+require 'lsa'

data/lib/svd_matrix.rb

@@ -0,0 +1,70 @@
+require 'mathn'
+require 'svd'
+
+class SVDMatrix < Matrix
+  public_class_method :new
+  
+  # Create a new SVD Matrix with m rows, n columns
+  def initialize(m, n)
+    @rows = Array.new(m)
+    @column_size = n
+    m.times {|i| @rows[i] = Array.new(n)}
+  end
+  
+  # Set the value of the cell i, j
+  def []=(i, j, val)
+    @rows[i][j] = val
+  end
+  
+  # Set the value of a row to an array
+  def set_row(i, row)
+    @rows[i] = row
+  end
+  
+  # Nicely formatted inspect string for the matrix
+  def inspect
+    @rows.collect {|row| row.inspect}.join("\n")
+  end
+
+  # Perform SVD and decompose the matrix into three matrices:
+  # U, W, and V. You can choose to reduce the dimensionality of
+  # the data by setting a number of diagonal cells to 0. For
+  # example,  reduce_dimentions_to = 2 will set a 4x4 W
+  # matrix into:
+  # [NUM, 0, 0, 0]
+  # [0, NUM, 0, 0]
+  # [ 0, 0, 0, 0 ]
+  # [ 0, 0, 0, 0 ]
+  def decompose(reduce_dimensions_to = nil)
+    input_array = []
+    @rows.each {|row| input_array += row}
+    u_array, w_array, v_array = SVD.decompose(input_array, row_size, @column_size)
+    
+    # recompose U matrix
+    u = SVDMatrix.new(row_size, reduce_dimensions_to || @column_size)
+    row_size.times {|i| u.set_row(i, u_array.slice!(0, @column_size)[0...(reduce_dimensions_to || @column_size)])}
+    
+    # recompose V matrix
+    v = SVDMatrix.new(@column_size, reduce_dimensions_to || @column_size)
+    @column_size.times {|i| v.set_row(i, v_array.slice!(0, @column_size)[0...(reduce_dimensions_to || @column_size)])}
+    
+    # diagonalise W array as a matrix
+    if reduce_dimensions_to
+      w_array = w_array[0...reduce_dimensions_to]
+    end
+    w = Matrix.diagonal(*w_array)
+    
+    [u, w, v]
+  end
+  
+  # Reduce the number of dimensions of the data to dimensions.
+  # Returns a back a recombined matrix (conceptually the original
+  # matrix dimensionally reduced). For example Latent Semantic
+  # Analysis uses 2 dimensions, and commonly tf-idf cell data.
+  # The recombined matrix, and the 3 decomposed matrices are
+  # returned.
+  def reduce_dimensions(dimensions = 2)
+    u, w, v = self.decompose(dimensions)
+    [(u * w * v.transpose), u, w, v]
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: ruby-esvidi
+version: !ruby/object:Gem::Version
+  version: 0.5.2
+platform: ruby
+authors:
+- Will Cannings
+- Patricio Sard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-03 00:00:00.000000000 Z
+dependencies: []
+description: Singular Value Decomposition with no dependency on GSL or LAPACK
+email: me@willcannings.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- ext/extconf.rb
+- ext/nrutil.h
+- ext/svd.c
+- ext/svd.h
+- lib/lsa.rb
+- lib/ruby-esvidi.rb
+- lib/svd_matrix.rb
+homepage: http://github.com/willcannings/ruby-svd
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 3
+summary: SVD for Ruby
+test_files: []