Показаны сообщения с ярлыком floating point. Показать все сообщения
Показаны сообщения с ярлыком floating point. Показать все сообщения

3 февраля 2011 г.

Что каждый программист...

...должен знать о плавающей запятой. Увлекся чтением очередной книги из серии. Черт, парни, которые создавали стандарт IEEE 754 -- да они просто гении! Надеюсь, лет через 10-15 я буду способен создавать настолько же продуманные системы.

1 февраля 2011 г.

NaN-ов много, надо это использовать

Сегодня на хабре проскочила замечательная статья Что нужно знать про арифметику с плавающей запятой. Там довольно подробное "человеческое" описание IEEE754, даже немного истории есть. Нет, принципиально нового в ней не так уж много, но все в одном месте, и на русском -- это дорогого стоит. Автору большое спасибо.

Что меня в ней поразило, так это фраза, цитирую:
Неопределенность или NaN (от not a number) – это представление, придуманное для того, чтобы арифметическая операция могла всегда вернуть какое-то не бессмысленное значение. В IEEE754 NaN представлен как число, в котором E=Emax+1, а мантисса не нулевая. Любая операция с NaN возвращает NaN. При желании в мантиссу можно записывать информацию, которую программа сможет интерпретировать. Стандартом это не оговорено и мантисса чаще всего игнорируется.

Что NaN-ов вообще-то много я знал, но что разные NaN-ы можно использовать для передачи каких-то подробностей -- это свежая идея. Нет, конечно, это не для использования в каждодневном программировании, но если есть какая-нибудь часто вызываемая функция, которая возвращает NaN как индикатор "не получилось", то ведь можно вместе с ним передавать, например, конкретную причину. Хотя будет ли это быстрее, чем бросать в таких ситуациях исключение специального типа, с нужной информацией -- вопрос. Нужно потестировать

9 сентября 2009 г.

Почему тригонометрия в джаве медленная?

Нашел интересную статью на тему "почему тригонометрия в джаве медленная"



Вкратце -- тригонометрия медленная, потому что точная. Реализация fsin/fcos на процессорах x86 несовершенна -- редукция больших значений аргумента к диапазону [-Pi/4, Pi/4] имеет высокий порядок погрешности, из-за чего для больших значений аргумента результат может быть очень сильно неточным. Эта ошибка тянется с древнейших времен, и теперь уже стала стандартом. Джава же пытается ее исправить, и делает "правильную" редукцию аргумента самостоятельно, перед тем, как вызвать fsin/fcos. Отсюда и дополнительный оверхенд

16 июля 2009 г.

Float vs Double

Тестировал производительность плавающей запятой в java. Обычно я везде использую double, но пока изучал jbullet заметил, что там вся арифметика на float-ах, и мне стало интересно.

  1. import junit.framework.TestCase;
  2.  
  3. public class FloatVsDoublePerfomance extends TestCase {
  4.     private static final int[] SIZES = new int[]{ 1000, 10000, 100000, 300000 };
  5.     private static final int ITER = 10000;
  6.  
  7.     public void test() {
  8.         for ( int i = 0; i < SIZES.length; i++ ) {
  9.             final int size = SIZES[i];
  10.  
  11.             _testFloat( size );
  12.             System.gc();
  13.             System.gc();
  14.  
  15.             _testDouble( size );
  16.             System.gc();
  17.             System.gc();
  18.         }
  19.     }
  20.  
  21.     private static void _testFloat( final int size ) {
  22.         final float[] arr = createFloatArray( size );
  23.  
  24.         System.out.printf( "float[%d * %d]\n", size, ITER );
  25.         //warm-up -- cache load, etc
  26.         testFloatCompare( arr );
  27.  
  28.  
  29.         long startedAt = System.currentTimeMillis();
  30.         //compare
  31.         for ( int i = 0; i < ITER; i++ ) {
  32.             testFloatCompare( arr );
  33.         }
  34.         System.out.printf( "\tcompare: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  35.  
  36.         //summ
  37.         startedAt = System.currentTimeMillis();
  38.         for ( int i = 0; i < ITER; i++ ) {
  39.             testFloatSumm( arr );
  40.         }
  41.         System.out.printf( "\tsum: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  42.  
  43.         //mul
  44.         startedAt = System.currentTimeMillis();
  45.         for ( int i = 0; i < ITER; i++ ) {
  46.             testFloatMul( arr );
  47.         }
  48.         System.out.printf( "\tmul: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  49.  
  50.         //div
  51.         startedAt = System.currentTimeMillis();
  52.         for ( int i = 0; i < ITER; i++ ) {
  53.             testFloatDiv( arr );
  54.         }
  55.         System.out.printf( "\tdiv: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  56.     }
  57.  
  58.     private static void _testDouble( final int size ) {
  59.         final double[] arr = createDoubleArray( size );
  60.  
  61.         System.out.printf( "double[%d * %d]\n", size, ITER );
  62.         //warm-up -- cache load, etc
  63.         testDoubleCompare( arr );
  64.  
  65.  
  66.         long startedAt = System.currentTimeMillis();
  67.         //compare
  68.         for ( int i = 0; i < ITER; i++ ) {
  69.             testDoubleCompare( arr );
  70.         }
  71.         System.out.printf( "\tcompare: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  72.  
  73.         //summ
  74.         startedAt = System.currentTimeMillis();
  75.         for ( int i = 0; i < ITER; i++ ) {
  76.             testDoubleSumm( arr );
  77.         }
  78.         System.out.printf( "\tsum: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  79.  
  80.         //mul
  81.         startedAt = System.currentTimeMillis();
  82.         for ( int i = 0; i < ITER; i++ ) {
  83.             testDoubleMul( arr );
  84.         }
  85.         System.out.printf( "\tmul: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  86.  
  87.         //div
  88.         startedAt = System.currentTimeMillis();
  89.         for ( int i = 0; i < ITER; i++ ) {
  90.             testDoubleDiv( arr );
  91.         }
  92.         System.out.printf( "\tdiv: %d ms\n", ( System.currentTimeMillis() - startedAt ) );
  93.     }
  94.  
  95.     private static float[] createFloatArray( final int size ) {
  96.         final float[] arr = new float[size];
  97.         for ( int i = 0; i < arr.length; i++ ) {
  98.             arr[i] = ( float )( Math.random() * 100 );
  99.         }
  100.         return arr;
  101.     }
  102.  
  103.     private static void testFloatDiv( final float[] arr ) {
  104.         for ( int i = 0; i < arr.length; i++ ) {
  105.             arr[i] = arr[i] / arr[i];
  106.         }
  107.     }
  108.  
  109.     private static void testFloatMul( final float[] arr ) {
  110.         for ( int i = 0; i < arr.length; i++ ) {
  111.             arr[i] = arr[i] * arr[i];
  112.         }
  113.     }
  114.  
  115.     private static void testFloatSumm( final float[] arr ) {
  116.         for ( int i = 0; i < arr.length; i++ ) {
  117.             arr[i] = arr[i] + arr[i];
  118.         }
  119.     }
  120.  
  121.     private static void testFloatCompare( final float[] arr ) {
  122.         int _ = 0;
  123.         for ( int i = 0; i < arr.length; i++ ) {
  124.             if ( arr[i] < 50 ) {
  125.                 _++;//просто чтобы компилятор не выкинул сравнение
  126.             }
  127.         }
  128.     }
  129.  
  130.  
  131.     private static double[] createDoubleArray( final int size ) {
  132.         final double[] arr = new double[size];
  133.         for ( int i = 0; i < arr.length; i++ ) {
  134.             arr[i] = Math.random() * 100;
  135.         }
  136.         return arr;
  137.     }
  138.  
  139.     private static void testDoubleDiv( final double[] arr ) {
  140.         for ( int i = 0; i < arr.length; i++ ) {
  141.             arr[i] = arr[i] / arr[i];
  142.         }
  143.     }
  144.  
  145.     private static void testDoubleMul( final double[] arr ) {
  146.         for ( int i = 0; i < arr.length; i++ ) {
  147.             arr[i] = arr[i] * arr[i];
  148.         }
  149.     }
  150.  
  151.     private static void testDoubleSumm( final double[] arr ) {
  152.         for ( int i = 0; i < arr.length; i++ ) {
  153.             arr[i] = arr[i] + arr[i];
  154.         }
  155.     }
  156.  
  157.     private static void testDoubleCompare( final double[] arr ) {
  158.         int _ = 0;
  159.         for ( int i = 0; i < arr.length; i++ ) {
  160.             if ( arr[i] < 50 ) {
  161.                 _++;//просто чтобы компилятор не выкинул сравнение
  162.             }
  163.         }
  164.     }
  165. }
* This source code was highlighted with Source Code Highlighter.



тестировал под 1.6.0_14, с опциями -server -XX:+DoEscapeAnalysis -Xmx300m -Xms300m

В итоге, получается, что сложение/умножение примерно в два раза медленнее для double, деление -- примерно на 30%, сравнение мало отличается. Буду теперь для операций, не требующих особой точности, активно использовать float.