1. 06 Dec, 2013 1 commit
  2. 05 May, 2013 1 commit
    • Lorenzo Marcantonio's avatar
      Migrated the interfaces accepting angles to the double type · d00c83cd
      Lorenzo Marcantonio authored
      The plan goes like this:
      - eeschema still uses int in decidegrees
      - all the other things internally use double in decidegrees (or radians
        in temporaries)
      - in pcbnew UI the unit is *still* int in decidegrees
      
      The idea is to have better precision everywhere while keeping the user with int i
      angles. Hopefully, if a fractional angle doesn't come in from the outside, everything
      should *look* like an integer angle (unless I forgot something and it broke)
      
      When the time comes, simply updating the UI for allowing doubles from the user should
      be enough to get arbitrary angles in pcbnew.
      d00c83cd
  3. 04 May, 2013 1 commit
  4. 02 May, 2013 1 commit
  5. 01 May, 2013 1 commit
    • Lorenzo Marcantonio's avatar
      Angle and distances cleanup (preparing for angles in doubles) · 0e903dba
      Lorenzo Marcantonio authored
      - Removed spurious int casts (these are truncated anyway and will break
        doubles)
      
      - Applied the Distance, GetLineLength, EuclideanNorm, DEG2RAD, RAD2DEG
        ArcTangente and NORMALIZE* functions where possible
      
      - ArcTangente now returns double and handles the 0,0 case like atan2, so
        it's no longer necessary to check for it before calling
      
      - Small functions in trigo moved as inline
      0e903dba
  6. 11 Feb, 2013 1 commit
    • Wayne Stambaugh's avatar
      Configuration and compile documentation improvements. · 4d465ec8
      Wayne Stambaugh authored
      * Improve the stable and testing build version option logic.
      * Use CMake FindPythonInterp to configure the Python interpreter.
      * Use Python interpreter to determine the system Python module install
        path if not already defined on the command line.
      * Add header symbol checks for asinh(), acosh(), and atanh().
      * Add test source to check for isinf() which can be defined as a C++template.
      * Replace conditional compile on windows systems for aXXXh() with CMake
        configuration tests.
      * A few minor MSVC compile fixes.
      * Fix incorrect python environment string in fixswigimports.py
      * Create a separate document for KiCad CMake build options.
      * Create a separate how to compile KiCad on Windows document.
      4d465ec8
  7. 06 Feb, 2013 1 commit
  8. 13 Oct, 2012 1 commit
  9. 15 Sep, 2012 1 commit
  10. 03 May, 2012 1 commit
  11. 19 Apr, 2012 1 commit
    • Dick Hollenbeck's avatar
      // Dick Hollenbeck's KiROUND R&D · c24863c0
      Dick Hollenbeck authored
      // This provides better project control over rounding to int from double
      // than wxRound() did.  This scheme provides better logging in Debug builds
      // and it provides for compile time calculation of constants.
      
      
      #include <stdio.h>
      #include <assert.h>
      #include <limits.h>
      
      //-----<KiROUND KIT>------------------------------------------------------------
      
      /**
       * KiROUND
       * rounds a floating point number to an int using
       * "round halfway cases away from zero".
       * In Debug build an assert fires if will not fit into an int.
       */
      
      #if defined( DEBUG )
      
      // DEBUG: a macro to capture line and file, then calls this inline
      
      static inline int KiRound( double v, int line, const char* filename )
      {
          v = v < 0 ? v - 0.5 : v + 0.5;
          if( v > INT_MAX + 0.5 )
          {
              printf( "%s: in file %s on line %d, val: %.16g too ' > 0 ' for int\n", __FUNCTION__, filename, line, v );
          }
          else if( v < INT_MIN - 0.5 )
          {
              printf( "%s: in file %s on line %d, val: %.16g too ' < 0 ' for int\n", __FUNCTION__, filename, line, v );
          }
          return int( v );
      }
      
      #define KiROUND( v )    KiRound( v, __LINE__, __FILE__ )
      
      #else
      
      // RELEASE: a macro so compile can pre-compute constants.
      
      #define KiROUND( v )  int( (v) < 0 ? (v) - 0.5 : (v) + 0.5 )
      
      #endif
      
      
      //-----</KiROUND KIT>-----------------------------------------------------------
      
      // Only a macro is compile time calculated, an inline function causes a static constructor
      // in a situation like this.
      // Therefore the Release build is best done with a MACRO not an inline function.
      int Computed = KiROUND( 14.3 * 8 );
      
      
      int main( int argc, char** argv )
      {
          for( double d = double(INT_MAX)-1;  d < double(INT_MAX)+8;  d += 2.0 )
          {
              int i = KiROUND( d );
      
              printf( "t: %d  %.16g\n", i, d );
          }
      
          return 0;
      }
      c24863c0
  12. 23 Jan, 2012 1 commit
  13. 03 Jan, 2012 1 commit
  14. 31 Dec, 2011 1 commit
  15. 22 Dec, 2011 1 commit
  16. 20 Apr, 2011 1 commit
  17. 11 Dec, 2010 1 commit
  18. 23 Nov, 2009 1 commit
  19. 26 Oct, 2009 1 commit
  20. 29 Aug, 2009 1 commit