sciruby 0.1.3 → 0.2.1

data/lib/sciruby/analysis/suite_report_builder.rb

@@ -1,44 +0,0 @@
-module SciRuby
-  module Analysis
-    class SuiteReportBuilder < Suite
-      attr_accessor :rb
-      def initialize(opts=Hash.new,&block)
-        if !opts.is_a? Hash
-          opts={:name=>opts}
-        end
-        super(opts,&block)
-        @rb=opts[:rb] || ReportBuilder.new(:name=>name)
-      end
-      def generate(filename)
-        run if @block
-        @rb.save(filename)
-      end
-      def to_text
-        run if @block
-        @rb.to_text
-      end
-      def summary(o)
-        @rb.add(o)
-      end
-      def desc(d)
-        @rb.add(d)
-      end
-      def echo(*args)
-        args.each do |a|
-          @rb.add(a)
-        end
-      end
-
-      def boxplot(*args)
-        @rb.add(old_boxplot(*args))
-      end
-      def histogram(*args)
-        @rb.add(old_histogram(*args))
-      end
-      def boxplot(*args)
-        @rb.add(old_boxplot(*args))
-      end
-
-    end
-  end
-end

data/lib/sciruby/analysis.rb

@@ -1,98 +0,0 @@
-require 'sciruby/analysis/suite'
-require 'sciruby/analysis/suite_report_builder'
-
-module SciRuby
-  # DSL to run a statistical analysis without hassle.
-  # * Shortcut methods to avoid having to use complete namespaces, many based on R.
-  # * Attach/detach vectors to workspace, as with R
-  # == Example
-  #  an1 = Statsample::Analysis.store(:first) do
-  #    # Load excel file with x,y,z vectors
-  #    ds = excel('data.xls')
-  #    # See variables on ds dataset
-  #    names(ds)
-  #    # Attach the vectors to workspace, like R
-  #    attach(ds)
-  #    # vector 'x' is attached to workspace like a method,
-  #    # so you can use like any variable
-  #    mean,sd = x.mean, x.sd
-  #    # Shameless R robbery
-  #    a = c( 1:10)
-  #    b = c(21:30)
-  #    summary(cor(ds)) # Call summary method on correlation matrix
-  #  end
-  #  # You can run the analysis by its name
-  #  Statsample::Analysis.run(:first)
-  #  # or using the returned variables
-  #  an1.run
-  #  # You can also generate a report using ReportBuilder.
-  #  # .summary() method call 'report_building' on the object,
-  #  # instead of calling text summary
-  #  an1.generate("report.html")
-  module Analysis
-    @@stored_analyses={}
-    @@last_analysis=nil
-    def self.clear_analysis
-      @@stored_analyses.clear
-    end
-    def self.stored_analyses
-      @@stored_analyses
-    end
-    def self.last
-      @@stored_analyses[@@last_analysis]
-    end
-    def self.store(name, opts=Hash.new,&block)
-      raise "You should provide a block" if !block
-      @@last_analysis=name
-      opts={:name=>name}.merge(opts)
-      @@stored_analyses[name]=Suite.new(opts,&block)
-    end
-    # Run analysis +*args+
-    # Without arguments, run all stored analyses
-    # Only 'echo' will be printed to screen.
-    def self.run(*args)
-      args=stored_analyses.keys if args.size==0
-      raise "Analysis #{args} doesn't exists" if (args - stored_analyses.keys).size>0
-      args.each do |name|
-        stored_analyses[name].run
-      end
-    end
-
-    # Add analysis +*args+ to a ReportBuilder object.
-    # Without arguments, add all stored analyses.
-    # Each analysis is wrapped inside a ReportBuilder::Section object.
-    # This is the method used by +save+ and +to_text+.
-    def self.add_to_reportbuilder(rb, *args)
-      args=stored_analyses.keys if args.size==0
-      raise "Analysis #{name} doesn't exists" if (args - stored_analyses.keys).size>0
-      args.each do |name|
-        section=ReportBuilder::Section.new(:name=>stored_analyses[name].name)
-        rb_an=stored_analyses[name].add_to_reportbuilder(section)
-        rb.add(section)
-        rb_an.run
-      end
-    end
-
-    # Save the analysis to a file.
-    # Without arguments, adds all stored analyses.
-    def self.save(filename, *args)
-      rb=ReportBuilder.new(:name=>filename)
-      add_to_reportbuilder(rb, *args)
-      rb.save(filename)
-    end
-
-    # Run analysis and return as string.
-    # Only 'echo' will be printed to screen.
-    # Without arguments, add all stored analyses.
-    def self.to_text(*args)
-      rb=ReportBuilder.new(:name=>"Analysis #{Time.now}")
-      add_to_reportbuilder(rb, *args)
-      rb.to_text
-    end
-
-    # Run analysis and print to screen all echo and summary callings
-    def self.run_batch(*args)
-      puts to_text(*args)
-    end
-  end
-end

data/lib/sciruby/config.rb

@@ -1,93 +0,0 @@
-module SciRuby
-  module Config
-    class << self
-
-      # Create a .sciruby directory if it doesn't exist (.sciruby) and chdir to it.
-      def dir
-        Dir.chdir(Dir.home) do
-          FileUtils.mkdir('.sciruby') unless Dir.exists?('.sciruby')
-          Dir.chdir '.sciruby' do
-            yield if block_given?
-          end
-        end
-      end
-
-      # Create a data dir in the .sciruby directory if it doesn't exist (data/) and chdir to it.
-      def data_dir
-        dir do
-          FileUtils.mkdir('data') unless Dir.exists?('data')
-          Dir.chdir 'data' do
-            yield
-          end
-        end
-      end
-
-      # Create a data source directory within the .sciruby dir for a given module, e.g., ./sciruby/data/guardian for Guardian.
-      def data_source_dir module_name, create=true
-        dir_name = module_name.to_s if module_name.is_a?(Symbol)
-        dir_name ||= module_name.split('::').tap{ |m| 2.times { m.shift } }.join('::').underscore
-        data_dir do
-          FileUtils.mkdir(dir_name) if !Dir.exists?(dir_name) && create
-          Dir.chdir dir_name do
-            yield if block_given?
-          end
-        end
-      end
-
-
-      # Add an extension to the basename for a dataset based on the format.
-      def filename_for_dataset id, format=nil
-        basename = basename_for_dataset(id)
-        format.nil? ? basename : [basename, format.to_s].join('.')
-      end
-
-      # Generate a unique and safe filename for a dataset. This may need to be improved to incorporate some kind of hash.
-      # Hopefully there will be no collisions.
-      def basename_for_dataset id
-        return id.gsub(/[^a-zA-Z0-9\_]/, '_')
-      end
-
-      # Determines whether the basename for a cached dataset exists in some format or another.
-      def basename_exists? id
-        matches = Dir.glob("#{basename_for_dataset(id)}.*")
-        return matches.first if matches.size >= 1
-        return nil
-      end
-
-      # Store a given dataset in the .sciruby/data directory.
-      def cache_dataset module_name, dataset_id, file_contents, format
-        for_dataset_filename(module_name, dataset_id, format) do |dataset_filename|
-          unless File.exists?(dataset_filename) || basename_exists?(dataset_id)
-            File.open(dataset_filename, 'w') do |file|
-              file.write file_contents
-            end
-          end
-        end
-      end
-
-      # In the data source directory, do something with the dataset cache file. e.g.,
-      #     for_dataset('Guardian', '963', :cvs) do |dataset_filename|
-      #       File.open(dataset_filename, 'w') do |f|
-      #         f.write "Hello, world!"
-      #       end
-      #     end
-      #
-      # It computes the block arg (here, +dataset_filename+) for you using Config::filename_for_dataset. It also puts
-      # you in the correct directory.
-      #
-      # This function is used by Config::cache_dataset.
-      def for_dataset_filename module_name, dataset_id, format, &block
-        data_source_dir module_name do
-          yield filename_for_dataset(dataset_id, format)
-        end
-      end
-
-      def for_dataset_basename module_name, dataset_id, &block
-        data_source_dir module_name do
-          yield basename_for_dataset(dataset_id)
-        end
-      end
-
-    end
-  end
-end

data/lib/sciruby/data/guardian.rb

@@ -1,96 +0,0 @@
-module SciRuby
-  module Data
-    
-    # World Government Data from the Guardian.
-    class Guardian < PublicSearcher
-      QUERY_DOMAIN = %q{www.guardian.co.uk}
-      QUERY_PATH   = %q{/world-government-data/search.json}
-      FOUR_OH_FOUR_MESSAGE = '404 Page not found'
-      ALLOWED_FORMATS = [:csv, :excel]
-
-      class DatasetInfo < ::OpenStruct
-        def initialize h
-          super h
-          self.download_links.each_index do |i|
-            self.download_links[i] = ::OpenStruct.new(self.download_links[i])
-          end
-        end
-      end
-
-
-      # Search the site or database using some set of parameters.
-      #
-      # This function is the one that you should redefine if you want to require certain parameters, or if there are
-      # parameter co-dependencies. Ultimately, you call `search_internal(params)`.
-      #
-      # == Arguments
-      # * q: keywords (default: '', if no other parameters are supplied)
-      # * facet_country: country code abbreviation to search
-      # * facet_source_title: e.g., data from Australian government would be data.nsw.org.au
-      # * facet_format: e.g., csv, excel, xml, shapefile, kml
-      def initialize args={}
-        #args[:facet_format] ||= :csv
-        #@require_format ||= args[:facet_format] # This should be removed when we can interpret other formats.
-
-        @search_result = search(args)
-      end
-
-      # Return dataset meta-data found in the search, hashed by source_id. So, do datasets.keys if you want a list of
-      # source_ids.
-      def datasets
-        @datasets ||= begin
-          h = {}
-          search_result["results"].each do |res|
-            h[res['source_id']] = DatasetInfo.new(res)
-          end
-          h
-        end
-      end
-
-      # Download a specific dataset by +source_id+ and cache it in the searcher. Returns a Statsample::Dataset.
-      #
-      # If this raises an exception, you can try this:
-      #
-      #     links = raw_dataset_links_cached(source_id)
-      #
-      # And then for each of +links+, do `raw_dataset(source_id, link)` to see what the actual downloaded data was.
-      # This is good for debugging -- e.g., did the page move? or is there something wrong with Ruby's CSV interpreter?
-      # Or is it in some other format altogether?
-      #
-      # Right now, this function only handles CSV. TODO: Add more format handlers!
-      def dataset source_id
-        @dataset ||= {}
-        @dataset[source_id] ||= begin # Datasets are stored by source ID
-          pos = 0
-          datasets[source_id].download_links.each do |link_info|
-
-            unless ALLOWED_FORMATS.include?(link_info.format)
-              pos += 1
-              next # Format is incorrect.
-            end
-
-            # Format appears to be correct, prior to actually downloading. Proceed.
-
-            # Attempt to read the cached one first, and if that fails, try downloading.
-            raw = cached_dataset(source_id) || download_dataset(link_info.link)
-            
-            begin
-              ds  = parse_dataset link_info.format, raw, datasets[source_id].title
-              cache_dataset(source_id, raw, link_info.format)
-            rescue TypeError => e
-              if pos == datasets[source_id].download_links.size - 1
-                raise DatasetNotFoundError.new(e)
-              end
-            ensure
-              pos += 1
-            end
-
-            return ds unless ds.nil?
-
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/sciruby/data/r/base.rb

@@ -1,110 +0,0 @@
-module SciRuby::Data
-  class R
-    # Parses datasets from R directly.
-    class Base
-      FLOAT_RE = /([.eE])/
-
-      require "simpler"
-
-      def initialize id
-        @rob  = id # R object name
-
-        assign_properties # Read as many properties as possible from R
-      end
-
-      def self.class obj
-        #STDERR.puts "obj=#{obj}"
-        Base.new(obj).send :read_class
-      end
-
-      attr_reader :rob
-      alias_method :rname, :rob
-
-    protected
-      def assign_properties; end
-
-      def r obj=nil
-        SciRuby::Data::R.r(obj)
-      end
-
-      def float_re
-        SciRuby::Data::R::Base::FLOAT_RE
-      end
-
-      def call_function fn=nil
-        #STDERR.puts "Call function: #{fn.to_s}\t#{rob}"
-        fn.nil? ? r.eval! { rob } : r.eval! { "#{fn.to_s}(#{rob})" }
-      end
-
-      def call_property prop
-        r.eval! { "#{rob}$'#{prop.to_s}'"}
-      end
-
-      def read_class fn=:class
-        read_single_line(fn).first
-      end
-
-      def read_single_line fn=nil
-        line = call_function fn
-        #STDERR.puts "rsl Got back: #{line}"
-        CSV::parse_line(line.split(' ', 2).tap{ |s| s.shift }.first, :col_sep => ' ')
-      end
-
-      def read_single_token fn=nil
-        line = call_function fn
-        #STDERR.puts "rst Got back: #{line}"
-        line.split.tap{ |s| s.shift }.first
-      end
-
-      # Read multiple lines from a function call. You can also pass in a block if you want to ask for a property instead
-      # of a function call, e.g.,
-      #     read_multiple_lines { call_property('height') }
-      def read_multiple_lines fn=nil
-        lines = block_given? ? yield : call_function(fn)
-        #STDERR.puts "rml Got back:\n#{lines}"
-
-        lines = lines.split("\n")
-
-        return nil if lines.first =~ /^NULL/
-        if lines.first =~ /^ *\[/
-          return lines.map do |line|
-            remaining_line = CSV::parse_line(line.split(' ', 2).tap { |s| s.shift }.first, :col_sep => ' ')
-            remaining_line = remaining_line.tap { |l| l.pop } if remaining_line.last.nil?
-            remaining_line
-          end.flatten
-        end
-
-        raise "Unrecognized R output"
-      end
-
-      def read_row_names fn='rownames'
-        attempt = read_multiple_lines(fn) # may return nil if no rownames found.
-        return [] if attempt.nil?
-        attempt
-      end
-
-      def read_col_names fn='colnames'
-        read_row_names fn
-      end
-
-      def read_names fn='names'
-        read_row_names fn
-      end
-
-      def read_levels fn='levels'
-        read_row_names fn
-      end
-
-      def read_columns fields
-        columns = {}
-        fields.each do |field|
-          raise(ArgumentError, "nil field") if field.nil?
-          columns_for_field = SciRuby::Data::R.r("#{rob}[,'#{field.to_s}']")
-          columns[field] = (columns_for_field.is_a?(Vector) && columns_for_field.has_levels?) || columns_for_field.is_a?(TimeSeries) ? columns_for_field : columns_for_field.to_a
-        end
-        columns
-      end
-
-    end
-  end
-end

data/lib/sciruby/data/r/data_frame.rb

@@ -1,24 +0,0 @@
-module SciRuby::Data
-  class R
-    class DataFrame < Base
-      attr_reader :row_names, :columns
-
-      def col_names
-        columns.keys
-      end
-
-      def levels col_name
-        columns[col_name].levels
-      end
-
-    protected
-
-      def assign_properties
-        @row_names = read_row_names
-        col_names  = read_col_names
-        @columns   = read_columns(col_names)
-      end
-
-    end
-  end
-end

data/lib/sciruby/data/r/grouped_data.rb

@@ -1,7 +0,0 @@
-module SciRuby::Data
-  class R
-    class GroupedData < DataFrame
-
-    end
-  end
-end

data/lib/sciruby/data/r/list.rb

@@ -1,20 +0,0 @@
-module SciRuby::Data
-  class R
-    # An intermediate object that doesn't really get used -- immediately gets converted to a Ruby Hash of other R objects.
-    class List < Base
-      def to_h
-        @data
-      end
-    protected
-      def assign_properties
-        @names = read_names
-        @names = nil if @names.nil? || (@names.is_a?(Array) && @names.empty?)
-
-        @data = {}
-        @names.each do |list_item|
-          @data[list_item] = r("#{rob}[['#{list_item}']]")
-        end
-      end
-    end
-  end
-end

data/lib/sciruby/data/r/multi_time_series.rb

@@ -1,24 +0,0 @@
-module SciRuby::Data
-  class R
-    # class 'mts' in R
-    class MultiTimeSeries < TimeSeriesBase
-      attr_reader :row_names, :columns
-
-      def col_names
-        columns.keys
-      end
-
-      def levels col_name
-        columns[col_name].levels
-      end
-
-    protected
-      def assign_properties
-        @row_names = read_row_names
-        col_names  = read_col_names
-        @columns   = read_columns(col_names)
-        super
-      end
-    end
-  end
-end

data/lib/sciruby/data/r/r_matrix.rb

@@ -1,7 +0,0 @@
-module SciRuby::Data
-  class R
-    class RMatrix < DataFrame
-
-    end
-  end
-end

data/lib/sciruby/data/r/time_series.rb

@@ -1,19 +0,0 @@
-module SciRuby::Data
-  class R
-    # class 'ts' in R
-    class TimeSeries < TimeSeriesBase
-      attr_reader :data, :levels
-
-      def initialize id
-        super id
-        @data = @data.to_a # Convert from R Vector to array.
-      end
-
-    protected
-      def assign_properties
-        super
-        @data       = r("c(#{rob})") # Repeat for the data, which is probably of type Vector.
-      end
-    end
-  end
-end

data/lib/sciruby/data/r/time_series_base.rb

@@ -1,40 +0,0 @@
-module SciRuby::Data
-  class R
-    # classes 'mts' and 'ts' in R; not instantiated directly. Use RTimeSeries or RMultiTimeSeries.
-    class TimeSeriesBase < Base
-      attr_reader :start, :end, :frequency, :delta_t
-
-    protected
-
-      def assign_properties
-        @start      = read_time(:start)
-        @end        = read_time(:end)
-        @frequency  = read_frequency
-
-        # in R, the user supplies either frequency or delta t, but not both. frequency is always an integer (if I remember correctly)
-        @delta_t    = @frequency.is_a?(Fixnum) && @frequency > 1 ? 1.0 / @frequency : read_delta_t
-      end
-
-      def read_frequency fn=:frequency
-        read_single_token(fn).to_i
-      end
-
-      def read_delta_t fn=:deltat
-        deltat = read_single_token(fn)
-        deltat =~ float_re ? deltat.to_f : deltat.to_i
-      end
-
-      # Returns either two integers (time and sample number) or a number (time) and nil
-      def read_time fn=nil
-        time  = read_single_line(fn)
-        if time.size == 2 # vector of two integers
-          time.map { |t| t.to_i }
-        else # single number
-          single = time.first
-          single =~ float_re ? single.to_f : single.to_i
-          [single, nil]
-        end
-      end
-    end
-  end
-end