jblas-ruby 1.1.1

data/lib/jblas/java.rb

@@ -0,0 +1,75 @@
+# Load the java libraries and import the classes into JBLAS.
+
+# Copyright (c) 2009-2010, Mikio L. Braun and contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#
+#     * Neither the name of the Technische Universität Berlin nor the
+#       names of its contributors may be used to endorse or promote
+#       products derived from this software without specific prior
+#       written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'java'
+begin
+  require 'jblas/jblas-1.1.1.jar'
+rescue LoadError => e
+  begin
+    org.jblas.DoubleMatrix
+  rescue NameError => e
+    raise LoadError, 'Cannot load jblas-1.1.jar, and it also does not seem to be in the class path!'
+  end
+end
+
+module JBLAS
+  ######################################################################
+  #
+  # Java Classes Import
+  #
+  ######################################################################
+
+  # In connection with rish (http://mikiobraun.github.com/rish/), we
+  # need this guard for possible reloading of this file.
+  unless JBLAS < Java
+    include Java
+
+    java_import org.jblas.DoubleMatrix
+    java_import org.jblas.FloatMatrix
+    java_import org.jblas.ComplexDoubleMatrix
+    java_import org.jblas.ComplexFloatMatrix
+    java_import org.jblas.ComplexDouble
+    java_import org.jblas.ComplexFloat
+    java_import org.jblas.SimpleBlas
+    java_import org.jblas.DoubleFunction
+    java_import org.jblas.FloatFunction
+
+    java_import org.jblas.Solve
+    java_import org.jblas.Eigen
+    java_import org.jblas.Geometry
+    java_import org.jblas.Decompose
+    java_import org.jblas.MatrixFunctions
+    java_import org.jblas.Singular
+  end
+end

data/lib/jblas/matrix_mixin.rb

@@ -0,0 +1,64 @@
+# Methods added to the Java classes are encoded as mixins in this file. Defines
+# JBLAS::MatrixMixin.
+
+# Copyright (c) 2009-2010, Mikio L. Braun and contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#
+#     * Neither the name of the Technische Universität Berlin nor the
+#       names of its contributors may be used to endorse or promote
+#       products derived from this software without specific prior
+#       written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+require 'jblas/mixin_general'
+require 'jblas/mixin_convert'
+require 'jblas/mixin_access'
+require 'jblas/mixin_arith'
+require 'jblas/mixin_class'
+require 'jblas/mixin_enum'
+
+module JBLAS
+  # Extensions to matrix classes (mostly arithmetics). This mixin is
+  # then used to automatically enrich the DoubleMatrix and FloatMatrix
+  # classes.
+  #
+  # See JBLAS for an overview. You can also browse the different functions
+  # by section:
+  #
+  # * MatrixGeneralMixin - general methods
+  # * MatrixConvertMixin - converting matrices to other representations
+  # * MatrixArithMixin - arithmetic operations
+  # * MatrixEnumMixin - matrices as an Enumerable
+  # * MatrixAccessMixin - accessing elements
+  #   Java-side jblas.
+  module MatrixMixin
+    include MatrixGeneralMixin
+    include MatrixConvertMixin
+    include MatrixArithMixin
+    include MatrixEnumMixin
+    include MatrixAccessMixin
+  end # module MatrixMixin
+end

data/lib/jblas/mixin_access.rb

@@ -0,0 +1,155 @@
+# Mixins and extensions for acessing elements.
+
+# Copyright (c) 2009-2010, Mikio L. Braun and contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#
+#     * Neither the name of the Technische Universität Berlin nor the
+#       names of its contributors may be used to endorse or promote
+#       products derived from this software without specific prior
+#       written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+class Numeric # :nodoc:
+  def to_indices
+    self
+  end
+end
+
+module Enumerable # :nodoc:
+  def to_indices
+    to_a.to_java :int
+  end
+end
+
+module Java::OrgJblasRanges::Range
+  def to_indices
+    self
+  end
+end
+
+module JBLAS
+  # Mixin for all kinds of element access.
+  #
+  # This mixin is collected into MatrixMixin.
+  #
+  # You have the following options of accessing elements:
+  #
+  # * <b>Linear access</b>: accessing all elements linearly, going down rows
+  #   first (x[i], x.get(i), x.put(i))
+  # * <b>Two-dimensional access</b>: Accessing element in row i,
+  #   column j (x[i,j], x.get(i,j), x.put(i,j)
+  # * <b>Accessing rows and columns</b>: get_row(i), get_column(i), put_row(i), put_column(i), and
+  #   also get_rows(i), get_columns(i).
+  # * <b>Accessing row and column ranges</b>: get_row_range, get_column_range, get_range
+  #
+  # As indices, you can use one of the following:
+  #
+  # * <b>Numbers</b>: x[10], x[3,4], x.getRow(3), etc.
+  # * <b>Indices as int[] arrays</b>: Unfortunately, these are bit hard
+  #   to construct in JRuby ([1,2,3].to_java :int), therefore the emthod
+  #   to_indices is added to Numeric, Enumerable, Array, and the matrices.
+  #   Then: `i = [1,2,3]; x[i.to_indices]`.
+  # * <b>Matrices</b>: In that case, x.find_indices is called to find the
+  #   non-zero elements and use those as indices.
+  # * <b>Ranges</b>: See JBLAS::Ranges
+  #
+  # For some access functions (in particular getting rows and columns), you
+  # can also specify where to copy the result to get better performance through
+  # suppressing object creations.
+  #
+  module MatrixAccessMixin
+    # Get the entry at _i_, _j_. If _j_ is omitted, linear
+    # addressing is used (that is, _i_ just enumerates all entries
+    # going down rows first.)
+    #
+    # As indices you can use numbers, int[] arrays, matrices (non-zero elements
+    # are taken as indices then), and ranges.
+    def [](i, j=nil)
+      if j
+        get(i.to_indices, j.to_indices)
+      else
+        get(i.to_indices)
+      end
+    end
+
+    # Set the entry at _i_, _j_ to _v_.  If _j_ is omitted, linear
+    # addressing is used (that is, _i_ just enumerates all entries
+    # going down rows first.)
+    #
+    # As indices you can use numbers, int[] arrays, matrices (non-zero elements
+    # are taken as indices then), and ranges.
+    def []=(i, j, v=nil)
+      if v
+        put(i.to_indices, j.to_indices, v)
+      else
+        put(i.to_indices, j)
+      end
+    end
+
+    # Get row of a matrix. Unlike the row(i) method, this method
+    # returns a copy of the given row. If result is given, the
+    # row is copied in that matrix.
+    def get_row(i, result=nil); JAVA_METHOD; end if false
+
+    # Get a number of rows.
+    #
+    # As indices you can use numbers, int[] arrays, matrices (non-zero elements
+    # are taken as indices then), and ranges.
+    def get_rows(i); JAVA_METHOD; end if false
+
+    # Get a column of a matrix. Unlike column(i) method, this
+    # method returns a copy of the given column.
+    def get_column(i); JAVA_METHOD; end if false
+
+    # Get a number of rows.
+    #
+    # As indices you can use numbers, int[] arrays, matrices (non-zero elements
+    # are taken as indices then), and ranges.
+    def get_columns(i); JAVA_METHOD; end if false
+
+    # Get a copy of rows i1 .. i2 - 1 from column j.
+    def get_row_range(i1, i2, j); JAVA_METHOD; end if false
+
+    # Get a copy of columns j1 .. j2 - 1 from row i.
+    def get_column_range(i, j1, j2); JAVA_METHOD; end if false
+
+    # Get a copy of the submatrix with rows i1 .. i2 - 1 and
+    # columns j1 .. j2 - 1.
+    def get_range(i1, i2, j1, j2); JAVA_METHOD; end if false
+
+    # Return an array usable as an index.
+    def to_indices
+      self
+    end
+  end
+
+  module_function
+
+  # Convenience function for converting arbitrary objects into indices.
+  def idx(i)
+    i.to_indices
+  end
+end

data/lib/jblas/mixin_arith.rb

@@ -0,0 +1,168 @@
+# Syntactic sugar for arithmetic operations. See JBLAS::MatrixArithMixin.
+
+# Copyright (c) 2009-2010, Mikio L. Braun and contributors
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above
+#       copyright notice, this list of conditions and the following
+#       disclaimer in the documentation and/or other materials provided
+#       with the distribution.
+#
+#     * Neither the name of the Technische Universität Berlin nor the
+#       names of its contributors may be used to endorse or promote
+#       products derived from this software without specific prior
+#       written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module JBLAS
+  # Mixin for syntactic sugar for arithmetic operations.
+  #
+  # Collected in MatrixMixin.
+  #
+  # Roughly defines the following types of operators:
+  # * arithmetic (+,-,*,/,...)
+  # * logical operations (|,&,...)
+  # * logical tests (==,>,<,...)
+  # * arithmetic operations with column and row vectors (add_column_vector, ...)
+  #
+  module MatrixArithMixin
+    # Add _o_ to this matrix. Works with matrices and scalars.
+    def +(o); add(o); end
+    # Subtract _o_ from this matrix. Works with matrices and scalars.
+    def -(o); sub(o); end
+    # Multiply this matrix with _o_. If _o_ is a matrix, this
+    # matrix-matrix multiplication. If you want element-wise
+    # multiplication, you must use +emul+
+    def *(o); mmul(o); end
+    # Divide this matrix by _o_.
+    def /(o); div(o); end
+    # Negating a matrix
+    def -@; neg; end
+
+    # Element-wise test on less-than with _o_.
+    def <(o); lt(o); end
+    # Element-wise test on less-than-or-equal with _o_.
+    def <=(o); le(o); end
+    # Element-wise test on greater-than with _o_.
+    def >(o); gt(o); end
+    # Element-wise test on greater-than-or-equal with _o_.
+    def >=(o); ge(o); end
+    # Element-wise test on equality with _o_.
+    def ===(o); eq(o); end
+
+    # Add matrices in-place.
+    def add!(s); addi(s); end
+    # Subtract matrices in-place.
+    def sub!(s); subi(s); end
+    # Multiply matrices element-wise in-place.
+    def mul!(s); muli(s); end
+    # Matrix multiply matrices in-place.
+    def mmul!(s); mmuli(s); end
+    # Divide matrices element-wise in-place.
+    def div!(s); divi(s); end
+    # Element-wise test for equality in-place.
+    def eq!(s); eqi(s); end
+    # Element-wise test for inequality in-place.
+    def ne!(s); nei(s); end
+    # Element-wise test for less-than in-place.
+    def lt!(s); lti(s); end
+    # Element-wise test for less-than-or-equal in-place.
+    def le!(s); lei(s); end
+    # Element-wise test for greater-than in-place.
+    def gt!(s); gti(s); end
+    # Element-wise test for greater-than-or-equal in-place.
+    def ge!(s); gei(s); end
+    # Element-wise logical "and" in-place.
+    def and!(s); andi(s); end
+    # Element-wise logical "or" in-place.
+    def or!(s); ori(s); end
+    # Element-wise logical exclusive-or in-place.
+    def xor!(s); xori(s); end
+
+    # Add column vector to matrix in-place.
+    def add_column_vector!(s); addi_column_vector(s); end
+    # Add row vector to matrix in-place.
+    def add_row_vector!(s); addi_row_vector(s); end
+    # Subtract column vector from matrix in-place.
+    def sub_column_vector!(s); subi_column_vector(s); end
+    # Subtract column vector from matrix in-place.
+    def sub_row_vector!(s); subi_row_vector(s); end
+    # Multiply row vector element-wise with matrix in-place.
+    def mul_column_vector!(s); muli_column_vector(s); end
+    # Divide matrix element-wise by column vector in-place.
+    def mul_row_vector!(s); muli_row_vector(s); end
+    # Multiply row vector element-wise with matrix in-place.
+    def div_column_vector!(s); divi_column_vector(s); end
+    # Divide matrix element-wise by row vector in-place.
+    def div_row_vector!(s); divi_row_vector(s); end
+
+    # Test on equality.
+    def ==(o)
+      #puts "== called with self = #{self.inspect}, o = #{o.inspect}"
+      equals(o)
+    end
+
+    # Element-wise logical and.
+    def &(o); self.and(o); end
+    # Element-wise logical or.
+    def |(o); self.or(o); end
+    # Element-wise logical exclusive-or.
+    def ^(o); self.xor(o); end
+
+    # Compute self to the power of o.
+    def **(o); MatrixFunctions.pow(self, o); end
+
+    def coerce(o) # :nodoc:
+      case o
+      when Numeric
+        return ReversedArithmetic.new(self), o
+      else
+        return self, o
+      end
+      #unless self.class === o
+      #  [ReversedArithmetic.new(self), o]
+      #end
+    end
+
+    # Documentation for Java methods
+    if false
+      # Add matrices (see also +).
+      def add(o); JAVA_METHOD; end
+      # Add matrices in-place (see also add!).
+      def addi(o, result=self); JAVA_METHOD; end
+
+      # Subtract matrices (see also -).
+      def sub(o); JAVA_METHOD; end
+      # Subtract matrices in-place (see also sub!).
+      def subi(o, result=self); JAVA_METHOD; end
+
+      # Multiply matrices element-wise. (see also *)
+      def mul(o); JAVA_METHOD; end
+      # Multiply matrices element-wise in-place. (see also mul!)
+      def muli(o, result=self); JAVA_METHOD; end
+
+      # Divide matrices element-wise (see also /)
+      def div(o); JAVA_METHOD; end
+      # Divide matric element-wise in-place (see also div!)
+      def divi(o, result=self); JAVA_METHOD; end
+    end
+  end
+end