ruby-svd 0.1.0

data/LICENSE

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

data/README

@@ -0,0 +1,6 @@
+Singular Value Decomposition for Ruby with no dependency on GSL or LAPACK. Uses a C extension
+to the Numerical Recipies C implementation of an SVD matrix decomposer. 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).
+

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/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/ruby-svd.rb

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

data/lib/svd_matrix.rb

@@ -0,0 +1,41 @@
+require 'mathn'
+require 'svd'
+
+class SVDMatrix < Matrix
+  public_class_method :new
+  def initialize(m, n)
+    @rows = Array.new(m)
+    m.times {|i| @rows[i] = Array.new(n)}
+  end
+  
+  def []=(i, j, val)
+    @rows[i][j] = val
+  end
+  
+  def []=(i, row)
+    @rows[i] = row
+  end
+  
+  def inspect
+    @rows.collect {|row| "#{row.inspect}\n"}
+  end
+  
+  def lsa
+    input_array = []
+    @rows.each {|row| input_array += row}
+    u_array, w_array, v_array = SVD.decompose(input_array, row_size, column_size)
+    
+    u = SVDMatrix.new(row_size, column_size)
+    row_size.times {|i| u[i] = u_array.slice!(0,column_size)}
+    
+    v = SVDMatrix.new(column_size, column_size)
+    column_size.times {|i| v[i] = v_array.slice!(0,column_size)}
+    v = v.transpose
+    
+    w_array = w_array[0...2] + Array.new(w_array.size - 2).collect {|i| 0}
+    w = Matrix.diagonal(*w_array)
+    
+    r = (u * w * v)
+  end
+end
+

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-svd
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Will
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-18 00:00:00 +11:00
+default_executable: 
+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
+files: 
+- ext/extconf.rb
+- ext/nrutil.h
+- ext/svd.c
+- ext/svd.h
+- lib/ruby-svd.rb
+- lib/svd_matrix.rb
+- LICENSE
+- README
+has_rdoc: true
+homepage: http://github.com/willcannings/ruby-svd
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: SVD for Ruby
+test_files: []
+