multiarray 0.2.0

data/lib/multiarray/sequence_operation.rb

@@ -0,0 +1,17 @@
+module Hornetseye
+
+  module SequenceOperation
+
+    def op( *args, &action )
+      for i in 0 ... num_elements
+        sub_args = args.collect do |arg|
+          arg.is_a?( Sequence_ ) ? arg[ i ] : arg
+        end
+        sel( i ).op *sub_args, &action
+      end
+      self
+    end
+
+  end
+
+end

data/lib/multiarray/storage.rb

@@ -0,0 +1,13 @@
+module Hornetseye
+
+  class Storage
+
+    attr_reader :ptr
+
+    def initialize( data )
+      @data = data
+    end
+
+  end
+
+end

data/lib/multiarray/type.rb

@@ -0,0 +1,108 @@
+module Hornetseye
+
+  class Type
+
+    class << self
+
+      def alloc
+        memory.alloc bytesize
+      end
+
+      def typecode
+        self
+      end
+
+      def basetype
+        self
+      end
+
+      def empty?
+        size == 0
+      end
+
+      def shape
+        []
+      end
+
+      def size
+        shape.inject( 1 ) { |a,b| a * b }
+      end
+
+    end
+
+    attr_accessor :memory
+
+    def bytesize
+      self.class.bytesize
+    end
+
+    def typecode
+      self.class.typecode
+    end
+
+    def basetype
+      self.class.basetype
+    end
+    
+    def empty?
+      self.class.empty?
+    end
+
+    def shape
+      self.class.shape
+    end
+
+    def size
+      self.class.size
+    end
+
+    def initialize( *args )
+      options = args.last.is_a?( Hash ) ? args.pop : {}
+      raise ArgumentError.new( 'Too many arguments' ) unless args.size <= 1
+      value = args.empty? ? nil : args.first
+      @memory = options[ :memory ] ? options[ :memory ] : self.class.alloc
+      set value unless value.nil?
+    end
+
+    def inspect
+      "#{self.class.inspect}(#{to_s})"
+    end
+
+    def to_s
+      get.to_s
+    end
+
+    def to_a
+      get.to_a
+    end
+
+    def set( value = typecode.default )
+      @memory.store self.class, value
+      value
+    end
+
+    def get
+      @memory.load self.class
+    end
+
+    def sel
+      self
+    end
+
+    def at( *indices )
+      sel( *indices ).get
+    end
+
+    alias_method :[], :at
+
+    def assign( *args )
+      sel( *args[ 0 ... -1 ] ).set args.last
+    end
+
+    alias_method :[]=, :assign
+
+  end
+
+  Type.class_eval { include TypeOperation }
+
+end

data/lib/multiarray/type_operation.rb

@@ -0,0 +1,12 @@
+module Hornetseye
+
+  module TypeOperation
+
+    def op( *args, &action )
+      instance_exec *args, &action
+      self
+    end
+
+  end
+
+end

data/source.gemspec

@@ -0,0 +1,23 @@
+require 'date'
+Gem::Specification.new do |s|
+  s.name = %q{multiarray}
+  s.version = '0.2.0'
+  s.platform = Gem::Platform::RUBY
+  s.date = Date.today.to_s
+  s.summary = %q{Multi-dimensional and uniform Ruby arrays}
+  s.description = %q{This Ruby-extension defines Hornetseye::MultiArray and other native datatypes. Hornetseye::MultiArray provides multi-dimensional Ruby arrays with elements of same type. The extension is designed to be mostly compatible with Masahiro Tanaka's NArray. However it allows the definition of custom element types and operations on them. This work was also inspired by Ronald Garcia's boost::multi_array and by Todd Veldhuizen's Blitz++.}
+  s.author = %q{Jan Wedekind}
+  s.email = %q{jan@wedesoft.de}
+  s.homepage = %q{http://wedesoft.github.com/multiarray/}
+  s.files = [ 'source.gemspec', 'Makefile', 'README', 'COPYING' ] +
+              Dir.glob( 'lib/*.rb' ) +
+              Dir.glob( 'lib/multiarray/*.rb' ) +
+              Dir.glob( 'test/*.rb' )
+  s.test_files = Dir.glob( 'test/tc_*.rb' )
+  s.require_paths = [ 'lib' ]
+  s.rubyforge_project = %q{hornetseye}
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ 'README' ]
+  s.rdoc_options = %w{--exclude=/Makefile|.*\.(rb)/ --main README}
+  s.add_dependency %q<malloc>, [ '~> 0.2' ]
+end

data/test/tc_int.rb

@@ -0,0 +1,116 @@
+require 'test/unit'
+require 'multiarray'
+
+class TC_Int < Test::Unit::TestCase
+
+  def setup
+    @@types = [ Hornetseye::UBYTE,
+                Hornetseye::BYTE,
+                Hornetseye::USINT,
+                Hornetseye::SINT,
+                Hornetseye::UINT,
+                Hornetseye::INT,
+                Hornetseye::ULONG,
+                Hornetseye::LONG ]
+  end
+
+  def teardown
+    @@types = nil
+  end
+
+  def test_int_default
+    for t in @@types
+      assert_equal 0, t.default
+    end
+  end
+
+  def test_int_to_s
+    assert_equal 'UBYTE', Hornetseye::UBYTE.to_s
+    assert_equal 'BYTE' , Hornetseye::BYTE.to_s
+    assert_equal 'USINT', Hornetseye::USINT.to_s
+    assert_equal 'SINT' , Hornetseye::SINT.to_s
+    assert_equal 'UINT' , Hornetseye::UINT.to_s
+    assert_equal 'INT'  , Hornetseye::INT.to_s
+    assert_equal 'ULONG', Hornetseye::ULONG.to_s
+    assert_equal 'LONG' , Hornetseye::LONG.to_s
+  end
+
+  def test_int_inspect
+    for t in @@types
+      assert_equal t.to_s, t.inspect
+    end
+  end
+
+  def test_bytesize
+    for i in [ 8, 16, 32, 64 ]
+      assert_equal i, 8 * Hornetseye::INT( i, Hornetseye::UNSIGNED ).bytesize
+      assert_equal i, 8 * Hornetseye::INT( i, Hornetseye::SIGNED   ).bytesize
+    end
+  end
+
+  def test_typecode
+    for t in @@types
+      assert_equal t, t.typecode
+    end
+  end
+
+  def test_shape
+    for t in @@types
+      assert_equal [], t.shape
+    end
+  end
+
+  def test_size
+    for t in @@types
+      assert_equal 1, t.size
+    end
+  end
+
+  def test_to_s
+    for t in @@types
+      assert_equal '42', t.new( 42 ).to_s
+    end
+  end
+
+  def test_inspect
+    for t in @@types
+      assert_equal "#{t.inspect}(42)", t.new( 42 ).inspect
+    end
+  end
+
+  def test_get_set
+    for t in @@types
+      i = t.new 0
+      assert_equal 0, i.get
+      assert_equal 42, i.set( 42 )
+      assert_equal 42, i.get
+      assert_equal 0, i.set
+      assert_equal 0, i.get
+    end
+  end
+
+  def test_at_assign
+    for t in @@types
+      i = t.new 0
+      assert_equal 0, i.at
+      assert_equal 42, i.assign( 42 )
+      assert_equal 42, i.at
+      assert_raise( ArgumentError ) { i.at 0 }
+      assert_raise( ArgumentError ) { i.assign 0, 0 }
+      i = t.new 0
+      assert_equal 0, i[]
+      assert_equal 42, i[] = 42 
+      assert_equal 42, i[]
+      assert_raise( ArgumentError ) { i[ 0 ] }
+      assert_raise( ArgumentError ) { i[ 0 ] = 0 }
+    end
+  end
+
+  def test_op
+    for t in @@types
+      i = t.new 1
+      assert_equal 3, i.op( 2 ) { |x| set get + x }.get
+    end
+  end
+
+end

data/test/tc_sequence.rb

@@ -0,0 +1,126 @@
+require 'test/unit'
+require 'multiarray'
+
+class TC_Sequence < Test::Unit::TestCase
+
+  def setup
+    @@types = [ Hornetseye::UBYTE,
+                Hornetseye::BYTE,
+                Hornetseye::USINT,
+                Hornetseye::SINT,
+                Hornetseye::UINT,
+                Hornetseye::INT,
+                Hornetseye::ULONG,
+                Hornetseye::LONG ]
+  end
+
+  def teardown
+    @@types = nil
+  end
+
+  def test_default
+    for t in @@types
+      assert_equal [ t.default ] * 3, Hornetseye::Sequence( t, 3 ).default.to_a
+    end
+  end
+
+  def test_sequence_to_s
+    for t in @@types
+      assert_equal "Sequence(#{t.to_s},3)", Hornetseye::Sequence( t, 3 ).to_s
+    end
+  end
+
+  def test_sequence_inspect
+    for t in @@types
+      assert_equal "Sequence(#{t.inspect},3)",
+                   Hornetseye::Sequence( t, 3 ).inspect
+    end
+  end
+
+  def test_bytesize
+    for t in @@types
+      assert_equal t.bytesize * 3, Hornetseye::Sequence( t, 3 ).bytesize
+    end
+  end
+
+  def test_typecode
+    for t in @@types
+      assert_equal t, Hornetseye::Sequence( t, 3 ).typecode
+    end
+  end
+
+  def test_empty
+    for t in @@types
+      assert Hornetseye::Sequence( t, 0 ).new.empty?
+      assert !Hornetseye::Sequence( t, 3 ).new.empty?
+    end
+  end
+
+  def test_shape
+    for t in @@types
+      assert_equal [ 3 ], Hornetseye::Sequence( t, 3 ).shape
+    end
+  end
+
+  def test_size
+    for t in @@types
+      assert_equal 3, Hornetseye::Sequence( t, 3 ).size
+    end
+  end
+
+  def test_inspect
+    for t in @@types
+      s = Hornetseye::Sequence( t, 3 ).new
+      s[] = [ 1, 2, 3 ]
+      assert_equal "Sequence(#{t.inspect},3):\n[ 1, 2, 3 ]", s.inspect
+    end
+  end
+
+  def test_to_a
+    for t in @@types
+      s = Hornetseye::Sequence( t, 3 ).new
+      s[] = [ 1, 2, 3 ]
+      assert_equal [ 1, 2, 3 ], s.to_a
+    end
+  end
+
+  def test_get_set
+    for t in @@types
+      s1 = Hornetseye::Sequence( t, 3 ).new
+      s1[] = 2
+      assert_equal 0, s1.set
+      assert_equal [ 0, 0, 0 ], s1.get.to_a
+      assert_equal [ 0, 0, 0 ], s1.to_a
+      assert_equal 1, s1.set( 1 )
+      assert_equal [ 1, 1, 1 ], s1.to_a
+      assert_equal [ 2, 3 ], s1.set( [ 2, 3 ] )
+      assert_equal [ 2, 3, 0 ], s1.to_a
+      s2 = Hornetseye::Sequence( t, 3 ).new
+      s2[] = [ 1, 2, 3 ]
+      s1[] = s2
+      assert_equal [ 1, 2, 3 ], s2.to_a
+    end
+  end
+
+  def test_at_assign
+    for t in @@types
+      s = Hornetseye::Sequence( t, 3 ).new
+      s[] = 0
+      assert_equal [ 0, 0, 0 ], [ s.at( 0 ), s.at( 1 ), s.at( 2 ) ]
+      assert_equal [ 1, 2, 3 ], [ s.assign( 0, 1 ),
+                                  s.assign( 1, 2 ),
+                                  s.assign( 2, 3 ) ]
+      assert_equal [ 1, 2, 3 ], [ s.at( 0 ), s.at( 1 ), s.at( 2 ) ]
+      assert_raise( ArgumentError ) { s.at 0, 0 }
+      assert_nothing_raised { s.at }
+      s = Hornetseye::Sequence( t, 3 ).new
+      s[] = 0
+      assert_equal [ 0, 0, 0 ], [ s[ 0 ], s[ 1 ], s[ 2 ] ]
+      assert_equal [ 1, 2, 3 ], [ s[ 0 ] = 1, s[ 1 ] = 2, s[ 2 ] = 3 ]
+      assert_equal [ 1, 2, 3 ], [ s[ 0 ], s[ 1 ], s[ 2 ] ]
+      assert_raise( ArgumentError ) { s[ 0, 0 ] }
+      assert_nothing_raised { s[] }
+    end
+  end
+
+end

data/test/ts_multiarray.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'tc_int'
+require 'tc_sequence'
+

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: multiarray
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Jan Wedekind
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-09 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: malloc
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.2"
+    version: 
+description: This Ruby-extension defines Hornetseye::MultiArray and other native datatypes. Hornetseye::MultiArray provides multi-dimensional Ruby arrays with elements of same type. The extension is designed to be mostly compatible with Masahiro Tanaka's NArray. However it allows the definition of custom element types and operations on them. This work was also inspired by Ronald Garcia's boost::multi_array and by Todd Veldhuizen's Blitz++.
+email: jan@wedesoft.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- source.gemspec
+- Makefile
+- README
+- COPYING
+- lib/multiarray.rb
+- lib/multiarray/composite_type.rb
+- lib/multiarray/multiarray.rb
+- lib/multiarray/sequence.rb
+- lib/multiarray/list.rb
+- lib/multiarray/descriptortype.rb
+- lib/multiarray/type_operation.rb
+- lib/multiarray/int.rb
+- lib/multiarray/type.rb
+- lib/multiarray/storage.rb
+- lib/multiarray/memory.rb
+- lib/multiarray/sequence_operation.rb
+- test/ts_multiarray.rb
+- test/tc_int.rb
+- test/tc_sequence.rb
+has_rdoc: true
+homepage: http://wedesoft.github.com/multiarray/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --exclude=/Makefile|.*\.(rb)/
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: hornetseye
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Multi-dimensional and uniform Ruby arrays
+test_files: 
+- test/tc_int.rb
+- test/tc_sequence.rb