spitzy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b4c4514dc16190a33abdb5c74642714f42c7909
+  data.tar.gz: 7e121d89a995d6f40a13862e3d5b4e9e5fc2499c
+SHA512:
+  metadata.gz: 3c646c95d3d443eadad900249330828f561de508690fe91e19649039b90867c2dfdded1c8d23d3da1a90776f670f92527d5ad0513f713cd80156d01379ba6cdf
+  data.tar.gz: 8bcd7262839166a08c38c91edd57f79d0d933381e33c23b1c2d898387b9e62b6d38db2b119617e188dac06f8a1ce8b9fb7b67ac7de248be2056b9e5896c781b4

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 2.1
+  - 2.2
+before_install:
+  - sudo apt-get update -qq
+  - sudo apt-get install -y liblapack-dev
+# for ATLAS implementation of LAPACK one can use;
+#  - sudo apt-get install -y libatlas-base-dev 
+install:
+  - gem install bundler
+  - bundle install
+  - bundle exec rake install
+script: 
+  - bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spitzy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Alexej Gossmann 
+
+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,83 @@
+# Spitzy
+
+[![Build Status](https://travis-ci.org/agisga/mixed_models.svg?branch=master)](https://travis-ci.org/agisga/mixed_models)
+
+![Spitzy](spitzy.jpg?raw=true "Optional Title")
+
+Spitzy is this cute pomeranian.
+Spitzy reads backwards as *yztips*, which translates into:
+
+***Y*our *Z*appy-*T*appy *I*nitial and boundary value *P*artial (and ordinary) differential equation *S*olver**
+
+Now, spitzy is also a growing collection of numerical methods for differential equations, written in Ruby.
+To my knowledge, apart from an [interface with the DASPK Fortran library](https://rubygems.org/gems/rb-daspk/versions/0.0.7-x86-mswin32-60), there currently does not exist another differential equation solver gem for Ruby.
+
+<!--
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/spitzy`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem 
+-->
+
+## Installation
+
+<!--
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spitzy'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spitzy
+-->
+
+Ruby is required in version >=2.0 because keyword arguments are excessively used in `spitzy`.
+Moreover, prior to the installation of `spitzy`, currently the `NMatrix` gem needs to be installed in its development version (because `Poissons_eq` uses `#meshgrid`)
+ from <https://github.com/SciRuby/nmatrix.git>.
+
+Then `spitzy` can be installed using the command line (or something similar):
+
+```
+git clone https://github.com/agisga/spitzy.git
+cd spitzy/
+bundle install
+bundle exec rake install
+```
+
+Feel free to contact me at alexej.go [at] googlemail.com, in case of difficulties with the installation.
+
+## Documentation, Tutorials and Usage Examples
+
+* Technical Report: <http://agisga.github.io/spitzy/documentation/>
+
+* Slide show: <http://agisga.github.io/presentations/spitzy.html#/>
+
+* Blog posts about some of the implemented methods:
+
+  - [Ordinary differential equations](http://agisga.github.io/ODE/)
+
+  - [Two point boundary value problem](http://agisga.github.io/BVP/)
+
+  - [Advection equation](http://agisga.github.io/Advection-Equation/)
+
+
+<!--
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+-->
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "spitzy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/spitzy.rb

@@ -0,0 +1,12 @@
+# Copyright (c) 2015 Alexej Gossmann 
+
+require "spitzy/version"
+
+require 'nmatrix/nmatrix'
+require 'nmatrix/lapack_plugin'
+
+require "spitzy/advection_eq.rb"
+require "spitzy/ode.rb"
+require "spitzy/bvp.rb"
+require "spitzy/poissons_eq.rb"
+

data/lib/spitzy/advection_eq.rb

@@ -0,0 +1,178 @@
+# Copyright (c) 2015 Alexej Gossmann 
+
+module Spitzy
+  # Numerically solves the 1D linear advection equation:
+  #
+  # * PDE: du/dt + a * du/dx = 0,
+  # * on the domain: 0 < x < xmax and 0 < t < tmax, 
+  # * with periodic boundary consitions: u(0,t) = u(xmax, t),
+  # * with initial condition as supplied by the user.
+  #   
+  class AdvectionEq
+
+    # time step in x                   
+    attr_reader :dx
+    # time step in t
+    attr_reader :dt
+    # parameter in the 1D linear advection equation
+    attr_reader :a
+    # array of space points
+    attr_reader :x
+    # array of time points
+    attr_reader :t
+    # number of space points (i.e. length of +x+)
+    attr_reader :mx
+    # number of time points (i.e. length of +t+)
+    attr_reader :mt
+    # the numerical solution as an array of arrays
+    attr_reader :u
+    # the numerical scheme applied
+    attr_reader :method
+
+    # Constructor for all solver routines for the 1D linear advection equation:
+    # * PDE: du/dt + a * du/dx = 0,
+    # * on the domain: xmin < x < xmax and tmin < t < tmax, 
+    # * with periodic boundary consitions: u(xmin,t) = u(xmax,t),
+    # * with initial condition u(x,tmin) as supplied by the user.
+    #
+    # It initializes the parameters and solves the equation
+    # using one of the methods: 
+    # Upwind, Leapfrog, Lax-Friedrichs, Lax-Wendroff.
+    #
+    # === Arguments
+    #
+    # * +xrange+  - An array of the form [xmin, xmax]. The space domain xmin<=x<=xmax 
+    #   on which the solution will be evaluated.
+    #
+    # * +trange+  - An array of the form [tmin, tmax]. The time domain tmin<=t<=tmax 
+    #   on which the solution will be evaluated.
+    #
+    # * +dx+      - Stepsize in space, i.e. in x
+    #
+    # * +dt+      - Stepsize in time, i.e. in t
+    #
+    # * +a+       - The constant speed +a+ in the PDE du/dt + a * du/dx = 0
+    #
+    # * +method+ - The numerical scheme used to solve the PDE. Possible values are:
+    #   +:upwind+, +:lax_friedrichs+, +:leapfrog+ or +:lax_wendroff+ (default is +:lax_wendroff+).
+    #
+    # * +&ic+     - The initial condition which must be supplied as a +proc+ object.
+    #   The initial condition is a function in x at time t=0.
+    #
+    # ==== Usage
+    #
+    #   ic = proc { |x| Math::cos(2*Math::PI*x) + 0.2*Math::cos(10*Math::PI*x) }
+    #   numsol = Spitzy::AdvectionEq.new(xrange: [0.0,1.0], trange: [0.0,10.0], dx: 1.0/101, 
+    #                                    dt: 0.95/101, a: 1.0, method: :upwind, &ic)
+    #
+    def initialize(xrange: , trange: , dx: , dt: , a: , method: :lax_wendroff, &ic)
+      raise(ArgumentError, "Expected xrange to be an array of length 2") unless xrange.length == 2
+      raise(ArgumentError, "Expected trange to be an array of length 2") unless trange.length == 2
+      @dx = dx # x step size
+      @dt = dt #t step size
+      @a = a # parameter in the 1-dim linear advection eq.
+      @ic = ic # initial condition
+      @x = (xrange[0]..xrange[1]).step(dx).to_a # x steps
+      @x << xrange[1] if @x.last < xrange[1]
+      @mx = @x.length # Number of x steps
+      @t = (trange[0]..trange[1]).step(dt).to_a # t steps
+      @t << trange[1] if @t.last < trange[1]
+      @mt = @t.length # Number of t steps
+      @u = [] # Stores numerical solution
+
+      @method = method
+      case @method
+        when :upwind then upwind
+        when :lax_friedrichs then lax_friedrichs
+        when :leapfrog then leapfrog
+        when :lax_wendroff then lax_wendroff
+        else raise(ArgumentError, "#{@method} is not a valid method.")
+      end
+    end
+
+    # Evaluate the initial condition at x0
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    def ic(x0)
+      @ic.call(x0)
+    end
+
+    # Get a character string representing the PDE, its domain and boundary condition. 
+    def equation
+      "du/dt + #{@a} * du/dx = 0, #{@x[0]} < x < #{@x[-1]} and #{@t[0]} < t < #{@t[-1]}, u(0,t) = u(#{@x[-1]}, t)"
+    end
+
+    ######### Available numeric schemes ##########
+    
+    private
+
+      # Solves the 1D linear advection equation 
+      # du/dt + a * du/dx = 0
+      # with the Upwind scheme.
+      # Requires: a > 0
+      def upwind
+        raise(ArgumentError, "the upwind scheme requires a>0.") if @a<=0
+        @u[0] = @mx.times.map { |j| self.ic(@x[j]) } # IC: u(x,0)
+        alpha = @a*@dt/@dx
+        0.upto(@mt-2) do |n|
+          @u[n+1] = (1.upto(@mx-2)).to_a
+          @u[n+1].map! { |j| @u[n][j]-alpha*(@u[n][j]-@u[n][j-1])}
+          @u[n+1].unshift @u[n][0]-alpha*(@u[n][0]-@u[n][@mx-2])
+          @u[n+1].push @u[n+1][0] # periodic BC
+        end
+      end
+
+      # Solves the 1D linear advection equation 
+      # du/dt + a * du/dx = 0
+      # with the Lax-Friedrichs scheme.
+      def lax_friedrichs
+        @u[0] = @mx.times.map { |j| self.ic(@x[j]) } # IC: u(x,0)
+        alpha = @a*@dt/@dx
+        0.upto(@mt-2) do |n|
+          @u[n+1] = (1.upto(@mx-3)).to_a
+          @u[n+1].map! { |j| 0.5*(@u[n][j+1]+u[n][j-1])-0.5*alpha*(@u[n][j+1]-@u[n][j-1]) }
+          @u[n+1].unshift 0.5*(@u[n][1]+u[n][@mx-2])-0.5*alpha*(@u[n][1]-@u[n][@mx-2]) # u(0,t)
+          @u[n+1].push 0.5*(@u[n][0]+u[n][@mx-3])-0.5*alpha*(@u[n][0]-@u[n][@mx-3]) # u(max(x), t)
+          @u[n+1].push @u[n+1][0] # periodic BC
+        end
+      end
+      
+      # Solves the 1D linear advection equation 
+      # du/dt + a * du/dx = 0
+      # with the Leapfrog scheme.
+      def leapfrog
+        @u[0] = @mx.times.map { |j| self.ic(@x[j]) } # IC: u(x,0)
+        alpha = @a*@dt/@dx
+        @u[1] = (1.upto(@mx-3)).to_a # u(x, t1)
+        @u[1].map! { |j| 0.5*(@u[0][j+1]+u[0][j-1])-0.5*alpha*(@u[0][j+1]-@u[0][j-1]) }
+        @u[1].unshift 0.5*(@u[0][1]+u[0][@mx-2])-0.5*alpha*(@u[0][1]-@u[0][@mx-2]) # u(0,t1)
+        @u[1].push 0.5*(@u[0][0]+u[0][@mx-3])-0.5*alpha*(@u[0][0]-@u[0][@mx-3]) # u(max(x), t1)
+        @u[1].push @u[1][0] # periodic BC
+        1.upto(@mt-2) do |n|
+          @u[n+1] = (1.upto(@mx-3)).to_a
+          @u[n+1].map! { |j| @u[n-1][j]-alpha*(@u[n][j+1]-@u[n][j-1])}
+          @u[n+1].unshift @u[n-1][0]-alpha*(@u[n][1]-@u[n][@mx-2]) # u(0,t)
+          @u[n+1].push @u[n-1][@mx-2]-alpha*(@u[n][0]-@u[n][@mx-3]) # u(max(x), t)
+          @u[n+1].push @u[n+1][0] # periodic BC
+        end
+      end
+
+      # Solves the 1D linear advection equation 
+      # du/dt + a * du/dx = 0
+      # with the Lax-Wendroff scheme.
+      def lax_wendroff
+        @u[0] = @mx.times.map { |j| self.ic(@x[j]) } # IC: u(x,0)
+        alpha = @a*@dt/@dx
+        0.upto(@mt-2) do |n|
+          @u[n+1] = (1.upto(@mx-3)).to_a
+          @u[n+1].map! { |j| @u[n][j]-0.5*alpha*(@u[n][j+1]-@u[n][j-1])+0.5*(alpha**2)*(u[n][j+1]-2*u[n][j]+u[n][j-1]) }
+          @u[n+1].unshift @u[n][0]-0.5*alpha*(@u[n][1]-@u[n][@mx-2])+0.5*(alpha**2)*(u[n][1]-2*u[n][0]+u[n][@mx-2]) # u(0,t)
+          @u[n+1].push @u[n][@mx-2]-0.5*alpha*(@u[n][0]-@u[n][@mx-3])+0.5*(alpha**2)*(u[n][0]-2*u[n][@mx-2]+u[n][@mx-3]) # u(max(x), t)
+          @u[n+1].push @u[n+1][0] # periodic BC
+        end
+      end
+  end
+end

data/lib/spitzy/bvp.rb

@@ -0,0 +1,242 @@
+# Copyright (c) 2015 Alexej Gossmann 
+
+module Spitzy
+  # Numerically solves a boundary value problem of the general form:
+  #
+  # * ODE: -(a*u')' + b*u' + c*u = f, xmin<x<xmax,
+  # * where a, b, c, f and u are functions of x,
+  # * with Dirichlet boundary conditions: u(xmin) = bc[1], u(xmax) = bc[2].
+  #   
+  class Bvp
+
+    # array of the points in the domain at which the numerical solution was evaluated
+    attr_reader :x
+    # number of grid points (i.e. length of +x+)
+    attr_reader :mx
+    # step size in x
+    attr_reader :dx
+    # the boundary conditions (an array of length two)
+    attr_reader :bc
+    # the numerical scheme applied
+    attr_reader :method
+    # the numerical solution as an array. It is obtained as a solution to a linear system.
+    attr_reader :u
+    # the right hand side of the solved linear system
+    attr_reader :rhs
+    # the stiffness matrix, i.e. the matrix of the solved linear system
+    attr_reader :mat
+
+    # Constructor for all solver routines for the boundary value problem:
+    #
+    # * ODE: -(a*u')' + b*u' + c*u = f, xmin<x<xmax,
+    # * where a, b, c, f and u are functions of x,
+    # * with Dirichlet boundary conditions: u(xmin) = bc[1], u(xmax) = bc[2].
+    #
+    # It initializes the parameters and solves the equation
+    # using one of the methods: 
+    # Linear Finite Elements. 
+    #
+    # === Arguments
+    #
+    # * +xrange+  - An array of the form [xmin, xmax]. The interval on which the solution will be evaluated.
+    #
+    # * +mx+      - Number of grid points. Determines the array x of equally spaced values on which the numerical
+    #   solution can be evaluated.
+    #
+    # * +bc+      - An array of length two, specifying the two boundary conditions.
+    #
+    # * +method+  - The numerical scheme used to solve the BVP. Possible values are:
+    #   +:lin_fin_elt+ (linear finite elements).
+    #
+    # * +a+       - A +Proc+ or +Numeric+ object. The function a(x) in the left hand side 
+    #   of the differential equation which can be supplied as a +Proc+ object.
+    #   If a +Numeric+ object is supplied then a(x) is assumed to be constant equal to that number.
+    #
+    # * +b+       - A +Proc+ or +Numeric+ object. The function b(x) in the left hand side 
+    #   of the differential equation which can be supplied as a +Proc+ object.
+    #   If a +Numeric+ object is supplied then b(x) is assumed to be constant equal to that number.
+    #
+    # * +c+       - A +Proc+ or +Numeric+ object. The function c(x) in the left hand side 
+    #   of the differential equation which can be supplied as a +Proc+ object.
+    #   If a +Numeric+ object is supplied then c(x) is assumed to be constant equal to that number.
+    #
+    # * +f+       - A +Proc+ or +Numeric+ object. The right hand side f(x) of the differential 
+    #   equation, which can be supplied as a +Proc+ object. If a +Numeric+ object is 
+    #   supplied then f(x) is assumed to be constant equal to that number.
+    #
+    # ==== Usage
+    #
+    #   # a,b,c and f are Numeric
+    #   bvp_sol = Spitzy::Bvp.new(xrange: [0.0, 100.0], mx: 100, bc: [10.0, 0.00090799859], 
+    #                             a: 800.0*Math::PI, b: 0.0, c: 8.0*Math::PI, f: 0.0)
+    #  
+    #   # a,b,c and f are Proc objects
+    #   a = Proc.new { |x| -Math::cos(x) }
+    #   b = Proc.new { |x| Math::sin(x) }
+    #   c = Proc.new { |x| Math::cos(x) }
+    #   f = Proc.new { |x| -2.0*(Math::cos(x))**2 }
+    #   xrange = [0.0, 10.0]
+    #   bc = [0.0, (1.0 - 10.0) * Math::sin(10.0)]
+    #   bvp_sol = Spitzy::Bvp.new(xrange: xrange, mx: 100, bc: bc, 
+    #                             a: a, b: b, c: c, f: f)
+    #
+    def initialize(xrange:, mx:, bc:, method: :lin_fin_elt, a:, b:, c:, f:)
+
+      raise(ArgumentError, "Expected xrange to be an array of length 2") unless xrange.length == 2
+      raise(ArgumentError, "Expected bc to be an array of length 2") unless bc.length == 2
+      @mx = mx
+      @xmin = xrange[0].to_f
+      @xmax = xrange[1].to_f
+      @dx = (@xmax-@xmin) / (@mx-1)
+      @x = (@xmin..@xmax).step(@dx).to_a # x steps
+      @bc = bc 
+      @u = [] # Stores numerical solution
+
+      if a.is_a? Proc then
+        @a = a 
+      elsif a.is_a? Numeric then
+        @a = Proc.new { |x| a }
+      else
+        raise(ArgumentError, "Expected Numeric or Proc input for a")
+      end
+      if b.is_a? Proc then
+        @b = b 
+      elsif b.is_a? Numeric then
+        @b = Proc.new { |x| b }
+      else
+        raise(ArgumentError, "Expected Numeric or Proc input for b")
+      end
+      if c.is_a? Proc then
+        @c = c 
+      elsif c.is_a? Numeric then
+        @c = Proc.new { |x| c }
+      else
+        raise(ArgumentError, "Expected Numeric or Proc input for c")
+      end
+      if f.is_a? Proc then
+        @f = f 
+      elsif f.is_a? Numeric then
+        @f = Proc.new { |x| f }
+      else
+        raise(ArgumentError, "Expected Numeric or Proc input for f")
+      end
+
+      @method = method
+      case @method
+        when :lin_fin_elt then lin_fin_elt
+        else raise(ArgumentError, "#{@method} is not a valid method.")
+      end
+    end
+
+    # Evaluate the function a(x) at x=x0 
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    def a(x0)
+      @a.call(x0)
+    end
+
+    # Evaluate the function b(x) at x=x0
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    def b(x0)
+      @b.call(x0)
+    end
+
+    # Evaluate the function c(x) at x=x0
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    def c(x0)
+      @c.call(x0)
+    end
+
+    # Evaluate the function f(x) at x=x0
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    def f(x0)
+      @f.call(x0)
+    end
+
+    ######### Available numeric schemes ##########
+    
+    private
+
+      # Solve the boundary value problem
+      #
+      # * ODE: -(a*u')' + b*u' + c*u = f, xmin<x<xmax,
+      # * where a, b, c, f and u are functions of x,
+      # * with Dirichlet boundary conditions: u(xmin) = bc[1], u(xmax) = bc[2]
+      #
+      # using the finite elements method with piecewise linear elements.
+      #
+      # === References
+      #
+      # * A Quarteroni, R Sacco, F Saleri, "Numerical Mathematics", 2nd ed., section 7.4.
+      #
+      def lin_fin_elt 
+        gridcenters = ((@xmin+@dx/2)..(@xmax-@dx/2)).step(@dx).to_a
+        a_gridcenters = NMatrix.new([@mx-1,1], gridcenters.map {|x0| self.a(x0) }, dtype: :float64)
+        b_gridcenters = NMatrix.new([@mx-1,1], gridcenters.map {|x0| self.b(x0) }, dtype: :float64) 
+        c_gridcenters = NMatrix.new([@mx-1,1], gridcenters.map {|x0| self.c(x0) }, dtype: :float64) 
+        f_gridcenters = NMatrix.new([@mx-1,1], gridcenters.map {|x0| self.f(x0) }, dtype: :float64) 
+
+        # Construct the  RHS for the linear system
+        @rhs = (f_gridcenters[0..-2] + f_gridcenters[1..-1]) * @dx * 0.5
+        @rhs[0] = @rhs[0] - @bc[0] * (-a_gridcenters[0] / @dx - b_gridcenters[0] / 2.0 + @dx * c_gridcenters[0] / 3.0)
+        @rhs[-1] = @rhs[-1] - @bc[1] * (-a_gridcenters[-1] / @dx + b_gridcenters[-1] / 2.0 + @dx * c_gridcenters[-1] / 3.0)
+        
+        # Construct the tridiagonal stiffness matrix
+        # TODO: the matrix should be saved as a sparse stype
+        dd = NMatrix.new([@mx-2,1], 0.0, dtype: :float64) 
+        dc = NMatrix.new([@mx-2,1], 0.0, dtype: :float64) 
+        dr = NMatrix.new([@mx-2,1], 0.0, dtype: :float64)  
+        ld = NMatrix.new([@mx-2,1], 0.0, dtype: :float64)  
+        lc = NMatrix.new([@mx-2,1], 0.0, dtype: :float64)  
+        lr = NMatrix.new([@mx-2,1], 0.0, dtype: :float64)  
+        ud = NMatrix.new([@mx-2,1], 0.0, dtype: :float64)  
+        uc = NMatrix.new([@mx-2,1], 0.0, dtype: :float64)  
+        ur = NMatrix.new([@mx-2,1], 0.0, dtype: :float64) 
+        1.upto(@mx-2) do |i|
+          dd[i-1] = (a_gridcenters[i-1] + a_gridcenters[i]) / @dx
+          dc[i-1] = (b_gridcenters[i-1] - b_gridcenters[i]) / 2.0
+          dr[i-1] = @dx * (c_gridcenters[i-1] + c_gridcenters[i]) / 3.0
+          if i>1 then
+            ld[i-2] = -a_gridcenters[i-1] / @dx
+            lc[i-2] = -b_gridcenters[i-1] / 2.0
+            lr[i-2] = @dx * c_gridcenters[i-1] / 6.0
+          end
+          if i<(@mx-2) then
+            ud[i-1] = -a_gridcenters[i] / @dx
+            uc[i-1] = b_gridcenters[i] / 2.0
+            ur[i-1] = @dx * c_gridcenters[i] / 6.0
+          end
+        end
+        diag = dd + dc + dr
+        ldiag = ld + lc + lr
+        udiag = ud + uc + ur
+        @mat = NMatrix.diagonal(diag.to_a, dtype: :float64)
+        1.upto(@mx-3) do |j|
+          @mat[j,j-1] = ldiag[j-1]
+          @mat[j-1,j] = udiag[j-1]
+        end
+
+        # Solve the system
+        # TODO: The system is tridiagonal and should be solved accordingly
+        w = @mat.solve(@rhs)
+        @u = w.to_flat_a
+        @u.insert(0, @bc[0])
+        @u.insert(-1, @bc[1])
+      end
+  end
+end

data/lib/spitzy/ode.rb

@@ -0,0 +1,290 @@
+# Copyright (c) 2015 Alexej Gossmann 
+
+module Spitzy
+  # Numerically solves an initial value problem of the form 
+  #
+  # * dy/dx = f(x,y), xmin < x < xmax, 
+  # * y(xmin) = yini
+  #   
+  class Ode
+
+    # array of the points in the domain at which the numerical solution was evaluated
+    attr_reader :x
+    # number of points (i.e. length of +x+)
+    attr_reader :mx
+    # value of f at every point in x
+    attr_reader :fx
+    # the numerical solution as an array
+    attr_reader :u
+    # the error tolerance of the method (only applicable for methods with automatic step size adjustment)
+    attr_reader :tol
+    # the numerical scheme applied
+    attr_reader :method
+
+    # Constructor for all solver routines for the initial value problem:
+    # * dy/dx = f(x,y), xmin < x < xmax, 
+    # * y(xmin) = yini
+    #
+    # It initializes the parameters and solves the equation
+    # using one of the methods: 
+    # Dormand-Prince, Forward Euler, Adams-Bashforth order 2.
+    #
+    # ==== Arguments
+    #
+    # * +xrange+  - An array of the form [xmin, xmax]. The interval on which the solution will be evaluated.
+    #
+    # * +dx+      - Determines the grid of x values. The length of the x step for methods without automatic step size adjustment,
+    #   or the maximum step size for methods with automatic step size adjustment. 
+    #
+    # * +yini+    - Initial value for y, i.e. y(xmin).
+    #
+    # * +tol+     - The desired error tolerance of the method (only for methods with automatic step size correction).
+    # 
+    # * +maxiter+ - The maximal number of performed iterations for methods with automatic step size adjustment.
+    #
+    # * +method+  - The numerical scheme used to solve the ODE. Possible values are:
+    #   +:dopri+ (Dormand-Prince), +:euler+ (Forward Euler), +:ab2+ (Adams-Bashforth of order 2). 
+    #   +:dopri+ performs an automatic step size adjustment and error estimation in order to 
+    #   keep the error of the numerical solution below +tol+. +:euler+ and +:ab2+ operate on a 
+    #   fixed step size +dx+, and cannot estimate the error of the numerical solution.
+    #   Currently, the default is +:dopri+ (Dormand-Prince is currently also the default method in MATLAB 
+    #   and GNU Octave's ode45 solver and is the default choice for the Simulink's model explorer solver).
+    #
+    # * +&f+      - The right hand side of the differential equation which must be supplied as a +proc+ object.
+    #   It is a function of x and y, where x should be the _first_ argument, and y the _second_.
+    #
+    # ==== Usage
+    #
+    #    # Dormand-Prince example 1
+    #    f = proc { |t,y| 1.0 + y/t + (y/t)**2 }
+    #    dopri_sol = Spitzy::Ode.new(xrange: [1.0,4.0], dx: 0.1, yini: 0.0, &f) 
+    #    puts "The numerical solution at x=4 is u(4)=#{dopri_sol.u[-1]}"
+    #
+    #    # Dormand-Prince example 2
+    #    f = proc { |t,y| -2.0 * y + Math::exp(-2.0 * (t - 6.0)**2) }
+    #    dopri_sol = Spitzy::Ode.new(xrange: [0.0,10.0], dx: 1.5, yini: 1.0, 
+    #                                tol: 1e-6, maxiter: 1e6, &f) 
+    #    # Plot dopri_sol.x agains dopri_sol.u to observe step size adaptivity
+    #
+    #    # Euler example 1
+    #    f = proc { |t,y| 1.0 + y/t + (y/t)**2 }
+    #    euler_sol = Spitzy::Ode.new(xrange: [1.0,4.0], dx: 0.01,
+    #                                yini: 0.0, method: :euler, &f) 
+    #
+    #    # Adams-Bashforth example 1
+    #    f = proc { |t,y| -2.0*t*y }
+    #    ab2_sol = Spitzy::Ode.new(xrange: [0.0,4.0], dx: 0.1, 
+    #                              yini: 1.0, method: :ab2, &f) 
+    #    exact_sol = ab2_sol.x.map { |tt| Math::exp(-(tt**2)) }
+    #    maxerror1 = exact_sol1.each_with_index.map {|n,i| n - ab2_sol1.u[i] }.max.abs
+    #    puts "Number of x steps: #{ab2_sol1.mx}"
+    #    puts "Error: #{maxerror1}maxerror2}"
+    #    puts "Error ratio: #{maxerror1/maxerror2}"
+
+    def initialize(xrange:, dx:, yini:, tol: 1e-2, maxiter: 1e6, method: :dopri, &f)
+
+      raise(ArgumentError, "Expected xrange to be an array of length 2") unless xrange.length == 2
+      @dx = dx
+      @xmin = xrange[0]
+      @xmax = xrange[1]
+      @yini = yini
+      @maxiter = maxiter
+      @tol = tol
+      @f = f 
+      @x = [] # Stores the x grid
+      @fx = [] # Stores the values of f at every point in x
+      @u = [] # Stores numerical solution
+
+      @method = method
+      case @method
+        when :euler then euler
+        when :ab2 then ab2
+        when :am3 then am3
+        when :dopri then dopri
+        else raise(ArgumentError, "#{@method} is not a valid method.")
+      end
+    end
+
+    # Evaluate the function f(x,y) at x=x0 and y=y0 
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    # * +y0+ - A floating point number representing y(x0)
+    #
+    def f(x0, y0)
+      @f.call(x0, y0)
+    end
+
+    ######### Available numeric schemes ##########
+    
+    private
+
+      # Solve the initial value problem
+      #  * dy/dx = f(x,y), xmin < x < xmax, 
+      #  * y(xmin) = yini
+      # with the forward Euler scheme u[n+1] = u[n] + dx * f[n].
+      def euler 
+        @x = (@xmin..@xmax).step(@dx).to_a # x steps
+        @x << @xmax if @x.last < @xmax
+        @mx = @x.length # Number of x steps
+        @u[0] = @yini
+        @fx[0] = self.f(@x[0], @u[0])
+        0.upto(@mx-2) do |n|
+          @u[n+1] = @u[n] + @dx * @fx[n]
+          @fx[n+1] = self.f(@x[n+1], @u[n+1])
+        end
+        #tol and maxiter not relevant for the Euler method
+        @tol = nil
+        @maxiter = nil
+      end
+     
+      # Solve the initial value problem
+      #  * dy/dx = f(x,y), xmin < x < xmax, 
+      #  * y(xmin) = yini
+      # with the Adams-Bashforth method of order 2, 
+      # given by the explicit formula u[n+1] = u[n] + dx/2 * (3*f[n] - f[n-1]).
+      # Since the method requires the last two functional values for the approximation 
+      # of the next functional value, a Runge-Kutta method of order 2 (Heun’s method) 
+      # is applied to approximate the functional value at the second time step.
+      #
+      def ab2 
+        @x = (@xmin..@xmax).step(@dx).to_a # x steps
+        @x << @xmax if @x.last < @xmax
+        @mx = @x.length # Number of x steps
+
+        @u[0] = @yini
+        @fx[0] = self.f(@x[0], @u[0])
+        # Runge-Kutta of order 2 for the second time step
+        @u[1] = @u[0] + @dx/2.0 * (@fx[0] + self.f(@x[1], @u[0] + @dx*@fx[0]))
+        @fx[1] = self.f(@x[1], @u[1])
+
+        1.upto(@mx-2) do |n|
+          @u[n+1] = @u[n] + @dx/2.0 * (3.0*@fx[n] - @fx[n-1])
+          @fx[n+1] = self.f(@x[n+1], @u[n+1])
+        end
+
+        #tol and maxiter not relevant for the this method
+        @tol = nil
+        @maxiter = nil
+      end
+   
+      # Solve the initial value problem
+      # * dy/dx = f(x,y), xmin < x < xmax, 
+      # * y(xmin) = yini
+      # with the Dormand-Prince method.
+      #
+      # This method automatically adapts the step size in order to keep the error
+      # of the numerical solution below the tolerance level +tol+. However, the step size
+      # is not allowed to exceed the specified maximal step size +dx+ (+dx+ is also the 
+      # initial step size). The algorithm throws an exception if it fails to compute the 
+      # numerical solution on the given x domain in less than or equal to +maxiter+ iterations.
+      # 
+      # === Reference
+      #
+      # * J R  Dormand, P J  Prince, "A family of embedded Runge-Kutta formulae"
+      #
+      # * E Hairer, S P Norsett and G Wanner, "Solving Differential Equations I, Nonstiff Problems", p. 176.
+      # 
+      def dopri
+        a21 = 1.0/5.0
+        a31 = 3.0/40.0
+        a32 = 9.0/40.0
+        a41 = 44.0/45.0
+        a42 = -56.0/15.0
+        a43 = 32.0/9.0
+        a51 = 19372.0/6561.0
+        a52 = -25360.0/2187.0
+        a53 = 64448.0/6561.0
+        a54 = -212.0/729.0
+        a61 = 9017.0/3168.0
+        a62 = -355.0/33.0
+        a63 = 46732.0/5247.0
+        a64 = 49.0/176.0
+        a65 = -5103.0/18656.0
+        a71 = 35.0/384.0
+        a72 = 0.0
+        a73 = 500.0/1113.0
+        a74 = 125.0/192.0
+        a75 = -2187.0/6784.0
+        a76 = 11.0/84.0
+
+        c2 = 1.0 / 5.0
+        c3 = 3.0 / 10.0
+        c4 = 4.0 / 5.0
+        c5 = 8.0 / 9.0
+        c6 = 1.0
+        c7 = 1.0
+
+        b1order5 = 35.0/384.0
+        b2order5 = 0.0
+        b3order5 = 500.0/1113.0
+        b4order5 = 125.0/192.0
+        b5order5 = -2187.0/6784.0
+        b6order5 = 11.0/84.0
+        b7order5 = 0.0
+
+        b1order4 = 5179.0/57600.0
+        b2order4 = 0.0
+        b3order4 = 7571.0/16695.0
+        b4order4 = 393.0/640.0
+        b5order4 = -92097.0/339200.0
+        b6order4 = 187.0/2100.0
+        b7order4 = 1.0/40.0
+
+        @x[0] = @xmin
+        @u[0] = @yini
+        @fx[0] = self.f(@x[0], @u[0])
+        h = @dx 
+        i = 0
+
+        0.upto(@maxiter) do |iter|
+           # Compute the function values
+           k1 = @fx[i] 
+           k2 = self.f(@x[i] + c2*h, @u[i] + h*(a21*k1))
+           k3 = self.f(@x[i] + c3*h, @u[i] + h*(a31*k1+a32*k2))
+           k4 = self.f(@x[i] + c4*h, @u[i] + h*(a41*k1+a42*k2+a43*k3))
+           k5 = self.f(@x[i] + c5*h, @u[i] + h*(a51*k1+a52*k2+a53*k3+a54*k4))
+           k6 = self.f(@x[i] + h, @u[i] + h*(a61*k1+a62*k2+a63*k3+a64*k4+a65*k5))
+           k7 = self.f(@x[i] + h, @u[i] + h*(a71*k1+a72*k2+a73*k3+a74*k4+a75*k5+a76*k6))
+
+           error = (b1order5 - b1order4)*k1 + (b3order5 - b3order4)*k3 + (b4order5 - b4order4)*k4 + 
+             (b5order5 - b5order4)*k5 + (b6order5 - b6order4)*k6 + (b7order5 - b7order4)*k7
+           error = error.abs
+
+           # error control
+           if error < @tol then
+              @x[i+1] = @x[i] + h
+              @u[i+1] = @u[i] + h * (b1order5*k1 + b3order5*k3 + b4order5*k4 + b5order5*k5 + b6order5*k6)
+              @fx[i+1] = self.f(@x[i+1], @u[i+1])
+              i = i+1
+           end
+
+           delta = 0.84 * (@tol / error)**0.2
+           if delta <= 0.1 then
+              h = h * 0.1
+           elsif delta >= 4.0 then
+              h = h * 4.0
+           else 
+              h = delta * h
+           end
+
+           # set h to the user specified maximal allowed value
+           h = @dx if h > @dx 
+
+           if @x[i] >= @xmax then
+             break
+           elsif @x[i] + h > @xmax then
+             h = @xmax - @x[i]
+           end
+        end
+
+        @mx = @x.length # Number of x steps
+
+        raise(RuntimeError, "Maximal number of iterations reached 
+              before evaluation of the solution on the entire x interval 
+              was completed (try to increase maxiter or use a different method") if @x.last < @xmax
+      end
+  end
+end

data/lib/spitzy/poissons_eq.rb

@@ -0,0 +1,204 @@
+# Copyright (c) 2015 Alexej Gossmann 
+
+module Spitzy
+  # Numerically solves the 2D Poisson's equation:
+  #
+  # * "Laplacian of u" = d^2 u / d^2 x + d^2 u / d^2 y = f(x,y),
+  # * on the rectangular domain [xmin,xmax] x [ymin,ymax],
+  # * with Dirichlet boundary conditions: u(x,y) = v(x,y) if 
+  #   (x,y) is on the boundary of the rectangular domain. 
+  #
+  class PoissonsEq
+
+    # array of the x coordinates of points in the domain at which the numerical solution was evaluated
+    attr_reader :x
+    # array of the y coordinates of points in the domain at which the numerical solution was evaluated
+    attr_reader :y
+    # number of points on the side of the rectangular domain in x direction 
+    attr_reader :mx
+    # number of points on the side of the rectangular domain in y direction 
+    attr_reader :my
+    # step size in x and y
+    attr_reader :h
+    # the matrix of the solved linear system
+    attr_reader :mat
+    # the right hand side of the solved linear system
+    attr_reader :rhs
+    # the numerical scheme applied
+    attr_reader :method
+    # the numerical solution as an array (the values are ordered as in +x+ and +y+). It is obtained as a solution to a linear system.
+    attr_reader :u
+
+    # Constructor for all solver routines for the 2D Poisson's equation:
+    #
+    # * "Laplacian of u" = d^2 u / d^2 x + d^2 u / d^2 y = f(x,y),
+    # * on the rectangular domain [xmin,xmax] x [ymin,ymax],
+    # * with Dirichlet boundary conditions: u(x,y) = v(x,y) if 
+    #   (x,y) is on the boundary of the rectangular domain. 
+    #   
+    # It initializes the parameters and solves the equation
+    # using one of the methods: 
+    # :five_pt (5-point Laplacian), :nine_pt (9-point Laplacian)
+    #
+    # ==== Arguments
+    #
+    # * +xrange+  - An array of the form [xmin, xmax]. Defines the domain 
+    #   on which the solution will be evaluated.
+    #
+    # * +yrange+  - An array of the form [ymin, ymax]. Defines the domain 
+    #   on which the solution will be evaluated.
+    #
+    # * +h+       - The step size in x and y direction. It should be chosen such that
+    #   subintervals of length +h+ cover the entire x range as well as the
+    #   entire y range. 
+    #
+    # * +method+  - The numerical scheme used to solve the differential equation. Possible values are:
+    #   +:five_pt+ (5-point Laplacian), +:nine_pt+ (9-point Laplacian)
+    #   Default is +:five_pt+.
+    #
+    # * +bc+      - A +Proc+ or +Numeric+ object. The boundary condition v(x,y) of the differential 
+    #   equation, which can be supplied as a +Proc+ object. If a +Numeric+ object is 
+    #   supplied then v(x,y) is assumed to be constant equal to that number.
+    #
+    # * +f+       - A +Proc+ or +Numeric+ object. The right hand side f(x,y) of the differential 
+    #   equation, which can be supplied as a +Proc+ object. If a +Numeric+ object is 
+    #   supplied then f(x,y) is assumed to be constant equal to that number.
+    #
+    # === Usage
+    #
+    #    f = Proc.new { |x,y| Math::exp(-0.5*(x**2.0 + y**2.0)) * (x**2.0 + y**2.0 - 2.0) }
+    #    bc = Proc.new { |x,y| Math::exp(-0.5*(x**2.0 + y**2.0)) }
+    #    numsol = Spitzy::PoissonsEq.new(xrange: [-1.0,1.0], yrange: [-5.0, 5.0], h: 0.2, bc: bc, f: f)
+    #
+    def initialize(xrange:, yrange:, h:, method: :five_pt, bc:, f:)
+      raise(ArgumentError, "Expected xrange to be an array of length 2") unless xrange.length == 2
+      raise(ArgumentError, "Expected yrange to be an array of length 2") unless yrange.length == 2
+      @h = h
+      @xmin, @xmax = xrange[0].to_f, xrange[1].to_f
+      @ymin, @ymax = yrange[0].to_f, yrange[1].to_f
+
+      xval = (@xmin..@xmax).step(@h).to_a 
+      yval = (@ymin..@ymax).step(@h).to_a 
+      @mx, @my = xval.length, yval.length
+      unless xval[-1]==@xmax and yval[-1]==@ymax then
+       raise(ArgumentError, "The step size +h+ should be chosen such that subintervals of 
+                             length +h+ cover the entire x range as well as the entire y range.")
+      end
+      x, y = NMatrix::meshgrid([xval, yval], indexing: :ij)
+      @x, @y = x.to_a, y.to_a
+      # interior points
+      @x_interior, @y_interior = NMatrix::meshgrid([xval[1..-2], yval[1..-2]], indexing: :ij)
+
+      if f.is_a? Proc then
+        @f = f 
+      elsif f.is_a? Numeric then
+        @f = Proc.new { |x| f }
+      else
+        raise(ArgumentError, "Expected Numeric or Proc input for a")
+      end
+
+      if bc.is_a? Proc then
+        @bc = bc 
+      elsif bc.is_a? Numeric then
+        @bc = Proc.new { |x| bc }
+      else
+        raise(ArgumentError, "Expected Numeric or Proc input for a")
+      end
+
+      @method = method
+      case @method
+        when :five_pt then five_pt
+        when :nine_pt then nine_pt
+        else raise(ArgumentError, "#{@method} is not a valid method.")
+      end
+    end
+    
+    # Evaluate the function f(x,y) at x=x0 and y=y0
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    # * +y0+ - A floating point number
+    #
+    def f(x0, y0)
+      @f.call(x0, y0)
+    end
+
+    # Evaluate the function bc(x,y) at x=x0 and y=y0
+    #
+    # ==== Arguments
+    #
+    # * +x0+ - A floating point number
+    #
+    # * +y0+ - A floating point number
+    #
+    def bc(x0, y0)
+      @bc.call(x0, y0)
+    end
+
+
+    ######### Available numeric schemes ##########
+    
+    private
+
+      # Use the five-point Laplacian to solve the 2D Poisson's equation:
+      #
+      # * "Laplacian of u" = d^2 u / d^2 x + d^2 u / d^2 y = f(x,y),
+      # * on the rectangular domain [xmin,xmax] x [ymin,ymax],
+      # * with Dirichlet boundary conditions: u(x,y) = v(x,y) if 
+      #   (x,y) is on the boundary of the rectangular domain. 
+      #   
+      def five_pt
+        # Number of interior points
+        mx_interior = @mx-2
+        my_interior = @my-2
+        m_interior = mx_interior*my_interior
+        h2 = @h**2.0
+
+        # Construct the right hand side for the linear system (only required at interiour points)
+        @rhs = NMatrix.new([mx_interior, my_interior], dtype: :float64)
+        @x_interior.each_with_indices do |v,i,j|
+          @rhs[i,j] = self.f(v, @y_interior[i,j])
+          @rhs[i,j] -= self.bc(v, @ymin)/h2 if j==0
+          @rhs[i,j] -= self.bc(v, @ymax)/h2 if j==my_interior-1 
+          @rhs[i,j] -= self.bc(@xmin, @y_interior[i,j])/h2 if i==0
+          @rhs[i,j] -= self.bc(@xmax, @y_interior[i,j])/h2 if i==mx_interior-1 
+        end
+        @rhs = @rhs.transpose
+        @rhs.reshape!([m_interior, 1])
+
+        # Construct the matrix for the linear system
+        # TODO: the matrix is pentadiagonal (i.e. sparse) and should be stored accordingly
+        @mat = NMatrix.new([m_interior, m_interior], dtype: :float64)
+        (0..(m_interior-1)).each {|i| @mat[i,i] = -4.0 / h2 }
+        (0...(m_interior-1)).each {|i| @mat[i,i+1] = 1.0 / h2 }
+        (0...(m_interior-1)).each {|i| @mat[i+1,i] = 1.0 / h2 }
+        (0...(m_interior-mx_interior)).each {|i| @mat[i,i+mx_interior] = 1.0 / h2 }
+        (0...(m_interior-mx_interior)).each {|i| @mat[i+mx_interior,i] = 1.0 / h2 }
+        (1...my_interior).each do |i|
+          @mat[mx_interior*i-1, mx_interior*i] = 0
+          @mat[mx_interior*i, mx_interior*i-1] = 0
+        end
+
+        # Compute the solution at the interior points
+        # TODO: @mat is pentadiagonal, and consequently, there are more
+        # efficient ways to solve the linear system (e.g. successive over-relaxation)
+        u_interior = @mat.solve(@rhs)
+        # x corresponds to columns, y corresponds to rows
+        u = NMatrix.new([@mx,@my], dtype: :float64)
+        # enforce boundary considitions
+        (0...@mx).each { |i| u[i,0] = self.bc(@x[i][0],@y[i][0]) }
+        (0...@mx).each { |i| u[i,-1] = self.bc(@x[i][-1],@y[i][-1]) }
+        (0...@my).each { |j| u[0,j] = self.bc(@x[0][j],@y[0][j]) }
+        (0...@my).each { |j| u[-1,j] = self.bc(@x[-1][j],@y[-1][j]) }
+        # populate the interior
+        1.upto(@my-2) do |j|
+          1.upto(@mx-2) do |i|
+            u[i,j] = u_interior[(j-1)*mx_interior+(i-1)]
+          end
+        end
+        @u = u.to_a
+      end
+  end
+end

data/lib/spitzy/version.rb

@@ -0,0 +1,3 @@
+module Spitzy
+  VERSION = "0.1.0"
+end

data/spitzy.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spitzy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spitzy"
+  spec.version       = Spitzy::VERSION
+  spec.authors       = ["Alexej Gossmann"]
+  spec.email         = ["alexej.go@googlemail.com"]
+
+  spec.summary       = %q{Solve differential equations in pure Ruby.}
+  spec.description   = %q{A toolbox of numerical differential equation solvers written in pure Ruby. Currently there are multiple methods available to solve initial value ODEs (Dormand-Prince, Forward Euler, 2nd order Adams-Bashforth), boundary value ODEs (Linear Finite Element Galerkin), 2D Poisson's equation (5-point Laplacian), and the 1D advection equation (Upwind, Lax-Friedrichs, Leapfrog, Lax-Wendroff).}
+  spec.homepage      = "https://github.com/agisga/spitzy.git"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+
+  spec.add_runtime_dependency "nmatrix", "~> 0.2.0"
+  spec.add_runtime_dependency "nmatrix-lapacke", "~> 0.2.0"
+
+  # This gem will work with Ruby 2.1 or newer, because it uses required 
+  # keyword arguments (i.e. keyword arguments without default values)
+  spec.required_ruby_version = '>= 2.1'
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: spitzy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexej Gossmann
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: nmatrix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: nmatrix-lapacke
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: A toolbox of numerical differential equation solvers written in pure
+  Ruby. Currently there are multiple methods available to solve initial value ODEs
+  (Dormand-Prince, Forward Euler, 2nd order Adams-Bashforth), boundary value ODEs
+  (Linear Finite Element Galerkin), 2D Poisson's equation (5-point Laplacian), and
+  the 1D advection equation (Upwind, Lax-Friedrichs, Leapfrog, Lax-Wendroff).
+email:
+- alexej.go@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/spitzy.rb
+- lib/spitzy/advection_eq.rb
+- lib/spitzy/bvp.rb
+- lib/spitzy/ode.rb
+- lib/spitzy/poissons_eq.rb
+- lib/spitzy/version.rb
+- spitzy.gemspec
+- spitzy.jpg
+homepage: https://github.com/agisga/spitzy.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Solve differential equations in pure Ruby.
+test_files: []
+has_rdoc: