0

我想在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 );
}

然而，当我尝试将它传递给arrayOp时，它会打印错误：“找不到像FAdd这样的东西”，即使println（FAdd.eval（10,20））工作正常。因此，由于某种原因，似乎不可能将静态类作为参数传递。

你有什么建议来解决这样的任务？我实际上希望 FAdd 类似于宏，并且 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];   }
}
4

6 回答 6

4

您是否考虑过使用枚举？

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]
于 2013-01-15T13:40:53.757 回答
1

您要实现的实际上是匿名函数或 lambda 表达式的功能，它在 JSR 335（Java 编程语言的 Lambda 表达式）中，将在 Java 8 中提供。目前，只有匿名内部类接近。stackoverflow中的这个问题（Java 中函数指针的最接近的替代品是什么？ ）可能会对您有所帮助。

于 2013-01-15T13:43:03.427 回答
1

您正在做出一些巨大的假设，即最快的代码只有在它是最终的静态方法时才会是。你很可能是错的，应该专注于正确地构建它并测试性能。

一种方法是使用敌人的，如上所述。我想说你应该做的是与 eval 函数有一个接口。然后，您可以传入接口的实现。

Java VM 将实现对代码的适当优化。

于 2013-01-15T13:54:03.170 回答
1

静态方法不能被覆盖，但您可以使用匿名类来实现：

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() 的方法声明不是静态的。

于 2013-01-15T13:55:17.913 回答
0

我做了一些测试，似乎真的没有必要在现代机器上尝试优化它。

机器 1 -（我的旧家用电脑）32 位 WinXP，Intel Pentium 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(TM) SE 运行时环境（build 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] " );
于 2013-01-16T11:05:04.023 回答
0

您实际上是在实现中混合了实例和类。当你有一个这样声明的方法时：

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] );   }
}

您基本上是在说您期望 class 的实例Function2，而不是真正的 class 参数。此语句在语法上也不正确：

arrayOp( a,b, out, FAdd );

因此，假设您想将类本身发送给一个方法，那么您的 arrayOp 声明将如下所示：

void arrayOp( float [] a, float [] b, float [] out, Class func ){

当你调用这个方法时，你会以这种方式传入参数：

arrayOp( a,b, out, FAdd.class );

但是静态方法不能通过继承覆盖。你需要一个完全不同的实现来实现你的目标。那就是说@OldCurmudgeon 为您的问题提供了一个非常好的解决方案。考虑使用它。

于 2013-01-15T13:53:20.087 回答