[英]Pass function as static class for fast numerics in Java
我想用Java进行一些数值计算,并使操作真正模块化,我希望将函数作为其他函数的参数传递。 我正在搜索,通常它是通过使用扭曲函数的类在Java中完成的。 我真的不需要实例化这些类(里面没有数据),并且我想使其尽可能快(有人写到最终静态方法由JIT编译器内联)。 所以我做了这样的事情
public static class Function2 {
public static float eval(float a, float b){ return Float.NaN; }
}
public static class FAdd extends Function2 {
public static float eval(float a, float b){ return a+b; }
}
public static class Fmult extends Function2 {
public static float eval(float a, float b){ return a*b; }
}
void arrayOp( float [] a, float [] b, float [] out, Function2 func ){
for (int i=0; i<a.length; i++){ out[i] = func.eval( a[i], b[i] ); }
}
float [] a,b, out;
void setup(){
println( FAdd.eval(10,20) );
arrayOp( a,b, out, FAdd );
}
但是,它会打印错误:即使将println(FAdd.eval(10,20))正常工作,当我尝试将其传递给arrayOp时,也会显示“找不到类似于FAdd的内容”。 因此,由于某种原因,似乎不可能通过静态类作为参数。
您建议解决该任务的是什么? 我实际上希望FAdd像宏一样,nad arrayOp是polymorf(取决于我传入的宏)。 但是理想的情况是在编译时(而不是在运行时)解决该问题以提高数值速度。 编译结果应该和我写的一样
void arrayAdd( float [] a, float [] b, float [] out ){
for (int i=0; i<a.length; i++){ out[i] = a[i] + b[i]; }
}
void arrayMult( float [] a, float [] b, float [] out ){
for (int i=0; i<a.length; i++){ out[i] = a[i] * b[i]; }
}
您是否考虑过使用枚举?
private void test() {
test(3.0f, 4.0f, F.Add);
test(3.0f, 4.0f, F.Sub);
test(3.0f, 4.0f, F.Mul);
test(3.0f, 4.0f, F.Div);
float[] a = {1f, 2f, 3f, 4f, 5f};
float[] b = {4f, 9f, 16f, 25f, 36f};
test(a, b, F.Add);
test(a, b, F.Sub);
test(a, b, F.Mul);
test(a, b, F.Div);
}
private void test(float[] a, float[] b, F f) {
System.out.println(Arrays.toString(a) + " " + f + " " + Arrays.toString(b) + " = " + Arrays.toString(f.f(a, b, f)));
}
private void test(float a, float b, F f) {
System.out.println(a + " " + f + " " + b + " = " + f.f(a, b));
}
public enum F {
Add {
@Override
public float f(float x, float y) {
return x + y;
}
@Override
public String toString() {
return "+";
}
},
Sub {
@Override
public float f(float x, float y) {
return x - y;
}
@Override
public String toString() {
return "-";
}
},
Mul {
@Override
public float f(float x, float y) {
return x * y;
}
@Override
public String toString() {
return "*";
}
},
Div {
@Override
public float f(float x, float y) {
return x / y;
}
@Override
public String toString() {
return "/";
}
};
// Evaluate to a new array.
static float[] f(float[] x, float[] y, F f) {
float[] c = new float[x.length];
for (int i = 0; i < x.length; i++) {
c[i] = f.f(x[i], y[i]);
}
return c;
}
// All must have an f(x,y) method.
public abstract float f(float x, float y);
// Also offer a toString - defaults to the enum name.
@Override
public String toString() {
return this.name();
}
}
印刷品:
3.0 + 4.0 = 7.0
3.0 - 4.0 = -1.0
3.0 * 4.0 = 12.0
3.0 / 4.0 = 0.75
[1.0, 2.0, 3.0, 4.0, 5.0] + [4.0, 9.0, 16.0, 25.0, 36.0] = [5.0, 11.0, 19.0, 29.0, 41.0]
[1.0, 2.0, 3.0, 4.0, 5.0] - [4.0, 9.0, 16.0, 25.0, 36.0] = [-3.0, -7.0, -13.0, -21.0, -31.0]
[1.0, 2.0, 3.0, 4.0, 5.0] * [4.0, 9.0, 16.0, 25.0, 36.0] = [4.0, 18.0, 48.0, 100.0, 180.0]
[1.0, 2.0, 3.0, 4.0, 5.0] / [4.0, 9.0, 16.0, 25.0, 36.0] = [0.25, 0.22222222, 0.1875, 0.16, 0.1388889]
您实际上想要实现的是匿名函数或lambda表达式的功能 ,该功能在JSR 335(Java编程语言的Lambda表达式)中,并且将在Java 8中可用。目前,只有匿名内部类与之接近。 stackoverflow中的这个问题( 在Java中最接近的替代函数指针的地方是什么? )可能会对您有所帮助。
您做出了一个巨大的假设,即最快的代码只有在最终的静态方法中才会生效。 您很可能错了,应该专注于正确地进行架构设计和性能测试。
如上所述,一种方法是使用敌人的方法。 我要说的是您应该做的是与eval函数建立接口。 然后,您可以传入接口的实现。
Java VM将实现适当地优化该代码。
静态方法不能被覆盖,但是您可以使用匿名类来实现:
public static class Function2 {
public float eval(float a, float b){ return Float.NaN; }
}
arrayOp(a, b, out, new Function2() {
public float eval(float a, float b){
return FAdd.eval(a, b);
}});
请注意,Function2中eval()中的方法声明不是静态的。
您实际上是在实现中混合了实例和类。 当您有一个这样声明的方法时:
void arrayOp( float [] a, float [] b, float [] out, Function2 func ){
for (int i=0; i<a.length; i++){ out[i] = func.eval( a[i], b[i] ); }
}
基本上,您是在说您希望使用Function2
类的实例,而不是真正的类参数。 另外,该语句在语法上是不正确的:
arrayOp( a,b, out, FAdd );
因此,假设您要将类本身发送给方法,那么您对arrayOp的声明将类似于:
void arrayOp( float [] a, float [] b, float [] out, Class func ){
当您调用此方法时,将以这种方式传递参数:
arrayOp( a,b, out, FAdd.class );
但是静态方法不能通过继承重写。 您需要完全不同的实现方式来实现目标。 就是说@OldCurmudgeon为您的问题提供了一个非常好的解决方案。 考虑使用它。
我进行了一些测试,似乎确实没有必要尝试在现代计算机上对其进行优化。
机器1-(我的旧家用计算机)32位WinXP,英特尔奔腾3(我不确定Java版本)对于float.mult和float.add这两个操作,静态版本的运行速度都快2倍以上
static 100000000 [ops] 406.0 [s] 4.06 [ns/op]
dynamic 100000000 [ops] 1188.0 [s] 11.88 [ns/op]
但是对于float Sqrt而言,差异已经很小
static 100000000 [ops] 922.0 [s] 9.22 [ns/op]
dynamic 100000000 [ops] 1172.0 [s] 11.719999 [ns/op]
机器2-(我的计算机在工作)-64位ubuntu 12.04LTS,Intel Core5,Java版本“ 1.6.0_12-ea,Java SE运行时环境(内部版本1.6.0_12-ea-b02),Java HotSpot(TM) 64位服务器VM(内部版本11.2-b01,混合模式)结果要好得多(对于float.add):
static 1000000000 [ops] 1747.0 [s] 1.7470001 [ns/op]
dynamic 1000000000 [ops] 1750.0 [s] 1.75 [ns/op]
所以-我认为处理器或JIT已经足够聪明,因此无论如何都不需要优化此功能。
注意:- 静态均值解决方案而不传递函数(我只是手动将操作内联到循环中),-当我将传递函数用作动态对象实例(非静态类)时,采用动态均值解决方案。 JIT似乎知道类内没有动态数据,因此无论如何它都会在编译时解决它。
所以我的动态解决方案很简单:
public class Function2 {
public float eval(float a, float b){ return Float.NaN; }
}
public class FAdd extends Function2 {
public float eval(float a, float b){ return a+b; }
}
public class FMult extends Function2 {
public float eval(float a, float b){ return a*b; }
}
public void arrayOp( float [] a, float [] b, float [] out, Function2 func ){
for (int i=0; i<a.length; i++){ out[i] = func.eval( a[i], b[i] ); }
}
final int m = 100;
final int n = 10000000;
float t1,t2;
float [] a,b, out;
a = new float[n]; b = new float[n]; out = new float[n];
t1 = millis();
Function2 func = new FMult();
for (int i=0;i<m;i++) arrayOp( a,b, out, func );
t2 = millis();
println( " dynamic " +(n*m)+" [ops] "+(t2-t1)+" [s] "+ 1000000*((t2-t1)/(n*m))+" [ns/op] " );
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.