tioga 1.6 → 1.7

data/split/Dvector/lib/Dvector_extras.rb

@@ -56,6 +56,33 @@ module Dobjects
       'remove_space' => true ,# removes spaces at the beginning of the lines
     }
 
+    # This function is a wrapper for #fast_fancy_read that reflects the
+    # look-and-feel of #old_fancy_read
+    def Dvector.fancy_read(stream, cols = nil, opts = {}) # :doc:
+      o = FANCY_READ_DEFAULTS.dup
+      o.update(opts)
+
+      if stream.is_a?(String)
+        stream = File.open(stream)
+      end
+      raise ArgumentError.new("'stream' should have a gets method") unless 
+        stream.respond_to? :gets
+      
+      o['sep'] = Regexp.new(o['sep']) unless o['sep'].is_a? Regexp
+      
+      res = Dvector.fast_fancy_read(stream, o)
+
+      # Adding the index columns if necessary
+      if o["index_col"] 
+        res.unshift(Dvector.new(res[0].length) { |i| i})
+      end
+
+      if cols
+        return cols.map {|i| res[i] }
+      else
+        return res
+      end
+    end
 
     # This function reads in +stream+ (can an IO object or a String,
     # in which case it represents the name of a file to be opened)
@@ -70,9 +97,10 @@ module Dobjects
     # 'skip_first':: how many lines to skip at the beginning of the file,
     # 'default':: the value taken for missing elements
     # 'index_col':: if set to true, the first column contains the
-    #               indices of the corresponding lines (0 for first and so on)
+    #               indices of the elements (starting from 0 for
+    #               first and so on)
 
-    def Dvector.fancy_read(stream, cols = nil, opts = {}) # :doc:
+    def Dvector.old_fancy_read(stream, cols = nil, opts = {}) # :doc:
       # first, we turn the stream into a real IO stream
       if stream.is_a?(String)
         stream = File.open(stream)

data/split/Flate/extconf.rb

@@ -1,4 +1,4 @@
-# Dtable installation file
+# Flate installation file
 require 'mkmf'
 
 unless have_header("zlib.h") and have_library("z", "compress", "zlib.h")

data/split/Function/function.c

@@ -687,8 +687,13 @@ static VALUE function_split_monotonic(VALUE self)
 	  rb_ary_push(ret, f);
 	  cur_x = Dvector_Create();
 	  cur_y = Dvector_Create();
-	  Dvector_Push_Double(cur_x, x[i-1]);
-	  Dvector_Push_Double(cur_y, y[i-1]);
+	  /* We don't store the previous point if 
+	   the X value is the same*/
+	  if(x[i] != last_x) 
+	    {
+	      Dvector_Push_Double(cur_x, x[i-1]);
+	      Dvector_Push_Double(cur_y, y[i-1]);
+	    }
 	  direction *= -1;
 	}
       /* store the current point */
@@ -927,6 +932,99 @@ static VALUE function_size(VALUE self)
   return LONG2NUM(size);
 }
 
+/* 
+   Fuzzy substraction of two curves. Substracts the Y values of _op_ to
+   the current Function, by making sure that the Y value substracted to
+   a given point corresponds to the closest X_ value of the point in _op_.
+   This function somehow assumes that the data is reasonably organised,
+   and will never go backwards to find a matching X value in _op_.
+
+   In any case, you really should consider using split_monotonic on it first.
+ */
+
+static VALUE function_fuzzy_substract(VALUE self, VALUE op)
+{
+  long ss = function_sanity_check(self);
+  const double *xs = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  double *ys = Dvector_Data_for_Write(get_y_vector(self),NULL);
+  long so = function_sanity_check(op);
+  const double *xo = Dvector_Data_for_Read(get_x_vector(op),NULL);
+  const double *yo = Dvector_Data_for_Read(get_y_vector(op),NULL);
+  long i,j = 0;
+  double diff;
+  double fuzz = 0; 		/* The actual sum of the terms */
+  
+  for(i = 0; i < ss; i++) 
+    {
+      /* We first look for the closest point */
+      diff = fabs(xs[i] - xo[j]);
+      while((j < (so - 1)) && (fabs(xs[i] - xo[j+1]) <  diff))
+	diff = fabs(xs[i] - xo[++j]);
+      fuzz += diff;
+      ys[i] -= yo[j];
+    }
+  return rb_float_new(fuzz);
+}
+
+/* 
+  call-seq:
+    f.bound_values(xmin, xmax, ymin, ymax)
+
+   This function browses the points inside the Function and stores in
+   the resulting new function only points which are within boundaries,
+   and the points just next to them (so the general direction on the sides
+   looks fine).
+
+   Make sure _xmin_ < _xmax_ and _ymin_ < _ymax_, else you simply won't
+   get any output.
+ */
+static VALUE function_bound_values(VALUE self, 
+				   VALUE vxmin, VALUE vxmax,
+				   VALUE vymin, VALUE vymax)
+{
+  long ss = function_sanity_check(self);
+  const double *xs = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  const double *ys = Dvector_Data_for_Read(get_y_vector(self),NULL);
+  double xmin = NUM2DBL(vxmin);
+  double xmax = NUM2DBL(vxmax);
+  double ymin = NUM2DBL(vymin);
+  double ymax = NUM2DBL(vymax);
+
+  /* Now, two dvectors for writing: */
+  VALUE x_out = rb_funcall(cDvector, idNew, 0);
+  VALUE y_out = rb_funcall(cDvector, idNew, 0);
+
+  /* No forward computation of the size of the targets, meaning
+     memory allocation penalty.
+  */
+  
+  int last_point_in = 0; 	/* Whether the last point was in */
+  long i;
+  for(i = 0; i < ss; i++) {
+    double x = xs[i];
+    double y = ys[i];
+    if( (xmin <= x) && (xmax >= x) && (ymin <= y) && (ymax >= y)) {
+      if(! last_point_in) {
+	last_point_in = 1;
+	if(i) {			/* Not for the first element */
+	  Dvector_Push_Double(x_out, xs[i-1]);
+	  Dvector_Push_Double(y_out, ys[i-1]);
+	}
+      }
+      Dvector_Push_Double(x_out, x);
+      Dvector_Push_Double(y_out, y);
+    }
+    else {			/* Outside boundaries */
+      if(last_point_in) {
+	last_point_in = 0;
+	Dvector_Push_Double(x_out, x);
+	Dvector_Push_Double(y_out, y);
+      }
+    }
+  }
+  return Function_Create(x_out, y_out);
+}
+
 /*
   Document-class: Dobjects::Function
 
@@ -941,6 +1039,9 @@ static VALUE function_size(VALUE self)
   - some utiliy functions: #split_monotonic, #strip_nan;
   - data inspection: #min, #max;
   - some computational functions: #integrate, #primitive, #derivative.
+  - utility for fuzzy operations, when the X values of two functions
+    differ, but only slightly, of when points are missing: 
+    #fuzzy_sub!
 
   And getting bigger everyday...
  */ 
@@ -1003,6 +1104,15 @@ void Init_Function()
   /* distance to a point */
   rb_define_method(cFunction, "distance", function_distance, -1);
 
+  /* Fuzzy operations */
+  rb_define_method(cFunction, "fuzzy_sub!", 
+		   function_fuzzy_substract, 1); /* Substraction */
+  
+
+  /* Boundary operations */
+  rb_define_method(cFunction, "bound_values", 
+		   function_bound_values, 4); /* Substraction */
+
 
   /* a few more methods better written in pure Ruby */
   rb_require("Dobjects/Function_extras.rb");

data/split/Tioga/figures.c

@@ -25,6 +25,9 @@
 
 #include "figures.h"
 #include "pdfs.h"
+#include "wrappers.h"
+#include "dvector.h"
+#include "dtable.h"
 #include "flate.h"
 
 #include <symbols.h>
@@ -32,46 +35,47 @@
 
 #include <stdio.h>
 
-char *data_dir = NULL;
 
-VALUE cFM; /* the Tioga/FigureMaker class object */
-
-static void FM_mark(FM *p) { /* all of the VALUEs in the FM struct should be marked */
-   rb_gc_mark(p->stroke_color);
-   rb_gc_mark(p->fill_color);
-   rb_gc_mark(p->line_type);
-   rb_gc_mark(p->title);
-   rb_gc_mark(p->title_color);
-   rb_gc_mark(p->xlabel);
-   rb_gc_mark(p->xlabel_color);
-   rb_gc_mark(p->ylabel);
-   rb_gc_mark(p->ylabel_color);
-   rb_gc_mark(p->xaxis_stroke_color);
-   rb_gc_mark(p->xaxis_locations_for_major_ticks);
-   rb_gc_mark(p->xaxis_locations_for_minor_ticks);
-   rb_gc_mark(p->yaxis_stroke_color);
-   rb_gc_mark(p->yaxis_locations_for_major_ticks);
-   rb_gc_mark(p->yaxis_locations_for_minor_ticks);
-   rb_gc_mark(p->fm);
-}
+#define DBL_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : rb_float_new(p->attr); } \
+static VALUE FM_##attr##_set(VALUE fmkr, VALUE val) { \
+   int ierr=0; FM *p = Get_FM(fmkr,&ierr); if (ierr != 0) RETURN_NIL; VALUE v = rb_Float(val); p->attr = NUM2DBL(v); return val; }
 
-static void FM_free(FM *p) {
-   free(p);
-}
+#define INT_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : INT2FIX(p->attr); } \
+static VALUE FM_##attr##_set(VALUE fmkr, VALUE val) { \
+   int ierr=0; FM *p = Get_FM(fmkr,&ierr); if (ierr != 0) RETURN_NIL; VALUE v = rb_Integer(val); p->attr = NUM2INT(v); return val; }
 
-static VALUE FM_alloc(VALUE klass) {
-   FM *p;
-   VALUE ary = Data_Make_Struct(klass, FM, FM_mark, FM_free, p);
-   Initialize_Figure(ary);
-   p->fm = ary;
-   return ary;
-}
+#define VAL_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : p->attr; } \
+static VALUE FM_##attr##_set(VALUE fmkr, VALUE val) { \
+   int ierr=0; FM *p = Get_FM(fmkr,&ierr); if (ierr != 0) RETURN_NIL; p->attr = val; return val; }
+
+#define BOOL_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : ((p->attr)? Qtrue : Qfalse); } \
+static VALUE FM_##attr##_set(VALUE fmkr, VALUE val) { \
+   int ierr=0; FM *p = Get_FM(fmkr,&ierr); if (ierr != 0) RETURN_NIL; p->attr = (val != Qfalse); return val; }
+
+#define RO_DBL_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : rb_float_new(p->attr); }
 
-bool Is_FM(VALUE fmkr) { return ( TYPE(fmkr) == T_DATA && RDATA(fmkr)->dfree == (RUBY_DATA_FUNC)FM_free ); }
+#define RO_INT_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : INT2FIX(p->attr); }
+
+#define RO_VAL_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : p->attr; }
+
+#define RO_BOOL_ATTR(attr) \
+static VALUE FM_##attr##_get(VALUE fmkr) { int ierr=0; FM *p = Get_FM(fmkr,&ierr); return (ierr != 0)? OBJ_NIL : ((p->attr)? Qtrue : Qfalse); }
+
+
+char *data_dir = NULL;
 
-FM *Get_FM(VALUE fmkr) {
-   FM *p;
-   Data_Get_Struct(fmkr, FM, p);
+OBJ_PTR cFM; /* the Tioga/FigureMaker class object */
+
+FM *Get_FM(OBJ_PTR fmkr, int *ierr) {
+   FM *p = (FM *)Dvector_Data_for_Write(Get_fm_data_attr(fmkr, ierr), NULL);
+   if (*ierr != 0) RAISE_ERROR("FigMkr is missing @fm_data", ierr);
    return p;
 }
 
@@ -129,19 +133,15 @@ FM *Get_FM(VALUE fmkr) {
    
 /* graphics attribute accessors */
    RO_DBL_ATTR(default_line_scale)        
-   RO_VAL_ATTR(stroke_color)
-   RO_VAL_ATTR(fill_color)
    RO_DBL_ATTR(line_width)        
    RO_INT_ATTR(line_cap)
    RO_INT_ATTR(line_join)
    RO_DBL_ATTR(miter_limit)
    RO_DBL_ATTR(stroke_opacity)
    RO_DBL_ATTR(fill_opacity)
-   RO_VAL_ATTR(line_type)
    
 /* Title */
    RO_BOOL_ATTR(title_visible)
-   VAL_ATTR(title)
    INT_ATTR(title_side)
    DBL_ATTR(title_position)
    DBL_ATTR(title_scale)
@@ -149,11 +149,10 @@ FM *Get_FM(VALUE fmkr) {
    DBL_ATTR(title_angle)
    INT_ATTR(title_alignment)
    INT_ATTR(title_justification)
-   VAL_ATTR(title_color)
+   //VAL_ATTR(title_color)
     
 /* X label */
    RO_BOOL_ATTR(xlabel_visible)
-   VAL_ATTR(xlabel)
    DBL_ATTR(xlabel_position)
    DBL_ATTR(xlabel_scale)
    DBL_ATTR(xlabel_shift)
@@ -161,11 +160,9 @@ FM *Get_FM(VALUE fmkr) {
    INT_ATTR(xlabel_side)
    INT_ATTR(xlabel_alignment)
    INT_ATTR(xlabel_justification)
-   VAL_ATTR(xlabel_color)
     
 /* Y label */
    RO_BOOL_ATTR(ylabel_visible)
-   VAL_ATTR(ylabel)
    DBL_ATTR(ylabel_position)
    DBL_ATTR(ylabel_scale)
    DBL_ATTR(ylabel_shift)
@@ -173,14 +170,12 @@ FM *Get_FM(VALUE fmkr) {
    INT_ATTR(ylabel_side)
    INT_ATTR(ylabel_alignment)
    INT_ATTR(ylabel_justification)
-   VAL_ATTR(ylabel_color)
     
 /* X axis */
    RO_BOOL_ATTR(xaxis_visible)
    INT_ATTR(xaxis_loc)
    INT_ATTR(xaxis_type)
    DBL_ATTR(xaxis_line_width)
-   VAL_ATTR(xaxis_stroke_color)
    DBL_ATTR(xaxis_major_tick_width)
    DBL_ATTR(xaxis_minor_tick_width)
    DBL_ATTR(xaxis_major_tick_length)
@@ -191,11 +186,8 @@ FM *Get_FM(VALUE fmkr) {
    DBL_ATTR(xaxis_tick_interval)
    DBL_ATTR(xaxis_min_between_major_ticks)
    INT_ATTR(xaxis_number_of_minor_intervals)
-   VAL_ATTR(xaxis_locations_for_major_ticks)
-   VAL_ATTR(xaxis_locations_for_minor_ticks)
    BOOL_ATTR(xaxis_use_fixed_pt)
    INT_ATTR(xaxis_digits_max)
-   VAL_ATTR(xaxis_tick_labels)
    INT_ATTR(xaxis_numeric_label_decimal_digits)
    DBL_ATTR(xaxis_numeric_label_scale)
    DBL_ATTR(xaxis_numeric_label_shift)
@@ -214,7 +206,6 @@ FM *Get_FM(VALUE fmkr) {
    INT_ATTR(yaxis_loc)
    INT_ATTR(yaxis_type)
    DBL_ATTR(yaxis_line_width)
-   VAL_ATTR(yaxis_stroke_color)
    DBL_ATTR(yaxis_major_tick_width)
    DBL_ATTR(yaxis_minor_tick_width)
    DBL_ATTR(yaxis_major_tick_length)
@@ -225,11 +216,8 @@ FM *Get_FM(VALUE fmkr) {
    DBL_ATTR(yaxis_tick_interval)
    DBL_ATTR(yaxis_min_between_major_ticks)
    INT_ATTR(yaxis_number_of_minor_intervals)
-   VAL_ATTR(yaxis_locations_for_major_ticks)
-   VAL_ATTR(yaxis_locations_for_minor_ticks)
    BOOL_ATTR(yaxis_use_fixed_pt)
    INT_ATTR(yaxis_digits_max)
-   VAL_ATTR(yaxis_tick_labels)
    INT_ATTR(yaxis_numeric_label_decimal_digits)
    DBL_ATTR(yaxis_numeric_label_scale)
    DBL_ATTR(yaxis_numeric_label_shift)
@@ -262,12 +250,26 @@ FM *Get_FM(VALUE fmkr) {
 /* Warning on non-ok numbers */
    BOOL_ATTR(croak_on_nonok_numbers)
 
+bool Get_initialized() {
+   OBJ_PTR v = rb_cv_get(cFM, "@@initialized");
+   return v != OBJ_FALSE && v != OBJ_NIL;
+}
+
+void Set_initialized() {
+   rb_cv_set(cFM, "@@initialized", OBJ_TRUE);
+}
+
+static void Set_fm_data_size() {
+   rb_cv_set(cFM, "@@fm_data_size", Integer_New(1 + (sizeof(FM) / sizeof(double)))); 
+   // size is number of doubles needed to hold FM data
+}
+
 #define attr_reader(attr) rb_define_method(cFM, #attr , FM_##attr##_get, 0);
 #define attr_writer(attr) rb_define_method(cFM, #attr "=", FM_##attr##_set, 1);
 #define attr_accessors(attr) attr_reader(attr) attr_writer(attr)
 
 void Init_FigureMaker(void) { 
-     /* called by Ruby when the extension is loaded */
+   /* called by Ruby when the extension is loaded */
 
    /* this function has been modified by Vincent Fourmond for the splitting
       out of libraries more general than Tioga */
@@ -286,12 +288,12 @@ void Init_FigureMaker(void) {
    rb_require("Flate");
 
    
-   VALUE mTioga = rb_define_module("Tioga");
+   OBJ_PTR mTioga = rb_define_module("Tioga");
 
 
    /* and now, we need to import Dobjects and Flate modules*/
-   VALUE mDobjects = rb_define_module("Dobjects");
-   VALUE mFlate = rb_define_module("Flate");
+   OBJ_PTR mDobjects = rb_define_module("Dobjects");
+   OBJ_PTR mFlate = rb_define_module("Flate");
    rb_include_module(mTioga, mDobjects);
    rb_include_module(mTioga, mFlate);
 
@@ -304,13 +306,13 @@ void Init_FigureMaker(void) {
    rb_include_module(cFM, mDobjects);
    rb_include_module(cFM, mFlate);
 
-   rb_define_alloc_func(cFM, FM_alloc);
    Init_IDs();
    Init_Font_Dictionary();
    rb_define_method(cFM, "private_make", FM_private_make, 2);
    rb_define_method(cFM, "get_save_filename", FM_get_save_filename, 1);
    rb_define_method(cFM, "private_make_portfolio", FM_private_make_portfolio, 3);
-   
+   rb_define_method(cFM, "private_init_fm_data", FM_private_init_fm_data, 0);
+
 /* page attribute accessors */
    attr_reader(root_figure)
    attr_reader(in_subplot)
@@ -364,15 +366,16 @@ void Init_FigureMaker(void) {
    attr_accessors(line_width)
    attr_accessors(line_cap)
    attr_accessors(line_join)
+   rb_define_method(cFM, "line_type_set", FM_line_type_set, 1);
    attr_accessors(miter_limit)
    attr_accessors(stroke_opacity)
    attr_accessors(fill_opacity)
-   attr_accessors(line_type)
 /* croak on non ok */
    attr_accessors(croak_on_nonok_numbers)
 
 /* methods */
-   rb_define_method(cFM, "private_context", FM_private_context, 1);
+   rb_define_method(cFM, "pdf_gsave", FM_pdf_gsave, 0);
+   rb_define_method(cFM, "pdf_grestore", FM_pdf_grestore, 0);
    rb_define_method(cFM, "private_set_bounds", FM_private_set_bounds, 4);
    rb_define_method(cFM, "private_set_subframe", FM_private_set_subframe, 4);
    rb_define_method(cFM, "doing_subfigure", FM_doing_subfigure, 0);
@@ -415,17 +418,20 @@ void Init_FigureMaker(void) {
    rb_define_method(cFM, "convert_output_to_figure_x", FM_convert_output_to_figure_x, 1);
    rb_define_method(cFM, "convert_output_to_figure_y", FM_convert_output_to_figure_y, 1);
    rb_define_method(cFM, "convert_output_to_figure_dx", FM_convert_output_to_figure_dx, 1);
-   rb_define_method(cFM, "convert_output_to_figuret_dy", FM_convert_output_to_figure_dy, 1);
+   rb_define_method(cFM, "convert_output_to_figure_dy", FM_convert_output_to_figure_dy, 1);
    rb_define_method(cFM, "convert_to_degrees", FM_convert_to_degrees, 2);
 /* text */
    rb_define_method(cFM, "private_set_default_font_size", FM_private_set_default_font_size, 1);
    rb_define_method(cFM, "rescale_text", FM_rescale_text, 1);
-   rb_define_method(cFM, "show_rotated_text", FM_show_rotated_text, 8);
-   rb_define_method(cFM, "show_rotated_label", FM_show_rotated_label, 7);
+   rb_define_method(cFM, "show_rotated_text", FM_show_rotated_text, 9);
+   rb_define_method(cFM, "show_rotated_label", FM_show_rotated_label, 8);
    rb_define_method(cFM, "check_label_clip", FM_check_label_clip, 2);
+/* text measurements */
+   rb_define_method(cFM, "private_save_measure", FM_save_measure, 4);
 /* path construction */
    rb_define_method(cFM, "move_to_point", FM_move_to_point, 2);
    rb_define_method(cFM, "append_point_to_path", FM_append_point_to_path, 2);
+   rb_define_method(cFM, "bezier_control_points", FM_bezier_control_points, 6);
    rb_define_method(cFM, "append_curve_to_path", FM_append_curve_to_path, 6);
    rb_define_method(cFM, "close_path", FM_close_path, 0);
    rb_define_method(cFM, "append_points_to_path", FM_append_points_to_path, 2);
@@ -512,13 +518,12 @@ void Init_FigureMaker(void) {
    rb_define_method(cFM, "no_top_edge", FM_no_top_edge, 0);
    rb_define_method(cFM, "no_bottom_edge", FM_no_bottom_edge, 0);
 /* makers */
-   rb_define_method(cFM, "private_make_contour", FM_private_make_contour, 9);
-   rb_define_method(cFM, "private_make_spline_interpolated_points", FM_private_make_spline_interpolated_points, 6);
-   rb_define_method(cFM, "private_make_steps", FM_private_make_steps, 8);
+   rb_define_method(cFM, "private_make_contour", FM_private_make_contour, 7);
+   rb_define_method(cFM, "private_make_spline_interpolated_points", FM_private_make_spline_interpolated_points, 5);
+   rb_define_method(cFM, "private_make_steps", FM_private_make_steps, 6);
    
 /* Title */
    attr_reader(title_visible)
-   attr_accessors(title)
    attr_accessors(title_side)
    attr_accessors(title_position)
    attr_accessors(title_scale)
@@ -530,7 +535,6 @@ void Init_FigureMaker(void) {
     
 /* X label */
    attr_reader(xlabel_visible)
-   attr_accessors(xlabel)
    attr_accessors(xlabel_position)
    attr_accessors(xlabel_scale)
    attr_accessors(xlabel_shift)
@@ -542,7 +546,6 @@ void Init_FigureMaker(void) {
     
 /* Y label */
    attr_reader(ylabel_visible)
-   attr_accessors(ylabel)
    attr_accessors(ylabel_position)
    attr_accessors(ylabel_scale)
    attr_accessors(ylabel_shift)
@@ -568,11 +571,8 @@ void Init_FigureMaker(void) {
    attr_accessors(xaxis_tick_interval)
    attr_accessors(xaxis_min_between_major_ticks)
    attr_accessors(xaxis_number_of_minor_intervals)
-   attr_accessors(xaxis_locations_for_major_ticks)
-   attr_accessors(xaxis_locations_for_minor_ticks)
    attr_accessors(xaxis_use_fixed_pt)
    attr_accessors(xaxis_digits_max)
-   attr_accessors(xaxis_tick_labels)
    attr_accessors(xaxis_numeric_label_decimal_digits)
    attr_accessors(xaxis_numeric_label_scale)
    attr_accessors(xaxis_numeric_label_shift)
@@ -602,11 +602,8 @@ void Init_FigureMaker(void) {
    attr_accessors(yaxis_tick_interval)
    attr_accessors(yaxis_min_between_major_ticks)
    attr_accessors(yaxis_number_of_minor_intervals)
-   attr_accessors(yaxis_locations_for_major_ticks)
-   attr_accessors(yaxis_locations_for_minor_ticks)
    attr_accessors(yaxis_use_fixed_pt)
    attr_accessors(yaxis_digits_max)
-   attr_accessors(yaxis_tick_labels)
    attr_accessors(yaxis_numeric_label_decimal_digits)
    attr_accessors(yaxis_numeric_label_scale)
    attr_accessors(yaxis_numeric_label_shift)
@@ -636,11 +633,13 @@ void Init_FigureMaker(void) {
 /* Debugging */
    attr_accessors(debug_verbosity_level)
       
+      
+   Set_fm_data_size(); // must set this before create a FigureMaker instance
    rb_require("Tioga/FigMkr.rb");
    /* We now need to import the symbols */
 
    /* imports from Dvector */
-   VALUE cDvector = rb_define_class_under(mDobjects, "Dvector", rb_cObject);
+   OBJ_PTR cDvector = rb_define_class_under(mDobjects, "Dvector", rb_cObject);
    RB_IMPORT_SYMBOL(cDvector, Dvector_Create);
    RB_IMPORT_SYMBOL(cDvector, Dvector_Data_Resize);
    RB_IMPORT_SYMBOL(cDvector, Dvector_Data_Replace);
@@ -656,7 +655,7 @@ void Init_FigureMaker(void) {
    RB_IMPORT_SYMBOL(mFlate, flate_expand);
 
    /* imports from Dtable */
-   VALUE cDtable = rb_define_class_under(mDobjects, "Dtable", rb_cObject);
+   OBJ_PTR cDtable = rb_define_class_under(mDobjects, "Dtable", rb_cObject);
    RB_IMPORT_SYMBOL(cDtable, Dtable_Ptr);
    RB_IMPORT_SYMBOL(cDtable, Read_Dtable);
 }