statsample-ekatena 2.0.2

data/examples/parallel_analysis.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+# == Description
+#
+# This example will explain how a parallel analysis can be performed on a PCA.
+# Parallel Analysis helps in determining how many components are to be retained
+# from the PCA.
+require 'statsample'
+samples=150
+variables=30
+iterations=50
+Statsample::Analysis.store(Statsample::Factor::ParallelAnalysis) do 
+  
+rng = Distribution::Normal.rng()
+f1  = rnorm(samples)
+f2  = rnorm(samples)
+f3  = rnorm(samples)
+
+vectors={}
+
+variables.times do |i|
+  vectors["v#{i}".to_sym] = Daru::Vector.new(samples.times.collect {|nv| f1[nv]*i+(f2[nv]*(15-i))+((f3[nv]*(30-i))*1.5)*rng.call})
+  vectors["v#{i}".to_sym].rename "Vector #{i}"
+end
+
+  ds = Daru::DataFrame.new(vectors)
+
+  pa=Statsample::Factor::ParallelAnalysis.new(ds, :iterations=>iterations, :debug=>true)
+  pca=pca(cor(ds))
+  echo "There are 3 real factors on data"
+  summary pca
+  echo "Traditional Kaiser criterion (k>1) returns #{pca.m} factors"
+  summary pa
+  echo "Parallel Analysis returns #{pa.number_of_factors} factors to preserve"
+end
+
+if __FILE__==$0
+   Statsample::Analysis.run_batch
+end

data/examples/polychoric.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+# == Description
+# Polychoric Correlation using two-step and joint method
+#
+# Polychoric correlation in statsample requires installation of 
+# the [statsample-bivariate-extension](https://rubygems.org/gems/statsample-bivariate-extension) 
+# gem. This gem extends the Statsample::Bivariate class with useful 
+# algorithms for polychoric and tetrachoric correlation.
+# 
+# Statsample will automatically detect presence of polychoric/tetrachoric 
+# algorithms so there is no need to explicitly require the gem.
+# 
+# In this example we'll see how polychoric correlation can be 
+# performed using statsample.
+require 'statsample'
+Statsample::Analysis.store(Statsample::Bivariate::Polychoric) do 
+  ct=Matrix[[rand(10)+50, rand(10)+50,  rand(10)+1],
+            [rand(20)+5,  rand(50)+4,   rand(10)+1],
+            [rand(8)+1,   rand(12)+1,   rand(10)+1]]
+
+  # Estimation of polychoric correlation using two-step (default)
+  poly=polychoric(ct, :name=>"Polychoric with two-step", :debug=>false)
+  summary poly
+
+  # Estimation of polychoric correlation using joint method (slow)
+  poly=polychoric(ct, :method=>:joint, :name=>"Polychoric with joint")
+  summary poly
+
+  # Uses polychoric series (not recomended)
+
+  poly=polychoric(ct, :method=>:polychoric_series, :name=>"Polychoric with polychoric series")
+  summary poly
+end
+
+if __FILE__==$0
+   Statsample::Analysis.run_batch
+end
+

data/examples/principal_axis.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+# Principal Axis Analysis¶
+#
+# Here we use the Statsample::Factor::PrincipalAnalysis class 
+# for principal axis analysis for a correlation or covariance matrix.
+require 'statsample'
+
+Statsample::Analysis.store(Statsample::Factor::PrincipalAxis) do
+
+  matrix=Matrix[
+  [1.0, 0.709501601093587, 0.877596585880047, 0.272219316266807],  
+  [0.709501601093587, 1.0, 0.291633797330304, 0.871141831433844], 
+  [0.877596585880047, 0.291633797330304, 1.0, -0.213373722977167], 
+  [0.272219316266807, 0.871141831433844, -0.213373722977167, 1.0]]
+  
+  matrix.extend Statsample::CovariateMatrix
+  fa=principal_axis(matrix,:m=>1,:smc=>false)
+  
+  summary fa
+end
+
+if __FILE__==$0
+   Statsample::Analysis.run_batch
+end
+

data/examples/reliability.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib')
+
+# == Description
+#
+# Reliability Scale Analysis with statsample
+require 'statsample'
+Statsample::Analysis.store(Statsample::Reliability) do 
+  samples=100
+  a=rnorm(samples)
+  
+  ds = Daru::DataFrame.new({})
+  
+  20.times do |i|
+    ds["v#{i}".to_sym]= a + rnorm(samples,0,0.2)
+  end
+  
+  rel=Statsample::Reliability::ScaleAnalysis.new(ds)
+  summary rel
+  
+  ms=Statsample::Reliability::MultiScaleAnalysis.new(:name=>"Multi Scale analyss") do |m|
+    m.scale "Scale 1", ds.clone([:v1, :v2, :v3, :v4, :v5, :v6, :v7, :v8, :v9, :v10])
+    m.scale "Scale 2", ds.clone([:v11, :v12, :v13, :v14, :v15, :v16, :v17, :v18, :v19])
+  end
+  
+  summary ms
+end
+
+if __FILE__==$0
+   Statsample::Analysis.run_batch
+end

data/examples/scatterplot.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+$:.unshift('/home/cdx/dev/reportbuilder/lib/')
+
+# == Description
+#
+# Creating a scatterplot with statsample's Statsample::Graph::Scatterplot class.
+# 
+# In this example we'll demonstrate how a normally distributed Daru::Vector can
+# be created using the daru and distribution gems, and how the values generated
+# can be plotted very easily using the 'scatterplot' shorthand and supplying X
+# and Y co-ordinates.
+require 'benchmark'
+require 'statsample'
+n=100
+
+Statsample::Analysis.store(Statsample::Graph::Scatterplot) do
+  x=rnorm(n)
+  y=x+rnorm(n,0.5,0.2)
+  scatterplot(x,y)
+end
+
+if __FILE__==$0
+  Statsample::Analysis.run
+end

data/examples/t_test.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib')
+# == Description
+#
+# This example illustrates how a T test can be done and summarized with statsample
+#
+# == References
+#
+# http://en.wikipedia.org/wiki/Student%27s_t-test
+require 'statsample'
+
+Statsample::Analysis.store(Statsample::Test::T) do
+  
+  
+  a=rnorm(10)
+  t_1=Statsample::Test.t_one_sample(a,{:u=>50})
+  summary t_1
+  
+  b=rnorm(10,2)
+  
+  t_2=Statsample::Test.t_two_samples_independent(a,b)
+  summary t_2
+end
+
+if __FILE__==$0
+  Statsample::Analysis.run_batch
+end

data/examples/tetrachoric.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+
+require 'statsample'
+
+Statsample::Analysis.store(Statsample::Bivariate::Tetrachoric) do
+  
+a=40
+b=10
+c=20
+d=30
+summary tetrachoric(a,b,c,d)
+end
+
+if __FILE__==$0
+  Statsample::Analysis.run_batch
+end

data/examples/u_test.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib')
+
+# == Description
+#
+# Example illustrating Mann-Whitney U test with statsample.
+#
+# == References
+# 
+# http://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test
+require 'statsample'
+
+Statsample::Analysis.store(Statsample::Test::UMannWhitney) do
+
+  a = Daru::Vector.new(10.times.map {rand(100)})
+  b = Daru::Vector.new(20.times.map {(rand(20))**2+50})
+
+  u=Statsample::Test::UMannWhitney.new(a,b)
+  summary u
+end
+
+if __FILE__==$0
+  Statsample::Analysis.run_batch
+end

data/examples/vector.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+# == Description
+#
+# This example provides a small sneak-peak into creating a Daru::Vector.
+# For details on using Daru::Vector (with example on math, statistics and plotting)
+# see the notebook at this link: 
+# http://nbviewer.ipython.org/github/SciRuby/sciruby-notebooks/blob/master/Data%20Analysis/Usage%20of%20Vector.ipynb
+require 'statsample'
+
+Statsample::Analysis.store(Daru::Vector) do
+  a = Daru::Vector.new_with_size(1000) {r=rand(5); r==4 ? nil: r;}
+  summary a
+  b = Daru::Vector[1,2,3,4,6..10]
+  summary b
+end
+
+if __FILE__==$0
+  Statsample::Analysis.run_batch
+end

data/examples/velicer_map_test.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__)+'/../lib/')
+# == Description
+#
+# Velicer MAP test.
+
+require 'statsample'
+
+Statsample::Analysis.store(Statsample::Factor::MAP) do
+  
+  rng=Distribution::Normal.rng
+  samples=100
+  variables=10
+  
+  f1=rnorm(samples)
+  f2=rnorm(samples)
+  
+  vectors={}
+  
+  variables.times do |i|
+  vectors["v#{i}".to_sym]= Daru::Vector.new(
+    samples.times.collect do |nv|    
+      if i<5
+        f1[nv]*5 + f2[nv] *2 +rng.call
+      else
+        f1[nv]*2 + f2[nv] *3 +rng.call
+      end
+    end)
+  end
+  
+  
+  ds = Daru::DataFrame.new(vectors)
+  cor=cor(ds)
+  pca=pca(cor)
+  
+  map=Statsample::Factor::MAP.new(cor)
+  
+  echo ("There are 2 real factors on data")
+  summary(pca)
+  echo("Traditional Kaiser criterion (k>1) returns #{pca.m} factors")
+  summary(map)
+  echo("Velicer's MAP Test returns #{map.number_of_factors} factors to preserve")
+end
+if __FILE__==$0
+  Statsample::Analysis.run_batch
+end

data/grab_references.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby1.9
+require 'reportbuilder'
+refs=[]
+Dir.glob "**/*.rb" do |f|
+  next if f=~/pkg/
+	reference=false
+	File.open(f).each_line 	do |l|
+		
+		if l=~/== Reference/
+		    reference=true
+		elsif reference
+			if l=~/\*\s+(.+)/
+				refs.push $1
+			else
+				reference=false
+			end
+	        end
+	    
+	end
+end
+
+
+rb=ReportBuilder.new(:name=>"References") do |g|
+	refs.uniq.sort.each do |r|
+		g.text "* #{r}"
+	end
+end
+
+rb.save_text("references.txt")

data/lib/spss.rb

@@ -0,0 +1,134 @@
+# = spss.rb -
+#
+# Provides utilites for working with spss files
+#
+# Copyright (C) 2009 Claudio Bustos
+#
+# Claudio Bustos mailto:clbustos@gmail.com
+
+module SPSS # :nodoc: all
+  module Dictionary
+    class Element
+      def add(a)
+        @elements.push(a)
+      end
+
+      def parse_elements(func = :to_s)
+        @elements.collect{ |e| "   "+e.send(func) }.join("\n")
+      end
+
+      def init_with config
+        config.each do |key, value|
+            self.send(key.to_s + "=", value) if methods.include? key.to_s
+        end
+      end
+
+      def initialize(config = {})
+        @config = config
+        @elements = []
+      end
+    end
+    class Dictionary < Element
+      attr_accessor :locale, :date_time, :row_count
+      def initialize(config = {})
+        super
+        init_with ({
+                :locale=>"en_US",
+                :date_time=>Time.new().strftime("%Y-%m-%dT%H:%M:%S"),
+                :row_count=>1
+        })
+        init_with config
+      end
+
+      def to_xml
+        "<dictionary locale='#{@locale}' creationDateTime='#{@date_time}' rowCount='#{@row_count}' xmlns='http://xml.spss.com/spss/data'>\n"+parse_elements(:to_xml)+"\n</dictionary>"
+
+      end
+      def to_spss
+        parse_elements(:to_spss)
+      end
+    end
+
+    class MissingValue < Element
+      attr_accessor :data, :type, :from, :to
+      def initialize(data,type=nil)
+        @data=data
+        if type.nil? or type=="lowerBound" or type=="upperBound"
+            @type=type
+        else
+            raise Exception,"Incorrect value for type"
+        end
+      end
+      def to_xml
+        "<missingValue data='#{@data}' "+(type.nil? ? "":"type='#{type}'")+"/>"
+      end
+    end
+    class LabelSet
+      attr_accessor
+      def initialize(labels)
+        @labels=labels
+      end
+      def parse_xml(name)
+        "<valueLabelSet>\n   "+@labels.collect{|key,value| "<valueLabel label='#{key}' value='#{value}' />"}.join("\n   ")+"\n   <valueLabelVariable name='#{name}' />\n</valueLabelSet>"
+      end
+      def parse_spss()
+        @labels.collect{|key,value| "#{key} '#{value}'"}.join("\n   ")
+      end
+    end
+    class Variable < Element
+      attr_accessor :aligment, :display_width, :label, :measurement_level, :name, :type, :decimals, :width, :type_format, :labelset, :missing_values
+      def initialize(config={})
+        super
+        @@var_number||=1
+        init_with({
+          :aligment           =>  "left",
+          :display_width      =>  8,
+          :label              =>  "Variable #{@@var_number}",
+          :measurement_level  =>  "SCALE",
+          :name               =>  "var#{@@var_number}",
+          :type               =>  0,
+          :decimals           =>  2,
+          :width              =>  10,
+          :type_format        =>  "F",
+          :labelset           => nil
+        })
+        init_with config
+        @missing_values=[]
+        @@var_number+=1
+      end
+      def to_xml
+        labelset_s=(@labelset.nil?) ? "":"\n"+@labelset.parse_xml(@name)
+        missing_values=(@missing_values.size>0) ? @missing_values.collect {|m| m.to_xml}.join("\n"):""
+        "<variable aligment='#{@aligment}' displayWidth='#{@display_width}' label='#{@label}' measurementLevel='#{@measurement_level}' name='#{@name}' type='#{@type}'>\n<variableFormat decimals='#{@decimals}' width='#{@width}' type='#{@type_format}' />\n"+parse_elements(:to_xml)+missing_values+"</variable>"+labelset_s
+      end
+      def to_spss
+        out=<<HERE
+VARIABLE LABELS #{@name} '#{label}' .
+VARIABLE ALIGMENT #{@name} (#{@aligment.upcase}) .
+VARIABLE WIDTH #{@name} (#{@display_width}) .
+VARIABLE LEVEL #{@name} (#{@measurement_level.upcase}) .
+HERE
+        if !@labelset.nil?
+            out << "VALUE LABELS #{@name} "+labelset.parse_spss()+" ."
+        end
+        if @missing_values.size>0
+            out << "MISSING VALUES #{@name} ("+@missing_values.collect{|m| m.data}.join(",")+") ."
+        end
+        out
+      end
+    end
+  end
+end
+n=SPSS::Dictionary::Dictionary.new
+ls=SPSS::Dictionary::LabelSet.new({1=>"Si",2=>"No"})
+var1=SPSS::Dictionary::Variable.new
+var1.labelset=ls
+mv1=SPSS::Dictionary::MissingValue.new("-99")
+var2=SPSS::Dictionary::Variable.new
+n.add(var1)
+n.add(var2)
+var2.missing_values=[mv1]
+
+File.open("dic_spss.sps","wb") {|f|
+    f.puts n.to_spss
+}