Generando clases Java con parámetros de valor en tiempo de compilación

Considere una situación en la que una clase implementa el mismo comportamiento básico, métodos, etc., pero podrían existir múltiples versiones diferentes de esa clase para diferentes usos. En mi caso particular, tengo un vector (un vector geométrico, no una lista) y ese vector podría aplicarse a cualquier espacio euclidiano N-dimensional (1 dimensional, 2 dimensional, ...). ¿Cómo se puede definir esta clase / tipo?

Esto sería fácil en C ++, donde las plantillas de clase pueden tener valores reales como parámetros, pero no tenemos ese lujo en Java.

Los dos enfoques que se me ocurren para resolver este problema son:

1. Tener una implementación de cada caso posible en tiempo de compilación.

   public interface Vector {
       public double magnitude();
   }
   
   public class Vector1 implements Vector {
       public final double x;
       public Vector1(double x) {
           this.x = x;
       }
       @Override
       public double magnitude() {
           return x;
       }
       public double getX() {
           return x;
       }
   }
   
   public class Vector2 implements Vector {
       public final double x, y;
       public Vector2(double x, double y) {
           this.x = x;
           this.y = y;
       }
       @Override
       public double magnitude() {
           return Math.sqrt(x * x + y * y);
       }
       public double getX() {
           return x;
       }
       public double getY() {
           return y;
       }
   }
   

   Obviamente, esta solución consume mucho tiempo y es extremadamente tediosa para el código. En este ejemplo, no parece tan malo, pero en mi código real estoy tratando con vectores que tienen múltiples implementaciones cada uno, con hasta cuatro dimensiones (x, y, zyw). Actualmente tengo más de 2.000 líneas de código, aunque cada vector realmente solo necesita 500.

2. Especificar parámetros en tiempo de ejecución.

   public class Vector {
       private final double[] components;
       public Vector(double[] components) {
           this.components = components;
       }
       public int dimensions() {
           return components.length;
       }
       public double magnitude() {
           double sum = 0;
           for (double component : components) {
               sum += component * component;
           }
           return Math.sqrt(sum);
       }
       public double getComponent(int index) {
           return components[index];
       }
   }
   

   Desafortunadamente, esta solución perjudica el rendimiento del código, da como resultado un código más desordenado que la solución anterior y no es tan seguro en el momento de la compilación (no se puede garantizar en el momento de la compilación que el vector con el que está tratando sea realmente bidimensional, por ejemplo).

Actualmente estoy desarrollando en Xtend, por lo que si hay soluciones Xtend disponibles, también serían aceptables.

En casos como este, uso la generación de código.

Escribo una aplicación Java que genera el código real. De esa manera, puede usar fácilmente un bucle for para generar un montón de versiones diferentes. Yo uso JavaPoet , lo que hace que sea bastante sencillo construir el código real. Luego puede integrar la ejecución de la generación de código en su sistema de compilación.

Tengo un modelo muy similar en mi aplicación y nuestra solución fue simplemente mantener un mapa de un tamaño dinámico, similar a su solución 2.

Simplemente no tendrá que preocuparse por el rendimiento con un primitivo java array como ese. Generamos matrices con tamaños de límite superior de 100 columnas (léase: 100 vectores dimensionales) por 10.000 filas, y hemos tenido un buen rendimiento con tipos de vectores mucho más complejos que su solución 2. Puede intentar sellar la clase o los métodos de marcado como final acelerarlo, pero creo que estás optimizando prematuramente.

Puede obtener algunos ahorros en el código (a costa del rendimiento) creando una clase base para compartir su código:

public interface Vector(){

    abstract class Abstract {           
        protected abstract double[] asArray();

        int dimensions(){ return asArray().length; }

        double magnitude(){ 
            double sum = 0;
            for (double component : asArray()) {
                sum += component * component;
            }
            return Math.sqrt(sum);
        }     

        //any additional behavior here   
    }
}

public class Scalar extends Vector.Abstract {
    private double x;

    public double getX(){
        return x;
    }

    @Override
    public double[] asArray(){
        return new double[]{x};
    }
}

public class Cartesian extends Vector.Abstract {

    public double x, y;

    public double getX(){ return x; }
    public double getY(){ return y; }

    @Override public double[] asArray(){ return new double[]{x, y}; }
}

Entonces, por supuesto, si está en Java-8 +, puede usar interfaces predeterminadas para hacer esto aún más estricto:

public interface Vector{

    default public double magnitude(){
        double sum = 0;
        for (double component : asArray()) {
            sum += component * component;
        }
        return Math.sqrt(sum);
    }

    default public int dimensions(){
        return asArray().length;
    }

    default double getComponent(int index){
        return asArray()[index];
    }

    double[] asArray();

    // giving up a little bit of static-safety in exchange for 
    // runtime exceptions, we can implement the getX(), getY() 
    // etc methods here, 
    // and simply have them throw if the dimensionality is too low 
    // (you can of course do this on the abstract-class strategy as well)

    //document or use checked-exceptions to indicate that these methods throw IndexOutOfBounds exceptions (or a wrapped version)

    default public getX(){
        return getComponent(0);
    }
    default public getY(){
        return getComponent(1);
    }
    //...


    }

    //as a general rule, defaulted interfaces should assume statelessness, 
    // so you want to avoid putting mutating operations 
    // as defaulted methods on an interface, since they'll only make your life harder
}

En última instancia, más allá de eso, no tiene opciones con la JVM. Por supuesto, puede escribirlos en C ++ y usar algo como JNA para unirlos; esta es nuestra solución para algunas de las operaciones de matriz rápida, donde usamos fortran e MKL de inteligencia, pero esto solo ralentizará las cosas si simplemente escribe tu matriz en C ++ y llama a sus captadores / establecedores desde java.

Considere una enumeración con cada Vector nombrado que tenga un constructor que consista en una matriz (inicializada en la lista de parámetros con los nombres de dimensión o similar, o tal vez solo un número entero para el tamaño o una matriz de componentes vacía, su diseño) y una lambda para El método getMagnitude. Podría hacer que la enumeración también implemente una interfaz para setComponents / getComponent (s), y simplemente establezca qué componente era cuál en su uso, eliminando getX, et al. Debería inicializar cada objeto con sus valores de componentes reales antes de su uso, posiblemente comprobando que el tamaño de la matriz de entrada coincida con los nombres o el tamaño de la dimensión.

Luego, si extiende la solución a otra dimensión, simplemente modifica la enumeración y lambda.

Según su opción 2, ¿por qué no simplemente hacer esto? Si desea evitar el uso de la base en bruto, puede hacerla abstracta:

class Vector2 extends Vector
{
  public Vector2(double x, double y) {
    super(new double[]{x,y});
  }

  public double getX() {
    return getComponent(0);
  }

  public double getY() {
    return getComponent(1);
  }
}

Una idea:

1. Un vector de clase base abstracto que proporciona implementaciones de dimensión variable basadas en un método getComponent (i).
2. Subclases individuales Vector1, Vector2, Vector3, que cubren los casos típicos, anulando los métodos de Vector.
3. Una subclase de DynVector para el caso general.
4. Métodos de fábrica con listas de argumentos de longitud fija para los casos típicos, declarados para devolver Vector1, Vector2 o Vector3.
5. Un método de fábrica var-args, declarado para devolver Vector, instanciando Vector1, Vector2, Vector3 o DynVector, dependiendo de la longitud del arglista.

Esto le brinda un buen rendimiento en casos típicos y algo de seguridad en tiempo de compilación (aún se puede mejorar) sin sacrificar el caso general.

Esqueleto de código:

public abstract class Vector {
    protected abstract int dimension();
    protected abstract double getComponent(int i);
    protected abstract void setComponent(int i, double value);

    public double magnitude() {
        double sum = 0.0;
        for (int i=0; i<dimension(); i++) {
            sum += getComponent(i) * getComponent(i);
        }
        return Math.sqrt(sum);
    }

    public void add(Vector other) {
        for (int i=0; i<dimension(); i++) {
            setComponent(i, getComponent(i) + other.getComponent(i));
        }
    }

    public static Vector1 create(double x) {
        return new Vector1(x);
    }

    public static Vector create(double... values) {
        switch(values.length) {
        case 1:
            return new Vector1(values[0]);
        default:
            return new DynVector(values);
        }

    }
}

class Vector1 extends Vector {
    private double x;

    public Vector1(double x) {
        super();
        this.x = x;
    }

    @Override
    public double magnitude() {
        return Math.abs(x);
    }

    @Override
    protected int dimension() {
        return 1;
    }

    @Override
    protected double getComponent(int i) {
        return x;
    }

    @Override
    protected void setComponent(int i, double value) {
        x = value;
    }

    @Override
    public void add(Vector other) {
        x += ((Vector1) other).x;
    }

    public void add(Vector1 other) {
        x += other.x;
    }
}

class DynVector extends Vector {
    private double[] values;
    public DynVector(double[] values) {
        this.values = values;
    }

    @Override
    protected int dimension() {
        return values.length;
    }

    @Override
    protected double getComponent(int i) {
        return values[i];
    }

    @Override
    protected void setComponent(int i, double value) {
        values[i] = value;
    }

}