mathgl 0.0.1

data/ext/mathgl/mathgl.i

@@ -0,0 +1,123 @@
+/***************************************************************************
+ * mgl.i is part of Math Graphic Library
+ * Copyright (C) 2007 Alexey Balakin <balakin@appl.sci-nnov.ru>,
+ *   Xavier Delacour <xavier.delacour@gmail.com>,
+ *   Alexander Filov <alexander.filov@gmail.com>                           *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+
+#ifdef SWIGRUBY
+%module MathGL
+#else
+%module mathgl
+#endif
+
+#ifdef SWIGOCTAVE
+%feature("autodoc", 1);
+#endif // SWIGOCTAVE
+
+#ifdef SWIGRUBY
+%feature("autodoc", 2);
+#endif
+
+%ignore operator!;
+%ignore operator=;
+%ignore operator!=;
+%ignore *::operator=;
+%ignore *::operator+=;
+%ignore *::operator-=;
+%ignore *::operator*=;
+%ignore *::operator/=;
+//%ignore mglDataA;
+
+%{
+#define SWIG_FILE_WITH_INIT
+//#include "mgl2/config.h"
+#include "mgl2/type.h"
+#include "mgl2/data.h"
+#include "mgl2/mgl.h"
+//#include "mgl2/window.h"
+%}
+
+#if MGL_USE_DOUBLE
+typedef double mreal;
+#else
+typedef float mreal;
+#endif
+
+
+#ifdef SWIGOCTAVE
+%rename(__add) operator+;
+%rename(__sub) operator-;
+%rename(__mul) operator*;
+%rename(__div) operator/;
+%rename(__eq) operator==;
+%rename(__ne) operator!=;
+%typemap(in,noblock=1) (double* d, int rows, int cols) (Matrix tmp) {
+	if (!$input.is_matrix_type())	{	error("A must be a matrix");	SWIG_fail;	}
+	tmp=$input.matrix_value();
+	$1=tmp.data();
+	$2=tmp.rows();
+	$3=tmp.columns();
+}
+#endif
+
+#ifdef SWIGPYTHON
+%rename(__add__) *::operator+(const mglData&, const mglData&);
+%rename(__sub__) *::operator-(const mglData&, const mglData &);
+%rename(__mul__) *::operator*(const mglData &, float);
+%rename(__div__) *::operator/(const mglData &, float);
+
+// Get the NumPy typemaps
+%include "numpy.i"
+%init %{
+import_array();
+%}
+%apply (double* IN_ARRAY1, int DIM1) {(const double* d, int size)};
+%apply (int DIM1, double* IN_ARRAY1) {(int size, const double* d)};
+%apply (double* IN_ARRAY2, int DIM1, int DIM2) {(const double* d, int rows, int cols)};
+%apply (int DIM1, int DIM2, double* IN_ARRAY2) {(int rows, int cols, const double* d)};
+%apply (double* IN_ARRAY3, int DIM1, int DIM2, int DIM3) {(const double* d, int rows, int cols, int slc)};
+%apply (int DIM1, int DIM2, int DIM3, double* IN_ARRAY3) {(int rows, int cols, int slc, const double* d)};
+#endif
+
+#ifdef SWIGRUBY
+%include "rubymgl.i"
+#endif
+
+%include "mgl2/config.h"
+//%include "mgl2/define.h"
+%include "mgl2/type.h"
+%include "mgl2/data.h"
+%include "mgl2/mgl.h"
+//%include "mgl2/window.h"
+%extend mglData
+{
+	float __getitem__( int i)	{	return self->GetVal(i);	};
+	float __paren( int i)		{	return self->GetVal(i);	};
+	void __setitem__( int i, float y)	{	self->SetVal(y,i);	};
+	void __paren_asgn( int i, float y)	{	self->SetVal(y,i);	};
+};
+
+#ifdef SWIGRUBY
+%{
+extern "C" {
+void Init_MathGL();
+void Init_mathgl(){ Init_MathGL(); }
+}
+%}
+#endif

data/ext/mathgl/qt/depend

@@ -0,0 +1,2 @@
+qt.cxx: ../tmpl/mkwin.rb ../tmpl/win.erb.cxx
+	ruby ../tmpl/mkwin.rb qt > $@

data/ext/mathgl/qt/extconf.rb

@@ -0,0 +1,20 @@
+require "mkmf"
+
+# configure options:
+#  --with-mathgl-dir=path
+#  --with-mathgl-include=path
+#  --with-mathgl-lib=path
+
+dir_config("mathgl")
+
+#with_cppflags "-g -O0 -Wall"
+
+exit unless have_header("mgl2/type.h")
+exit unless have_header("mgl2/data.h")
+exit unless have_header("mgl2/mgl.h")
+exit unless have_header("mgl2/qt.h")
+exit unless have_library("mgl")
+exit unless have_library("mgl-qt")
+$objs = ["qt.o"]
+$CPPFLAGS.split.each{|x| $INCFLAGS+=" "+x if /^-I\S+$/=~x}
+create_makefile("qt")

data/ext/mathgl/rubymgl.i

@@ -0,0 +1,172 @@
+%include "typemaps.i"
+%include "wchar.i"
+
+//-- mglPoint --
+%{
+static mglPoint GetMglPoint(VALUE arg)
+{
+    if (TYPE(arg)==T_ARRAY) {
+        mreal v[4] = {0,0,0,0};
+        long len = RARRAY_LEN(arg);
+        if (len < 1 || len > 4) {
+            rb_raise(rb_eArgError, "wrong size array");
+        }
+        for (long i=0; i<len; i++) {
+            VALUE x = rb_ary_entry(arg, i);
+            v[i] = NUM2DBL(x);
+        }
+        return mglPoint(v[0],v[1],v[2],v[3]);
+    } else {
+        void *vptr = 0;
+        SWIG_ConvertPtr(arg, &vptr, SWIGTYPE_p_mglPoint, 1);
+        return *reinterpret_cast< mglPoint * >(vptr);
+    }
+}
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_DOUBLE_ARRAY)
+  mglPoint
+{
+    $1 = (TYPE($input)==T_ARRAY);
+    if (!($1)) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr($input, &vptr, SWIGTYPE_p_mglPoint, 0);
+        $1 = SWIG_CheckState(res);
+    }
+}
+
+%typemap(in) mglPoint {
+    $1 = GetMglPoint($input);
+}
+
+
+//-- mglData --
+%{
+static mglData *GetMglData(VALUE arg)
+{
+    if (TYPE(arg)==T_ARRAY) {
+        long len = RARRAY_LEN(arg);
+        mglData *d = new mglData(len);
+        for (long i=0; i<len; i++) {
+            VALUE x = rb_ary_entry(arg, i);
+            d->SetVal(NUM2DBL(x), i);
+        }
+        return d;
+    } else {
+        void *vptr = 0;
+        SWIG_ConvertPtr(arg, &vptr, SWIGTYPE_p_mglData, 1);
+        mglData *src = reinterpret_cast< mglData * >(vptr);
+        mglData *link = new mglData;
+        link->Link(*src);
+        return link;
+    }
+}
+%}
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_DOUBLE_ARRAY)
+  mglData&, mglDataA&
+{
+    $1 = (TYPE($input)==T_ARRAY);
+    if (!($1)) {
+        void *vptr = 0;
+        int res = SWIG_ConvertPtr($input, &vptr, $1_descriptor, 0);
+        $1 = SWIG_CheckState(res);
+    }
+}
+
+%typemap(in) mglData&, mglDataA& {
+    $1 = GetMglData($input);
+}
+
+%typemap(freearg) mglData&, mglDataA& {
+    delete $1;
+}
+
+%extend mglData {
+  mglData(const double *d, int size, int rows, int cols)
+  {
+      if (size != rows*cols) {
+          rb_raise(rb_eArgError,"array size(%d) mismatches (rows=%d)*(cols=%d)",
+                   size, rows, cols);
+      }
+      return new mglData(d, rows, cols);
+  }
+
+  void Set(const double *A, long size)
+  {   $self->Set(A, size);  }
+
+  void Set(const double *A, long size, long NX, long NY)
+  {
+      if (size != NX*NY) {
+          rb_raise(rb_eArgError,"array size(%ld) mismatches NX(%ld)*NY(%ld)",
+                   size, NX, NY);
+      }
+      $self->Set(A, NX, NY);
+  }
+
+  void Set(const double *A, long size, long NX, long NY, long NZ)
+  {
+      if (size != NX*NY*NZ) {
+          rb_raise(rb_eArgError,"array size(%ld) mismatches (NX=%ld)*(NY=%ld)*(NZ=%ld)",
+                   size, NX, NY, NZ);
+      }
+      $self->Set(A, NX, NY, NZ);
+  }
+
+  inline mglData operator*(const mglDataA &d)
+  {       mglData a(self);  a*=d;   return a;       }
+  inline mglData operator*(double b)
+  {       mglData a(self);  a*=b;   return a;       }
+  inline mglData operator-(const mglDataA &d)
+  {       mglData a(self);  a-=d;   return a;       }
+  inline mglData operator-(double b)
+  {       mglData a(self);  a-=b;   return a;       }
+  inline mglData operator+(const mglDataA &d)
+  {       mglData a(self);  a+=d;   return a;       }
+  inline mglData operator+(double b)
+  {       mglData a(self);  a+=b;   return a;       }
+  inline mglData operator/(const mglDataA &d)
+  {       mglData a(self);  a/=d;   return a;       }
+  inline mglData operator/(double b)
+  {       mglData a(self);  a/=b;   return a;       }
+
+}
+
+%apply (double* INPUT, int) {(const double* d, int size)};
+%apply (double* INPUT, long) {(const double *A, long size)};
+
+%typemap(typecheck, precedence=SWIG_TYPECHECK_DOUBLE_ARRAY)
+  (const double* d, int size), (const double *A, long size)
+{
+    $1 = (TYPE($input)==T_ARRAY);
+}
+
+// Get a list of double
+%typemap(in)
+  (const double* d, int size), (const double *A, long size)
+{
+    if (TYPE($input)!=T_ARRAY) {
+        rb_raise(rb_eArgError,"argument is not Array");
+    }
+    //Check_Type($input, T_ARRAY);
+    $2 = RARRAY_LEN($input);
+    $1 = ALLOC_N(double,$2);
+    for (long i=0; i<$2; i++) {
+        $1[i] = NUM2DBL(RARRAY_PTR($input)[i]);
+    }
+}
+
+// Free the list
+%typemap(freearg) (const double* d, int size), (const double *A, long size)
+{
+    xfree($1);
+}
+
+%extend mglGraph {
+  inline void SetFunc(const char *EqX, int EqY=0, int EqZ=0, int EqA=0)
+  { self->SetFunc(EqX, 0, 0, 0); }
+  inline void SetFunc(const char *EqX, const char *EqY, int EqZ=0, int EqA=0)
+  { self->SetFunc(EqX, EqY, 0, 0); }
+  inline void SetFunc(const char *EqX, const char *EqY, const char *EqZ=NULL, int EqA=0)
+  { self->SetFunc(EqX, EqY, EqZ, 0); }
+}

data/ext/mathgl/tmpl/mkwin.rb

@@ -0,0 +1,9 @@
+require "erb"
+
+path = File.join(File.dirname($0),"win.erb.cxx")
+low = ARGV[0]
+up = low.upcase
+has_run = !["glut"].include?(low)
+
+erb = ERB.new(File.read(path))
+erb.run(binding)

data/lib/mathgl/version.rb

@@ -0,0 +1,3 @@
+module Mathgl
+  VERSION = "0.0.1"
+end

data/mathgl.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mathgl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mathgl"
+  spec.version       = Mathgl::VERSION
+  spec.authors       = ["Masahiro TANAKA"]
+  spec.email         = ["masa16.tanaka@gmail.com"]
+  spec.description   = %q{Ruby wrapper for MathGL - library for scientific data visualization}
+  spec.summary       = %q{Ruby wrapper for MathGL - library for scientific data visualization}
+  spec.homepage      = "https://github.com/masa16/ruby-mathgl"
+  spec.license       = "LGPL"
+  spec.extensions    = `git ls-files ext`.split($/).grep(/extconf/)
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/sample/conv_sample.rb

@@ -0,0 +1,310 @@
+class ConvSample
+  def initialize
+    @a = []
+    @n_indent = 0
+  end
+
+  def parse
+    @s = ARGF.read
+    @s.gsub!(/\/\/.*?$/m, "")
+    @i = -1
+
+    print "
+libdir = File.expand_path(File.dirname(__FILE__))
+require libdir+"/../ext/mathgl/mathgl.so"
+require libdir+"/prepare"
+
+def mgl_rnd
+  rand
+end
+
+def pow(a,b)
+  a**b
+end
+
+M_PI = Math::PI
+NULL = nil
+NAN  = 0.0/0.0
+
+procs = {}
+"
+    @s.scan(/^(void (\w+)\(([^)]*)\)\s*^{(.*?)^})/m) do |f|
+      parse_func($1,$2,$3,$4)
+    end
+    print "
+kind = 'png'
+gr = MathGL::MglGraph.new
+procs.each do |key,blk|
+  file = 'smpl_'+key+'.'+kind
+  if !File.exist?(file)
+    puts key
+    gr.set_size(960,720)
+    gr.vertex_color(false)
+    gr.compression(false)
+    gr.default_plot_param()
+    gr.clf
+    gr.instance_eval(&blk)
+    case kind
+    when 'eps'
+      gr.write_eps(file)
+    when 'png'
+      gr.write_png(file,'',false)
+    end
+  end
+end
+"
+  end
+
+  def parse_func(all,name,args,body)
+    if /^smgl_(\w+)/ =~ name
+      name = $1
+    end
+    return if name == "parser"
+
+    all.split(/^/).each do |line|
+      print "# "+line
+    end
+    print "\n"
+
+    body.gsub!(/\bsplot1\(b\);/m, "b.Norm(-1,1,true);gr->Rotate(70,60);gr->Box();gr->Surf3(b);")
+    body.gsub!(/\bsplot2\(b\);/m, "b.Norm(-1,1,true);gr->Rotate(70,60);gr->Box();gr->Surf3(0.5,b);gr->Surf3(-0.5,b);")
+    body.gsub!(/'0'\+i/m,"'%d'%i")
+
+    re = /(?<pare>\(([^\(\)]++|\g<pare>)*+\))/
+    body.gsub!(re){ @i+=1; @a[@i]=$1; "@#{@i}@" }
+    re = /=\s*\{([^{}]*)\}/
+    body.gsub!(re){ @i+=1; @a[@i]="[#{$1}]"; "=@#{@i}@" }
+
+    if /mgls_/=~name
+      a = args.split(/,/).map{|x| /(\w+)$/=~x; "#{$1}=nil"}
+      print "def "+name+"("+a.join(",")+")\n"
+    else
+      print "procs['#{name}'] = proc do\n"
+    end
+    indent_up
+    parse_body(body)
+    indent_down
+    print "end\n\n"
+  end
+
+  def restore_fix(s)
+    s = s.gsub(/(\w+)?@(\d+)@/){ ($1||"")+fix_arg($1,@a[$2.to_i]) }
+    s.gsub!(/\bmgl([A-Z]\w*\()/){ 'MathGL.'+fix_name('Mgl'+$1) }
+    s.gsub!(/\bin\b/,"inp")
+    s.gsub!(/\bL"/,'"')
+    s.gsub!(/\b(\d+\.)(?![\w.])/){|x| x+'0'}
+    s.sub!(/\.a\[([^\]]+)\]\s*=\s*(.*)/, '.set_val(\2,\1)')
+    s.sub!(/putsw/,"#putsw")
+    s.gsub!(/\bgr\./,'')
+    s += "='%d'%i" if /\s*txt\[1\]=stl\[1\]/=~s
+    s
+  end
+
+  def restore(s)
+    s.gsub(/@(\d+)@/){@a[$1.to_i]}
+  end
+
+  def fix_arg(func,a)
+    a = a.gsub(/"\s*\n\s*"/,"")
+    para = a.sub!(/^\((.*)\)$/,'\1')
+    re = /mglPoint(?<pare>\(([^\(\)]++|\g<pare>)*+\))/
+    a.gsub!(re){|x| x.sub(/^mglPoint\((.*)\)$/,'[\1]')}
+    re = /mglData(?<pare>\(([^\(\)]++|\g<pare>)*+\))/
+    a.gsub!(re){|x|
+      x.sub(/^mglData\((.*)\)$/){|x|
+        c = $1.split(/,/)
+        if c.size == 2
+          c = [c[-1]]
+        else
+          c = [c[-1]]+c[0..-2]
+        end
+        c = c.join(",")
+        "MathGL::MglData.new(#{c})"
+      }
+    }
+    a.gsub!(/&(\w+)/, '\1')
+    a.gsub!(/\b([a-z]\w*\.)(\w+)\(/) do
+      var,meth = $1,$2
+      var+fix_name(meth)+'('
+    end
+    b = a.split(",")
+    case func
+    when "set_func"
+      b = b.map{|y| y=="0" ? '""' : y}
+    when /dens_?/
+      b[1] = '""' if b[1]=="0"
+    when /^mgls_prepare/
+      b = b.map{|y| y=="0" ? 'nil' : y}
+    end
+    a = b.join(",")
+    a = "("+a+")" if para
+    a
+  end
+
+  def indent
+    " " * @n_indent
+  end
+
+  def indent_up
+    @n_indent += 2
+  end
+
+  def indent_down
+    @n_indent -= 2
+  end
+
+  def puts_asis(a)
+    Kernel.puts indent+a
+  end
+
+  def puts(a)
+    Kernel.puts restore_fix(indent+a)
+  end
+
+  def fix_name(x)
+    x = x.gsub(/(?<=[a-z])(?=[A-Z])/,"_").downcase
+    x.gsub!(/(?<=[a-z])(?=[0-9]+[a-z])/i,"_")
+    x
+  end
+
+  def parse_arg(x)
+    x
+  end
+
+  def parse_body(body)
+    body.scan(/([^;{}]*?)(;|\{|\})/m) do |x|
+      line, term = x
+      line.strip!
+      #p [line,term]
+      case line
+      when /^for@.*d\.a\[i\] = hypot@/
+        puts_asis "for j in 0...a.ny"
+        puts_asis "  for i in 0...a.nx"
+        puts_asis "    d.set_val(Math.hypot(a.get_val(i,j),b.get_val(i,j)), i,j)"
+        puts_asis "  end"
+        puts_asis "end"
+      when /^if\s*@(\d+)@\s*(.*)/
+        i,s = $1.to_i,$2
+        @a[i].gsub!(/\bmini\b/,"$mini")
+        @a[i].gsub!(/^\((.*)\)$/,'\1')
+        puts "if @#{i}@"
+        s.strip!
+        if s != ""
+          indent_up
+          parse_body(s+";")
+          indent_down
+          puts "end"
+        end
+      when /^for\s*@(\d+)@\s*(.*)/m
+        j,s = $1,$2||""
+        if /(int )?(\w+)=([^;]+);(\w+)<([^;]+);(\w+)\+\+/ =~ @a[j.to_i]
+          i,b,n = $2,$3,$5
+          print indent+"for #{i} in #{b}...#{n}\n"
+          s.strip!
+          case s
+          when /^for\b/
+            #indent_up
+            parse_body(s+"{")
+            indent_down
+            puts "end"
+          when ""
+          else
+            indent_up
+            parse_line(s)
+            indent_down
+            puts "end"
+          end
+        else
+          puts line
+        end
+      when /^\s*$/
+        if term != "}" and term != ""
+          puts
+        end
+      else
+        parse_line(line)
+      end
+      #
+      case term
+      when /\{/
+        indent_up
+      when /\}/
+        indent_down
+        puts "end"
+      end
+    end
+  end
+
+  def parse_line(line)
+    line.gsub!(/(a?sinh?|a?cosh?|a?tanh?|hypot|exp|log)@/, 'Math.\1@')
+    line.gsub!(/(\w+)(?:\.|->)(\w+)(@(\d+)@)?/) do |x|
+      v,m,a = $1,$2,$3||""
+      "#{v}.#{fix_name(m)}#{a}"
+    end
+    case line
+    when /^mgl(\w+)\s+([^;]+)/
+      klass, vars = "Mgl"+$1, $2
+      vars.scan(/([^,]+)/) do |vardef|
+        vd = vardef[0].strip
+        case vd
+        when /^\*\s*(\w+)\s*=\s*new\s+mgl(\w+)(@\d+@)?/
+          v,c,a = $1, "MathGL::Mgl"+$2, $3||""
+          puts "#{v} = #{c}.new#{a}"
+        when /^\*?\s*(\w+)\s*=\s*(.*)/
+          v,d = $1, $2
+          puts "#{v} = #{d}"
+        when /^\s*(\w+)(@(\d+)@)?/
+          v,a,i = $1,$2,$3
+          if a
+            i = i.to_i
+            if klass == "MglData"
+              if /\(((\d+),)?(\d+),([a-z]+)\)/ =~ @a[i]
+                if $1
+                  @a[i] = "(#{$4},#{$2},#{$3})"
+                else
+                  @a[i] = "(#{$4})"
+                end
+              end
+            end
+            puts "#{v} = MathGL::#{klass}.new#{a}"
+          else
+            puts "#{v} = MathGL::#{klass}.new"
+          end
+        else
+          puts vd
+        end
+      end
+    when /^\s*(int|register long|double) ([^;]+)/
+      $2.split(',').each do |v|
+        case v
+        when /(\w+)(\[\d*\])?\s*(=\s*([^,]+))/
+          if $3
+            puts "#{$1} = #{$4}"
+          elsif $2
+            puts "#{$1} = []"
+          end
+        end
+      end
+    when /^(const)?\s*char ([^;]+)/
+      args = $2+","
+      args.scan(/(\*)?(\w+)(\[\d*\])?\s*=\s*([^,]+?),/) do
+        puts "#{$2} = #{$4}"
+      end
+    when /\bgr.(\w+)(@\d+@)/
+      meth,args = $1,$2
+      puts meth+args
+    when /,/
+      line.split(',').each do |v|
+        puts v.strip
+      end
+    when /([^=]+)=([^=]+)/
+      x,y = $1,$2
+      puts parse_arg(x)+"="+parse_arg(y)
+    else
+      puts line
+    end
+  end
+
+end
+
+ConvSample.new.parse