Передать функцию как статический класс для быстрых чисел в Java

Question

Передать функцию как статический класс для быстрых чисел в 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 );
}

Однако он выдает ошибку: "Не удается найти что-то вроде FAdd", когда я пытаюсь передать его в arrayOp, даже если println( FAdd.eval(10,20)) работает нормально. Поэтому кажется, что по какой-то причине статический класс просто невозможно передать в качестве параметра.

Что вы рекомендуете для решения такой задачи? Я действительно хочу, чтобы FAdd был чем-то вроде макроса, а не arrayOp быть полиморфным (поведение зависит от того, какой макрос я передаю). Но идеально было бы, если бы это было разрешено во время компиляции (не во время выполнения), чтобы улучшить числовую скорость. Скомпилированный результат должен быть таким же, как если бы я написал

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

0

java function static numerics

Источник

user1291544 15 янв '13 в 13:35

6 ответов

Другие вопросы по тегам java function static numerics

user823393 15 янв '13 в 13:40 2013-01-15 13:40 · Answer 1 · 2013-01-15 13:40

Рассматривали ли вы использование перечислений?

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]

user844759 15 янв '13 в 13:43 2013-01-15 13:43 · Answer 2 · 2013-01-15 13:43

На самом деле вы хотите добиться функциональности анонимной функции или лямбда-выражения, которые есть в JSR 335 (лямбда-выражения для языка программирования Java) и будут доступны в Java 8. В настоящее время только анонимный внутренний класс близок к этому. Этот вопрос ( что является ближайшим заменителем указателя на функцию в Java?) В stackru может помочь вам.

user256196 15 янв '13 в 13:55 2013-01-15 13:55 · Answer 3 · 2013-01-15 13:55

Статические методы не могут быть переопределены, но вы можете сделать это с анонимным классом:

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

Обратите внимание, что объявление метода в eval() в Function2 не является статическим.

user84378 15 янв '13 в 13:54 2013-01-15 13:54 · Answer 4 · 2013-01-15 13:54

Вы делаете серьезные предположения, что самый быстрый код будет только в том случае, если это последний статический метод. Скорее всего, вы ошибаетесь, и вам следует сосредоточиться на правильной архитектуре и тестировании производительности.

Один из методов - использование противника, как указано выше. Я бы сказал, что вам нужно сделать, это иметь интерфейс с функцией eval. Затем вы можете передать реализацию интерфейса.

Java VM поймет, оптимизировать этот код соответствующим образом.

user1291544 16 янв '13 в 11:05 2013-01-16 11:05 · Answer 5 · 2013-01-16 11:05

Я провел несколько тестов, и кажется, что на самом деле нет необходимости пытаться оптимизировать его на современных машинах.

Машина 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]

но для поплавка 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 Runtime Environment (сборка 1.6.0_12-ea-b02)", Java HotSpot(TM) 64-разрядная серверная виртуальная машина (сборка 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] " );

user987519 15 янв '13 в 13:53 2013-01-15 13:53 · Answer 6 · 2013-01-15 13:53

Вы фактически смешиваете экземпляры и классы в своей реализации. Когда у вас есть метод, объявленный так:

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 представил действительно хорошее решение вашей проблемы. Подумайте об этом.