tioga 1.9 → 1.11

data/split/Dtable/dvector.h

@@ -55,15 +55,23 @@ DECLARE_SYMBOL(void, Dvector_Push_Double, (VALUE ary, double val));
 
 
 /* functions for interpolation */
-DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
-	       (double x, int n_pts_data, double *Xs, double *Ys, 
-		double *Bs, double *Cs, double *Ds));
-DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
-	       (int num_pts, double *xs, double *ys, double x));
 DECLARE_SYMBOL(void, c_dvector_create_spline_interpolant,
 	       (int n_pts_data, double *Xs, double *Ys,
 		bool start_clamped, double start_slope, 
 		bool end_clamped, double end_slope,
 		double *As, double *Bs, double *Cs));
+DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+
+DECLARE_SYMBOL(void, c_dvector_create_pm_cubic_interpolant,
+	       (int n_pts_data, double *Xs, double *Ys,
+		double *As, double *Bs, double *Cs));
+DECLARE_SYMBOL(double, c_dvector_pm_cubic_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+
+DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
+	       (int num_pts, double *xs, double *ys, double x));
 #endif   /* __Dvector_H__ */
 

data/split/Dvector/dvector.c

@@ -49,6 +49,9 @@
 #ifndef MIN
 #define MIN(a,b)    (((a) < (b)) ? (a) : (b))
 #endif
+#ifndef SIGN
+#define SIGN(a)    (((a) > 0) ? 1 : -1)
+#endif
 
 
 
@@ -1068,7 +1071,8 @@ PRIVATE
  *  call-seq:
  *     dvector.min_gt(val)  -> float or nil
  *  
- *  Returns the minimum entry in _dvector_ which is greater than _val_, or <code>nil</code> if no such entry if found.
+ *  Returns the minimum entry in _dvector_ which is greater than _val_,
+ *  or <code>nil</code> if no such entry if found.
  */ VALUE dvector_min_gt(VALUE ary, VALUE val) {
    Dvector *d = Get_Dvector(ary);
    val = rb_Float(val);
@@ -1092,7 +1096,8 @@ PRIVATE
  *  call-seq:
  *     dvector.max_lt(val)  -> float or nil
  *  
- *  Returns the maximum entry in _dvector_ which is less than _val_, or <code>nil</code> if no such entry if found.
+ *  Returns the maximum entry in _dvector_ which is less than _val_,
+ *  or <code>nil</code> if no such entry if found.
  */ VALUE dvector_max_lt(VALUE ary, VALUE val) {
    Dvector *d = Get_Dvector(ary);
    val = rb_Float(val);
@@ -1390,7 +1395,8 @@ PRIVATE
    Dvector *d2 = Get_Dvector(ary2);
    long len = d->len;
    if (len != d2->len) {
-      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for reverse_each2_with_index", len, d2->len);
+      rb_raise(rb_eArgError, "vectors with different lengths (%d vs %d) for reverse_each2_with_index", 
+         len, d2->len);
    }
    while (len--) {
       rb_yield_values(3, rb_float_new(d->ptr[len]), rb_float_new(d2->ptr[len]), LONG2NUM(len));
@@ -1687,8 +1693,10 @@ PRIVATE
  *  call-seq:
  *     dvector.dup  -> a_dvector
  *  
- *  Returns a copy of _dvector_.  For performance sensitive situations involving a series of vector operations,
- *  first make a copy using dup and then do "bang" operations to modify the result without further copying.
+ *  Returns a copy of _dvector_.
+ *  For performance sensitive situations involving a series of vector operations,
+ *  first make a copy using dup and then do "bang" operations to modify the result
+ *  without further copying.
  */ VALUE dvector_dup(VALUE ary) {
    Dvector *d = Get_Dvector(ary);
    return dvector_new4_dbl(d->len, d->ptr);
@@ -1700,7 +1708,8 @@ PRIVATE
  *     dvector.collect {|x| block }  -> a_dvector
  *     dvector.map     {|x| block }  -> a_dvector
  *  
- *  Invokes <i>block</i> once for each element of _dvector_.  Returns a new vector holding the values returned by _block_.
+ *  Invokes <i>block</i> once for each element of _dvector_.
+ *  Returns a new vector holding the values returned by _block_.
  *  Note that for numeric operations on long vectors, it is more efficient to
  *  apply the operator directly to the vector rather than using map or collect.
  *     
@@ -4896,7 +4905,8 @@ PRIVATE
  *  Replaces contents of _dvector_ by control points for Bezier curve.
  *  The cubic, y(x), is defined from x0 to x0+delta_x.
  *  At location x = x0 + dx, with dx between 0 and delta_x, define y = a*dx^3 + b*dx^2 + c*dx + y0.
- *  This routine replaces the contents of _dest_ by [x1, y1, x2, y2, x3, y3], the Bezier control points to match this cubic.
+ *  This routine replaces the contents of _dest_ by [x1, y1, x2, y2, x3, y3],
+ *  the Bezier control points to match this cubic.
  *     
  */ 
 VALUE dvector_make_bezier_control_points_for_cubic_in_x(VALUE dest, VALUE x0, VALUE y0, VALUE delta_x, VALUE a, VALUE b, VALUE c)
@@ -4911,6 +4921,162 @@ VALUE dvector_make_bezier_control_points_for_cubic_in_x(VALUE dest, VALUE x0, VA
       NUM2DBL(x0), NUM2DBL(y0), NUM2DBL(delta_x), NUM2DBL(a), NUM2DBL(b), NUM2DBL(c));
 }
 
+
+
+
+
+void c_dvector_create_pm_cubic_interpolant(int nx, double *x, double *f,
+    double *As, double *Bs, double *Cs)
+{
+   double *h = (double *)ALLOC_N(double, nx);
+   double *s = (double *)ALLOC_N(double, nx);
+   double *p = (double *)ALLOC_N(double, nx);
+   double as00, asm1, ap00, sm1, s00;
+   int n = nx-1, i;
+   
+   
+   for (i=0; i < n; i++) {
+      h[i] = x[i+1] - x[i];
+      s[i] = (f[i+1] - f[i])/h[i];
+   }
+   
+   /* slope at i of parabola through i-1, i, and i+1 */
+   for (i=1; i < n; i++) {
+      p[i] = (s[i-1]*h[i] + s[i]*h[i-1])/(h[i]+h[i-1]);
+   }
+   
+   /* "safe" slope at i to ensure monotonic -- see Steffen paper for explanation. */
+   for (i=1; i < n; i++) {
+      asm1 = fabs(s[i-1]);
+      as00 = fabs(s[i]);
+      ap00 = fabs(p[i]);
+      sm1 = (s[i-1] > 0)? 1.0 : -1.0;
+      s00 = (s[i] > 0)? 1.0 : -1.0;
+      Cs[i] = (sm1+s00)*MIN(asm1, MIN(as00, 0.5*ap00));
+   }
+      
+   /* slope at 1st point of parabola through 1st 3 points */
+   p[0] = s[0]*(1 + h[0] / (h[0] + h[1])) - s[1] * h[0] / (h[0] + h[1]);
+   
+   /* safe slope at 1st point */
+   if (p[0]*s[0] <= 0) {
+      Cs[0] = 0;
+   } else if (fabs(p[0]) > 2.0*fabs(s[0])) {
+      Cs[0] = 2.0*s[0];
+   } else {
+      Cs[0] = p[0];
+   }
+   
+   /* slope at last point of parabola through last 3 points */   
+   p[n] = s[n-1]*(1 + h[n-1] / (h[n-1] + h[n-2])) - s[n-2]*h[n-1] / (h[n-1] + h[n-2]);
+
+   /* safe slope at last point */    
+   if (p[n]*s[n-1] <= 0) {
+      Cs[n] = 0;
+   } else if (fabs(p[n]) > 2.0*fabs(s[n-1])) {
+      Cs[n] = 2.0*s[n-1];
+   } else {
+      Cs[n] = p[n];
+   }
+         
+   for (i=0; i < n; i++) {
+      Bs[i] = (3.0*s[i] - 2.0*Cs[i] - Cs[i+1]) / h[i];
+   }
+   Bs[n] = 0;
+         
+   for (i=1; i < n; i++) {
+      As[i] = (Cs[i] + Cs[i+1] - 2.0*s[i]) / (h[i]*h[i]);
+   }
+   As[n] = 0;
+      
+   free(p); free(s); free(h);
+}
+
+PRIVATE
+/*
+ *  call-seq:
+ *     Dvector.create_pm_cubic_interpolant(xs, ys) ->  interpolant
+ *
+ *  Uses Dvectors _xs_ and _ys_ to create a cubic pm_cubic interpolant.  The _xs_ must be given in ascending order.
+ *  The interpolant is an array of Dvectors: [Xs, Ys, As, Bs, Cs].
+ *  For x between Xs[j] and Xs[j+1], let dx = x - Xs[j], and find interpolated y for x by
+ *  y = As[j]*dx^3 + Bs[j]*dx^2 + Cs[j]*dx + Ys[j].
+ *  pm_cubic algorithms derived from Steffen, M., "A simple method for monotonic interpolation in one dimension", 
+ *        Astron. Astrophys., (239) 1990, 443-450.
+ *  
+ */ 
+VALUE dvector_create_pm_cubic_interpolant(int argc, VALUE *argv, VALUE klass) {
+   if (argc != 2)
+      rb_raise(rb_eArgError, "wrong # of arguments(%d) for create_pm_cubic_interpolant", argc);
+   klass = Qnil;
+   VALUE Xs = argv[0], Ys = argv[1];
+   long xdlen, ydlen;
+   double start = 0.0, end = 0.0;
+   double *X_data = Dvector_Data_for_Read(Xs, &xdlen);
+   double *Y_data = Dvector_Data_for_Read(Ys, &ydlen);
+   if (X_data == NULL || Y_data == NULL || xdlen != ydlen)
+      rb_raise(rb_eArgError, "Data for create_pm_cubic_interpolant must be equal length Dvectors");
+   int nx = xdlen;
+   VALUE As = Dvector_Create(), Bs = Dvector_Create(), Cs = Dvector_Create();
+   double *As_data = Dvector_Data_Resize(As, nx);
+   double *Bs_data = Dvector_Data_Resize(Bs, nx);
+   double *Cs_data = Dvector_Data_Resize(Cs, nx);
+   c_dvector_create_pm_cubic_interpolant(nx, X_data, Y_data, As_data, Bs_data, Cs_data);
+   VALUE result = rb_ary_new2(5);
+   rb_ary_store(result, 0, Xs);
+   rb_ary_store(result, 1, Ys);
+   rb_ary_store(result, 2, As);
+   rb_ary_store(result, 3, Bs);
+   rb_ary_store(result, 4, Cs);
+   return result;
+}
+
+double c_dvector_pm_cubic_interpolate(double x, int nx, 
+    double *Xs, double *Ys, double *As, double *Bs, double *Cs)
+{
+   int j;
+   for (j = 0; j < nx && x >= Xs[j]; j++);
+   if (j == nx) return Ys[j-1];
+   if (j == 0) return Ys[0];
+   j--;
+   double dx = x - Xs[j];
+   return Ys[j] + dx*(Cs[j] + dx*(Bs[j] + dx*As[j]));
+}
+
+PRIVATE
+/*
+ *  call-seq:
+ *     Dvector.pm_cubic_interpolate(x, interpolant)  ->  y
+ *
+ *  Returns the _y_ corresponding to _x_ by pm_cubic interpolation using the _interpolant_
+ *  which was previously created by calling _create_pm_cubic_interpolant_.
+ *  
+ */ 
+VALUE dvector_pm_cubic_interpolate(int argc, VALUE *argv, VALUE klass) {
+   if (argc != 2)
+      rb_raise(rb_eArgError, "wrong # of arguments(%d) for pm_cubic_interpolate", argc);
+   klass = Qnil;
+   VALUE x = argv[0];
+   VALUE interpolant = argv[1];
+   x = rb_Float(x);
+   interpolant = rb_Array(interpolant);
+   if (RARRAY(interpolant)->len != 5)
+      rb_raise(rb_eArgError, "interpolant must be array of length 5 from create_pm_cubic_interpolant");
+   Dvector *Xs = Get_Dvector(rb_ary_entry(interpolant,0));
+   Dvector *Ys = Get_Dvector(rb_ary_entry(interpolant,1));
+   Dvector *As = Get_Dvector(rb_ary_entry(interpolant,2));
+   Dvector *Bs = Get_Dvector(rb_ary_entry(interpolant,3));
+   Dvector *Cs = Get_Dvector(rb_ary_entry(interpolant,4));
+   if (Xs->len <= 0 || Xs->len != Ys->len || Xs->len != Bs->len || Xs->len != Cs->len || Xs->len != As->len)
+      rb_raise(rb_eArgError, "interpolant must be from create_pm_cubic_interpolant");
+   double y = c_dvector_pm_cubic_interpolate(NUM2DBL(x), Xs->len, Xs->ptr, Ys->ptr, As->ptr, Bs->ptr, Cs->ptr);
+   return rb_float_new(y);
+}
+
+
+
+
+
 void c_dvector_create_spline_interpolant(int n_pts_data, double *Xs, double *Ys,
     bool start_clamped, double start_slope, bool end_clamped, double end_slope,
     double *As, double *Bs, double *Cs)
@@ -5319,7 +5485,8 @@ static VALUE dvector_convolve(VALUE self, VALUE kernel, VALUE middle)
   :call-seq:
   Dvector.fast_fancy_read(stream, options) => Array_of_Dvectors
   
-  Reads data from an IO stream and separate it into columns of data
+  Reads data from an IO stream (or anything that supports a gets method)
+  and separate it into columns of data
   according to the _options_, a hash holding the following elements
   (compulsory, but you can use FANCY_READ_DEFAULTS):
   * 'sep': a regular expression that separate the entries
@@ -5333,8 +5500,6 @@ static VALUE dvector_convolve(VALUE self, VALUE kernel, VALUE middle)
 
   As a side note, the read time is highly non-linear, which suggests that
   the read is memory-allocation/copying-limited, at least for big files.
-  Well, the read time is non-linear for 
-
 
   An internal memory allocation with aggressive policy should solve that,
   that is, not using directly Dvectors (and it would be way faster to store
@@ -5534,6 +5699,10 @@ void Init_Dvector() {
    rb_define_singleton_method(cDvector, "read_row", dvector_read_row, -1);
    rb_define_singleton_method(cDvector, "create_spline_interpolant", dvector_create_spline_interpolant, -1);
    rb_define_singleton_method(cDvector, "spline_interpolate", dvector_spline_interpolate, -1);
+
+   rb_define_singleton_method(cDvector, "create_pm_cubic_interpolant", dvector_create_pm_cubic_interpolant, -1);
+   rb_define_singleton_method(cDvector, "pm_cubic_interpolate", dvector_pm_cubic_interpolate, -1);
+
    rb_define_singleton_method(cDvector, "linear_interpolate", dvector_linear_interpolate, -1);
    rb_define_singleton_method(cDvector, "min_of_many", dvector_min_of_many, 1);
    rb_define_singleton_method(cDvector, "max_of_many", dvector_max_of_many, 1);

data/split/Dvector/dvector_intern.h

@@ -135,6 +135,18 @@ PRIVATE double c_dvector_spline_interpolate(double x, int n_pts_data,
     double *Xs, double *Ys, double *Bs, double *Cs, double *Ds);
 PRIVATE VALUE dvector_spline_interpolate(int argc, VALUE *argv, VALUE klass);
 
+
+
+PRIVATE void c_dvector_create_pm_cubic_interpolant(int n_pts_data, double *Xs, double *Ys,
+    double *Bs, double *Cs, double *Ds);
+PRIVATE VALUE dvector_create_pm_cubic_interpolant(int argc, VALUE *argv, VALUE klass);
+    
+PRIVATE double c_dvector_pm_cubic_interpolate(double x, int n_pts_data, 
+    double *Xs, double *Ys, double *Bs, double *Cs, double *Ds);
+PRIVATE VALUE dvector_pm_cubic_interpolate(int argc, VALUE *argv, VALUE klass);
+
+
+
 PRIVATE double c_dvector_linear_interpolate(int num_pts, double *xs, double *ys, double x);
 PRIVATE VALUE dvector_linear_interpolate(int argc, VALUE *argv, VALUE klass);
 

data/split/Dvector/include/dvector.h

@@ -55,15 +55,23 @@ DECLARE_SYMBOL(void, Dvector_Push_Double, (VALUE ary, double val));
 
 
 /* functions for interpolation */
-DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
-	       (double x, int n_pts_data, double *Xs, double *Ys, 
-		double *Bs, double *Cs, double *Ds));
-DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
-	       (int num_pts, double *xs, double *ys, double x));
 DECLARE_SYMBOL(void, c_dvector_create_spline_interpolant,
 	       (int n_pts_data, double *Xs, double *Ys,
 		bool start_clamped, double start_slope, 
 		bool end_clamped, double end_slope,
 		double *As, double *Bs, double *Cs));
+DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+
+DECLARE_SYMBOL(void, c_dvector_create_pm_cubic_interpolant,
+	       (int n_pts_data, double *Xs, double *Ys,
+		double *As, double *Bs, double *Cs));
+DECLARE_SYMBOL(double, c_dvector_pm_cubic_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+
+DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
+	       (int num_pts, double *xs, double *ys, double x));
 #endif   /* __Dvector_H__ */
 

data/split/Dvector/lib/Dvector_extras.rb

@@ -33,9 +33,28 @@ module Dobjects
     #
     #  e = MathEvaluator.new("x*y", "x,y")
     #  e.compute(1,2)         -> 2
+    #
+    # If an exception arises, NaN is returned. Note that compilation
+    # problems will be caught before ;-)...
     def compute(*args)
+      begin
+        return compute_unsafe(*args)
+      rescue
+        return 0.0/0.0
+      end
+    end
+
+    # This function does the actual evaluation with the blocks
+    # given.
+    #
+    #  e = MathEvaluator.new("x*y", "x,y")
+    #  e.compute(1,2)         -> 2
+    # 
+    # No care is taken to intercept exceptions.
+    def compute_unsafe(*args)
       return @block.call(*args)
     end
+
   end
 
   class Dvector

data/split/Function/dvector.h

@@ -55,15 +55,23 @@ DECLARE_SYMBOL(void, Dvector_Push_Double, (VALUE ary, double val));
 
 
 /* functions for interpolation */
-DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
-	       (double x, int n_pts_data, double *Xs, double *Ys, 
-		double *Bs, double *Cs, double *Ds));
-DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
-	       (int num_pts, double *xs, double *ys, double x));
 DECLARE_SYMBOL(void, c_dvector_create_spline_interpolant,
 	       (int n_pts_data, double *Xs, double *Ys,
 		bool start_clamped, double start_slope, 
 		bool end_clamped, double end_slope,
 		double *As, double *Bs, double *Cs));
+DECLARE_SYMBOL(double, c_dvector_spline_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+
+DECLARE_SYMBOL(void, c_dvector_create_pm_cubic_interpolant,
+	       (int n_pts_data, double *Xs, double *Ys,
+		double *As, double *Bs, double *Cs));
+DECLARE_SYMBOL(double, c_dvector_pm_cubic_interpolate,
+	       (double x, int n_pts_data, double *Xs, double *Ys, 
+		double *Bs, double *Cs, double *Ds));
+
+DECLARE_SYMBOL(double, c_dvector_linear_interpolate,
+	       (int num_pts, double *xs, double *ys, double x));
 #endif   /* __Dvector_H__ */
 

data/split/Tioga/axes.c

@@ -20,19 +20,15 @@
    along with Tioga; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
+#include <math.h>
+
 #include "figures.h"
 #include "pdfs.h"
 
+
+
 /* 
    Here is my (Vincent) big TODO-list for the axes stuff:
-   * provide a way to reliably get the location from major/minor
-     ticks for a given axis, so users can build lines/grids that build on
-     top of that (or rather under it ;-)...)
-     -> this is partly done, as you can now get the major ticks position.
-   * let the users choose between the current way to pick up ticks position
-     and another, such as the one I'm using in SciYAG, which seems to give
-     results that are more according to my expectations.
-
    * BUG fix: apparently, two calls to the axes stuff do no return the
      same thing, so I'll need to have a careful look at that
  */
@@ -41,9 +37,17 @@ typedef struct {
    int type;
    int other_axis_type;
    double line_width;
+
+   /* Stroke color... */
    double stroke_color_R;
    double stroke_color_G;
    double stroke_color_B;
+
+   /* Tick labels color */
+   double labels_color_R;
+   double labels_color_G;
+   double labels_color_B;
+
    double major_tick_width; // same units as line_width
    double minor_tick_width; // same units as line_width
    double major_tick_length; // in units of numeric label char heights
@@ -127,6 +131,11 @@ static void Get_xaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    s->stroke_color_R = p->xaxis_stroke_color_R; // for axis line and tick marks
    s->stroke_color_G = p->xaxis_stroke_color_G;
    s->stroke_color_B = p->xaxis_stroke_color_B;
+
+   s->labels_color_R = p->xaxis_labels_color_R; // for axis line and tick marks
+   s->labels_color_G = p->xaxis_labels_color_G;
+   s->labels_color_B = p->xaxis_labels_color_B;
+
    s->major_tick_width = p->xaxis_major_tick_width; // same units as line_width
    s->minor_tick_width = p->xaxis_minor_tick_width; // same units as line_width
    s->major_tick_length = p->xaxis_major_tick_length; // in units of numeric label char heights
@@ -163,9 +172,15 @@ static void Get_yaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    s->type = p->yaxis_type;
    s->other_axis_type = p->xaxis_type;
    s->line_width = p->yaxis_line_width; // for axis line
+
    s->stroke_color_R = p->yaxis_stroke_color_R; // for axis line and tick marks
    s->stroke_color_G = p->yaxis_stroke_color_G;
    s->stroke_color_B = p->yaxis_stroke_color_B;
+
+   s->labels_color_R = p->yaxis_labels_color_R; // for axis line and tick marks
+   s->labels_color_G = p->yaxis_labels_color_G;
+   s->labels_color_B = p->yaxis_labels_color_B;
+
    s->major_tick_width = p->yaxis_major_tick_width; // same units as line_width
    s->minor_tick_width = p->yaxis_minor_tick_width; // same units as line_width
    s->major_tick_length = p->yaxis_major_tick_length; // in units of numeric label char heights
@@ -635,16 +650,21 @@ static double * pick_major_ticks_positions_Vincent(OBJ_PTR fmkr, FM *p,
    double norm_tick_min = tick_min/factor;
    int i;
    
+   /*    printf("axis_min: %g\taxis_max: %g\n", axis_min, axis_max); */
    /* We get the one just above tick_min */
    for(i = 0; i < nb_natural_distances; i++)
       if(natural_distances[i] >= norm_tick_min)
 	 break;
 
+
    *tick = natural_distances[i] * factor;
+/*    printf("norm_tick_min: %g\ttick: %g\ttick_min:%g\n",  */
+/* 	  norm_tick_min, *tick, tick_min); */
    double first_tick = ceil(axis_min /(*tick)) * (*tick);
    double last_tick = floor(axis_max /(*tick)) * (*tick);
    
-   *num_locations = (int)((last_tick - first_tick)/(*tick) + 1);
+   *num_locations = (int)round((last_tick - first_tick)/(*tick));
+   *num_locations += 1;
 
    double *majors = ALLOC_N_double(*num_locations);
    for (i = 0; i < *num_locations; i++)
@@ -831,6 +851,13 @@ static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
 static void show_numeric_label(OBJ_PTR fmkr, FM *p, PlotAxis *s, 
    char *text, int location, double position, double shift, int *ierr)
 { 
+   /* We need a buffer to implement the color */
+   long len = strlen(text) + 100; /* Should be enough overhead ! */
+   char * buffer = ALLOC_N_char(len);
+   snprintf(buffer, len, "\\textcolor[rgb]{%0.2f,%0.2f,%0.2f}{%s}",
+	    s->labels_color_R, s->labels_color_G, s->labels_color_B,
+	    text);
+	    
    if(location == AXIS_FREE_LOCATION) {
       /* We convert the tick position into frame position */
       double x,y, ft_ht = p->default_text_scale * 
@@ -852,7 +879,7 @@ static void show_numeric_label(OBJ_PTR fmkr, FM *p, PlotAxis *s,
 						 ft_ht * ENLARGE * shift);
       }
 
-      c_show_rotated_label(fmkr, p, text, x, y, 
+      c_show_rotated_label(fmkr, p, buffer, x, y, 
 			   s->numeric_label_scale, 
 			   s->numeric_label_angle + angle, 
 			   s->numeric_label_justification, 
@@ -862,9 +889,10 @@ static void show_numeric_label(OBJ_PTR fmkr, FM *p, PlotAxis *s,
    else {
       // position is in figure coords and must be converted to frame coords
       double pos = ((!s->reversed)? (position - s->axis_min) : (s->axis_max - position)) / s->length;
-      c_show_rotated_text(fmkr, p, text, location, shift, pos, 
+      c_show_rotated_text(fmkr, p, buffer, location, shift, pos, 
 			  s->numeric_label_scale, s->numeric_label_angle, s->numeric_label_justification, s->numeric_label_alignment, OBJ_NIL, ierr);
    }
+   free(buffer);
 }
 
 static void draw_numeric_labels(OBJ_PTR fmkr, FM *p, int location, PlotAxis *s, int *ierr)
@@ -1168,6 +1196,40 @@ static int prepare_dict_PlotAxis(OBJ_PTR fmkr, FM *p,
    if(Hash_Has_Key(axis_spec, "minor_tick_length"))
       axis->minor_tick_length = Hash_Get_Double(axis_spec, "minor_tick_length");
 
+   /* Stroke color */
+   if(Hash_Has_Key(axis_spec, "stroke_color") || 
+      Hash_Has_Key(axis_spec, "color")) {
+      OBJ_PTR color = (Hash_Has_Key(axis_spec, "stroke_color") ? 
+		       Hash_Get_Obj(axis_spec, "stroke_color") :
+		       Hash_Get_Obj(axis_spec, "color") );
+      int err;
+      axis->stroke_color_R = Array_Entry_double(color, 0, &err);
+      axis->stroke_color_G = Array_Entry_double(color, 1, &err);
+      axis->stroke_color_B = Array_Entry_double(color, 2, &err);
+   }
+
+   /* Labels color */
+   if(Hash_Has_Key(axis_spec, "labels_color") || 
+      Hash_Has_Key(axis_spec, "color")) {
+      OBJ_PTR color = (Hash_Has_Key(axis_spec, "labels_color") ? 
+		       Hash_Get_Obj(axis_spec, "labels_color") :
+		       Hash_Get_Obj(axis_spec, "color") );
+      int err;
+      axis->labels_color_R = Array_Entry_double(color, 0, &err);
+      axis->labels_color_G = Array_Entry_double(color, 1, &err);
+      axis->labels_color_B = Array_Entry_double(color, 2, &err);
+   }
+
+   /* Log scale: */
+   if(Hash_Has_Key(axis_spec, "log")) {
+      OBJ_PTR val = Hash_Get_Obj(axis_spec, "log");
+      if(val == OBJ_NIL || val == OBJ_FALSE)
+	 axis->log_vals = 0;
+      else
+	 axis->log_vals = 1;
+   }
+   
+
    return 1;
 }
 
@@ -1193,7 +1255,8 @@ void c_show_axis_generic(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec, int *ierr)
 /* 
    This function takes an axis specification (either integer or
    hash) and returns a hash containing the following keys:
-   * 'major' : position of all major ticks
+   * 'major_ticks' : position of all major ticks
+   * 'minor_ticks' : position of all major ticks
    * 'labels' : the names of all labels
    * 'vertical' : if the axis is vertical or horizontal
    * 'line_width' : the line width
@@ -1202,8 +1265,9 @@ void c_show_axis_generic(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec, int *ierr)
    * 'scale', 'shift' and 'angle': the scale, shift and angle of numeric
      labels
    * 'x0', 'y0', 'x1', 'y1': the position of the axis in figure coordinates
-
- */
+   * 'stroke_color': the color to use for drawing lines.
+   * 'labels_color': the color to use for drawing tick labels.
+*/
 OBJ_PTR c_axis_get_information(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec,
 			       int *ierr)
 {
@@ -1219,14 +1283,15 @@ OBJ_PTR c_axis_get_information(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec,
    /* First, major ticks positions */
    prepare_axis_coordinates(fmkr, p, axis.location, &axis, ierr);
    compute_major_ticks(fmkr, p, &axis, ierr);
-   Hash_Set_Obj(hash, "major", Vector_New(axis.nmajors, axis.majors));
+   Hash_Set_Obj(hash, "major_ticks", Vector_New(axis.nmajors, axis.majors));
 
    /* Then, minor ticks positions */
    double * minor;
    long count;
+   OBJ_PTR color;
    minor = get_minor_ticks_location(fmkr, p, &axis, &count);
    if(minor) {
-      Hash_Set_Obj(hash, "minor", Vector_New(count, minor));
+      Hash_Set_Obj(hash, "minor_ticks", Vector_New(count, minor));
       free(minor);
    }
 
@@ -1259,6 +1324,25 @@ OBJ_PTR c_axis_get_information(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec,
    Hash_Set_Double(hash, "y0", axis.y0);
    Hash_Set_Double(hash, "y1", axis.y1);
 
+   /* Log values */
+   Hash_Set_Obj(hash, "log", axis.log_vals ? OBJ_TRUE : OBJ_FALSE);
+
+   /* Stroke color */
+   color = Array_New(3);
+   Array_Store(color, 0, Float_New(axis.stroke_color_R),ierr);
+   Array_Store(color, 1, Float_New(axis.stroke_color_G),ierr);
+   Array_Store(color, 2, Float_New(axis.stroke_color_B),ierr);
+   Hash_Set_Obj(hash, "stroke_color", color);
+
+   /* Tick labels color */
+   color = Array_New(3);
+   Array_Store(color, 0, Float_New(axis.labels_color_R),ierr);
+   Array_Store(color, 1, Float_New(axis.labels_color_G),ierr);
+   Array_Store(color, 2, Float_New(axis.labels_color_B),ierr);
+   Hash_Set_Obj(hash, "labels_color", color);
+
+
+
    free_allocated_memory(&axis);
    return hash;
 }