---

sxy_series_coef.cpp

Go to the documentation of this file.

// =======================================================================

char* series_coef_cpp = "$Id: sxy_series_coef.cpp,v 1.3 2003/01/17 17:43:13 clinio Exp $";

// =======================================================================

#include <float.h>
#include "sxy_series_coef.h"

// =======================================================================

#define MAX_PARAMETERS 10

// =======================================================================

// .......................................................................
SXYCoeficientsAproximationSeries::SXYCoeficientsAproximationSeries(
unsigned int num_variables, unsigned int buffer_size, 
unsigned int resolution) { 
   // Inicialização do vetor de séries (parâmetros)
   parameters_vector = new SXYVector<SXYSeries*>(MAX_PARAMETERS, NULL);

   // Alocação do buffer interno
   max_index = buffer_size;
   num_points = resolution;
   num_coeficients = num_variables;
   buffer_x = new double[max_index];
   buffer_y = new double[max_index];
   coeficients = new double[num_coeficients];
   has_manual_limit = 0;

   assert(buffer_x && buffer_y && coeficients);
   resetCoeficients();
}

// .......................................................................
SXYCoeficientsAproximationSeries::~SXYCoeficientsAproximationSeries(void) {
   if (parameters_vector != NULL) delete parameters_vector;
   parameters_vector = NULL;

   delete[] buffer_x;
   delete[] buffer_y;
   delete[] coeficients;

   buffer_x = NULL;
   buffer_y = NULL;
   coeficients = NULL;
}

// .......................................................................
unsigned int SXYCoeficientsAproximationSeries::getNumPoints(void) {
   return num_points;
}

// .......................................................................

unsigned int SXYCoeficientsAproximationSeries::fillBuffer(void) {
   // Valores extremos dos pontos das séries de entrada (parâmetros)
   // que serão aquisitados no loop de preenchimento abaixo.
   double minx = FLT_MAX;
   double maxx = -FLT_MAX;

   unsigned int is_log_x = isLogXCallback();
   unsigned int is_log_y = isLogYCallback();
   // Loop de preenchimento dos buffers de cálculo (pontos)
   unsigned int index = 0;
   for (unsigned int p = 0; p < getNumParameters(); p++) {
      SXYSeries* serie = getParameter(p);
      unsigned int np = serie->getNumPoints();
      for (unsigned int i = 0; i < np; i++) {
         assert( index < getBufferSize() );
         double vx, vy;
         unsigned int has_point = serie->getPoint(i, vx, vy);
         unsigned int is_correct = is_log_x ? vx > 1e-15 : 1; 
         is_correct &= is_log_y ? vy > 1e-15 : 1; 
         if (has_point && is_correct) {
            vx = is_log_x ? log10(vx) : vx;
            vy = is_log_y ? log10(vy) : vy;

            buffer_x[index] = vx;
            buffer_y[index] = vy;
            if (vx < minx) minx = vx;
            if (vx > maxx) maxx = vx;
            index++;
         }
      }
   }
   return index;
}

// .......................................................................
unsigned int SXYCoeficientsAproximationSeries::getPoint(unsigned int n, 
double& x, double& y) {
   // Testes para instrumentação 
   if (n < 0) return 0;

   // Cálculo dos coeficiente A e B da equação: y = A.x + B
   if (n == 0) {
      resetCoeficients();
      unsigned int index = fillBuffer();
      assert(index < getBufferSize() );
      if (!calculateCoeficients(index, buffer_x, buffer_y)) {
         resetCoeficients();
         return 0;
      }
   }

   unsigned int is_log_x = isLogXCallback();
   unsigned int is_log_y = isLogYCallback();

   // Utilizando os extremos valores calculados no loop para achar
   // um limite para a reta
   double _lxmin, _lxmax, _lymin, _lymax;
   getLimits(_lxmin, _lxmax, _lymin, _lymax);
   _lxmin = is_log_x ? log10(_lxmin) : _lxmin;
   _lxmax = is_log_x ? log10(_lxmax) : _lxmax;
   _lymin = is_log_y ? log10(_lymin) : _lymin;
   _lymax = is_log_y ? log10(_lymax) : _lymax;

   double dx = (_lxmax - _lxmin) / (getNumPoints() - 1); 
   x = _lxmin + dx*n; 
   if ( !aproxFunctionCallback(x, y) ) return 0;
   x = is_log_x ? pow(10,x) : x;
   y = is_log_y ? pow(10,y) : y;
   return 1;
}

// .......................................................................

unsigned int SXYCoeficientsAproximationSeries::getNumCoeficients(void) const {
   return num_coeficients;
}

// .......................................................................

void SXYCoeficientsAproximationSeries::resetCoeficients( void ) {
   for (unsigned int c = 0; c < getNumCoeficients(); c++) 
      coeficients[c] = SXYSeries::getAnInvalidNumber();
}

// .......................................................................
void SXYCoeficientsAproximationSeries::insertParameter(SXYSeries* param) {
   assert(param != NULL);
   assert(parameters_vector != NULL);
   parameters_vector->insertElement(param);
}

// .......................................................................
unsigned int SXYCoeficientsAproximationSeries::getNumParameters(void) const {
   if (parameters_vector == NULL) return 0;
   return parameters_vector->getLength();
}

// .......................................................................
SXYSeries* SXYCoeficientsAproximationSeries::getParameter(int i) const {
   assert(parameters_vector != NULL);
   return parameters_vector->getElement(i);
}


// .......................................................................

void SXYCoeficientsAproximationSeries::setCoeficient(unsigned int c, 
double coef) {
   coeficients[c] = coef;
   assert(c < num_coeficients);
}

// .......................................................................
unsigned int SXYCoeficientsAproximationSeries::getCoeficient(unsigned int c, 
double& coef) const {
   coef = coeficients[c];
   assert(c < num_coeficients);
   return SXYSeries::isValidNumber(coef);
}

// .......................................................................
void SXYCoeficientsAproximationSeries::getLog( unsigned int& logx, 
unsigned int& logy ) { 
   logx = isLogXCallback();
   logy = isLogYCallback();
}

// .......................................................................
unsigned int SXYCoeficientsAproximationSeries::getBufferSize(void) const {
   return max_index;
}

// .......................................................................
void SXYCoeficientsAproximationSeries::resetLimits(void) {
   has_manual_limit = 0;
}

// .......................................................................
void SXYCoeficientsAproximationSeries::setLimits( double xmin, double xmax, 
double ymin, double ymax ) {
   lxmin = xmin; lxmax = xmax;
   lymin = ymin; lymax = ymax;
   has_manual_limit = 1;
}

// .......................................................................
void SXYCoeficientsAproximationSeries::getLimits( double& xmin, double& xmax, 
double& ymin, double& ymax ) {
   xmin = lxmin; xmax = lxmax;
   ymin = lymin; ymax = lymax;
   if (has_manual_limit) return;
   SXYSeries::getSeveralLimits(parameters_vector, xmin, xmax, ymin, ymax);
}

// .......................................................................

---

SXY
Tecgraf / PUC-Rio - Computer Graphics Technology Group