tioga 1.8 → 1.9

data/split/Flate/symbols.h

@@ -22,7 +22,7 @@ PRIVATE void * rb_import_symbol_no_raise(VALUE module,
 		   
 #define DECLARE_SYMBOL(ret_type,name,args) \
   typedef ret_type (*rb_export_##name##_type) args;\
-  INTERN rb_export_##name##_type name
+  INTERN INTERN_EXTERN rb_export_##name##_type name
 
 #define IMPLEMENT_SYMBOL(name)\
   INTERN rb_export_##name##_type name = 0;

data/split/Function/dvector.h

@@ -31,6 +31,13 @@
 
 /* functions for handling Dvectors: */
 
+DECLARE_SYMBOL(bool, isa_Dvector, (VALUE obj));
+ /* returns true if the obj is a Dvector */
+DECLARE_SYMBOL(long, len_Dvector, (VALUE dvector));
+ /* returns length of the dvector */
+DECLARE_SYMBOL(double, access_Dvector, (VALUE dvector, long idx));
+ /* returns the value of entry idx in dvector */
+
 DECLARE_SYMBOL(double *, Dvector_Data_for_Read, (VALUE dvector, long *len_ptr));
  /* returns pointer to the dvector's data (which may be shared) */
 DECLARE_SYMBOL(double *, Dvector_Data_Copy, (VALUE dvector, long *len_ptr)); 
@@ -46,6 +53,7 @@ DECLARE_SYMBOL(void, Dvector_Store_Double, (VALUE ary, long idx, double val));
 /* pushes one element onto the vector */
 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, 

data/split/Function/function.c

@@ -898,6 +898,8 @@ static VALUE function_primitive(VALUE self)
 /*
   Computes the derivative of the Function and returns it as a new Function.
   The newly created function shares the X vector with the previous one.
+
+  WARNING: this is a very naive 3-points algorithm.
 */
 static VALUE function_derivative(VALUE self)
 {
@@ -906,7 +908,6 @@ static VALUE function_derivative(VALUE self)
   const double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
   VALUE derivative = Dvector_Create();
   long i = 0;
-  double val = 0;
   /* First value */
   Dvector_Push_Double(derivative, (y[i+1] - y[i]) /(x[i+1] - x[i]));
   i++;

data/split/Function/namespace.h

@@ -21,27 +21,35 @@
 #ifndef _NAMESPACE_H
 #define _NAMESPACE_H
 
-/* This header file provides two OS-specific macros for the definition of
-   extern symbols:
+/* This header file provides three OS-specific macros for the definition of
+   extern (or NOT extern) symbols:
 
    * PUBLIC, which has to be used to mark objects that will be used
-   outside the module
+     outside the module
 
-   * PRIVATE, for symbols which are "extern" but intern to the module
+   * INTERN, for symbols which are shared among compilation units within a
+     module, but are NOT exported to other modules.
+
+   * PRIVATE, for symbols which are visible only within the containing
+     compilation unit (i.e. C source file) and, of course, are not exported to
+     other modules.
 
    Please don't add "extern" after the PRIVATE or PUBLIC declaration
    as this would break compilation on Darwin.
 */
 
-#ifdef __APPLE__
+#if __GNUC__ >= 4 /* we have the visibility attribute */
+# define INTERN __attribute__ ((visibility ("hidden")))
+# define PUBLIC __attribute__ ((visibility ("default"))) 
+# define INTERN_EXTERN extern
+#elif defined __APPLE__
 # define INTERN __private_extern__
 # define PUBLIC 
-#elif __GNUC__ >= 4 /* we have the visibility attribute */
-# define INTERN __attribute__ ((visibility ("hidden"))) 
-# define PUBLIC __attribute__ ((visibility ("default"))) 
+# define INTERN_EXTERN
 #else /* not really good */
 # define INTERN
 # define PUBLIC 
+# define INTERN_EXTERN
 #endif /* __APPLE__  and __GNU_C_ >= 4*/
 
 /* In any case, PRIVATE is static */

data/split/Function/symbols.h

@@ -22,7 +22,7 @@ PRIVATE void * rb_import_symbol_no_raise(VALUE module,
 		   
 #define DECLARE_SYMBOL(ret_type,name,args) \
   typedef ret_type (*rb_export_##name##_type) args;\
-  INTERN rb_export_##name##_type name
+  INTERN INTERN_EXTERN rb_export_##name##_type name
 
 #define IMPLEMENT_SYMBOL(name)\
   INTERN rb_export_##name##_type name = 0;

data/split/Tioga/axes.c

@@ -81,6 +81,9 @@ typedef struct {
    int num_minors; // number of minor intervals
    double interval; // tick interval
    int location;
+   bool vincent_or_bill; 	/* True if we use Vincent's algorithm
+				   for picking major ticks
+				*/
 } PlotAxis;
 
 static void figure_moveto(OBJ_PTR fmkr, FM *p, double x, double y, int *ierr) // figure coords
@@ -147,6 +150,8 @@ static void Get_xaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    s->numeric_label_justification = p->xaxis_numeric_label_justification;
    s->numeric_label_frequency = p->xaxis_numeric_label_frequency;
    s->numeric_label_phase = p->xaxis_numeric_label_phase;
+
+   s->vincent_or_bill = p->vincent_or_bill;
 }
 
 static void Get_yaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
@@ -184,6 +189,8 @@ static void Get_yaxis_Specs(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    s->numeric_label_justification = p->yaxis_numeric_label_justification;
    s->numeric_label_frequency = p->yaxis_numeric_label_frequency;
    s->numeric_label_phase = p->yaxis_numeric_label_phase;
+
+   s->vincent_or_bill = p->vincent_or_bill;
 }
 
 /*======================================================================*/
@@ -474,6 +481,42 @@ static char **Get_Labels(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    return labels;
 }
          
+static int Pick_Number_of_Minor_Intervals(double length, int *ierr)
+{
+   double t1, fuzz, newlen;
+   int np, num_subintervals, inewlen;
+   if (length < 10.0 && length > 1.0) {
+      newlen = length;
+   } else {
+      t1 = (double) log10(length);
+      np = (int) floor(t1);
+      t1 -= np;
+      newlen = pow(10.0, t1);
+   }
+   inewlen = (int) floor(newlen + 0.5);
+   fuzz = newlen - inewlen;
+   fuzz = abs(fuzz);
+   num_subintervals = 4;
+   if (fuzz < 1e-2) {
+      switch (inewlen) {
+         case 0: case 1: case 2: num_subintervals = 4; break;
+         case 4: break;
+         case 8: case 10: num_subintervals = 2; break;
+         case 3: case 6: case 9: num_subintervals = 3; break;
+         default: num_subintervals = 5;
+      }
+   } else {
+      if (newlen > 5.0) num_subintervals = 4;
+      else if (newlen > 3.0) num_subintervals = 5;
+      else if (newlen > 1.5) num_subintervals = 5;
+   }
+   return num_subintervals;
+}
+
+/* Refactoring of the axis location picking code */
+
+/* First, Bill's point of view */
+
 static double *Pick_Locations_for_Major_Ticks(double interval, 
    double axis_min, double axis_max, int *num_locations, int *ierr)
 {
@@ -503,34 +546,6 @@ static double *Pick_Locations_for_Major_Ticks(double interval,
    return majors;
 }
 
-static int Pick_Number_of_Minor_Intervals(double length, int *ierr)
-{
-   double t1, fuzz, newlen;
-   int np, num_subintervals, inewlen;
-   t1 = (double) log10(length);
-   np = (int) floor(t1);
-   t1 -= np;
-   newlen = pow(10.0, t1);
-   inewlen = (int) floor(newlen + 0.5);
-   fuzz = newlen - inewlen;
-   fuzz = abs(fuzz);
-   num_subintervals = 4;
-   if (fuzz < 1e-2) {
-      switch (inewlen) {
-         case 0: case 1: case 2: num_subintervals = 4; break;
-         case 4: break;
-         case 8: case 10: num_subintervals = 2; break;
-         case 3: case 6: case 9: num_subintervals = 3; break;
-         default: num_subintervals = 5;
-      }
-   } else {
-      if (newlen > 5.0) num_subintervals = 4;
-      else if (newlen > 3.0) num_subintervals = 5;
-      else if (newlen > 1.5) num_subintervals = 5;
-   }
-   return num_subintervals;
-}
-
 static void Pick_Major_Tick_Interval(OBJ_PTR fmkr, FM *p, 
       double tick_min, double tick_gap, double length, bool log_vals, double *tick, int *ierr)
 {
@@ -569,6 +584,76 @@ static void Pick_Major_Tick_Interval(OBJ_PTR fmkr, FM *p,
    }
 }
 
+static double * pick_major_ticks_positions_Bill(OBJ_PTR fmkr, FM *p, 
+						double axis_min, 
+						double axis_max, 
+						int *num_locations, 
+						double tick_min, 
+						double tick_gap, 
+						double length, 
+						bool log_vals, 
+						double *tick,
+						int *ierr)
+{
+   /* This code is using Bill's initial implementation */
+   Pick_Major_Tick_Interval(fmkr, p, tick_min, tick_gap, 
+			    length, log_vals, tick, ierr);
+   /*    printf("Tick gap: %f, length: %f, tick_min: %f, tick interval: %f\n", */
+   /* 	  tick_gap, length, tick_min, *tick); */
+   if (*ierr != 0) 
+      return NULL;
+   return Pick_Locations_for_Major_Ticks(*tick, axis_min, axis_max, 
+					 num_locations, ierr);
+}
+
+/* Then, Vincent's point of view ;-) ... */
+
+static double natural_distances[] = { 1.0, 2.0, /*2.5,*/ 5.0, 10.0 };
+const int nb_natural_distances = sizeof(natural_distances)/sizeof(double);
+
+static double * pick_major_ticks_positions_Vincent(OBJ_PTR fmkr, FM *p, 
+				   double axis_min, 
+				   double axis_max, 
+				   int *num_locations, 
+				   double tick_min, 
+				   double tick_gap, 
+				   double length, 
+				   bool log_vals, 
+				   double *tick,
+				   int *ierr)
+{
+   /* I like Bill's way of handling log scale */
+   if(log_vals)
+      return pick_major_ticks_positions_Bill(fmkr,p, 
+					     axis_min, axis_max, 
+					     num_locations, tick_min, 
+					     tick_gap, length, log_vals, 
+					     tick, ierr);
+   /* The factor by which you need to divide to get
+      the tick_min within [1,10[ */
+   double factor = pow(10, floor(log10(tick_min)));
+   double norm_tick_min = tick_min/factor;
+   int i;
+   
+   /* 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;
+   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);
+
+   double *majors = ALLOC_N_double(*num_locations);
+   for (i = 0; i < *num_locations; i++)
+      majors[i] = first_tick + (*tick) * i;
+   
+   return majors;
+}
+
+
 /* This functions fills the majors attribute of the PlotAxis object
    with the position of major ticks
 */
@@ -588,10 +673,22 @@ static void compute_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
       double height = ((s->vertical)? p->default_text_height_dy : p->default_text_height_dx);
       double tick_min = s->min_between_major_ticks * height;
       double tick_gap = 10.0 * height;
-      Pick_Major_Tick_Interval(fmkr, p, tick_min, tick_gap, s->length, s->log_vals, &s->interval, ierr);
-      if (*ierr != 0) return;
-      s->majors = Pick_Locations_for_Major_Ticks(s->interval, s->axis_min, s->axis_max, &s->nmajors, ierr);
-      if (*ierr != 0) return;
+
+      s->majors = (s->vincent_or_bill ? 
+		   pick_major_ticks_positions_Vincent(fmkr, p, 
+						      s->axis_min, 
+						      s->axis_max, &s->nmajors,
+						      tick_min, tick_gap, 
+						      s->length, s->log_vals, 
+						      &s->interval, ierr) :
+		   pick_major_ticks_positions_Bill(fmkr, p, s->axis_min, 
+						   s->axis_max, &s->nmajors,
+						   tick_min, tick_gap, 
+						   s->length, s->log_vals, 
+						   &s->interval, ierr));
+
+      if(*ierr || ! s->majors)
+	 return;
       s->free_majors = true;
    }
 }
@@ -626,51 +723,53 @@ static void draw_major_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
    if (did_line) axis_stroke(fmkr,p, ierr);
 }
 
-static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
+static double log_subintervals[8] = {
+   0.301030, 0.477121, 0.602060, 0.698970, 
+   0.778151, 0.845098, 0.903090, 0.954243 };
+
+
+/* A function that returns a double array *TO BE FREED* containing
+   the position of the minor ticks for the given axis.
+
+   The number of ticks is stored in the cnt (long) parameter.
+
+   Returns NULL in case of problems
+*/
+static double * get_minor_ticks_location(OBJ_PTR fmkr, FM *p,
+					 PlotAxis *s, long * cnt)
 {
+   double * target = NULL;
+   int ierr = 0;
+   *cnt = 0;
+ 
+   /* First, pick up the number of ticks to be used */
    if (s->number_of_minor_intervals <= 0) {
       if (s->log_vals) {
          double interval = s->majors[1] - s->majors[0];
          s->number_of_minor_intervals = (abs(interval) != 1.0 || s->nmajors > 10)? 1 : 9; 
       }  else {
-         s->number_of_minor_intervals = Pick_Number_of_Minor_Intervals(s->interval, ierr);
-         if (*ierr != 0) return;
+         s->number_of_minor_intervals = Pick_Number_of_Minor_Intervals(s->interval, &ierr);
+         if (ierr != 0) return NULL;
       }
    }
    int i, j, nsub = s->number_of_minor_intervals;
-   double inside=0.0, outside=0.0, length;
-   bool did_line = false;
-   double log_subintervals[8];
-   log_subintervals[0] = 0.301030;
-   log_subintervals[1] = 0.477121;
-   log_subintervals[2] = 0.602060;
-   log_subintervals[3] = 0.698970;
-   log_subintervals[4] = 0.778151;
-   log_subintervals[5] = 0.845098;
-   log_subintervals[6] = 0.903090;
-   log_subintervals[7] = 0.954243;
+
    if (s->log_vals && nsub > 9) nsub = 9;
-   length = s->minor_tick_length * ((s->vertical)? p->default_text_height_dx : p->default_text_height_dy);
-   if (s->ticks_inside) inside = length;
-   if (s->ticks_outside) outside = -length;
-   if (s->top_or_right) { inside = -inside; outside = -outside; }
-   if (s->line_width != s->minor_tick_width) {
-      c_line_width_set(fmkr, p, s->line_width = s->minor_tick_width, ierr);
-      if (*ierr != 0) return;
-   }
+
+   /* First case: user-supplied position of minor ticks */
    if (s->locations_for_minor_ticks != OBJ_NIL) {
-      long cnt;
-      double *locs = Vector_Data_for_Read(s->locations_for_minor_ticks, &cnt, ierr);
-      if (*ierr != 0) return;
-      for (i=0; i < cnt; i++) {
-         if (s->vertical)
-            figure_join(fmkr, p, s->x0+inside, locs[i], s->x0+outside, locs[i], ierr);
-         else
-            figure_join(fmkr, p, locs[i], s->y0+inside, locs[i], s->y0+outside, ierr);
-         did_line = true;
-         if (*ierr != 0) return;
-      }
+      double *locs = Vector_Data_for_Read(s->locations_for_minor_ticks, 
+					  cnt, &ierr);
+      if (ierr != 0) 
+	 return NULL;
+      target = ALLOC_N_double(*cnt);
+      long i;
+      for(i = 0; i < *cnt; i++)
+	 target[i] = locs[i];
+      return target;
    } else {
+      /* We allocate sligthly more space than should be necessary: */
+      target = ALLOC_N_double(nsub * (s->nmajors + 1));
       for (i=0; i <= s->nmajors; i++) {
          double loc = (i==0)? s->majors[0] - s->interval : s->majors[i-1];
          double next_loc = (i==s->nmajors)? loc + s->interval : s->majors[i];
@@ -680,18 +779,53 @@ static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
             double subloc = loc + ((!s->log_vals) ? (j * subinterval) : log_subintervals[j-1]);
             if (subloc >= next_loc) break;
             if (subloc <= s->axis_min || subloc >= s->axis_max) continue;
-            if (s->vertical) {
-               figure_join(fmkr, p, s->x0+inside, subloc, s->x0+outside, subloc, ierr);
-            }
-            else {
-               figure_join(fmkr, p, subloc, s->y0+inside, subloc, s->y0+outside, ierr);
-            }
-            did_line = true;
-            if (*ierr != 0) return;
+	    
+	    /* We add one */
+	    target[*cnt] = subloc;
+	    (*cnt)++;
          }
       }
+      return target;
    }
-   if (did_line) axis_stroke(fmkr,p, ierr);
+}
+
+
+static void draw_minor_ticks(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr)
+{
+   long number;
+   double * locs = get_minor_ticks_location(fmkr, p, s, &number);
+   if(! locs) {
+      *ierr = 1;
+      return ;
+   }
+   long i;
+   double inside=0.0, outside=0.0, length;
+   bool did_line = false;
+
+   /* Initialization of the various lengths */
+   length = s->minor_tick_length * ((s->vertical)? p->default_text_height_dx : p->default_text_height_dy);
+   if (s->ticks_inside) inside = length;
+   if (s->ticks_outside) outside = -length;
+   if (s->top_or_right) { inside = -inside; outside = -outside; }
+   if (s->line_width != s->minor_tick_width) {
+      c_line_width_set(fmkr, p, s->line_width = s->minor_tick_width, ierr);
+      if (*ierr != 0) return;
+   }
+
+   /* Now, we stroke the ticks */
+   for(i = 0; i < number; i++) {
+      if (s->vertical)
+	 figure_join(fmkr, p, s->x0+inside, locs[i], 
+		     s->x0+outside, locs[i], ierr);
+      else
+	 figure_join(fmkr, p, locs[i], s->y0+inside, locs[i], 
+		     s->y0+outside, ierr);
+      did_line = true;
+   }
+   /* And we free the array returned by get_minor_ticks_location */
+   free(locs);
+   if (did_line) 
+      axis_stroke(fmkr,p, ierr);
 }
 
 static void show_numeric_label(OBJ_PTR fmkr, FM *p, PlotAxis *s, 
@@ -762,7 +896,6 @@ static void free_allocated_memory(PlotAxis *s)
 }
 
 static void c_show_side(OBJ_PTR fmkr, FM *p, PlotAxis *s, int *ierr) {
-   int i;
    if (s->type == AXIS_HIDDEN) return;
    Start_Axis_Standard_State(fmkr, p, 
       s->stroke_color_R, s->stroke_color_G, s->stroke_color_B, 
@@ -1088,6 +1221,15 @@ OBJ_PTR c_axis_get_information(OBJ_PTR fmkr, FM *p, OBJ_PTR axis_spec,
    compute_major_ticks(fmkr, p, &axis, ierr);
    Hash_Set_Obj(hash, "major", Vector_New(axis.nmajors, axis.majors));
 
+   /* Then, minor ticks positions */
+   double * minor;
+   long count;
+   minor = get_minor_ticks_location(fmkr, p, &axis, &count);
+   if(minor) {
+      Hash_Set_Obj(hash, "minor", Vector_New(count, minor));
+      free(minor);
+   }
+
    /* Then, labels */
    ar = Array_New(axis.nmajors);
    axis.labels = Get_Labels(fmkr, p, &axis, ierr);