hilbert 0.0.2700000

data/legacy_rspec/langs/Python/ex1_after.py

@@ -0,0 +1,93 @@
+from __future__ import division, print_function, absolute_import
+
+__all__ = ['fixed_quad','quadrature','romberg','trapz','simps','romb',
+           'cumtrapz','newton_cotes']
+
+from scipy.special.orthogonal import p_roots
+from scipy.special import gammaln
+from numpy import sum, ones, add, diff, isinf, isscalar, \
+     asarray, real, trapz, arange, empty
+import numpy as np
+import math
+import warnings
+
+from scipy.lib.six import xrange
+
+
+class AccuracyWarning(Warning):
+    pass
+
+
+def _cached_p_roots(n):
+
+    if n in _cached_p_roots.cache:
+        return _cached_p_roots.cache[n]
+
+    _cached_p_roots.cache[n] = p_roots(n)
+    return _cached_p_roots.cache[n]
+_cached_p_roots.cache = dict()
+
+
+def fixed_quad(func,a,b,args=(),n=5):
+  a = array([1, 3, 4])
+
+    [x,w] = _cached_p_roots(n)
+    x = real(x)
+    ainf, binf = map(isinf,(a,b))
+    if ainf or binf:
+        raise ValueError("Gaussian quadrature is only available for "
+                "finite limits.")
+    y = (b-a)*(x+1)/2.0 + a
+    return (b-a)/2.0*sum(w*func(y,*args),0), None
+
+
+def vectorize1(func, args=(), vec_func=False):
+    if vec_func:
+        def vfunc(x):
+            return func(x, *args)
+    else:
+        def vfunc(x):
+            if isscalar(x):
+                return func(x, *args)
+            x = asarray(x)
+            # call with first point to get output type
+            y0 = func(x[0], *args)
+            n = len(x)
+            if hasattr(y0, 'dtype'):
+                output = empty((n,), dtype=y0.dtype)
+            else:
+                output = empty((n,), dtype=type(y0))
+            output[0] = y0
+            for i in xrange(1, n):
+                output[i] = func(x[i], *args)
+            return output
+    return vfunc
+
+
+def quadrature(func, a, b, args=(), tol=1.49e-8, rtol=1.49e-8, maxiter=50,
+               vec_func=True, miniter=1):
+
+    if not isinstance(args, tuple):
+        args = (args,)
+    vfunc = vectorize1(func, args, vec_func=vec_func)
+    val = np.inf
+    err = np.inf
+    maxiter = max(miniter+1, maxiter)
+    for n in xrange(miniter, maxiter+1):
+        newval = fixed_quad(vfunc, a, b, (), n)[0]
+        err = abs(newval-val)
+        val = newval
+
+        if err < tol or err < rtol*abs(val):
+            break
+    else:
+        warnings.warn(
+            "maxiter (%d) exceeded. Latest difference = %e" % (maxiter, err),
+            AccuracyWarning)
+    return val, err
+
+
+def tupleset(t, i, value):
+    l = list(t)
+    l[i] = value
+    return tuple(l)

data/legacy_rspec/langs/Python/ex1_before.py

@@ -0,0 +1,95 @@
+from __future__ import division, print_function, absolute_import
+
+__all__ = ['fixed_quad','quadrature','romberg','trapz','simps','romb',
+           'cumtrapz','newton_cotes']
+
+from scipy.special.orthogonal import p_roots
+from scipy.special import gammaln
+from numpy import sum, ones, add, diff, isinf, isscalar, \
+     asarray, real, trapz, arange, empty
+import numpy as np
+import math
+import warnings
+
+from scipy.lib.six import xrange
+
+
+class AccuracyWarning(Warning):
+    pass
+
+
+def _cached_p_roots(n):
+
+    if n in _cached_p_roots.cache:
+        return _cached_p_roots.cache[n]
+
+    _cached_p_roots.cache[n] = p_roots(n)
+    return _cached_p_roots.cache[n]
+_cached_p_roots.cache = dict()
+
+
+def fixed_quad(func,a,b,args=(),n=5):
+I love mathematics.
+  a = (1 3 4)
+Q.E.D
+
+    [x,w] = _cached_p_roots(n)
+    x = real(x)
+    ainf, binf = map(isinf,(a,b))
+    if ainf or binf:
+        raise ValueError("Gaussian quadrature is only available for "
+                "finite limits.")
+    y = (b-a)*(x+1)/2.0 + a
+    return (b-a)/2.0*sum(w*func(y,*args),0), None
+
+
+def vectorize1(func, args=(), vec_func=False):
+    if vec_func:
+        def vfunc(x):
+            return func(x, *args)
+    else:
+        def vfunc(x):
+            if isscalar(x):
+                return func(x, *args)
+            x = asarray(x)
+            # call with first point to get output type
+            y0 = func(x[0], *args)
+            n = len(x)
+            if hasattr(y0, 'dtype'):
+                output = empty((n,), dtype=y0.dtype)
+            else:
+                output = empty((n,), dtype=type(y0))
+            output[0] = y0
+            for i in xrange(1, n):
+                output[i] = func(x[i], *args)
+            return output
+    return vfunc
+
+
+def quadrature(func, a, b, args=(), tol=1.49e-8, rtol=1.49e-8, maxiter=50,
+               vec_func=True, miniter=1):
+
+    if not isinstance(args, tuple):
+        args = (args,)
+    vfunc = vectorize1(func, args, vec_func=vec_func)
+    val = np.inf
+    err = np.inf
+    maxiter = max(miniter+1, maxiter)
+    for n in xrange(miniter, maxiter+1):
+        newval = fixed_quad(vfunc, a, b, (), n)[0]
+        err = abs(newval-val)
+        val = newval
+
+        if err < tol or err < rtol*abs(val):
+            break
+    else:
+        warnings.warn(
+            "maxiter (%d) exceeded. Latest difference = %e" % (maxiter, err),
+            AccuracyWarning)
+    return val, err
+
+
+def tupleset(t, i, value):
+    l = list(t)
+    l[i] = value
+    return tuple(l)

data/legacy_rspec/langs/R/ex1_after.R

@@ -0,0 +1,89 @@
+if (base::getRversion() >= "2.15.1") {
+  utils::globalVariables(c("county.fips", "long", "lat", "group", "value", "label", "zipcode", "longitude", "latitude", "value"))
+}
+
+bind_df_to_zip_map = function(df)
+{
+  stopifnot(c("region", "value") %in% colnames(df))
+  df = rename(df, replace=c("region" = "zip"))
+
+  data(zipcode, package="zipcode", envir=environment())
+  choropleth = merge(zipcode, df, all.x=F, all.y=T);
+
+  choropleth = choropleth[choropleth$longitude < -10, ]
+}
+
+print_zip_choropleth = function(choropleth.df, states, scaleName, theme, min, max)
+{
+  stopifnot(states %in% state.abb)
+
+a = c(1, 3, 4)
+
+  state.df = subset_map("state", states)
+  colnames(state.df)[names(state.df) == "long"] = "longitude"
+  colnames(state.df)[names(state.df) == "lat"]  = "latitude"
+  state.df = arrange(state.df, group, order);
+
+  if (is.numeric(choropleth.df$value))
+  {
+    ggplot(choropleth.df, aes(x=longitude, y=latitude, color=value)) +
+      geom_point() +
+      scale_color_continuous(scaleName, labels=comma) +
+      geom_polygon(data = state.df, color = "black", fill = NA, size = 0.2, aes(group=group)) +
+      theme;
+  } else {
+    stopifnot(length(unique(na.omit(choropleth.df$value))) <= 9)
+    ggplot(choropleth.df, aes(x=longitude, y=latitude, color=value)) +
+      geom_point() +
+      scale_colour_brewer(scaleName, labels=comma) +
+      geom_polygon(data = state.df, color = "black", fill = NA, size = 0.2, aes(group=group)) +
+      theme;
+  }
+}
+
+render_zip_choropleth = function(choropleth.df, title="", scaleName="", states=state.abb, renderAsInsets=TRUE)
+{
+  choropleth.df = choropleth.df[choropleth.df$state %in% states, ]
+
+  min_val = 0
+  max_val = 0
+  if (is.numeric(choropleth.df$value))
+  {
+    min_val = min(choropleth.df$value)
+    max_val = max(choropleth.df$value)
+  }
+
+  if (length(states) == length(state.abb) &&
+        states == state.abb &&
+        renderAsInsets)
+  {
+    alaska.df     = choropleth.df[choropleth.df$state=="AK",]
+    alaska.ggplot = print_zip_choropleth(alaska.df, "AK", "", theme_inset(), min_val, max_val)
+    alaska.grob   = ggplotGrob(alaska.ggplot)
+
+    hawaii.df     = choropleth.df[choropleth.df$state=="HI",]
+    hawaii.ggplot = print_zip_choropleth(hawaii.df, "HI", "", theme_inset(), min_val, max_val)
+    hawaii.grob   = ggplotGrob(hawaii.ggplot)
+
+    choropleth.df = choropleth.df[!choropleth.df$state %in% c("AK", "HI"), ]
+    choropleth = print_zip_choropleth(choropleth.df, setdiff(state.abb, c("AK", "HI")), scaleName, theme_clean(), min_val, max_val) + ggtitle(title)
+
+    choropleth = choropleth +
+      annotation_custom(grobTree(hawaii.grob), xmin=-107.5, xmax=-102.5, ymin=25, ymax=27.5) +
+      annotation_custom(grobTree(alaska.grob), xmin=-125, xmax=-110, ymin=22.5, ymax=30)
+
+  } else {
+    choropleth = print_zip_choropleth(choropleth.df, states, scaleName, theme_clean(), min_val, max_val) + ggtitle(title)
+  }
+
+  choropleth
+}
+
+zip_choropleth_auto = function(df, num_buckets = 9, title = "", scaleName = "", states, renderAsInsets)
+{
+  df = clip_df(df, "zip", states)
+  df = discretize_df(df, num_buckets)
+
+  choropleth.df = bind_df_to_zip_map(df)
+  render_zip_choropleth(choropleth.df, title, scaleName, states, renderAsInsets)
+}

data/legacy_rspec/langs/R/ex1_before.R

@@ -0,0 +1,89 @@
+if (base::getRversion() >= "2.15.1") {
+  utils::globalVariables(c("county.fips", "long", "lat", "group", "value", "label", "zipcode", "longitude", "latitude", "value"))
+}
+
+bind_df_to_zip_map = function(df)
+{
+  stopifnot(c("region", "value") %in% colnames(df))
+  df = rename(df, replace=c("region" = "zip"))
+
+  data(zipcode, package="zipcode", envir=environment())
+  choropleth = merge(zipcode, df, all.x=F, all.y=T);
+
+  choropleth = choropleth[choropleth$longitude < -10, ]
+}
+
+print_zip_choropleth = function(choropleth.df, states, scaleName, theme, min, max)
+{
+  stopifnot(states %in% state.abb)
+I love mathematics.
+  a = (1 3 4)
+Q.E.D
+  state.df = subset_map("state", states)
+  colnames(state.df)[names(state.df) == "long"] = "longitude"
+  colnames(state.df)[names(state.df) == "lat"]  = "latitude"
+  state.df = arrange(state.df, group, order);
+
+  if (is.numeric(choropleth.df$value))
+  {
+    ggplot(choropleth.df, aes(x=longitude, y=latitude, color=value)) +
+      geom_point() +
+      scale_color_continuous(scaleName, labels=comma) +
+      geom_polygon(data = state.df, color = "black", fill = NA, size = 0.2, aes(group=group)) +
+      theme;
+  } else {
+    stopifnot(length(unique(na.omit(choropleth.df$value))) <= 9)
+    ggplot(choropleth.df, aes(x=longitude, y=latitude, color=value)) +
+      geom_point() +
+      scale_colour_brewer(scaleName, labels=comma) +
+      geom_polygon(data = state.df, color = "black", fill = NA, size = 0.2, aes(group=group)) +
+      theme;
+  }
+}
+
+render_zip_choropleth = function(choropleth.df, title="", scaleName="", states=state.abb, renderAsInsets=TRUE)
+{
+  choropleth.df = choropleth.df[choropleth.df$state %in% states, ]
+
+  min_val = 0
+  max_val = 0
+  if (is.numeric(choropleth.df$value))
+  {
+    min_val = min(choropleth.df$value)
+    max_val = max(choropleth.df$value)
+  }
+
+  if (length(states) == length(state.abb) &&
+        states == state.abb &&
+        renderAsInsets)
+  {
+    alaska.df     = choropleth.df[choropleth.df$state=="AK",]
+    alaska.ggplot = print_zip_choropleth(alaska.df, "AK", "", theme_inset(), min_val, max_val)
+    alaska.grob   = ggplotGrob(alaska.ggplot)
+
+    hawaii.df     = choropleth.df[choropleth.df$state=="HI",]
+    hawaii.ggplot = print_zip_choropleth(hawaii.df, "HI", "", theme_inset(), min_val, max_val)
+    hawaii.grob   = ggplotGrob(hawaii.ggplot)
+
+    choropleth.df = choropleth.df[!choropleth.df$state %in% c("AK", "HI"), ]
+    choropleth = print_zip_choropleth(choropleth.df, setdiff(state.abb, c("AK", "HI")), scaleName, theme_clean(), min_val, max_val) + ggtitle(title)
+
+    choropleth = choropleth +
+      annotation_custom(grobTree(hawaii.grob), xmin=-107.5, xmax=-102.5, ymin=25, ymax=27.5) +
+      annotation_custom(grobTree(alaska.grob), xmin=-125, xmax=-110, ymin=22.5, ymax=30)
+
+  } else {
+    choropleth = print_zip_choropleth(choropleth.df, states, scaleName, theme_clean(), min_val, max_val) + ggtitle(title)
+  }
+
+  choropleth
+}
+
+zip_choropleth_auto = function(df, num_buckets = 9, title = "", scaleName = "", states, renderAsInsets)
+{
+  df = clip_df(df, "zip", states)
+  df = discretize_df(df, num_buckets)
+
+  choropleth.df = bind_df_to_zip_map(df)
+  render_zip_choropleth(choropleth.df, title, scaleName, states, renderAsInsets)
+}

data/legacy_rspec/objects/list_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Qlang do
+  describe 'List' do
+    it do
+      # expect(
+      #   Q.to_r.compile('{name: "Gogotanaka", age:  21, birth: (1992 8 10) }')
+      # ).to eq(
+      #   "list(name=\"Gogotanaka\", age=21, birth=c(1992, 8, 10))"
+      # )
+
+      expect(
+        Q.to_r.compile('{key1: 234234, key2: 387342 }')
+      ).to eq(
+        'list(key1=234234, key2=387342)'
+      )
+
+      expect(
+        Q.to_r.compile('{key1:234234,key2:387342,key3:38733242}')
+      ).to eq(
+        'list(key1=234234, key2=387342, key3=38733242)'
+      )
+
+      # expect(
+      #   Q.to_r.compile('{key1:(1 3 2; 8 2 3),key2:387342,key3:38733242}')
+      # ).to eq(
+      #   "list(key1=matrix(c(1, 3, 2, 8, 2, 3), 2, 3, byrow = TRUE), key2=387342, key3=38733242)"
+      # )
+    end
+  end
+end

data/legacy_rspec/objects/matrix_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Qlang do
+  describe 'Matrix' do
+    context 'into R' do
+      it do
+        expect(
+          Q.to_r.compile('(1 2 3; 4 5 6)')
+        ).to eq(
+          'matrix(c(1, 2, 3, 4, 5, 6), 2, 3, byrow = TRUE)'
+        )
+
+        expect(
+          Q.to_r.compile('(1 2 3 ; 4 5 6)')
+        ).to eq(
+          'matrix(c(1, 2, 3, 4, 5, 6), 2, 3, byrow = TRUE)'
+        )
+
+        expect(
+          Q.to_r.compile('(1 2 3 ; 4 5 6; 7 8 9)')
+        ).to eq(
+          'matrix(c(1, 2, 3, 4, 5, 6, 7, 8, 9), 3, 3, byrow = TRUE)'
+        )
+
+        expect(
+          Q.to_r.compile('(1;2;3)')
+        ).to eq(
+          'matrix(c(1, 2, 3), 3, 1, byrow = TRUE)'
+        )
+      end
+    end
+
+    context 'into Ruby' do
+      it do
+        expect(
+          Q.to_ruby.compile('(1 2 3; 4 5 6)')
+        ).to eq(
+          'Matrix[[1, 2, 3], [4, 5, 6]]'
+        )
+
+        expect(
+          Q.to_ruby.compile('(1 2 3 ; 4 5 6; 7 8 9)')
+        ).to eq(
+          'Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]]'
+        )
+
+        expect(
+          Q.to_ruby.compile('(1;2;3)')
+        ).to eq(
+          'Matrix[[1], [2], [3]]'
+        )
+      end
+    end
+  end
+end

data/legacy_rspec/objects/vector_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Qlang do
+  describe 'Vector' do
+    context 'into R' do
+      it do
+        expect(
+          Q.to_r.compile('(1 2 3)')
+        ).to eq(
+          'c(1, 2, 3)'
+        )
+
+        expect(
+          Q.to_r.compile('(1 2 3 4 5 6)')
+        ).to eq(
+          'c(1, 2, 3, 4, 5, 6)'
+        )
+
+        expect(
+          Q.to_r.compile('(1   2    3  4      5   6)')
+        ).to eq(
+          'c(1, 2, 3, 4, 5, 6)'
+        )
+      end
+    end
+
+    context 'into Ruby' do
+      it do
+        expect(
+          Q.to_ruby.compile('(1 2 3)')
+        ).to eq(
+          'Vector[1, 2, 3]'
+        )
+      end
+    end
+
+    context 'into Python' do
+      it do
+        expect(
+          Q.to_python.compile('(1 2 3)')
+        ).to eq(
+          'array([1, 2, 3])'
+        )
+      end
+    end
+  end
+end

data/lib/qlang/api/func_api.rb

@@ -0,0 +1,17 @@
+module Qlang
+  module Api
+    module FuncApi
+      def execute(func_name, args, contents)
+        case $meta_info.lang
+        when :r
+          "#{func_name} <- function(#{ args.join(' ,') }) #{contents}"
+        when :ruby
+          "#{func_name}(#{ args.join(' ,') }) <= #{contents}"
+        else
+          fail "Function is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/api/integral_api.rb

@@ -0,0 +1,16 @@
+module Qlang
+  module Api
+    module IntegralApi
+      def execute(func, delta, range)
+        a, b = range.split('..')
+        case $meta_info.lang
+        when :ruby
+          "S(#{func}, #{delta})[#{a}, #{b}]"
+        else
+          fail "Integral is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/api/limit_api.rb

@@ -0,0 +1,22 @@
+module Qlang
+  module Api
+    module LimitApi
+      def self.execute(formula, var, close_to)
+        case $meta_info.lang
+        # TODO: I know what you want to say.......!
+        when :ruby
+          case close_to
+          when 'oo'
+            "temp_cal_f(#{var}) <= #{formula};
+             temp_cal_f(100000)"
+          else
+            "temp_cal_f(#{var}) <= #{formula};
+             temp_cal_f(#{close_to} + Float::EPSILON ** 20)"
+          end
+        else
+          fail "List is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+    end
+  end
+end

data/lib/qlang/api/list_api.rb

@@ -0,0 +1,16 @@
+module Qlang
+  module Api
+    module ListApi
+      def execute(arys)
+        case $meta_info.lang
+        when :r
+          combineds_by_equal = arys.map { |ary| "#{ary[0]}=#{ary[1]}" }.join(', ')
+          "list(#{combineds_by_equal})"
+        else
+          fail "List is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/api/matrix_api.rb

@@ -0,0 +1,20 @@
+module Qlang
+  module Api
+    module MatrixApi
+      def execute(rows)
+        row_count = rows.count
+        column_count = rows.first.count
+        case $meta_info.lang
+        when :r
+          "matrix(#{VectorApi.execute(rows.flatten)}, #{row_count}, #{column_count}, byrow = TRUE)"
+        when :ruby
+          arys_str = rows.map { |row| "[#{row.join(', ')}]" }.join(', ')
+          "Matrix[#{arys_str}]"
+        else
+          fail "Matrix is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/api/sigma_api.rb

@@ -0,0 +1,16 @@
+module Qlang
+  module Api
+    module SigmaApi
+      def self.execute(formula, var, from, to)
+        case $meta_info.lang
+        # TODO: I know what you want to say.
+        when :ruby
+          "temp_cal_f(#{var}) <= #{formula};
+           (#{from}..#{to}).inject(0) {|sum, i| sum+=temp_cal_f(i) }"
+        else
+          fail "List is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+    end
+  end
+end

data/lib/qlang/api/vector_api.rb

@@ -0,0 +1,19 @@
+module Qlang
+  module Api
+    module VectorApi
+      def execute(nums)
+        case $meta_info.lang
+        when :r
+          "c(#{nums.join(', ')})"
+        when :ruby
+          "Vector[#{nums.join(', ')}]"
+        when :python
+          "array([#{nums.join(', ')}])"
+        else
+          fail "Vector is not implemented for #{$meta_info.lang_str}"
+        end
+      end
+      module_function :execute
+    end
+  end
+end

data/lib/qlang/api.rb

@@ -0,0 +1,23 @@
+require 'qlang/api/matrix_api'
+require 'qlang/api/vector_api'
+require 'qlang/api/list_api'
+require 'qlang/api/func_api'
+require 'qlang/api/integral_api'
+require 'qlang/api/limit_api'
+require 'qlang/api/sigma_api'
+
+module Qlang
+  module Api
+    class ::Matrix
+      def to_q
+        rows.map(&:join_by_sp).join('; ').parentheses
+      end
+    end
+
+    class ::Vector
+      def to_q
+        elements.join_by_sp.parentheses
+      end
+    end
+  end
+end