Platon Technologies
not logged in Login Registration
EnglishSlovak
open source software development celebrating 10 years of open source development! Saturday, October 17, 2026
[BACK] [TXT][DIR] Up to [Platon] / dead / diplomovka / xgrafix / src

Diff for dead/diplomovka/xgrafix/src/xgrescale.c between version 1.1 and 1.2

version 1.1, 2001/09/20 14:12:00 version 1.2, 2002/07/11 23:44:38
Line 67  void RescaleTwoDWindow(WindowType theWin
Line 67  void RescaleTwoDWindow(WindowType theWin
         if (Is_X_Log(theWindow)) {          if (Is_X_Log(theWindow)) {
                 label_Ptr->X_Max = pow(10.0, ceil(log10(max(label_Ptr->X_Max, DBL_MIN))));                  label_Ptr->X_Max = pow(10.0, ceil(log10(max(label_Ptr->X_Max, DBL_MIN))));
                 label_Ptr->X_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->X_Min,                  label_Ptr->X_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->X_Min,
                                                                                         DBL_MIN))));                                                          DBL_MIN))));
         }          }
   
         /****************************/          /****************************/
Line 96  void RescaleTwoDWindow(WindowType theWin
Line 96  void RescaleTwoDWindow(WindowType theWin
         if (Is_Y_Log(theWindow)) {          if (Is_Y_Log(theWindow)) {
                 label_Ptr->Y_Max = pow(10.0, ceil(log10(max(label_Ptr->Y_Max, DBL_MIN))));                  label_Ptr->Y_Max = pow(10.0, ceil(log10(max(label_Ptr->Y_Max, DBL_MIN))));
                 label_Ptr->Y_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Y_Min,                  label_Ptr->Y_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Y_Min,
                                                                                         DBL_MIN))));                                                          DBL_MIN))));
         }          }
 } // }}}  } // }}}
   
 // Function void RescaleVectorDWindow(theWindow, ms, *me, ns, ne) {{{  // Function void RescaleVectorDWindow(theWindow, ms, *me, ns, ne) {{{
 void RescaleVectorDWindow(WindowType theWindow, int *ms, int *me, int *ns,  void RescaleVectorDWindow(WindowType theWindow, int *ms, int *me, int *ns,
                                                 int *ne)                  int *ne)
 {  {
         DataType data_Ptr = theWindow->data;          DataType data_Ptr = theWindow->data;
         LabelType label_Ptr = theWindow->label;          LabelType label_Ptr = theWindow->label;
Line 110  void RescaleVectorDWindow(WindowType the
Line 110  void RescaleVectorDWindow(WindowType the
   
         m = *(data_Ptr->mpoints);          m = *(data_Ptr->mpoints);
         n = *(data_Ptr->npoints);          n = *(data_Ptr->npoints);
           mstart = 0;
           nstart = 0;
           mend   = m - 1;
           nend   = n - 1;
   
   
         /****************************/          /****************************/
         /* AutoRescaling the x-axis */          /* AutoRescaling the x-axis */
   
         if (Is_X_AutoRescale(theWindow)) {          if (Is_X_AutoRescale(theWindow)) {
                 if (n) {                  if (n) {
                         mstart = 0;  
                         mend = m - 1;  
                         label_Ptr->X_Max = label_Ptr->X_Min = VectorX(data_Ptr,0);                          label_Ptr->X_Max = label_Ptr->X_Min = VectorX(data_Ptr,0);
                         for (i = 1; i < m; i++) {                          for (i = 1; i < m; i++) {
                                 label_Ptr->X_Max = max(label_Ptr->X_Max, VectorX(data_Ptr,i));                                  label_Ptr->X_Max = max(label_Ptr->X_Max, VectorX(data_Ptr,i));
Line 128  void RescaleVectorDWindow(WindowType the
Line 131  void RescaleVectorDWindow(WindowType the
                 label_Ptr->X_Min *= label_Ptr->X_Scale;                  label_Ptr->X_Min *= label_Ptr->X_Scale;
         }          }
         else {          else {
                 mstart = 0;  
                 while (VectorX(data_Ptr,mstart) * label_Ptr->X_Scale <                  while (VectorX(data_Ptr,mstart) * label_Ptr->X_Scale <
                                                                 label_Ptr->X_Min - DBL_MIN)                                  label_Ptr->X_Min - DBL_MIN)
                         mstart++;                          mstart++;
                 mend = m - 1;  
                 while (VectorX(data_Ptr,mend) * label_Ptr->X_Scale >                  while (VectorX(data_Ptr,mend) * label_Ptr->X_Scale >
                                                                 label_Ptr->X_Max + DBL_MIN)                                  label_Ptr->X_Max + DBL_MIN)
                         mend--;                          mend--;
         }          }
   
Line 143  void RescaleVectorDWindow(WindowType the
Line 144  void RescaleVectorDWindow(WindowType the
   
         if (Is_Y_AutoRescale(theWindow)) {          if (Is_Y_AutoRescale(theWindow)) {
                 if (m) {                  if (m) {
                         nstart = 0;  
                         nend = n - 1;  
                         label_Ptr->Y_Max = label_Ptr->Y_Min = VectorY(data_Ptr,0);                          label_Ptr->Y_Max = label_Ptr->Y_Min = VectorY(data_Ptr,0);
                         for (i = 1; i < n; i++) {                          for (i = 1; i < n; i++) {
                                 label_Ptr->Y_Max = max(label_Ptr->Y_Max, VectorY(data_Ptr,i));                                  label_Ptr->Y_Max = max(label_Ptr->Y_Max, VectorY(data_Ptr,i));
Line 155  void RescaleVectorDWindow(WindowType the
Line 154  void RescaleVectorDWindow(WindowType the
                 label_Ptr->Y_Min *= label_Ptr->Y_Scale;                  label_Ptr->Y_Min *= label_Ptr->Y_Scale;
         }          }
         else {          else {
                 nstart = 0;  
                 while (VectorY(data_Ptr,nstart) * label_Ptr->Y_Scale <                  while (VectorY(data_Ptr,nstart) * label_Ptr->Y_Scale <
                                                                 label_Ptr->Y_Min - DBL_MIN)                                  label_Ptr->Y_Min - DBL_MIN)
                         nstart++;                          nstart++;
                 nend = n - 1;  
                 while (VectorY(data_Ptr,nend) * label_Ptr->Y_Scale >                  while (VectorY(data_Ptr,nend) * label_Ptr->Y_Scale >
                                                                 label_Ptr->Y_Max + DBL_MIN)                                  label_Ptr->Y_Max + DBL_MIN)
                         nend--;                          nend--;
         }          }
   
Line 173  void RescaleVectorDWindow(WindowType the
Line 170  void RescaleVectorDWindow(WindowType the
   
 // Function void RescaleThreeDWindow(theWindow, ms, me, ns, ne) {{{  // Function void RescaleThreeDWindow(theWindow, ms, me, ns, ne) {{{
 void RescaleThreeDWindow(WindowType theWindow, int *ms, int *me, int *ns,  void RescaleThreeDWindow(WindowType theWindow, int *ms, int *me, int *ns,
                                                 int *ne)                  int *ne)
 {  {
         DataType data_Ptr = theWindow->data;          DataType data_Ptr = theWindow->data;
         LabelType label_Ptr = theWindow->label;          LabelType label_Ptr = theWindow->label;
         int i, j, n, m, mstart, mend, nstart, nend;          int i, j;
           int m, n;
           int mstart, mend, nstart, nend;
   
           m = n = mstart = mend = nstart = nend = 0;
   
         /****************************/          /****************************/
         /* AutoRescaling the x-axis */          /* AutoRescaling the x-axis */
Line 223  void RescaleThreeDWindow(WindowType theW
Line 224  void RescaleThreeDWindow(WindowType theW
         if (Is_X_Log(theWindow)) {          if (Is_X_Log(theWindow)) {
                 label_Ptr->X_Max = pow(10.0, ceil(log10(max(label_Ptr->X_Max, DBL_MIN))));                  label_Ptr->X_Max = pow(10.0, ceil(log10(max(label_Ptr->X_Max, DBL_MIN))));
                 label_Ptr->X_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->X_Min,                  label_Ptr->X_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->X_Min,
                                                                                         DBL_MIN))));                                                          DBL_MIN))));
         }          }
         if (!Is_Scatter(data_Ptr)) {          if (!Is_Scatter(data_Ptr)) {
                 if (Is_Irr_Surf(data_Ptr)) {                  if (Is_Irr_Surf(data_Ptr)) {
                         for (i = 0, j = 0; j < n; j++) {                          for (i = 0, j = 0; j < n; j++) {
                                 while (label_Ptr->X_Min / label_Ptr->X_Scale >                                  while (label_Ptr->X_Min / label_Ptr->X_Scale >
                                                                                 IrregularX(data_Ptr,i,j)                                                  IrregularX(data_Ptr,i,j)
                                                                                 && i < m - 1)                                                  && i < m - 1)
                                         i++;                                          i++;
                                 mstart = i;                                  mstart = i;
                         }                          }
                         for (i = m - 1, j = 0; j < n; j++) {                          for (i = m - 1, j = 0; j < n; j++) {
                                 while (label_Ptr->X_Max / label_Ptr->X_Scale <                                  while (label_Ptr->X_Max / label_Ptr->X_Scale <
                                                                                 IrregularX(data_Ptr,i,j)                                                  IrregularX(data_Ptr,i,j)
                                                                                 && i)                                                  && i)
                                         i--;                                          i--;
                                 mend = i + 1;                                  mend = i + 1;
                         }                          }
                 }                  }
                 else {                  else {
                         mstart = m * (label_Ptr->X_Min / label_Ptr->X_Scale -                          mstart = m * (label_Ptr->X_Min / label_Ptr->X_Scale -
                                                                         SurfaceX(data_Ptr,0)) /                                          SurfaceX(data_Ptr,0)) /
                                 (SurfaceX(data_Ptr,m-1) - SurfaceX(data_Ptr,0)) + .5;                                  (SurfaceX(data_Ptr,m-1) - SurfaceX(data_Ptr,0)) + .5;
                         mend = m * (label_Ptr->X_Max / label_Ptr->X_Scale -                          mend = m * (label_Ptr->X_Max / label_Ptr->X_Scale -
                                                                         SurfaceX(data_Ptr,0)) /                                          SurfaceX(data_Ptr,0)) /
                                 (SurfaceX(data_Ptr,m-1) - SurfaceX(data_Ptr,0));                                  (SurfaceX(data_Ptr,m-1) - SurfaceX(data_Ptr,0));
                 }                  }
                 if (mstart < 0)                  if (mstart < 0)
Line 268  void RescaleThreeDWindow(WindowType theW
Line 269  void RescaleThreeDWindow(WindowType theW
                                 label_Ptr->Y_Max = label_Ptr->Y_Min = ScatterY(data_Ptr,0);                                  label_Ptr->Y_Max = label_Ptr->Y_Min = ScatterY(data_Ptr,0);
                                 for (i = 1; i < n; i++) {                                  for (i = 1; i < n; i++) {
                                         label_Ptr->Y_Max = max(label_Ptr->Y_Max,                                          label_Ptr->Y_Max = max(label_Ptr->Y_Max,
                                                                                         ScatterY(data_Ptr,i));                                                          ScatterY(data_Ptr,i));
                                         label_Ptr->Y_Min = min(label_Ptr->Y_Min,                                          label_Ptr->Y_Min = min(label_Ptr->Y_Min,
                                                                                         ScatterY(data_Ptr,i));                                                          ScatterY(data_Ptr,i));
                                 }                                  }
                                 if (label_Ptr->Y_Max == label_Ptr->Y_Min) return;                                  if (label_Ptr->Y_Max == label_Ptr->Y_Min) return;
                         }                          }
Line 301  void RescaleThreeDWindow(WindowType theW
Line 302  void RescaleThreeDWindow(WindowType theW
         if (Is_Y_Log(theWindow)) {          if (Is_Y_Log(theWindow)) {
                 label_Ptr->Y_Max = pow(10.0, ceil(log10(max(label_Ptr->Y_Max, DBL_MIN))));                  label_Ptr->Y_Max = pow(10.0, ceil(log10(max(label_Ptr->Y_Max, DBL_MIN))));
                 label_Ptr->Y_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Y_Min,                  label_Ptr->Y_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Y_Min,
                                                                                         DBL_MIN))));                                                          DBL_MIN))));
         }          }
         if (!Is_Scatter(data_Ptr)) {          if (!Is_Scatter(data_Ptr)) {
                 if (Is_Irr_Surf(data_Ptr)) {                  if (Is_Irr_Surf(data_Ptr)) {
                         for (j = 0, i = 0; i < m; i++) {                          for (j = 0, i = 0; i < m; i++) {
                                 while (label_Ptr->Y_Min / label_Ptr->Y_Scale >                                  while (label_Ptr->Y_Min / label_Ptr->Y_Scale >
                                                                                 IrregularY(data_Ptr,i,j)                                                  IrregularY(data_Ptr,i,j)
                                                                                 && j < n - 1)                                                  && j < n - 1)
                                         j++;                                          j++;
                                 nstart = j;                                  nstart = j;
                         }                          }
                         for (j = n - 1, i = 0; i < m; i++) {                          for (j = n - 1, i = 0; i < m; i++) {
                                 while (label_Ptr->Y_Max / label_Ptr->Y_Scale <                                  while (label_Ptr->Y_Max / label_Ptr->Y_Scale <
                                                                                 IrregularY(data_Ptr,i,j)                                                  IrregularY(data_Ptr,i,j)
                                                                                 && j)                                                  && j)
                                         j--;                                          j--;
                                 nend = j + 1;                                  nend = j + 1;
                         }                          }
                 }                  }
                 else {                  else {
                         nstart = n * (label_Ptr->Y_Min / label_Ptr->Y_Scale -                          nstart = n * (label_Ptr->Y_Min / label_Ptr->Y_Scale -
                                                                         SurfaceY(data_Ptr,0)) /                                          SurfaceY(data_Ptr,0)) /
                                 (SurfaceY(data_Ptr,n - 1) - SurfaceY(data_Ptr,0)) + .5;                                  (SurfaceY(data_Ptr,n - 1) - SurfaceY(data_Ptr,0)) + .5;
                         nend = n * (label_Ptr->Y_Max / label_Ptr->Y_Scale -                          nend = n * (label_Ptr->Y_Max / label_Ptr->Y_Scale -
                                                                         SurfaceY(data_Ptr,0)) /                                          SurfaceY(data_Ptr,0)) /
                                 (SurfaceY(data_Ptr,n - 1) - SurfaceY(data_Ptr,0));                                  (SurfaceY(data_Ptr,n - 1) - SurfaceY(data_Ptr,0));
                 }                  }
                 if (nstart < 0)                  if (nstart < 0)
Line 367  void RescaleThreeDWindow(WindowType theW
Line 368  void RescaleThreeDWindow(WindowType theW
         if (Is_Z_Log(theWindow)) {          if (Is_Z_Log(theWindow)) {
                 label_Ptr->Z_Max = pow(10.0, ceil(log10(max(label_Ptr->Z_Max, DBL_MIN))));                  label_Ptr->Z_Max = pow(10.0, ceil(log10(max(label_Ptr->Z_Max, DBL_MIN))));
                 label_Ptr->Z_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Z_Min,                  label_Ptr->Z_Min = pow(10.0, floor(0.01 + log10(max(label_Ptr->Z_Min,
                                                                                         DBL_MIN))));                                                          DBL_MIN))));
         }          }
   
         *ms = mstart;          *ms = mstart;
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.2
Platon Group <platon@platon.org> http://platon.org/
Copyright © 2002-2006 Platon Group
Site powered by Metafox CMS 		Go to Top