git.gag.com Git - debian/openrocket/blob - test/net/sf/openrocket/util/MathUtilTest.java

   1 package net.sf.openrocket.util;
   2
   3 import static java.lang.Double.NaN;
   4 import static java.lang.Math.PI;
   5 import static org.junit.Assert.*;
   6
   7 import org.junit.Test;
   8
   9 public class MathUtilTest {
  10
  11         public static final double EPS = 0.00000000001;
  12
  13         @Test
  14         public void miscMathTest() {
  15
  16                 assertEquals(PI*PI, MathUtil.pow2(PI), EPS);
  17                 assertEquals(PI*PI*PI, MathUtil.pow3(PI), EPS);
  18                 assertEquals(PI*PI*PI*PI, MathUtil.pow4(PI), EPS);
  19
  20                 assertEquals(1.0, MathUtil.clamp(0.9999, 1.0, 2.0), 0);
  21                 assertEquals(1.23, MathUtil.clamp(1.23, 1.0, 2.0), 0);
  22                 assertEquals(2.0, MathUtil.clamp(2 + EPS/100, 1.0, 2.0), 0);
  23
  24                 assertEquals(1.0f, MathUtil.clamp(0.9999f, 1.0f, 2.0f), 0);
  25                 assertEquals(1.23f, MathUtil.clamp(1.23f, 1.0f, 2.0f), 0);
  26                 assertEquals(2.0f, MathUtil.clamp(2.0001f, 1.0f, 2.0f), 0);
  27
  28                 assertEquals(1, MathUtil.clamp(-3, 1, 5));
  29                 assertEquals(3, MathUtil.clamp(3, 1, 5));
  30                 assertEquals(5, MathUtil.clamp(6, 1, 5));
  31
  32                 assertEquals(-1.0, MathUtil.sign(Double.NEGATIVE_INFINITY), EPS);
  33                 assertEquals(-1.0, MathUtil.sign(-100), EPS);
  34                 assertEquals(-1.0, MathUtil.sign(Math.nextAfter(0.0, -1.0)), EPS);
  35                 assertEquals( 1.0, MathUtil.sign(Math.nextUp(0.0)), EPS);
  36                 assertEquals( 1.0, MathUtil.sign(100), EPS);
  37                 assertEquals( 1.0, MathUtil.sign(Double.POSITIVE_INFINITY), EPS);
  38         }
  39
  40         @Test
  41         public void hypotTest() {
  42
  43                 for (int i=0; i<10000; i++) {
  44                         double x = Math.random()*100 - 50;
  45                         double y = Math.random()*i - i/2;
  46                         double z = Math.hypot(x, y);
  47                         assertEquals(z, MathUtil.hypot(x, y), EPS);
  48                 }
  49
  50         }
  51
  52         @Test
  53         public void reduceTest() {
  54
  55                 for (int i=-1000; i<1000; i++) {
  56                         double angle = Math.random() * 2*PI;
  57                         double shift = angle + i*2*PI;
  58                         assertEquals(angle, MathUtil.reduce360(shift), EPS);
  59                 }
  60
  61                 for (int i=-1000; i<1000; i++) {
  62                         double angle = Math.random() * 2*PI - PI;
  63                         double shift = angle + i*2*PI;
  64                         assertEquals(angle, MathUtil.reduce180(shift), EPS);
  65                 }
  66
  67         }
  68
  69         @Test
  70         public void minmaxTest() {
  71                 assertEquals(1.0, MathUtil.min(1.0, Math.nextUp(1.0)), 0);
  72                 assertEquals(1.0, MathUtil.min(1.0, Double.POSITIVE_INFINITY), 0);
  73                 assertEquals(1.0, MathUtil.min(NaN, 1.0), 0);
  74                 assertEquals(1.0, MathUtil.min(1.0, NaN), 0);
  75                 assertEquals(NaN, MathUtil.min(NaN, NaN), 0);
  76
  77                 assertEquals(Math.nextUp(1.0), MathUtil.max(1.0, Math.nextUp(1.0)), 0);
  78                 assertEquals(Double.POSITIVE_INFINITY, MathUtil.max(1.0, Double.POSITIVE_INFINITY), 0);
  79                 assertEquals(1.0, MathUtil.max(NaN, 1.0), 0);
  80                 assertEquals(1.0, MathUtil.max(1.0, NaN), 0);
  81                 assertEquals(NaN, MathUtil.max(NaN, NaN), 0);
  82
  83                 assertEquals(1.0, MathUtil.min(1.0, 2.0, 3.0), 0);
  84                 assertEquals(1.0, MathUtil.min(1.0, NaN, NaN), 0);
  85                 assertEquals(1.0, MathUtil.min(NaN, 1.0, NaN), 0);
  86                 assertEquals(1.0, MathUtil.min(NaN, NaN, 1.0), 0);
  87                 assertEquals(1.0, MathUtil.min(2.0, NaN, 1.0), 0);
  88                 assertEquals(1.0, MathUtil.min(1.0, 2.0, NaN), 0);
  89                 assertEquals(1.0, MathUtil.min(NaN, 2.0, 1.0), 0);
  90
  91                 assertEquals(3.0, MathUtil.max(1.0, 3.0, 2.0), 0);
  92                 assertEquals(1.0, MathUtil.max(1.0, NaN, NaN), 0);
  93                 assertEquals(1.0, MathUtil.max(NaN, 1.0, NaN), 0);
  94                 assertEquals(1.0, MathUtil.max(NaN, NaN, 1.0), 0);
  95                 assertEquals(2.0, MathUtil.max(2.0, NaN, 1.0), 0);
  96                 assertEquals(2.0, MathUtil.max(1.0, 2.0, NaN), 0);
  97                 assertEquals(2.0, MathUtil.max(NaN, 2.0, 1.0), 0);
  98         }
  99
 100         @Test
 101         public void mapTest() {
 102                 assertEquals(1.0, MathUtil.map(1.0, 0.0, 5.0, -1.0, 9.0), EPS);
 103                 assertEquals(7.0, MathUtil.map(1.0, 5.0, 0.0, -1.0, 9.0), EPS);
 104                 assertEquals(7.0, MathUtil.map(1.0, 0.0, 5.0, 9.0, -1.0), EPS);
 105                 assertEquals(6.0, MathUtil.map(6.0, 0.0, 5.0, Math.nextUp(6.0), 6.0), EPS);
 106                 assertEquals(6.0, MathUtil.map(6.0, 0.0, 0.0, Math.nextUp(6.0), 6.0), EPS);
 107                 try {
 108                         MathUtil.map(6.0, 1.0, Math.nextUp(1.0), 1.0, 2.0);
 109                         fail("Should not be reached.");
 110                 } catch (IllegalArgumentException normal) { }
 111
 112                 assertEquals(7.0, MathUtil.map(Math.nextUp(1.0), 0.0, 5.0, 9.0, -1.0), EPS);
 113         }
 114
 115
 116         @Test
 117         public void mapCoordinateTest() {
 118                 assertEquals(new Coordinate(0.8, 2.0, 1.6, 4.0),
 119                                 MathUtil.map(1.0, 0.0, 5.0, new Coordinate(0, 1, 2, 3), new Coordinate(4, 6, 0, 8)));
 120         }
 121
 122
 123         @Test
 124         public void equalsTest() {
 125                 assertTrue(MathUtil.equals(1.0, 1.0 + MathUtil.EPSILON/3));
 126                 assertFalse(MathUtil.equals(1.0, 1.0 + MathUtil.EPSILON*2));
 127                 assertTrue(MathUtil.equals(-1.0, -1.0 + MathUtil.EPSILON/3));
 128                 assertFalse(MathUtil.equals(-1.0, -1.0 + MathUtil.EPSILON*2));
 129
 130                 for (double zero: new double[] { 0.0, MathUtil.EPSILON/10, -MathUtil.EPSILON/10 }) {
 131
 132                         assertTrue(MathUtil.equals(zero, MathUtil.EPSILON/3));
 133                         assertTrue(MathUtil.equals(zero, -MathUtil.EPSILON/3));
 134                         assertFalse(MathUtil.equals(zero, MathUtil.EPSILON*2));
 135                         assertFalse(MathUtil.equals(zero, -MathUtil.EPSILON*2));
 136
 137                         assertTrue(MathUtil.equals(MathUtil.EPSILON/3, zero));
 138                         assertTrue(MathUtil.equals(-MathUtil.EPSILON/3, zero));
 139                         assertFalse(MathUtil.equals(MathUtil.EPSILON*2, zero));
 140                         assertFalse(MathUtil.equals(-MathUtil.EPSILON*2, zero));
 141
 142                 }
 143
 144                 for (double value: new double[] { PI*1e20, -PI*1e20 }) {
 145                         assertTrue("value=" + value, MathUtil.equals(value, value + 1));
 146                         assertTrue("value=" + value, MathUtil.equals(value, Math.nextUp(value)));
 147                         assertTrue("value=" + value, MathUtil.equals(value, value * (1+MathUtil.EPSILON)));
 148                 }
 149
 150                 assertFalse(MathUtil.equals(NaN, 0.0));
 151                 assertFalse(MathUtil.equals(0.0, NaN));
 152                 assertFalse(MathUtil.equals(NaN, NaN));
 153         }
 154
 155 }