hilbert 0.0.2700000

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWNmNzJhODczNmNmYTAzZTEwZDMzMzAwMzY3YjYyODk1MGZkZTQzYg==
+  data.tar.gz: !binary |-
+    NzY5Mjc1OWIyMjcyNDczZGYzZTljN2UyMDNjMzViMTVjZWQzN2U4Mw==
+SHA512:
+  metadata.gz: !binary |-
+    ZjUzYzk2MWFjNzk5NmJkMzExNTk0YzM2ZDU1N2QzODZiZGNkOTQ3OWQwNTg3
+    YWY4MDA4YzZiYmQ4NjZkYmM1NmY2MzM4Y2I3NmQyZmE4MWJhZjlmYTZiZDU2
+    Y2Y1NWYxODdiMjFjMjZkMWQ2YWQ0Njc1NTUzNGVjYmNkODQ1OGY=
+  data.tar.gz: !binary |-
+    ZjNmMTBlZGMxNzc5OGQzNTVmOTg3MzAwYWNlOWJjMzNjMjkzZWYwN2U1Zjkz
+    NDVmZDQxODFlYzU1YzJjMmI5NjliOTI0MzM3YTM3NjdmZmFhYjU4M2NmZDc5
+    YTEzYzRmMWQxMjY3YzFjMGI5YzY2ZDA3MjdhYTIwNTgwMGVkZjI=

data/.coveralls.yml

@@ -0,0 +1,2 @@
+repo_token: ZdXKADwEPNW5PJkIaC76yjqq4w04dIpuZ
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.ruby-version

data/.rubocop.yml

@@ -0,0 +1,25 @@
+Eval:
+  Enabled: false
+
+LineLength:
+  Enabled: false
+
+# Configuration parameters: AllowedVariables.
+GlobalVars:
+  Enabled: false
+
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+MethodName:
+  Enabled: false
+
+OpMethod:
+  Enabled: false
+
+Void:
+  Enabled: false
+
+SpaceInsideParens:
+  Enabled: false
+
+SpaceAroundOperators:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'rubocop'
+gem 'coveralls', require: false
+gem 'pry'
+gem 'guard'
+gem 'guard-rspec', require: false
+
+gemspec

data/Guardfile

@@ -0,0 +1,33 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  watch('spec/rails_helper.rb')                       { "spec" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 gogotanaka
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,159 @@
+# Qlang
+
+[![Gem Version](https://badge.fury.io/rb/qlang.svg)](http://badge.fury.io/rb/qlang) [![Build Status](https://travis-ci.org/gogotanaka/Q.svg?branch=master)](https://travis-ci.org/gogotanaka/Q) [![Coverage Status](https://coveralls.io/repos/gogotanaka/Q/badge.png?branch=master)](https://coveralls.io/r/gogotanaka/Q?branch=master) [![Code Climate](https://codeclimate.com/github/gogotanaka/Q/badges/gpa.svg)](https://codeclimate.com/github/gogotanaka/Q) [![Dependency Status](https://gemnasium.com/gogotanaka/Q.svg)](https://gemnasium.com/gogotanaka/Q)
+
+## Do you know the one best language in this world?
+
+#### I believe mathematics is absolutely that one.
+
+## How can we deal something as great as mathematics in a discrete world?
+
+#### Q-language is the answer.
+
+Q lets you have a sense of mathematics using a keyboard, the same as you would with a pen.
+
+```
++---Discrete world---+                    +------Mathematics-------+
+|        Ruby        |                    |        axiom           |
+|        TeX         |<------   Q  ------>|    Uncountable noun    |
+|       Python       |                    |  real number topology  |
++--------------------+                    +------------------------+
+```
+
+## Demo
+
+The code below is input and output for the q-lang interpreter
+
+(you can try it by `qlang -i`)
+
+### Differentiate
+
+```
+d/dx(cos(x))
+=> ( - sin( x ) )
+
+# You can omit parentheses
+
+d/dx log(x)
+=> ( 1 / x )
+
+d/dy xy
+=> ( x )
+
+d/dx e^x
+=> e ^ x
+```
+
+### Integrate
+
+```
+S(log(x)dx)[0..1]
+=> - oo
+
+S(sin(x)dx)[0..pi]
+=> 2.0
+
+S(cos(x)dx)[0..pi]
+=> 0.0
+```
+
+### Limit
+
+```
+lim[x->oo] (1 + 1/x)^x
+=> 2.7182682371744895
+
+lim[x->0] 1/x
+=> oo
+```
+
+### Sigma
+```
+∑[x=0,10] x
+=> 55.0
+```
+
+### Matrix
+
+```
+(1 2 3; 4 5 6)
+=> (1 2 3; 4 5 6)
+
+(1 2 3; 4 5 6) + (1 2 3; 4 5 6)
+=> (2 4 6; 8 10 12)
+
+(1 2 3; 4 5 6) * (1 2 3)
+=> (14 32)
+```
+
+### Function
+```
+f(x, y) = xy
+f(1, 2)
+=> 2
+```
+
+
+## How to use
+
+Install qlang gem.
+
+    $ gem install qlang
+
+## Interpreter
+
+    $ qlang -i
+    Q:->
+
+## Use as native language
+
+### Compile into R
+
+    $ qlang -r foo.q
+
+### Compile into Ruby
+
+    $ qlang -rb foo.q
+
+### Compile into Python
+
+    $ qlang -py foo.q
+
+
+## Use as math template within other langs
+
+
+```rb
+class ExampleClass
+  def example_method
+    #your Ruby codes
+    ......
+
+I love mathematics.
+  a = (1 3 4)
+  # your Q codes
+Q.E.D
+
+  end
+end
+```
+
+    $ qlang -rb example.rb
+
+
+```rb
+class ExampleClass
+  def example_method
+    #your Ruby codes
+    ......
+
+    a = Vector[1, 3, 4]
+
+  end
+end
+```
+
+## Contributing
+
+Any PRs or issues are welcome.
+You can become a commiter, even if you only commit once.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+require 'rake/extensiontask'
+
+Rake::ExtensionTask.new('qlang') do |ext|
+  ext.lib_dir = 'lib/qlang'
+end
+
+task :compile_and_test do
+  Rake::Task['compile'].invoke
+  Rake::Task['test'].invoke
+end
+
+task default: :compile_and_test

data/bin/qlang

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'qlang'
+
+# Q command line
+require 'qlang/exec'
+
+# Q interpreter
+require 'qlang/iq'
+
+# TODO: There are vanch of todo ..
+case ARGV.first
+when '-i'
+  loop do
+    print 'Q:-> '
+    begin
+      input = $stdin.gets
+      output = Qlang::Iq.execute(input)
+      $stdout.puts output
+    rescue => e
+      puts e
+    end
+  end
+when '-v'
+  puts Qlang::VERSION
+when '-r', '-rb', '-py'
+  exec = Qlang::Exec::Compiler.new(ARGV)
+  exec.output!
+end

data/core/Q/Lexer.hs

@@ -0,0 +1,9 @@
+{- |
+Module      : Language.Q
+Copyright   : Kazuki Tanaka (a.k.a gogotanaka)
+Licence     : MIT
+
+q-language.org.
+-}
+
+module Q.Lexer where

data/core/Q/Parser.hs

@@ -0,0 +1,9 @@
+{- |
+Module      : Language.Q
+Copyright   : Kazuki Tanaka (a.k.a gogotanaka)
+Licence     : MIT
+
+q-language.org.
+-}
+
+module Q.Parser where

data/core/Q.hs

@@ -0,0 +1,19 @@
+{- |
+Module      : Language.Q
+Copyright   : Kazuki Tanaka (a.k.a gogotanaka)
+Licence     : MIT
+
+q-language.org.
+-}
+
+module Q
+       ( module Q.Lexer
+       , module Q.Parser
+       , version
+       ) where
+
+
+import Q.Lexer
+import Q.Parser
+
+import Data.Version

data/ext/qlang/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('qlang/qlang')

data/ext/qlang/qlang.c

@@ -0,0 +1,65 @@
+#include "qlang.h"
+#include <stdio.h>
+#define Need_Float(x) do {if (!RB_TYPE_P(x, T_FLOAT)) {(x) = rb_to_float(x);}} while(0)
+#define GET_FLOAT(x) Need_Float(x);(x) = RFLOAT_VALUE(x)
+
+double func(double x)
+{
+  return((x * x) * 3);
+}
+
+static VALUE
+rb_func(VALUE self, VALUE x)
+{
+  GET_FLOAT(x);
+  return(DBL2NUM((x * x)/2));
+}
+
+
+static VALUE
+execute(VALUE self, VALUE a, VALUE b, VALUE n)
+{
+  GET_FLOAT(a);
+  GET_FLOAT(b);
+  GET_FLOAT(n);
+
+  int i;
+  double s1=0.0, s2=0.0, d;
+  double x, y[n+1];
+  d=(b-a)/(double)n;
+  for(i=0; i<=n; i++)
+  {
+    x=(double)i*d+a;
+    y[i]=func(x);
+  }
+  for(i=1; i<=n-1; i+=2)
+  {
+    s1+=y[i];
+  }
+  for(i=2; i<=n-2; i+=2)
+  {
+    s2+=y[i];
+  }
+
+  double s=(y[0]+4.0*s1+2.0*s2+y[n])*d/3.0;
+
+  return DBL2NUM(s);
+}
+
+
+
+void
+Init_qlang(void)
+{
+  VALUE rb_mQMatrix = rb_define_class("QMatrix", rb_cObject);
+  rb_define_method(rb_mQMatrix, "execute", execute, 3);
+  rb_define_method(rb_mQMatrix, "func", rb_func, 1);
+}
+
+// VALUE rb_mQMatrix;
+
+// void
+// Init_q_matrix(void)
+// {
+//   rb_mQMatrix = rb_define_module("QMatrix");
+// }

data/ext/qlang/qlang.h

@@ -0,0 +1,6 @@
+#ifndef QLANG_H
+#define QLANG_H 1
+
+#include "ruby.h"
+
+#endif /* QLANG_H */

data/legacy_rspec/langs/Haskell/ex1_after.hs

@@ -0,0 +1,74 @@
+module Main where
+
+filter' :: (a -> Bool) -> [a] -> [a]
+filter' _ []                 = []
+filter' p (x:xs) | p x       = x : filter' p xs
+                 | otherwise = filter' p xs
+
+
+-- pattern match for Algebraic data type
+data Node = Leaf Integer | Branch Node Node deriving (Show)
+
+depth :: Node -> Integer
+depth node = case node of
+  Leaf _     -> 1
+  Branch a b -> 1 + max (depth a) (depth b)
+
+sumLeaf :: Node -> Integer
+sumLeaf node = case node of
+  Leaf x     -> x
+  Branch a b -> (sumLeaf a) + (sumLeaf b)
+
+-- Maybe monado
+
+--data Maybee a = Justt a | Nothingg deriving (Show)
+
+--return :: a -> Maybee a
+--return a = Maybee a
+
+--(>>=) :: Maybee a -> (a -> Maybee b) -> Maybee b
+--Nothingg >>= _  = Nothingg
+--Justt a >>=  f = f a
+
+add1 :: Maybe Int -> Maybe Int -> Maybe Int
+add1 mx my =
+  case mx of
+    Nothing -> Nothing
+    Just x  -> case my of
+                 Nothing -> Nothing
+                 Just y  -> Just (x + y)
+
+add2 :: Maybe Int -> Maybe Int -> Maybe Int
+add2 mx my =
+  mx >>= (\x ->
+    my >>= (\y ->
+      return (x + y)))
+
+add3 :: Maybe Int -> Maybe Int -> Maybe Int
+add3 mx my = do
+  x <- mx
+  y <- my
+  return (x + y)
+
+
+putResult x = putStrLn $ show x
+
+
+main = do putResult $ filter' (> 2) [1..10]
+
+          let tree = Branch (Leaf 3) (Branch (Leaf 2) (Leaf 4))
+          putResult $ depth tree
+          putResult $ sumLeaf tree
+
+          putResult $ (Just 1) `add1` Nothing
+          putResult $ Nothing `add1` (Just 3)
+          putResult $ (Just 1) `add1` (Just 3)
+          putResult $ Nothing `add1` Nothing
+          putResult $ (Just 1) `add2` Nothing
+          putResult $  Nothing `add2` (Just 3)
+          putResult $ (Just 1) `add2` (Just 3)
+          putResult $ Nothing `add2` Nothing
+          putResult $ (Just 1) `add3` Nothing
+          putResult $ Nothing `add3` (Just 3)
+          putResult $ (Just 1) `add3` (Just 3)
+          putResult $ Nothing `add3` Nothing

data/legacy_rspec/langs/Haskell/ex1_before.hs

@@ -0,0 +1,74 @@
+module Main where
+
+filter' :: (a -> Bool) -> [a] -> [a]
+filter' _ []                 = []
+filter' p (x:xs) | p x       = x : filter' p xs
+                 | otherwise = filter' p xs
+
+
+-- pattern match for Algebraic data type
+data Node = Leaf Integer | Branch Node Node deriving (Show)
+
+depth :: Node -> Integer
+depth node = case node of
+  Leaf _     -> 1
+  Branch a b -> 1 + max (depth a) (depth b)
+
+sumLeaf :: Node -> Integer
+sumLeaf node = case node of
+  Leaf x     -> x
+  Branch a b -> (sumLeaf a) + (sumLeaf b)
+
+-- Maybe monado
+
+--data Maybee a = Justt a | Nothingg deriving (Show)
+
+--return :: a -> Maybee a
+--return a = Maybee a
+
+--(>>=) :: Maybee a -> (a -> Maybee b) -> Maybee b
+--Nothingg >>= _  = Nothingg
+--Justt a >>=  f = f a
+
+add1 :: Maybe Int -> Maybe Int -> Maybe Int
+add1 mx my =
+  case mx of
+    Nothing -> Nothing
+    Just x  -> case my of
+                 Nothing -> Nothing
+                 Just y  -> Just (x + y)
+
+add2 :: Maybe Int -> Maybe Int -> Maybe Int
+add2 mx my =
+  mx >>= (\x ->
+    my >>= (\y ->
+      return (x + y)))
+
+add3 :: Maybe Int -> Maybe Int -> Maybe Int
+add3 mx my = do
+  x <- mx
+  y <- my
+  return (x + y)
+
+
+putResult x = putStrLn $ show x
+
+
+main = do putResult $ filter' (> 2) [1..10]
+
+          let tree = Branch (Leaf 3) (Branch (Leaf 2) (Leaf 4))
+          putResult $ depth tree
+          putResult $ sumLeaf tree
+
+          putResult $ (Just 1) `add1` Nothing
+          putResult $ Nothing `add1` (Just 3)
+          putResult $ (Just 1) `add1` (Just 3)
+          putResult $ Nothing `add1` Nothing
+          putResult $ (Just 1) `add2` Nothing
+          putResult $  Nothing `add2` (Just 3)
+          putResult $ (Just 1) `add2` (Just 3)
+          putResult $ Nothing `add2` Nothing
+          putResult $ (Just 1) `add3` Nothing
+          putResult $ Nothing `add3` (Just 3)
+          putResult $ (Just 1) `add3` (Just 3)
+          putResult $ Nothing `add3` Nothing