kristal 0.0.1

data/crystal/crystal.rb

@@ -0,0 +1,63 @@
+require_relative 'lib/helper/all'
+require_relative 'lib/collection/collection'
+require_relative 'lib/surface/surface'
+
+require_relative 'lib/crystal/catom'
+require_relative 'lib/crystal/surface'
+
+class Crystal
+  #TODO define select/reject etc for crystal module.
+  attr_reader :a, :b, :c, :alpha, :beta, :gamma,:atoms
+  def initialize *args
+    @a = @b = @c = args[0].to_f
+    @alpha = @beta = @gamma = 90.0
+    if args.length > 2
+      @b = args[1]
+      @c = args[2]
+    end
+    case args.length
+    when 4
+      @beta = args[3]
+    when 6
+      @alpha = args[3]
+      @beta = args[4]
+      @gamma = args[5]
+    end
+    @abc2xyz = conversion_matrix 
+    @xyz2abc = @abc2xyz.inv
+    @atoms = Collection.new
+    @crystal = []
+  end
+  def << arg 
+    case arg 
+    when Atom
+      arg.crystal = self
+      @atoms << arg
+      @crystal << CAtom.new(arg)
+    when CAtom
+      arg.crystal = self
+      @atoms << arg.atom
+      @crystal << arg
+    when Collection
+      arg.crystal = self
+      @atoms = arg
+      @crystal = [].tap{|t| @atoms.each{|a| t << CAtom.new(a)}}
+    end
+    return self
+  end
+  def frac(v) @xyz2abc * v.to_v end
+  def real(v) @abc2xyz * v.to_v end
+  def [] i, j = nil
+    j.nil?? @crystal[i] : @crystal[i,j]
+  end
+  def []= i, v
+    @crystal[i] = CAtom.new(arg) if v.is_a? Atom
+  end
+  def to_s
+    String.new.tap{|s| @crystal.each{|e| s << e.to_s << "\n"}}
+  end
+  private
+  def method_missing *args, &block
+    @atoms.send(*args, &block)
+  end
+end

data/crystal/lib/atom/atom.rb

@@ -0,0 +1,34 @@
+require_relative "lib/atom"
+require_relative "lib/elements"
+class Atom
+  attr_reader :pos, :crystal, :type, :fixed
+  def initialize params = {}
+    @type = Elements[params[:type]] || Elements[:X]
+    @name = (params[:name]||@type.name).to_sym
+    @pos = (params[:pos].to_v rescue nil)
+    @crystal = params[:crystal]
+    @fixed = params[:fixed]
+  end
+  def type= (el)
+    @type = Elements[el.to_sym]
+    @name = @type.name
+  end
+  def name() @name.to_s end
+  def name=(s)
+    @name = s.to_sym
+  end
+  def pos=(v)
+    @pos = v.to_v
+  end
+  def fixed=(*a)
+    a.flatten!
+    @fixed = a.length == 3 ? a : a * 3
+  end
+  def crystal=(c)
+    @crystal = c if (c.is_a? Crystal rescue false)
+  end
+  def evaluate str, b=nil
+    str = str.gsub(/={1,2}/,"==").gsub(/(\[[^\]]*\])/,'\1.to_v')
+    eval(str) ? true : false
+  end
+end

data/crystal/lib/atom/lib/atom.rb

@@ -0,0 +1,39 @@
+class Atom
+  def x() @pos[0] end
+  def y() @pos[1] end
+  def z() @pos[2] end
+  def x=(p) 
+    @pos = Vector[p,y,z] 
+  end
+  def y=(p) 
+    @pos = Vector[x,p,z] 
+  end
+  def z=(p) 
+    @pos = Vector[x,y,p] 
+  end
+  def has_crystal?() !(@crystal.nil?) end
+  def move! v, n = 1
+    @pos += v.to_v * n
+    self
+  end
+  def move v, n = 1
+    ret = self.dup
+    ret.move! v,n
+  end
+  def dist other
+    pos = other.is_a?(Atom) ? other.pos : other.to_v
+    has_crystal? ? crystal.dist(self, other):(@pos - pos).magnitude
+  end
+  def dup
+    Atom.new(to_hash)
+  end
+  def to_hash
+    { :type => @type.name.to_sym, :name => @name, :pos => @pos, :fixed => @fixed, :crystal => @crystal }
+  end
+  def to_s f = '%8.4f'
+    ("%-6s" + "#{f} " * 3) % ([name] + pos.to_a) + (fixed.nil? ? "" : fixed.map{|v| v ? 0 : 1}.join(" "))
+  end
+  def inspect
+    to_hash.to_s
+  end
+end

data/crystal/lib/atom/lib/elements.rb

@@ -0,0 +1,27 @@
+class Atom
+  Elements = {
+    :O => {
+      :z => 8,
+      :m => 15.999,
+      :fname => "Oxygen",
+      :name => :O,
+      :pp => []
+    },
+    :Ti => {
+      :z => 22,
+      :m => 47.867,
+      :fname => "Titanium",
+      :name => :Ti,
+      :pp => []
+    },
+    :X => {
+      :z => 1,
+      :m => 1,
+      :fname => "Unspecified",
+      :name => :X,
+      :pp => []
+    }
+  }
+  Elements.method_access = true
+  Elements.each{ |_,v| v.method_access = true }
+end

data/crystal/lib/atom/test/test.rb

@@ -0,0 +1,22 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative "../atom.rb"
+
+describe "Atom" do
+  before do
+    @atom = Atom.new :element => :Os, :pos => [0,0,0]
+    @atom2 = Atom.new :pos => [0,3,4]
+  end
+  it "can be copied around" do
+    @atom2 = @atom.move([2,3,4])
+    @atom2.pos.must_equal(Vector[2,3,4])
+    @atom.pos.must_equal(Vector[0,0,0])
+  end
+  it "and can be moved" do
+    @atom.move!(Vector[1,0,0],2).pos.must_equal(Vector[2,0,0])
+  end
+  it "can calculate distances" do
+    @atom.dist(@atom2).must_equal(5)
+    @atom2.dist([2,3,4]).must_equal(2)
+  end
+end

data/crystal/lib/collection/collection.rb

@@ -0,0 +1,48 @@
+require_relative "../atom/atom"
+require_relative "lib/enum"
+require_relative "lib/selector"
+require_relative "lib/sort"
+require_relative "lib/atom"
+require_relative "lib/rotate"
+
+class Collection
+  attr_reader :crystal
+  def initialize *args
+    @collection = []
+    @tol = 0
+    [*args].each{ |arg| self << arg }
+  end
+  def << arg
+    if arg.is_a? Atom
+      @collection << arg unless @collection.include? arg
+      return self
+    elsif arg.is_a? Collection
+      @collection += arg.to_a
+      @collection.uniq!
+      return self
+    elsif arg.is_a? Array
+      @collection += arg if arg.all?{|v| v.is_a? Atom}
+      @collection.uniq!
+      return self
+    end
+    return false
+  end
+  def length() @collection.length end
+  def pop n = 1
+    @collection.pop n
+  end
+  def [] i, j = nil
+    j.nil?? @collection[i] : Collection.new.tap{|t| t << @collection[i,j]}
+  end
+  def []= index, atom
+    if atom.is_a?(Atom) 
+      @collection[index]=atom 
+      @collection = @collection.uniq.compact
+      true
+    end
+      false
+  end
+  def to_s
+    String.new.tap{|s| @collection.each{|e| s << e.to_s << "\n"}}
+  end
+end

data/crystal/lib/collection/lib/atom.rb

@@ -0,0 +1,21 @@
+class Collection
+  def move! v, n=1
+    @collection.each{|atom| atom.move! v, n}
+    return self
+  end
+  def move v, n=1
+    dup.move! v, n
+  end
+  def fixed= bool = true
+    @collection.each{|atom| atom.fixed = bool}
+  end
+  def type= str
+    @collection.each{|atom| atom.type = str}
+  end
+  def name= str
+    @collection.each{|atom| atom.name = str}
+  end
+  def crystal= crystal
+    @collection.each{|atom| atom.crystal = crystal}
+  end
+end

data/crystal/lib/collection/lib/enum.rb

@@ -0,0 +1,33 @@
+class Collection
+  # include Enumerable
+  def each
+    if block_given?
+      @collection.each { |e| yield(e) }
+    else
+      Enumerator.new(self, :each)
+    end
+  end 
+  def map!
+      @collection.map!{|c| yield(c); c}
+  end
+  def map &block
+    dup.map!(&block)
+  end
+  def clone
+    Collection.new.tap{|t| t << @collection }
+  end
+  def dup
+    Collection.new.tap do |t|
+      @collection.each do |e|
+        t << e.dup
+      end
+    end
+  end
+  def to_a 
+    @collection
+  end
+  def remove arg 
+    arg.is_a?(Atom)? @collection.delete(arg): @collection.delete_at(arg)
+  end
+  alias :delete :remove
+end

data/crystal/lib/collection/lib/rotate.rb

@@ -0,0 +1,9 @@
+class Collection
+  def rotate! d, o = Vector[0,0,0], a
+    @collection.each{|v| v.pos = v.pos.rotate(d.to_v,o.to_v,a)}
+    self
+  end
+  def rotate *args
+    dup.rotate! *args
+  end
+end

data/crystal/lib/collection/lib/selector.rb

@@ -0,0 +1,18 @@
+class Collection
+  def select! str = nil, &block
+    @collection.select!{|v| v.evaluate(str)} unless str.nil?
+    @collection.select!(&block) if block_given?
+    self
+  end
+  def reject! str = nil, &block
+    @collection.reject!{|v| v.evaluate(str)} unless str.nil?
+    @collection.reject!(&block) if block_given?
+    self
+  end
+  def select str = nil, &block
+    dup.select! str, &block
+  end
+  def reject str = nil, &block
+    dup.select! str, &block
+  end
+end

data/crystal/lib/collection/lib/sort.rb

@@ -0,0 +1,33 @@
+class Collection
+  def sort! *keys
+    tol = []
+    tol << keys.pop while keys[-1].is_a? Numeric
+    @collection.sort! do |a,b|
+      result = 0
+      ks = keys.dup
+      t = tol.dup
+      while result == 0 and ks.length > 0
+        key = ks.shift
+        t.push @tol if t.length == 0
+        case key
+        when :type
+          result = (a.type.name <=> b.type.name)
+        when Symbol
+          result = a.send(key)
+          if result.is_a? Numeric
+            result = result.approx_sort(b.send(key), t.pop)
+          else
+            result = result <=> b.send(key)
+          end
+        else
+          result = (key.to_a * a.pos).approx_sort(key.to_a * b.pos, t.pop)
+        end
+      end
+      result
+    end
+    return @collection
+  end
+  def sort *keys
+    dup.sort! *keys
+  end
+end

data/crystal/lib/collection/test/selector.rb

@@ -0,0 +1,27 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative "../../helper/lib/array"
+
+describe "Selector" do
+  before "parser and yielder" do
+    def parse arg
+      conj = arg.scan(/and|or/).map{|v| v == 'and' ? :& : :|}
+      args = arg.split /and|or/
+      procs = []
+      args.each do |arg|
+        operator = arg.scan(/[>=<]{1,2}/)[0]
+        arg = arg.split(operator).map{|v| v.numeric?? Float(v) : v} #.to_sym}
+        procs.push Proc.new{|x| x.send(operator, arg[1])}
+      end
+      var = a
+      return Pr
+    end
+    def calc *args
+      yield *args
+    end
+  end
+  it "parses (and/or)s" do
+    c = "x < 10 and y > 10 or z > 1"
+    assert calc(11,1,2, &parse(c))
+  end
+end

data/crystal/lib/collection/test/test.rb

@@ -0,0 +1,24 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative "../Collection.rb"
+
+describe "Simple Cubic" do
+  before do
+    a = Atom.new :element => :Ti, :pos => [0,0,0]
+    @coll = Collection.new
+    @coll << a << a.move([0,0,1])
+    @coll << @coll.move([0,1,0])
+    @coll << @coll.move([1,1,0])
+  end
+  it "can be cloned and deep-cloned" do
+    clone = @coll.clone
+    deep_clone = @coll.dup
+    assert clone.object_id != @coll.object_id
+    assert clone[0].object_id == @coll[0].object_id
+    assert deep_clone.object_id != @coll.object_id
+    assert deep_clone[0].object_id != @coll[0].object_id
+  end
+  it "can be sorted in arbitrary directions" do
+
+  end
+end

data/crystal/lib/crystal/catom.rb

@@ -0,0 +1,41 @@
+class CAtom
+  attr_reader :atom
+  def initialize arg
+    if arg.is_a? Atom
+      @atom = arg
+    else
+      @atom = Atom.new(arg)
+    end
+  end
+  def pos= arg 
+    @atom.pos = @atom.crystal.real(arg)
+  end
+  def pos 
+    @atom.crystal.frac(@atom.pos)
+  end
+  def x() pos[0] end
+  def y() pos[0] end
+  def z() pos[0] end
+  def x=(p) 
+    @atom.pos = @atom.crystal.real([p,y,z])
+  end
+  def y=(p) 
+    @atom.pos = @atom.crystal.real([x,p,z])
+  end
+  def z=(p) 
+    @atom.pos = @atom.crystal.real([x,y,p])
+  end
+  def move!(v, n = 1)
+    @atom.move! @atom.crystal.real(v), n
+  end
+  def move(v, n) 
+    @atom.move @atom.crystal.real(v), n
+  end
+  def to_s f = '%8.4f'
+    ("%-6s" + "#{f} " * 3) % ([@atom.name] + pos.to_a) + (fixed.nil? ? "" : fixed.map{|v| v ? 0 : 1}.join(" "))
+  end
+  private
+  def method_missing *args
+    @atom.send(*args)
+  end
+end

data/crystal/lib/crystal/surface.rb

@@ -0,0 +1,35 @@
+class Crystal
+  def surface v, p, tol = 0
+    Surface.new(surface_converter(v), real(p), tol)
+  end
+  private
+  def conversion_matrix
+    cos = -> x {Math.cos( x * Math::PI / 180 ).round(10)}
+    sin = -> x {Math.sin( x * Math::PI / 180 ).round(10)}
+    Matrix[
+      [@a, @b * cos[@gamma], @c * cos[@beta]],
+      [0, @b * sin[@gamma], @c * (cos[@alpha] - cos[@beta] * cos[@gamma]) / sin[@gamma]],
+      [0, 0, @c * (1 - cos[@alpha] ** 2 - cos[@beta] ** 2 - cos[@gamma] ** 2 + 2 * cos[@gamma] * cos[@alpha] * cos[@beta])]
+    ]
+  end
+  def surface_converter arr
+    x = arr[0] == 0 ? Vector[1.0 / 0, 0, 0] : real([1.0 / arr[0], 0, 0])
+    y = arr[1] == 0 ? Vector[0,1.0/0,0] : real([0, 1.0 / arr[1], 0])
+    z = arr[2] == 0 ? Vector[0,0,1.0/0] : real([0, 0, 1.0 / arr[2]])
+    hxy = get_h x, y
+    get_h hxy, z
+  end
+  def get_h v1, v2
+    m = [v1.magnitude, v2.magnitude, (v1-v2).magnitude]
+    if m[0] == 1.0/0
+      v2
+    elsif m[1] == 1.0/0
+      v1
+    else
+      s = m.reduce(:+)/2
+      h = 2 * (s * m.map{|v| s - v}.reduce(:*)).sqrt / m[2]
+      angle = (Math.acos(h/m[0]) * 180 / Math::PI).round(10)
+      (v1/m[0]).rotate(v1.cross(v2), angle)*h
+    end
+  end
+end

data/crystal/lib/helper/all.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/lib/*.rb"].each {|file| require_relative file }

data/crystal/lib/helper/lib/array.rb

@@ -0,0 +1,55 @@
+require_relative 'string'
+require_relative 'object'
+require_relative 'numeric'
+class Array
+  #exclusive elements
+  def ^(other)
+    (self - other) | (other - self)
+  end
+  #new array from two arrays. 
+  def combine(other, op=nil)
+    return [] if self.empty? || other.empty?
+    clipped = self[0..other.length-1]
+    zipped = clipped.zip(other)
+    if op
+      zipped.map { |a, b| a.send(op, b) }
+    else
+      zipped.map { |a, b| yield(a, b) }
+    end
+  end
+  alias :old_x :*
+  def *(x)
+    if (x.is_a? Vector rescue false)
+      (Matrix[self] * x)[0]
+    else
+      old_x x
+    end
+  end
+  def to_v
+    Vector[*self]
+  end
+  #TODO Rewrite/Rename these:
+  def numbers!
+    i = length - 1
+    self.reverse_each do |elem|
+      if elem.is_a? Array
+        self[i] = elem.numbers!
+      else
+        elem.numeric? ? self[i] = Float(elem):self.delete_at(i)
+      end
+      i -= 1
+    end
+    return self
+  end
+  def numerify!
+    self.each_index do |i|
+      if self[i].is_a? Array
+        self[i] = self[i].numerify!
+      else
+        self[i] = Float(self[i]) if self[i].numeric?
+      end
+    end
+    return self
+  end
+
+end

data/crystal/lib/helper/lib/file.rb

@@ -0,0 +1,152 @@
+class File
+  # repeat last ff/rew command
+  def repeat
+    if @find_registry[:method] == :ff
+      seek(1,1)
+      ff(@find_registry[:re])
+    else
+      rew(@find_registry[:re])
+    end
+  end
+  # find all occurences of args (with or) 
+  # in the file egardless of the current
+  # position
+  def findall *args
+    p = pos
+    seek(0)
+    results = [ ff(*args).pos ]
+    while !repeat.nil?
+      results.push pos
+    end
+    seek(p)
+    return results
+  end
+  # do not rewind, just give
+  # the position that rew would 
+  # rewind to.
+  def rew? *args
+    p = pos 
+    p1 = rew(*args)
+    p1.nil? ? p1 = nil : p1 = pos
+    seek p
+    return p1
+  end
+  # do not fast forward, just give
+  # the position that ff would fast
+  # forward to.
+  def ff? *args
+    p = pos 
+    p1 = ff(*args)
+    p1.nil? ? p1 = nil : p1 = pos
+    seek p
+    return p1
+  end
+  # rewind until it finds one of args
+  # supplied as string or regex 
+  # returns nil if nothing found 
+  def rew *args
+    p = pos
+    psearch = p
+    re = Regexp.union(args)
+    @find_registry = { :method => :rew, :re => re }
+    begin
+      break if psearch == 0
+      512 > pos ? buffer = pos : buffer = 512 # buffer = [512, p].min
+      seek(-buffer, 1)
+      psearch = pos
+      chunk = read(buffer+80)
+      seek(-chunk.length, 1)
+      check = chunk.rindex(re)
+      if !check.nil? and buffer <= check
+        chunk.slice!(-(chunk.length-buffer)..-1)
+        check = chunk.rindex(re)
+      end
+    end while check.nil? or buffer <= check 
+    begin
+      if buffer <= check
+        seek p
+        return nil
+      else 
+        seek(psearch + check)
+        return self
+      end
+    rescue
+      seek p
+      return nil
+    end
+  end
+  # fast forward until it finds one of args
+  # supplied as string or regex 
+  # returns nil if nothing found 
+  def ff *args
+    p = pos
+    re = Regexp.union(args)
+    @find_registry = { :method => :ff, :re => re }
+    buffer = 512
+    begin
+      psearch = pos
+      chunk = read(buffer)
+      seek(-80,1) unless eof?
+      check = chunk.index(re)
+    end while check.nil? and !eof?
+    begin
+      seek(psearch + check)
+      return self
+    rescue
+      seek p
+      return nil
+    end
+  end
+  # unix head like utility, returns lines
+  # as an array. optional arguments cur for
+  # start from current line (default is start)
+  # from beggining; reset for do not change
+  # current position (default).
+  def head(n, cur=false, reset=true)
+    #eof guard
+    p = pos
+    line_start
+    lines = []
+    seek(0) unless cur
+    for i in 1..n 
+      break if eof?
+      lines.push(readline.chomp)
+    end
+    seek(p) if reset
+    return lines
+  end
+  # unix tail like utility, returns lines
+  # as an array. optional arguments cur for
+  # start from current line (default is start)
+  # from end; reset for do not change
+  # current position (default).
+  def tail(n, cur=false, reset=true)
+    p = pos
+    chunks = ''
+    lines = 0
+    cur ? line_end : seek(size)
+    begin
+      p1 = pos
+      p1 < 512 ? buffer = p1 : buffer = 512
+      seek(-buffer, 1)
+      chunk = read(buffer)
+      lines += chunk.count("\n")
+      chunks = chunk + chunks
+      seek(-chunk.size,1)
+    end while lines < ( n + 1 ) && p1 != 0
+    ary = chunks.split(/\n/)
+    reset ? seek(p) : seek(p1-1-(ary.last(n).join("\n").length))
+    return ary.last(n)
+  end
+  # move to the first char of current line
+  def line_start
+    unless readchar == "\n"
+      return rew(/^/)
+    end
+    return self
+  end
+  # move to the last char of current line
+  def line_end
+    return ff(/$/)
+  end
+end

data/crystal/lib/helper/lib/fixnum.rb

@@ -0,0 +1,8 @@
+class Fixnum
+  def zero_pad total
+    "%0#{total}d" % self
+  end
+  def length
+    self.to_s.length
+  end
+end

data/crystal/lib/helper/lib/hash.rb

@@ -0,0 +1,27 @@
+class Hash
+  def extract(*ks)
+    existing = keys & ks
+    Hash[existing.zip(values_at(*existing))]
+  end
+  def has_shape?(shape)
+    all? do |k, v|
+      Hash === v ? v.has_shape?(shape[k]) : shape[k] === v
+    end
+  end
+  attr_accessor :method_access
+  alias :old_m :method_missing
+  def method_missing(m)
+    if (@method_access.nil? ? (@@method_access rescue false) : @method_access)
+      if has_key? m
+        return self[m]
+      elsif has_key? m.to_s
+        return self[m.to_s]
+      end
+    end
+    return old_m(m)
+  end
+  class << self
+    def method_access=(bool) @@method_access = bool end
+    def method_access() @@method_access end
+  end
+end

data/crystal/lib/helper/lib/kernel.rb

@@ -0,0 +1,20 @@
+module Kernel
+  def fn(*funs)
+    -> x do
+      funs.inject(x) do |v,f|
+        Proc === f ? f.call(v) : v.send(f)
+      end
+    end
+  end
+  def prompt(text='', conversion=nil)
+    print text unless text.empty?
+    input = gets.chomp
+    CONVERSIONS.include?(conversion) ? input.send(conversion) : input
+  end
+  def with(object,&block)
+    object.instance_eval(&block)
+  end
+  # def with(o, &blk)
+  #   o.tap(&blk)
+  # end
+end

data/crystal/lib/helper/lib/matrix.rb

@@ -0,0 +1,12 @@
+require 'matrix'
+class Matrix
+  def to_s format='%.4f'
+    return "" if empty?
+    f = column_vectors.map(&->x{"%#{x.longest_string(format)}s"}).join(" ")
+    map{|v| format % v}.row_vectors.map{|v| f % v.to_a}.join("\n")
+  end
+  def inspect format = '%.4f'
+    return "Matrix[]" if empty?
+    (["\nMatrix[ "] + ["        "]*(row_size-1)).zip(to_s.lines).map{|v| v.join}.join() + " ]"
+  end
+end

data/crystal/lib/helper/lib/numeric.rb

@@ -0,0 +1,14 @@
+class Numeric
+  (Math.methods - Module.methods - ["hypot", "ldexp"]).each do |method|
+    define_method method do
+      Math.send method, self
+    end
+  end
+  def approx_sort other, tol = self.to_f/1000
+    d = self - other
+    d > tol ? 1 : (-d > tol ? -1 : 0)
+  end
+  def numeric?
+    true
+  end
+end

data/crystal/lib/helper/lib/object.rb

@@ -0,0 +1,35 @@
+class Object
+  alias :old_display :display
+  def display(new_line = true)
+    m = new_line ? :puts : :print
+    self.tap { |o| send(m, o) }
+  end
+  def it
+    self
+  end
+  def numeric?
+    false
+  end
+  def deep_clone
+    return @deep_cloning_obj if @deep_cloning
+    @deep_cloning_obj = clone
+    @deep_cloning_obj.instance_variables.each do |var|
+      val = @deep_cloning_obj.instance_variable_get(var)
+      begin
+        @deep_cloning = true
+        val = val.deep_clone
+      rescue TypeError
+        next
+      ensure
+        @deep_cloning = false
+      end
+      @deep_cloning_obj.instance_variable_set(var, val)
+    end
+    deep_cloning_obj = @deep_cloning_obj
+    @deep_cloning_obj = nil
+    deep_cloning_obj
+  end
+  def to_sym
+    self.to_s.to_sym
+  end
+end

data/crystal/lib/helper/lib/string.rb

@@ -0,0 +1,32 @@
+class String
+  def paste str, j = ' ', align = :left
+    if str.is_a? Array
+      tmp = self.dup
+      str.each do |s|
+        tmp = tmp.paste s, j, align
+      end
+      tmp
+    else
+      slines = self.lines.map(&:chomp)
+      s1lines = str.lines.map(&:chomp)
+      (s1lines.count - slines.count).times{slines.push ""}
+      l = slines.map(&:length).max
+      l1 = s1lines.map(&:length).max
+      case align
+      when :left
+        f  = "%-#{l}s"
+        f1 = "%-#{l1}s"
+      when :right
+        f  = "%#{l}s"
+        f1 = "%#{l1}s"
+      else
+        f  = '%s'
+        f1 = '%s'
+      end
+      slines.map{|v| f % v}.zip(s1lines.map{|v| f1 % v}).map{|v| v.join(j)}.join("\n")
+    end
+  end
+  def numeric?
+    Float(self) != nil rescue false
+  end
+end

data/crystal/lib/helper/lib/vector.rb

@@ -0,0 +1,54 @@
+class Vector
+  def to_s format = '%.4f'
+    return "" if size == 0
+    w = longest_string format
+    map{|v| "%#{w}s" % (format % v)}.to_a.join("\n")
+  end
+  def inspect format = '%.4f'
+    return "Vector[]" if size == 0
+    (["\nVector[ "] + ["        "]*(size-1)).zip(to_s.lines).map{|v| v.join}.join() +" ]"
+  end
+  def longest_string format
+    map{|x| (format % x).length}.max
+  end
+  def to_v
+    self
+  end
+  def rotate direction, origin = Vector[0,0,0], angle
+    Vector[*(rotation_matrix(direction, origin, angle) * Vector[*(self),1]).to_a[0,3]]
+  end
+  def cross v2
+    raise ArgumentError, "Vectors should be 3D" if self.size != 3 or v2.size != 3
+    Vector[
+      self[1]*v2[2] - self[2]*v2[1],
+      self[2]*v2[0] - self[0]*v2[2],
+      self[0]*v2[1] - self[1]*v2[0]
+    ]
+  end
+  private
+  def rotation_matrix direction, origin, theta 
+    u,v,w = direction.normalize.to_a
+    a,b,c = origin.to_a
+    cos = Math.cos(theta / 180.0 * Math::PI).round(10)
+    sin = Math.sin(theta / 180.0 * Math::PI).round(10)
+    return Matrix.columns([
+      [ u**2+cos*(v**2+w**2),
+        u*v*(1-cos)+w*sin,
+        u*w*(1-cos)-v*sin,
+        0 ],
+        [ v*u*(1-cos)-w*sin,
+          v**2+cos*(u**2+w**2),
+          v*w*(1-cos)+u*sin,
+          0],
+          [ u*w*(1-cos)+v*sin,
+            w*v*(1-cos)-u*sin,
+            w**2+cos*(v**2+u**2),
+            0 ],
+            [ (a*(v**2+w**2)-u*(b*v+c*w))*(1-cos)+(b*w-c*v)*sin,
+              (b*(u**2+w**2)-v*(a*u+c*w))*(1-cos)+(c*u-a*w)*sin,
+              (c*(u**2+v**2)-w*(a*u+b*v))*(1-cos)+(a*v-b*u)*sin,
+              1 ]
+    ])
+  end
+
+end

data/crystal/lib/surface/surface.rb

@@ -0,0 +1,30 @@
+class Surface
+  attr_accessor :tol
+  attr_reader :normal, :p
+  def initialize v, p, tol = 0
+    @normal = v.to_v || nil
+    @p = p.to_v || Vector[0,0,0]
+    @tol = tol
+  end
+  def normal=(a) @normal=a.to_v end
+  def p=(a) @p=a.to_v end
+  def above? p, tol = @tol
+    dist(p) + tol < 0
+  end
+  def below? p, tol = @tol
+    dist(p) - tol > 0
+  end
+  def include? p, tol = @tol
+    dist(p).abs <= tol
+  end
+  def dist p
+    p = p.pos if p.is_a? Atom
+    (p.to_v- @p).to_a * @normal / @normal.magnitude
+  end
+  def rotate! d,o,a
+    @normal = @normal.rotate!(d.to_v,o.to_v,a)
+  end
+  def move! v
+    @p += v.to_v
+  end
+end

data/crystal/lib/surface/test/test.rb

@@ -0,0 +1,19 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require_relative "../surface.rb"
+
+describe "Surface" do
+  before do
+    @surface = Surface.new [0,0,1], [1,1,1], 0.5
+  end
+  it "know up and down" do
+    assert @surface.below? [-1,-3,5]
+    assert @surface.above? [5,13,0]
+  end
+  it "tolerates deviations" do
+    assert @surface.include? [2,5,0.5]
+  end
+  it "gives the distances" do
+    @surface.dist([0,0,0]).must_equal -1
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: kristal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sencer Selcuk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-10 00:00:00.000000000 Z
+dependencies: []
+description: A crystal structure manipulator wanna-be
+email: sencerselcuk@twitter
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- crystal/crystal.rb
+- crystal/lib/atom/atom.rb
+- crystal/lib/atom/lib/atom.rb
+- crystal/lib/atom/lib/elements.rb
+- crystal/lib/atom/test/test.rb
+- crystal/lib/collection/collection.rb
+- crystal/lib/collection/lib/atom.rb
+- crystal/lib/collection/lib/enum.rb
+- crystal/lib/collection/lib/rotate.rb
+- crystal/lib/collection/lib/selector.rb
+- crystal/lib/collection/lib/sort.rb
+- crystal/lib/collection/test/selector.rb
+- crystal/lib/collection/test/test.rb
+- crystal/lib/crystal/catom.rb
+- crystal/lib/crystal/surface.rb
+- crystal/lib/helper/all.rb
+- crystal/lib/helper/lib/array.rb
+- crystal/lib/helper/lib/file.rb
+- crystal/lib/helper/lib/fixnum.rb
+- crystal/lib/helper/lib/hash.rb
+- crystal/lib/helper/lib/kernel.rb
+- crystal/lib/helper/lib/matrix.rb
+- crystal/lib/helper/lib/numeric.rb
+- crystal/lib/helper/lib/object.rb
+- crystal/lib/helper/lib/string.rb
+- crystal/lib/helper/lib/vector.rb
+- crystal/lib/surface/surface.rb
+- crystal/lib/surface/test/test.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A crystal structure manipulator wanna-be
+test_files: []
+has_rdoc: