001package net.minecraft.util; 002 003import cpw.mods.fml.relauncher.Side; 004import cpw.mods.fml.relauncher.SideOnly; 005import java.util.Random; 006 007public class MathHelper 008{ 009 /** 010 * A table of sin values computed from 0 (inclusive) to 2*pi (exclusive), with steps of 2*PI / 65536. 011 */ 012 private static float[] SIN_TABLE = new float[65536]; 013 014 /** 015 * sin looked up in a table 016 */ 017 public static final float sin(float par0) 018 { 019 return SIN_TABLE[(int)(par0 * 10430.378F) & 65535]; 020 } 021 022 /** 023 * cos looked up in the sin table with the appropriate offset 024 */ 025 public static final float cos(float par0) 026 { 027 return SIN_TABLE[(int)(par0 * 10430.378F + 16384.0F) & 65535]; 028 } 029 030 public static final float sqrt_float(float par0) 031 { 032 return (float)Math.sqrt((double)par0); 033 } 034 035 public static final float sqrt_double(double par0) 036 { 037 return (float)Math.sqrt(par0); 038 } 039 040 /** 041 * Returns the greatest integer less than or equal to the float argument 042 */ 043 public static int floor_float(float par0) 044 { 045 int i = (int)par0; 046 return par0 < (float)i ? i - 1 : i; 047 } 048 049 @SideOnly(Side.CLIENT) 050 051 /** 052 * returns par0 cast as an int, and no greater than Integer.MAX_VALUE-1024 053 */ 054 public static int truncateDoubleToInt(double par0) 055 { 056 return (int)(par0 + 1024.0D) - 1024; 057 } 058 059 /** 060 * Returns the greatest integer less than or equal to the double argument 061 */ 062 public static int floor_double(double par0) 063 { 064 int i = (int)par0; 065 return par0 < (double)i ? i - 1 : i; 066 } 067 068 /** 069 * Long version of floor_double 070 */ 071 public static long floor_double_long(double par0) 072 { 073 long i = (long)par0; 074 return par0 < (double)i ? i - 1L : i; 075 } 076 077 public static float abs(float par0) 078 { 079 return par0 >= 0.0F ? par0 : -par0; 080 } 081 082 /** 083 * Returns the unsigned value of an int. 084 */ 085 public static int abs_int(int par0) 086 { 087 return par0 >= 0 ? par0 : -par0; 088 } 089 090 public static int ceiling_float_int(float par0) 091 { 092 int i = (int)par0; 093 return par0 > (float)i ? i + 1 : i; 094 } 095 096 public static int ceiling_double_int(double par0) 097 { 098 int i = (int)par0; 099 return par0 > (double)i ? i + 1 : i; 100 } 101 102 /** 103 * Returns the value of the first parameter, clamped to be within the lower and upper limits given by the second and 104 * third parameters. 105 */ 106 public static int clamp_int(int par0, int par1, int par2) 107 { 108 return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0); 109 } 110 111 @SideOnly(Side.CLIENT) 112 113 /** 114 * Returns the value of the first parameter, clamped to be within the lower and upper limits given by the second and 115 * third parameters 116 */ 117 public static float clamp_float(float par0, float par1, float par2) 118 { 119 return par0 < par1 ? par1 : (par0 > par2 ? par2 : par0); 120 } 121 122 /** 123 * Maximum of the absolute value of two numbers. 124 */ 125 public static double abs_max(double par0, double par2) 126 { 127 if (par0 < 0.0D) 128 { 129 par0 = -par0; 130 } 131 132 if (par2 < 0.0D) 133 { 134 par2 = -par2; 135 } 136 137 return par0 > par2 ? par0 : par2; 138 } 139 140 @SideOnly(Side.CLIENT) 141 142 /** 143 * Buckets an integer with specifed bucket sizes. Args: i, bucketSize 144 */ 145 public static int bucketInt(int par0, int par1) 146 { 147 return par0 < 0 ? -((-par0 - 1) / par1) - 1 : par0 / par1; 148 } 149 150 @SideOnly(Side.CLIENT) 151 152 /** 153 * Tests if a string is null or of length zero 154 */ 155 public static boolean stringNullOrLengthZero(String par0Str) 156 { 157 return par0Str == null || par0Str.length() == 0; 158 } 159 160 public static int getRandomIntegerInRange(Random par0Random, int par1, int par2) 161 { 162 return par1 >= par2 ? par1 : par0Random.nextInt(par2 - par1 + 1) + par1; 163 } 164 165 public static double getRandomDoubleInRange(Random par0Random, double par1, double par3) 166 { 167 return par1 >= par3 ? par1 : par0Random.nextDouble() * (par3 - par1) + par1; 168 } 169 170 public static double average(long[] par0ArrayOfLong) 171 { 172 long i = 0L; 173 long[] along1 = par0ArrayOfLong; 174 int j = par0ArrayOfLong.length; 175 176 for (int k = 0; k < j; ++k) 177 { 178 long l = along1[k]; 179 i += l; 180 } 181 182 return (double)i / (double)par0ArrayOfLong.length; 183 } 184 185 /** 186 * the angle is reduced to an angle between -180 and +180 by mod, and a 360 check 187 */ 188 public static float wrapAngleTo180_float(float par0) 189 { 190 par0 %= 360.0F; 191 192 if (par0 >= 180.0F) 193 { 194 par0 -= 360.0F; 195 } 196 197 if (par0 < -180.0F) 198 { 199 par0 += 360.0F; 200 } 201 202 return par0; 203 } 204 205 /** 206 * the angle is reduced to an angle between -180 and +180 by mod, and a 360 check 207 */ 208 public static double wrapAngleTo180_double(double par0) 209 { 210 par0 %= 360.0D; 211 212 if (par0 >= 180.0D) 213 { 214 par0 -= 360.0D; 215 } 216 217 if (par0 < -180.0D) 218 { 219 par0 += 360.0D; 220 } 221 222 return par0; 223 } 224 225 /** 226 * parses the string as integer or returns the second parameter if it fails 227 */ 228 public static int parseIntWithDefault(String par0Str, int par1) 229 { 230 int j = par1; 231 232 try 233 { 234 j = Integer.parseInt(par0Str); 235 } 236 catch (Throwable throwable) 237 { 238 ; 239 } 240 241 return j; 242 } 243 244 /** 245 * parses the string as integer or returns the second parameter if it fails. this value is capped to par2 246 */ 247 public static int parseIntWithDefaultAndMax(String par0Str, int par1, int par2) 248 { 249 int k = par1; 250 251 try 252 { 253 k = Integer.parseInt(par0Str); 254 } 255 catch (Throwable throwable) 256 { 257 ; 258 } 259 260 if (k < par2) 261 { 262 k = par2; 263 } 264 265 return k; 266 } 267 268 /** 269 * parses the string as double or returns the second parameter if it fails. 270 */ 271 public static double parseDoubleWithDefault(String par0Str, double par1) 272 { 273 double d1 = par1; 274 275 try 276 { 277 d1 = Double.parseDouble(par0Str); 278 } 279 catch (Throwable throwable) 280 { 281 ; 282 } 283 284 return d1; 285 } 286 287 public static double func_82713_a(String par0Str, double par1, double par3) 288 { 289 double d2 = par1; 290 291 try 292 { 293 d2 = Double.parseDouble(par0Str); 294 } 295 catch (Throwable throwable) 296 { 297 ; 298 } 299 300 if (d2 < par3) 301 { 302 d2 = par3; 303 } 304 305 return d2; 306 } 307 308 static 309 { 310 for (int i = 0; i < 65536; ++i) 311 { 312 SIN_TABLE[i] = (float)Math.sin((double)i * Math.PI * 2.0D / 65536.0D); 313 } 314 } 315}