symbols 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    symbols (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (10.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake
+  symbols!

data/README.md

@@ -0,0 +1,125 @@
+# symbols
+
+This small library defines constants, aliases and some originial math functionality for a lot of UTF-8 symbols and combinations thereof.
+
+Warning: This gem pollutes the Kernel module and extends built-in classes. If you don't like that, don't use it.
+
+## install
+
+There seems to be a problem with RDoc, ri and UTF-8 characters. So install the gem manually without documentation like this
+
+    gem install symbols --no-rdoc --no-ri
+
+## example
+
+Here are some examples (See the tests for more examples):
+
+### constants
+
+e, i, π, ∞, etc. are all defined.
+
+    e**(i*π)+1
+
+### fractions
+
+Most common fractions are defined, for example:
+
+    ⅛, ⅕, ¼, ⅓, ½, ¾, ⅚ and ⅞
+
+### comparison
+
+Short cuts for comparison operators
+
+    3.≤ 4
+    4.≥ 3
+    5.≠ 10
+    ϵ.≈ 0.0
+
+### logarithm
+
+For any number _n_ between 1 and 10, a log_n_ function is defined, with _n_ as subscript:
+
+    log₂(64)
+    log₁₀(10)
+
+### plus-minus
+
+The plus-minus and minus-plus operators are defined. With them, you can calculate e.g. the quadratic formula like this:
+
+    (-b.±(√(b.²-4*a*c)))/2*a
+
+### power
+
+For any number _n_ between 0 and 9, there is a function n defined on Numeric, where _n_ is a superscript, that calculates the _n_th power of the caller.
+
+    4 == 2.²
+    16 == 2.⁴
+
+### root
+
+There is a root function:
+
+    √(4) == 2
+
+For common roots, constants are defined:
+
+    √2
+    √3
+    √5
+
+Also, for any number _n_ between 1 and 9, there is a function defined that calculates the _n_th root:
+
+    ³√(8)
+    ⁴√(16)
+    ⁵√(32)
+
+### sets
+
+Common set operators are defined:
+
+    [1,2,3].⊆([1,2,3,4,5])
+    [1,2,3].⊂([1,2,3,4,5])
+    [1,2,3,4,5].⊇([1,2,3,4,5])
+    [1,2,3,4,5].⊃([1,2,3])
+    [1,2].∪([5,6])
+    [1,2,5].∩([2,5,6])
+    [1,2,5].∖([2,5,6])
+
+"Element of" and "Not element of" are defined on Object. They work for classes, containers and anything that responds to "include?":
+
+    4.∈([4,5,6])
+    "foo".∈(["foo", "bar", "baz"])
+    4.∈(1..10)
+    5.∉(1..3)
+    5.0.∉(Fixnum)
+    3.∉(String)
+
+### number sets
+
+The following sets are defined (Warning: These are not just capital letters; they are the double-struck capital letters you know from math lessons):
+
+    ℤ - Integers
+    ℕ - Positive integers
+    ℚ - Rational numbers
+    ℝ - Floats
+    ℂ - Complex
+    𝔹 - Booleans
+
+Use them in combination with the "Element of" function:
+
+    20.∈(ℕ)
+    -1.∈(ℤ)
+    Rational(4,5).∈(ℚ)
+    π.∈(ℝ)
+    i.∈(ℂ)
+    false.∈(𝔹)
+
+### ruby
+
+The lambda function got the short cut λ:
+
+    λ { |x| x ** 2 }
+
+# fork
+
+Feel free to fork and submit pull requests!

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "rake/testtask"
+require "bundler/gem_tasks"
+Bundler.setup
+Bundler.require
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end

data/lib/math/comparison.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+class Numeric
+  alias ≤ <=
+  alias ≥ >=
+  
+  def ≈(other)
+    (self - other).abs <= ϵ
+  end
+end
+
+class Object
+  def ≠(other)
+    self != other
+  end
+end

data/lib/math/constants.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+require 'complex'
+
+module Kernel
+  const_def :π => Math::PI,
+            :τ => Math::PI * 2,
+            :e => Math::E,
+            :i => Complex::I,
+            :ϵ => Float::EPSILON,
+            :∞ => +1.0/0.0
+end

data/lib/math/frac.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+module Kernel
+  const_def :⅛ => 0.125,
+            :⅙ => 1.0/6.0,
+            :⅕ => 0.2,
+            :¼ => 0.25,
+            :⅓ => 1.0/3.0,
+            :⅜ => 0.375,
+            :⅖ => 0.4,
+            :½ => 0.5,
+            :⅗ => 0.6,
+            :⅝ => 0.625,
+            :⅔ => 2.0/3.0,
+            :¾ => 0.75,
+            :⅘ => 0.8,
+            :⅚ => 5.0/6.0,
+            :⅞ => 0.875
+end

data/lib/math/logarithm.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+module Kernel
+  [:₁, :₂, :₃, :₄, :₅, :₆, :₇, :₈, :₉, :₁₀].each_with_index do |name, index|
+    define_method "log#{name}" do |val|
+      Math.log(val) / Math.log(index + 1)
+    end
+  end
+  
+  def ln(val)
+    Math.log(val) / Math.log(e)
+  end
+end

data/lib/math/mod.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+class Fixnum
+  def ≡(rest, divisor)
+    (self - rest) % divisor == 0
+  end
+end

data/lib/math/numeric.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+class Numeric
+  def ×(other)
+    self * other
+  end
+  
+  def ‰
+    self / 1000.0
+  end
+  
+  def ‱
+    self / 10000.0
+  end
+end

data/lib/math/numeric_pair.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+class NumericPair
+  attr_accessor :first, :second
+  
+  def initialize(first, second)
+    @first, @second = first, second
+  end
+  
+  def ±(other)
+    if other.is_a?(NumericPair)
+      NumericPair.new(first + other.first, second - other.second)
+    else
+      NumericPair.new(first + other, second - other)
+    end
+  end
+  
+  def ∓(other)
+    if other.is_a?(NumericPair)
+      NumericPair.new(first - other.first, second + other.second)
+    else
+      NumericPair.new(first - other, second + other)
+    end
+  end
+  
+  def method_missing(method, *args)
+    if first.respond_to?(method) && second.respond_to?(method)
+      NumericPair.new(first.send(method, *args), second.send(method, *args))
+    else
+      super
+    end
+  end
+  
+  def to_a
+    [first, second]
+  end
+  
+  def sort
+    NumericPair.new(*to_a.sort)
+  end
+  
+  def to_range
+    first..second
+  end
+  
+  def ==(other)
+    first == other.first && second == other.second
+  end
+  
+  def inspect
+    to_a.inspect
+  end
+end

data/lib/math/plus_minus.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+class Numeric
+  def ±(other = nil)
+    if other
+      NumericPair.new(self + other, self - other)
+    else
+      NumericPair.new(self, -self)
+    end
+  end
+  
+  def ∓(other = nil)
+    if other
+      NumericPair.new(self - other, self + other)
+    else
+      NumericPair.new(-self, self)
+    end
+  end
+end
+
+module Kernel
+  def ±(numeric)
+    numeric.±
+  end
+
+  def ∓(numeric)
+    numeric.∓
+  end
+end

data/lib/math/power.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+class Numeric
+  [:⁰, :¹, :², :³, :⁴, :⁵, :⁶, :⁷, :⁸, :⁹].each_with_index do |name, index|
+    define_method name do
+      self ** index
+    end
+  end
+end

data/lib/math/root.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+module Kernel
+  def √(val)
+    Math.sqrt(val)
+  end
+  
+  const_def :√2 => √(2),
+            :√3 => √(3),
+            :√5 => √(5)
+  
+  [:¹, :², :³, :⁴, :⁵, :⁶, :⁷, :⁸, :⁹].each_with_index do |name, index|
+    define_method "#{name}√" do |val|
+      val ** (1.0 / (index + 1).to_f)
+    end
+  end
+end

data/lib/ruby/lambda.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module Kernel
+  alias λ lambda
+end

data/lib/set/number_set.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+require 'complex'
+require 'rational'
+
+class NumberSet
+  def initialize(&block)
+    @block = block
+  end
+  
+  def include?(value)
+    @block.call(value)
+  end
+end
+
+module Kernel
+  const_def :ℤ => Fixnum,
+            :ℕ => NumberSet.new { |val| val.∈(ℤ) && val > 0 },
+            :ℚ => NumberSet.new { |val| val.∈(ℤ) || val.∈(Rational) },
+            :ℝ => NumberSet.new { |val| val.∈(ℚ) || val.∈(Float) },
+            :ℂ => NumberSet.new { |val| val.∈(ℝ) || val.∈(Complex) },
+            :𝔹 => [true, false]
+end

data/lib/set/set.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+module Enumerable
+  alias ∀ all?
+  alias ∃ find
+end
+
+class Array
+  def ⊆(other)
+    ∀ { |val| val.∈ other }
+  end
+  
+  def ⊂(other)
+    ⊆(other) && self.≠(other)
+  end
+  
+  def ⊇(other)
+    other.⊆(self)
+  end
+  
+  def ⊃(other)
+    other.⊂(self)
+  end
+  
+  alias ∪ |
+  alias ∩ &
+  alias ∖ -
+end
+
+class Object
+  def ∈(container)
+    if container.is_a?(Class)
+      self.is_a?(container)
+    else
+      container.include?(self)
+    end
+  end
+  
+  def ∉(container)
+    !∈(container)
+  end
+end

data/lib/symbols.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+class Module
+  def const_def(hash)
+    hash.each do |key, value|
+      define_method key do
+        value
+      end
+    end
+  end
+end
+
+Dir.glob(File.expand_path(File.dirname(__FILE__) + '/**/*.rb')).each do |file|
+  require file
+end

data/symbols.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "symbols"
+  s.version     = "0.0.1"
+  s.authors     = ["Thomas Kadauke"]
+  s.email       = ["thomas.kadauke@googlemail.com"]
+  s.homepage    = "https://github.com/tkadauke/symbols"
+  s.summary     = "Defines UTF-8 symbols for common math concepts"
+  s.description = "Defines UTF-8 symbols for common math concepts"
+
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake'
+end

data/test/math/comparison_test.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ComparisonTest < Test::Unit::TestCase
+  def test_should_define_lower_equal_operator
+    assert 3.≤ 4
+    assert 2.5.≤ 4
+    assert 5.≤ 5
+  end
+
+  def test_should_define_greater_equal_operator
+    assert 4.≥ 3
+    assert 4.≥ 2.5
+    assert 5.≥ 5
+  end
+  
+  def test_should_define_inequality_operator
+    assert 5.≠ 10
+    assert 2.0.≠ 4
+    assert !(4.≠ 4)
+  end
+  
+  def test_should_define_approximate_equality_operator
+    assert 3.≈(3)
+    assert ϵ.≈(0.0)
+  end
+end

data/test/math/constants_test.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ConstantsTest < Test::Unit::TestCase
+  def test_should_define_pi
+    assert respond_to?(:π)
+    assert_equal Math::PI, π
+  end
+  
+  def test_should_define_tau
+    assert respond_to?(:τ)
+    assert_equal 2*π, τ
+  end
+  
+  def test_should_define_e
+    assert respond_to?(:e)
+    assert_equal Math::E, e
+  end
+  
+  def test_should_define_i
+    assert respond_to?(:i)
+    assert_equal Complex::I, i
+  end
+  
+  def test_should_define_epsilon
+    assert respond_to?(:ϵ)
+    assert_equal Float::EPSILON, ϵ
+  end
+  
+  def test_should_define_infinity
+    assert respond_to?(:∞)
+    assert -∞ < ∞
+    assert ∞ > -∞
+    assert ∞ == ∞
+    assert ∞ <= ∞
+    assert ∞ >= ∞
+  end
+  
+  def test_should_allow_nice_euler_formula
+    v = e**(i*π)+1
+    assert v.real == 0
+    assert v.imag.≈ 0
+  end
+end

data/test/math/frac_test.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class FracTest < Test::Unit::TestCase
+  def test_should_define_fractions
+    assert ⅛ == 0.125
+    assert ⅙ == 1.0/6.0
+    assert ⅕ == 0.2
+    assert ¼ == 0.25
+    assert ⅓ == 1.0/3.0
+    assert ⅜ == 0.375
+    assert ⅖ == 0.4
+    assert ½ == 0.5
+    assert ⅗ == 0.6
+    assert ⅝ == 0.625
+    assert ⅔ == 2.0/3.0
+    assert ¾ == 0.75
+    assert ⅘ == 0.8
+    assert ⅚ == 5.0/6.0
+    assert ⅞ == 0.875
+  end
+end

data/test/math/logarithm_test.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class LogarithmTest < Test::Unit::TestCase
+  def test_should_calculate_logarithms
+    assert_equal 2, log₂(4)
+    assert_equal 6, log₂(64)
+    assert_equal 1, log₁₀(10)
+    assert_equal 2, log₁₀(100)
+  end
+  
+  def test_should_calculate_ln
+    assert_equal 1, ln(e)
+  end
+end

data/test/math/mod_test.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ModTest < Test::Unit::TestCase
+  def test_should_calculate_mod_with_rest
+    assert 5.≡ 2, 3
+    assert 8.≡ 2, 3
+  end
+end

data/test/math/numeric_pair_test.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class NumericPairTest < Test::Unit::TestCase
+  def test_should_initialize
+    pair = NumericPair.new(1, 2)
+    assert_equal [1, 2], pair.to_a
+  end
+  
+  def test_should_initialize_from_plus_minus
+    pair = 5.±(2)
+    assert_equal [7, 3], pair.to_a
+  end
+  
+  def test_should_initialize_from_minus_plus
+    pair = 5.∓(2)
+    assert_equal [3, 7], pair.to_a
+  end
+  
+  def test_should_allow_chain_of_plus_minus_with_number
+    pair = 5.±(2).±(1)
+    assert_equal [8, 2], pair.to_a
+  end
+  
+  def test_should_allow_chain_of_plus_minus_with_pair
+    pair = 5.±(2).±(1.±(1))
+    assert_equal [9, 3], pair.to_a
+  end
+  
+  def test_should_allow_chain_of_minus_plus_with_number
+    pair = 5.±(2).∓(1)
+    assert_equal [6, 4], pair.to_a
+  end
+  
+  def test_should_allow_chain_of_minus_plus_with_pair
+    pair = 5.±(2).∓(1.±(1))
+    assert_equal [5, 3], pair.to_a
+  end
+  
+  def test_should_allow_numeric_operators
+    assert_equal [6, 4], (3.±(1) + 2).to_a
+    assert_equal [2, 0], (3.±(1) - 2).to_a
+    assert_equal [2, 1], (3.±(1) / 2).to_a
+  end
+  
+  def test_should_convert_to_range
+    assert_equal (2..4), 3.∓(1).to_range
+  end
+  
+  def test_should_inspect
+    assert_equal '[4, 2]', 3.±(1).inspect
+  end
+  
+  def test_should_sort
+    assert_equal [2, 3], NumericPair.new(2, 3).sort.to_a
+    assert_equal [-2, 4], NumericPair.new(4, -2).sort.to_a
+    assert_equal 4.±(2).sort, 4.∓(2).sort
+  end
+  
+  def test_should_test_for_equality
+    assert NumericPair.new(2, 3) == NumericPair.new(2, 3)
+    assert !(NumericPair.new(2, 3) == NumericPair.new(3, 4))
+  end
+  
+  def test_should_test_for_inequality
+    assert !(NumericPair.new(2, 3) != NumericPair.new(2, 3))
+    assert NumericPair.new(2, 3) != NumericPair.new(3, 4)
+  end
+  
+  def test_should_solve_quadratic_formula
+    a = 1; b = 0; c = -4
+    pair = (-b.±(√(b.²-4*a*c)))/2*a
+    assert_equal [-2, 2], pair.to_a
+  end
+end

data/test/math/numeric_test.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class NumericTest < Test::Unit::TestCase
+  def test_should_multiply_with_x_operator
+    assert_equal 15, 3.×(5)
+  end
+  
+  def test_should_calculate_promille
+    assert_equal 0.001, 1.‰
+  end
+  
+  def test_should_calculate_pro_ten_thousand
+    assert_equal 0.0001, 1.‱
+  end
+end

data/test/math/plus_minus_test.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class PlusMinusTest < Test::Unit::TestCase
+  def test_should_define_unary_plus_minus_operator
+    assert_equal [3, -3], 3.±.to_a
+    assert_equal [∞, -∞], ∞.±.to_a
+  end
+  
+  def test_should_define_binary_plus_minus_operator
+    assert_equal [8, 2], 5.±(3).to_a
+  end
+  
+  def test_should_define_plus_minus_prefix
+    assert_equal [3, -3], ±(3).to_a
+    assert_equal [∞, -∞], ±(∞).to_a
+  end
+end

data/test/math/power_test.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class PowerTest < Test::Unit::TestCase
+  def test_should_calculate_powers
+    assert_equal 1, 2.⁰
+    assert_equal 4, 2.²
+    assert_equal 16, 2.⁴
+    assert_equal 64, 2.⁶
+  end
+end

data/test/math/root_test.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class RootTest < Test::Unit::TestCase
+  def test_should_define_sqrt_2
+    assert_equal √(2), √2
+  end
+  
+  def test_should_define_sqrt_3
+    assert_equal √(3), √3
+  end
+  
+  def test_should_define_sqrt_5
+    assert_equal √(5), √5
+  end
+  
+  def test_should_define_square_root
+    assert_equal 2, √(4)
+    assert_equal Math.sqrt(5), √(5)
+  end
+  
+  def test_should_calculate_roots
+    assert_equal 2, ³√(8)
+    assert_equal 2, ⁴√(16)
+    assert_equal 2, ⁵√(32)
+  end
+end

data/test/ruby/lambda_test.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class LambdaTest < Test::Unit::TestCase
+  def test_should_create_lambda
+    called = false
+    l = λ { called = true }
+    l.call
+    assert called
+  end
+end

data/test/set/number_set_test.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class NumberSetTest < Test::Unit::TestCase
+  def test_should_define_natural_number_set
+    assert ! -1.∈(ℕ)
+    assert 20.∈(ℕ)
+  end
+  
+  def test_should_define_integer_number_set
+    assert 20.∈(ℤ)
+    assert -1.∈(ℤ)
+    assert ! 10.5.∈(ℤ)
+  end
+  
+  def test_should_define_integer_number_set
+    assert Rational(4,5).∈(ℚ)
+    assert 20.∈(ℚ)
+    assert ! 10.5.∈(ℚ)
+  end
+  
+  def test_should_define_real_number_set
+    assert π.∈(ℝ)
+    assert √2.∈(ℝ)
+    assert 20.5.∈(ℝ)
+    assert Rational(4,5).∈(ℝ)
+    assert -1.∈(ℝ)
+    assert ! i.∈(ℝ)
+  end
+  
+  def test_should_define_complex_number_set
+    assert √2.∈(ℂ)
+    assert i.∈(ℂ)
+  end
+  
+  def test_should_define_boolean_number_set
+    assert true.∈(𝔹)
+    assert false.∈(𝔹)
+  end
+end

data/test/set/set_test.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class SetTest < Test::Unit::TestCase
+  def test_should_define_for_all
+    assert [1,2,3].∀ { |x| x < 10 }
+    assert ! [1,2,3].∀ { |x| x > 10 }
+  end
+  
+  def test_should_define_exist
+    assert [1,2,3].∃ { |x| x % 2 == 0 }
+    assert ! [1,2,3].∃ { |x| x % 14 == 0 }
+  end
+  
+  def test_should_define_subset
+    assert [1,2,3].⊆([1,2,3,4,5])
+    assert [1,2,3].⊆([1,2,3])
+    assert ! [1,2,4].⊆([1,2,3])
+  end
+  
+  def test_should_define_proper_subset
+    assert [1,2,3].⊂([1,2,3,4,5])
+    assert ! [1,2,3].⊂([1,2,3])
+  end
+  
+  def test_should_define_superset
+    assert [1,2,3,4,5].⊇([1,2,3,4,5])
+    assert [1,2,3].⊇([1,2,3])
+    assert ! [1,2,3].⊇([1,2,4])
+  end
+  
+  def test_should_define_proper_superset
+    assert [1,2,3,4,5].⊃([1,2,3])
+    assert ! [1,2,3].⊃([1,2,3])
+  end
+  
+  def test_should_define_union
+    assert_equal [1,2,5,6], [1,2].∪([5,6])
+    assert_equal [1,2,5,6], [1,2,5].∪([2,5,6])
+  end
+  
+  def test_should_define_intersection
+    assert_equal [], [1,2].∩([5,6])
+    assert_equal [2,5], [1,2,5].∩([2,5,6])
+  end
+  
+  def test_should_define_difference
+    assert_equal [1], [1,2,5].∖([2,5,6])
+    assert_equal [1,2,5], [1,2,5].∖([4,9,10])
+  end
+  
+  def test_should_return_if_element_is_in_container
+    assert 4.∈([4,5,6])
+    assert "foo".∈(["foo", "bar", "baz"])
+  end
+  
+  def test_should_return_if_element_is_in_range
+    assert 4.∈(1..10)
+  end
+  
+  def test_should_return_if_element_is_in_number_set
+    set = NumberSet.new { |x| x % 2 == 0 }
+    assert 4.∈(set)
+    assert ! 5.∈(set)
+  end
+  
+  def test_should_return_if_element_is_of_type
+    assert 4.∈(Fixnum)
+    assert "foo".∈(String)
+  end
+  
+  def test_should_define_not_element
+    assert 5.∉(1..3)
+    assert 5.0.∉(Fixnum)
+    assert 3.∉(String)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.expand_path(File.dirname(__FILE__) + '/../lib/symbols')

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: symbols
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thomas Kadauke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-12-10 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+description: Defines UTF-8 symbols for common math concepts
+email: 
+- thomas.kadauke@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/math/comparison.rb
+- lib/math/constants.rb
+- lib/math/frac.rb
+- lib/math/logarithm.rb
+- lib/math/mod.rb
+- lib/math/numeric.rb
+- lib/math/numeric_pair.rb
+- lib/math/plus_minus.rb
+- lib/math/power.rb
+- lib/math/root.rb
+- lib/ruby/lambda.rb
+- lib/set/number_set.rb
+- lib/set/set.rb
+- lib/symbols.rb
+- symbols.gemspec
+- test/math/comparison_test.rb
+- test/math/constants_test.rb
+- test/math/frac_test.rb
+- test/math/logarithm_test.rb
+- test/math/mod_test.rb
+- test/math/numeric_pair_test.rb
+- test/math/numeric_test.rb
+- test/math/plus_minus_test.rb
+- test/math/power_test.rb
+- test/math/root_test.rb
+- test/ruby/lambda_test.rb
+- test/set/number_set_test.rb
+- test/set/set_test.rb
+- test/test_helper.rb
+homepage: https://github.com/tkadauke/symbols
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1290685105589525560
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1290685105589525560
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Defines UTF-8 symbols for common math concepts
+test_files: 
+- test/math/comparison_test.rb
+- test/math/constants_test.rb
+- test/math/frac_test.rb
+- test/math/logarithm_test.rb
+- test/math/mod_test.rb
+- test/math/numeric_pair_test.rb
+- test/math/numeric_test.rb
+- test/math/plus_minus_test.rb
+- test/math/power_test.rb
+- test/math/root_test.rb
+- test/ruby/lambda_test.rb
+- test/set/number_set_test.rb
+- test/set/set_test.rb
+- test/test_helper.rb