STL-ified the interpolation table so it is not size limited.

simgear/math/interpolater.cxx

@@ -38,10 +38,18 @@
 
 SG_USING_STD(string);
 
+// Constructor -- starts with an empty table.
+SGInterpTable::SGInterpTable()
+    : size(0)
+{
+}
+
 
 // Constructor -- loads the interpolation table from the specified
 // file
-SGInterpTable::SGInterpTable( const string& file ) {
+SGInterpTable::SGInterpTable( const string& file ) 
+  : size(0)
+{
     SG_LOG( SG_MATH, SG_INFO, "Initializing Interpolator for " << file );
 
     sg_gzifstream in( file );
@@ -50,56 +58,62 @@ SGInterpTable::SGInterpTable( const string& file ) {
 	exit(-1);
     }
 
-    size = 0;
     in >> skipcomment;
     while ( in ) {
-	if ( size < MAX_TABLE_SIZE ) {
+      double ind, dep;
-	    in >> table[size][0] >> table[size][1];
+      in >> ind >> dep;
-	    in >> skipws;
+      in >> skipws;
-	    size++;
+      table.push_back(Entry(ind, dep));
-	} else {
+      size++;
-            SG_LOG( SG_MATH, SG_ALERT,
-		    "fgInterpolateInit(): Exceed max table size = "
-		    << MAX_TABLE_SIZE );
-	    exit(-1);
-	}
     }
 }
 
 
+// Add an entry to the table.
+void SGInterpTable::addEntry (double ind, double dep)
+{
+  table.push_back(Entry(ind,dep));
+  size++;
+}
+
+
 // Given an x value, linearly interpolate the y value from the table
-double SGInterpTable::interpolate(double x) {
+double SGInterpTable::interpolate(double x) const
+{
     int i;
     double y;
 
+    if (size == 0.0)
+      return 0.0;
+
     i = 0;
 
-    while ( (x > table[i][0]) && (i < size) ) {
+    while ( (i < size) && (x > table[i].ind) ) {
-	// cout << "  i = " << i << " table[i][0] = " << table[i][0] << endl;
+	// cout << "  i = " << i << " table[i].ind = " << table[i].ind << endl;
 	// cout << "  size = " << size << endl;
 	i++;
     }
 
     // printf ("i = %d ", i);
 
-    if ( (i == 0) && (x < table[0][0]) ) {
+    if ( (i == 0) && (x < table[0].ind) ) {
 	SG_LOG( SG_MATH, SG_DEBUG, 
 		"interpolate(): lookup error, x to small = " << x );
-	return table[0][1];
+	return table[0].dep;
     }
 
-    // cout << " table[size-1][0] = " << table[size-1][0] << endl;
+    // cout << " table[size-1].ind = " << table[size-1].ind << endl;
-    if ( x > table[size-1][0] ) {
+    if ( x > table[size-1].ind ) {
 	SG_LOG( SG_MATH, SG_DEBUG, 
 		"interpolate(): lookup error, x to big = " << x );
-	return table[size-1][1];
+	return table[size-1].dep;
     }
 
     // y = y1 + (y0 - y1)(x - x1) / (x0 - x1)
-    y = table[i][1] + 
+    y = table[i].dep + 
-	( (table[i-1][1] - table[i][1]) * 
+	( (table[i-1].dep - table[i].dep) * 
-	  (x - table[i][0]) ) /
+	  (x - table[i].ind) ) /
-	(table[i-1][0] - table[i][0]);
+	(table[i-1].ind - table[i].ind);
 
     return(y);
 }

simgear/math/interpolater.hxx

@@ -36,10 +36,12 @@
 
 #include <simgear/compiler.h>
 
+#include <vector>
+SG_USING_STD(vector);
+
 #include STL_STRING
 SG_USING_STD(string);
 
-#define MAX_TABLE_SIZE 32
 
 /**
  * A class that provids a simple linear 2d interpolation lookup table.
@@ -48,23 +50,49 @@ SG_USING_STD(string);
  * variable can be anything.
  */
 class SGInterpTable {
+
+    struct Entry
+    {
+      Entry ()
+	: ind(0.0L), dep(0.0L) {}
+      Entry (double independent, double dependent)
+	: ind(independent), dep(dependent) {}
+      double ind;
+      double dep;
+    };
+
     int size;
-    double table[MAX_TABLE_SIZE][2];
+    vector<Entry> table;
 
 public:
 
+    /**
+     * Constructor. Creates a new, empty table.
+     */
+    SGInterpTable();
+
     /**
      * Constructor. Loads the interpolation table from the specified file.
      * @param file name of interpolation file
      */
     SGInterpTable( const string& file );
 
+
+    /**
+     * Add an entry to the table, extending the table's length.
+     *
+     * @param ind The independent variable.
+     * @param dep The dependent variable.
+     */
+    void addEntry (double ind, double dep);
+    
+
     /**
      * Given an x value, linearly interpolate the y value from the table.
      * @param x independent variable
      * @return interpolated dependent variable
      */
-    double interpolate(double x);
+    double interpolate(double x) const;
 
     /** Destructor */
     ~SGInterpTable();