Line data    Source code

       1             : /* File: geometry_non_linear_scale.c; Copyright and License: see below */
       2             : 
       3             : #define __STDC_LIMIT_MACROS
       4             : #include "geometry/geometry_non_linear_scale.h"
       5             : #include "u8/u8_trace.h"
       6             : #include "u8/u8_log.h"
       7             : #include <assert.h>
       8             : #include <stdint.h>
       9             : #include <stdbool.h>
      10             : 
      11          14 : void geometry_non_linear_scale_init ( geometry_non_linear_scale_t *this_, double lower_bound, double upper_bound )
      12             : {
      13          14 :     U8_TRACE_BEGIN();
      14          14 :     assert( lower_bound <= upper_bound );
      15             : 
      16          14 :     (*this_).num_points = 2;
      17          14 :     (*this_).location[0] = lower_bound;
      18          14 :     (*this_).order[0] = INT32_MIN;
      19          14 :     (*this_).location[1] = upper_bound;
      20          14 :     (*this_).order[1] = INT32_MAX;
      21             : 
      22          14 :     U8_TRACE_END();
      23          14 : }
      24             : 
      25           5 : void geometry_non_linear_scale_trace ( const geometry_non_linear_scale_t *this_ )
      26             : {
      27           5 :     U8_TRACE_BEGIN();
      28           5 :     assert( (*this_).num_points <= GEOMETRY_NON_LINEAR_SCALE_MAX_POINTS );
      29             : 
      30           5 :     U8_TRACE_INFO( "geometry_non_linear_scale_t" );
      31           5 :     U8_TRACE_INFO_INT( "- num_points:", (*this_).num_points );
      32          17 :     for ( uint32_t pos = 0; pos < (*this_).num_points; pos ++ )
      33             :     {
      34          12 :         U8_TRACE_INFO_INT_INT( "- location-%, order:", (int)((*this_).location[pos]*100.0), (*this_).order[pos] );
      35             :     }
      36             : 
      37           5 :     U8_TRACE_END();
      38           5 : }
      39             : 
      40          34 : u8_error_t geometry_non_linear_scale_add_order ( geometry_non_linear_scale_t *this_, int32_t order )
      41             : {
      42          34 :     U8_TRACE_BEGIN();
      43          34 :     assert( (*this_).num_points <= GEOMETRY_NON_LINEAR_SCALE_MAX_POINTS );
      44          34 :     assert( (*this_).num_points >= 2 );  /* prevent division by zero */
      45          34 :     u8_error_t result = U8_ERROR_NONE;
      46             : 
      47             :     /* check for duplicates and for possible insert position */
      48          34 :     bool duplicate = false;
      49          34 :     uint32_t insert_pos = 0;
      50         570 :     for ( uint32_t pos = 0; pos < (*this_).num_points; pos ++ )
      51             :     {
      52         536 :         if ( order > (*this_).order[pos] )
      53             :         {
      54         501 :             insert_pos = pos+1;
      55             :         }
      56          35 :         else if ( order == (*this_).order[pos] )
      57             :         {
      58           1 :             duplicate = true;
      59           1 :             U8_TRACE_INFO_INT( "duplicate:", order );
      60             :         }
      61             :     }
      62             : 
      63             :     /* insert if possible */
      64          34 :     if ( ! duplicate )
      65             :     {
      66          33 :         if ( (*this_).num_points < GEOMETRY_NON_LINEAR_SCALE_MAX_POINTS )
      67             :         {
      68             :             double lower_bound;
      69             :             double upper_bound;
      70          32 :             lower_bound = (*this_).location[ 0 ];
      71          32 :             upper_bound = (*this_).location[ (*this_).num_points - 1 ];
      72             : 
      73             :             /* insert order value */
      74          64 :             for ( uint32_t pos2 = (*this_).num_points; pos2 > insert_pos; pos2 -- )
      75             :             {
      76          32 :                 (*this_).order[ pos2 ] = (*this_).order[ pos2-1 ];
      77             :             }
      78          32 :             (*this_).order[ insert_pos ] = order;
      79          32 :             (*this_).num_points ++;
      80             : 
      81             :             /* re-location in interval */
      82             :             double interval_width;
      83          32 :             interval_width = ( upper_bound - lower_bound );
      84         564 :             for ( uint32_t pos3 = 0; pos3 < (*this_).num_points; pos3 ++ )
      85             :             {
      86         532 :                 (*this_).location[ pos3 ] = lower_bound + ( (double) pos3 * interval_width ) / (double) ( (*this_).num_points - 1 );
      87             :             }
      88             :         }
      89             :         else
      90             :         {
      91           1 :             U8_LOG_WARNING( "geometry_non_linear_scale_t has not enough points." );
      92           1 :             result = U8_ERROR_ARRAY_BUFFER_EXCEEDED;
      93             :         }
      94             :     }
      95             : 
      96             :     /* check for monotonic increase of order values and location values */
      97             : #ifndef NDEBUG
      98          34 :     assert( (*this_).num_points <= GEOMETRY_NON_LINEAR_SCALE_MAX_POINTS );
      99          34 :     assert( (*this_).num_points >= 2 );
     100         568 :     for ( uint32_t pos2 = 1; pos2 < (*this_).num_points; pos2 ++ )
     101             :     {
     102         534 :         assert( (*this_).order[pos2-1] < (*this_).order[pos2] );
     103         534 :         assert( (*this_).location[pos2-1]-0.000000001 < (*this_).location[pos2] );  /* equal locations are possible if lower_bound == upper_bound */
     104             :     }
     105             : #endif
     106             : 
     107          34 :     U8_TRACE_END_ERR( result );
     108          34 :     return result;
     109             : }
     110             : 
     111             : 
     112             : /*
     113             : Copyright 2016-2025 Andreas Warnke
     114             : 
     115             : Licensed under the Apache License, Version 2.0 (the "License");
     116             : you may not use this file except in compliance with the License.
     117             : You may obtain a copy of the License at
     118             : 
     119             :     http://www.apache.org/licenses/LICENSE-2.0
     120             : 
     121             : Unless required by applicable law or agreed to in writing, software
     122             : distributed under the License is distributed on an "AS IS" BASIS,
     123             : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     124             : See the License for the specific language governing permissions and
     125             : limitations under the License.
     126             : */