public abstract class MathFP
{
private static int _fbits = 12;
private static int _digits = 4;
private static int _one = 4096;
private static int _fmask = 4095;
private static int _dmul = 10000;
private static int _flt = 0;
private static int _pi = 12868;
private static int[] e = { _one, 11134, 30266, 82270, 223636 };
public static int PI = _pi;
public static int E = e[1];
public static final int MAX_VALUE = 2147483647;
public static final int MIN_VALUE = -2147483647;
public static int setPrecision(int paramInt)
{
if ((paramInt > 12) || (paramInt < 0))
return _digits;
_fbits = paramInt;
_one = 1 << paramInt;
_flt = 12 - paramInt;
_digits = 0;
_dmul = 1;
_fmask = _one - 1;
PI = _pi >> _flt;
E = e[1] >> _flt;
int i = _one;
while (i != 0)
{
i /= 10;
_digits += 1;
_dmul *= 10;
}
return _digits;
}
public static int getPrecision()
{
return _fbits;
}
public static int toInt(int paramInt)
{
paramInt = round(paramInt, 0);
return (paramInt >> _fbits);
}
public static int toFP(int paramInt)
{
return (paramInt << _fbits);
}
public static int convert(int paramInt1, int paramInt2)
{
int i = (paramInt1 < 0) ? -1 : 1;
if (abs(paramInt2) < 13)
if (_fbits < paramInt2)
paramInt1 = paramInt1 + i * (1 << paramInt2 - _fbits >> 1) >> paramInt2 - _fbits;
else
paramInt1 <<= _fbits - paramInt2;
return paramInt1;
}
public static int toFP(String paramString)
{
int i = 0;
if (paramString.charAt(0) == '-')
i = 1;
String str = "-1";
int j = paramString.indexOf(46);
if (j >= 0)
{
for (str = paramString.substring(j + 1, paramString.length()); str.length() < _digits; str = str + "0");
if (str.length() > _digits)
str = str.substring(0, _digits);
}
else
{
j = paramString.length();
}
int k = 0;
if (i != j)
k = Integer.parseInt(paramString.substring(i, j));
int l = Integer.parseInt(str) + 1;
int i1 = (k << _fbits) + (l << _fbits) / _dmul;
if (i == 1)
i1 = -i1;
return i1;
}
public static String toString(int paramInt)
{
int i = 0;
if (paramInt < 0)
{
i = 1;
paramInt = -paramInt;
}
int j = paramInt >> _fbits;
int k = _dmul * (paramInt & _fmask) >> _fbits;
for (String str = Integer.toString(k); str.length() < _digits; str = "0" + str);
return ((i != 0) ? "-" : "") + Integer.toString(j) + "." + str;
}
public static String toString(int paramInt1, int paramInt2)
{
if (paramInt2 > _digits)
paramInt2 = _digits;
String str = toString(round(paramInt1, paramInt2));
return str.substring(0, str.length() - _digits + paramInt2);
}
public static int max(int paramInt1, int paramInt2)
{
return ((paramInt1 < paramInt2) ? paramInt2 : paramInt1);
}
public static int min(int paramInt1, int paramInt2)
{
return ((paramInt2 < paramInt1) ? paramInt2 : paramInt1);
}
public static int round(int paramInt1, int paramInt2)
{
int i = 10;
for (int j = 0; j < paramInt2; ++j)
i *= 10;
i = div(toFP(5), toFP(i));
if (paramInt1 < 0)
i = -i;
return (paramInt1 + i);
}
public static int mul(int paramInt1, int paramInt2)
{
int i = 0;
int j = _fbits;
int k = _fmask;
if ((paramInt1 & k) == 0)
return ((paramInt1 >> j) * paramInt2);
if ((paramInt2 & k) == 0)
return (paramInt1 * (paramInt2 >> j));
if (((paramInt1 < 0) && (paramInt2 > 0)) || ((paramInt1 > 0) && (paramInt2 < 0)))
i = 1;
if (paramInt1 < 0)
paramInt1 = -paramInt1;
if (paramInt2 < 0)
paramInt2 = -paramInt2;
while (max(paramInt1, paramInt2) >= 1 << 31 - --j)
{
paramInt1 >>= 1;
paramInt2 >>= 1;
k >>= 1;
}
int l = (paramInt1 >> j) * (paramInt2 >> j) << j;
int i1 = (paramInt1 & k) * (paramInt2 & k) >> j;
i1 += ((paramInt1 & (k ^ 0xFFFFFFFF)) * (paramInt2 & k) >> j);
l = l + i1 + ((paramInt1 & k) * (paramInt2 & (k ^ 0xFFFFFFFF)) >> j) << _fbits - j;
if (l < 0)
throw new ArithmeticException("Overflow");
return ((i != 0) ? -l : l);
}
public static int div(int paramInt1, int paramInt2)
{
int i = 0;
int j = _fbits;
if (paramInt2 == _one)
return paramInt1;
if ((paramInt2 & _fmask) == 0)
return (paramInt1 / (paramInt2 >> j));
if (((paramInt1 < 0) && (paramInt2 > 0)) || ((paramInt1 > 0) && (paramInt2 < 0)))
i = 1;
if (paramInt1 < 0)
paramInt1 = -paramInt1;
if (paramInt2 < 0)
paramInt2 = -paramInt2;
while (max(paramInt1, paramInt2) >= 1 << 31 - --j)
{
paramInt1 >>= 1;
paramInt2 >>= 1;
}
int k = (paramInt1 << j) / paramInt2 << _fbits - j;
return ((i != 0) ? -k : k);
}
public static int add(int paramInt1, int paramInt2)
{
return (paramInt1 + paramInt2);
}
public static int sub(int paramInt1, int paramInt2)
{
return (paramInt1 - paramInt2);
}
public static int abs(int paramInt)
{
if (paramInt < 0)
return (-paramInt);
return paramInt;
}
public static int sqrt(int paramInt1, int paramInt2)
{
if (paramInt1 < 0)
throw new ArithmeticException("Bad Input");
if (paramInt1 == 0)
return 0;
int i = paramInt1 + _one >> 1;
for (int j = 0; j < paramInt2; ++j)
i = i + div(paramInt1, i) >> 1;
if (i < 0)
throw new ArithmeticException("Overflow");
return i;
}
public static int sqrt(int paramInt)
{
return sqrt(paramInt, 16);
}
public static int sin(int paramInt)
{
int i = mul(paramInt, div(toFP(180), PI));
i %= toFP(360);
if (i < 0)
i = toFP(360) + i;
int j = i;
if ((i >= toFP(90)) && (i < toFP(270)))
j = toFP(180) - i;
else if ((i >= toFP(270)) && (i < toFP(360)))
j = -(toFP(360) - i);
int k = j / 90;
int l = mul(k, k);
int i1 = mul(mul(mul(mul(-18 >> _flt, l) + (326 >> _flt), l) - (2646 >> _flt), l) + (6434 >> _flt), k);
return i1;
}
public static int asin(int paramInt)
{
if (abs(paramInt) > _one)
throw new ArithmeticException("Bad Input");
int i = (paramInt < 0) ? 1 : 0;
if (paramInt < 0)
paramInt = -paramInt;
int j = mul(mul(mul(mul(35 >> _flt, paramInt) - (146 >> _flt), paramInt) + (347 >> _flt), paramInt) - (877 >> _flt), paramInt) + (6434 >> _flt);
int k = PI / 2 - mul(sqrt(_one - paramInt), j);
return ((i != 0) ? -k : k);
}
public static int cos(int paramInt)
{
return sin(PI / 2 - paramInt);
}
public static int acos(int paramInt)
{
return (PI / 2 - asin(paramInt));
}
public static int tan(int paramInt)
{
return div(sin(paramInt), cos(paramInt));
}
public static int cot(int paramInt)
{
return div(cos(paramInt), sin(paramInt));
}
public static int atan(int paramInt)
{
return asin(div(paramInt, sqrt(_one + mul(paramInt, paramInt))));
}
public static int exp(int paramInt)
{
if (paramInt == 0)
return _one;
int i = (paramInt < 0) ? 1 : 0;
paramInt = abs(paramInt);
int j = paramInt >> _fbits;
int k = _one;
for (int l = 0; l < j / 4; ++l)
k = mul(k, e[4] >> _flt);
if (j % 4 > 0)
k = mul(k, e[(j % 4)] >> _flt);
paramInt &= _fmask;
if (paramInt > 0)
{
int i1 = _one;
int i2 = 0;
int i3 = 1;
for (int i4 = 0; i4 < 16; ++i4)
{
i2 += i1 / i3;
i1 = mul(i1, paramInt);
i3 *= (i4 + 1);
if ((i3 > i1) || (i1 <= 0))
break;
if (i3 <= 0)
break;
}
k = mul(k, i2);
}
if (i != 0)
k = div(_one, k);
return k;
}
public static int log(int paramInt)
{
if (paramInt <= 0)
throw new ArithmeticException("Bad Input");
int i = 0;
int j = 0;
for (int k = 0; paramInt >= _one << 1; ++k)
paramInt >>= 1;
int l = k * (2839 >> _flt);
int i1 = 0;
if (paramInt < _one)
return (-log(div(_one, paramInt)));
paramInt -= _one;
for (int i2 = 1; i2 < 20; ++i2)
{
if (i == 0)
j = paramInt;
else
j = mul(i, paramInt);
if (j == 0)
break;
i1 += ((i2 % 2 == 0) ? -1 : 1) * j / i2;
i = j;
}
return (l + i1);
}
public static int pow(int paramInt1, int paramInt2)
{
int i = (paramInt2 < 0) ? 1 : 0;
int j = _one;
paramInt2 = abs(paramInt2);
int k = paramInt2 >> _fbits;
while (k-- > 0)
j = mul(j, paramInt1);
if (j < 0)
throw new ArithmeticException("Overflow");
if (paramInt1 != 0)
j = mul(j, exp(mul(log(paramInt1), paramInt2 & _fmask)));
else
j = 0;
if (i != 0)
return div(_one, j);
return j;
}
public static int atan2(int paramInt1, int paramInt2)
{
int i = 0;
if (paramInt2 > 0)
{
i = atan(div(paramInt1, paramInt2));
}
else if (paramInt2 < 0)
{
i = ((paramInt2 < 0) ? -PI : PI) - atan(abs(div(paramInt1, paramInt2)));
}
else
{
if ((paramInt2 == 0) && (paramInt1 == 0))
throw new ArithmeticException("Bad Input");
i = ((paramInt2 < 0) ? -PI : PI) / 2;
}
return i;
}
}
分享到：
相关推荐
在Java编程语言中，"工具类"通常指的是包含各种实用方法的类，这些方法可以用于执行常见的编程任务，而无需创建实例。它们通常是静态方法集合，可以被不同类方便地调用，提高了代码的可复用性和效率。下面我们将深入...
主要讲解了System类、Object类、Arrays类、Cloneable接口、IO系统输入输出类及装饰类、IO系统文本读写工具类、IO系统二进制读写工具类、对象序列化工具类、File类及文件搜索工具类、java异常机制及自定义异常类、...
"Java常用工具类汇总"是一个集合了各种实用工具类的资源，旨在方便开发者在处理常见任务时提高效率。这个工具类库覆盖了字符串、文件、数组以及数学等多个方面，同时也提供了相应的API文档，使得开发者能够更好地...
4. **数学计算工具类**：如Apache Commons Math提供了各种数学计算，包括统计、矩阵、随机数生成等。 5. **IO工具类**：Java的java.io包基础功能，以及Apache Commons IO提供了更多高级操作，如文件复制、读写、流...
day08_18_数学工具类Math
在Java编程语言中，工具类（Utility Class）是包含各种静态方法的类，这些方法用于执行特定任务，如数据操作、文件处理、数学计算等。它们通常不包含实例变量，只提供静态方法服务，帮助开发者提高代码的复用性和...
在Java编程语言中，工具类（Utility Classes）是程序员日常工作中不可或缺的一部分，它们提供了一系列静态方法，用于执行特定任务或处理特定数据类型。"java常用开发工具类大全"可能包含了一系列这样的工具类，旨在...
Math: 优化的 math 工具类，经过完整测试。 十三. Reflection: Guava 的 Java 反射机制工具类。 如果文件打开看不到右边的内容，是因为你的操作系统为了安全对下载的chm文件进行了锁定，只需要在打开前右键单击...
在Java编程语言中，工具类（Utility Class）是包含各种静态方法的类，这些方法用于执行特定任务，如数据处理、格式化、计算等。Java提供了丰富的内置工具类，但开发者也经常创建自定义工具类以满足项目需求。标题...
Java语言在设计时就考虑到了代码的复用性和可维护性，因此提供了许多内置的工具类，这些工具类分布在不同的包下，极大地丰富了Java的功能并简化了开发工作。本篇将详细介绍一些Java中常用的工具类及其应用。 一、`...
JavaUtils工具类是Java开发中常见的一类辅助代码集合，它们通常包含各种静态方法，用于简化常见的编程任务，提高开发效率。这篇博文链接（已提供但无法直接访问）可能详细探讨了JavaUtils工具类的设计原则、常用方法...
在Java编程中，工具类（Utility Class）是包含各种静态方法的类，这些方法用于执行特定的、重复的任务，而不需实例化对象。本压缩包提供了27个常用的Java工具类，涵盖了编码解码、安全加密、日期时间处理、文件操作...
Java工具类库是Java开发中的重要组成部分，它们提供了一系列预定义的函数，帮助开发者更高效地处理各种常见任务。在Java中，工具类通常被组织在各种不同的包下，如`java.util`、`java.lang`、`java.io`等。这些工具...
这个压缩包“C#基础类 常用类 常用方法源码 .NET 工具类 源码”包含了C#编程中的基础类和常用工具类的源代码，对于学习和理解C#的编程实践非常有帮助。下面，我们将详细探讨这些关键知识点。 1. **基础类**：在C#中...
这样的设计使得工具类不需实例化就可以直接调用方法，如`Math`类中的`Add`或`Max`等。工具类常用于封装一些简单的、独立的操作，比如字符串处理、日期时间操作、数学计算等。在C#中，创建工具类时，应避免包含状态...
Java工具类是Java编程语言中一个非常重要的组成部分，它们提供了许多实用的方法，帮助开发者更高效地处理各种编程任务。在Java中，工具类通常被设计为静态方法集合，不依赖于实例化对象，可以直接调用类中的方法进行...
在Java开发中，工具类是程序员经常会用到的代码库，它们提供了许多便捷的方法，以简化常见的编程任务。本文将详细解析"java开发常用工具类"中的关键知识点，包括日历、时间处理、Excel导出、网络请求、流操作、数据...
在Java编程语言中，`java.lang.Math`类提供了一系列用于执行基本数学运算的方法和常量。这个类包含静态方法和常量，使得开发者无需实例化对象即可直接调用其功能，极大地简化了数学计算的过程。 ### 常量 #### ...