Vector3{{E}}.java.peb

package org.spongepowered.math.vector;

import java.io.Serializable;
import java.lang.Override;
import java.util.Random;

import com.google.errorprone.annotations.Immutable;
import org.spongepowered.math.GenericMath;

@Immutable
public final class Vector3{{ E }} implements Vector{{ E }}, Comparable<Vector3{{ E }}>, Serializable {

    private static final long serialVersionUID = 1;
    public static final Vector3{{ E }} ZERO = new Vector3{{ E }}(0, 0, 0);
    public static final Vector3{{ E }} UNIT_X = new Vector3{{ E }}(1, 0, 0);
    public static final Vector3{{ E }} UNIT_Y = new Vector3{{ E }}(0, 1, 0);
    public static final Vector3{{ E }} UNIT_Z = new Vector3{{ E }}(0, 0, 1);
    public static final Vector3{{ E }} ONE = new Vector3{{ E }}(1, 1, 1);
    public static final Vector3{{ E }} RIGHT = Vector3{{ E }}.UNIT_X;
    public static final Vector3{{ E }} UP = Vector3{{ E }}.UNIT_Y;
    public static final Vector3{{ E }} FORWARD = Vector3{{ E }}.UNIT_Z;
    private final {{ e }} x;
    private final {{ e }} y;
    private final {{ e }} z;
    @SuppressWarnings("Immutable")
    private transient volatile boolean hashed = false;
    @SuppressWarnings("Immutable")
    private transient volatile int hashCode = 0;

    public Vector3{{ E }}(final Vector2{{ E }} v) {
        this(v, 0);
    }

    public Vector3{{ E }}(final Vector2{{ E }} v, final {{ EOverload }} z) {
        this(v, {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }}(final Vector2{{ E }} v, final {{ e }} z) {
        this(v.x(), v.y(), z);
    }

    public Vector3{{ E }}(final Vector4{{ E }} v) {
        this(v.x(), v.y(), v.z());
    }

    public Vector3{{ E }}(final VectorN{{ E }} v) {
        this(v.get(0), v.get(1), v.size() > 2 ? v.get(2) : 0);
    }

    public Vector3{{ E }}(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        this({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }}(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        this.x = x;
        this.y = y;
        this.z = z;
    }

    public {{ e }} x() {
        return this.x;
    }

    public {{ e }} y() {
        return this.y;
    }

    public {{ e }} z() {
        return this.z;
    }

    public Vector3{{ E }} add(final Vector3{{ E }} v) {
        return this.add(v.x, v.y, v.z);
    }

    public Vector3{{ E }} add(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.add({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} add(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(this.x + x, this.y + y, this.z + z);
    }

    public Vector3{{ E }} sub(final Vector3{{ E }} v) {
        return this.sub(v.x, v.y, v.z);
    }

    public Vector3{{ E }} sub(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.sub({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} sub(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(this.x - x, this.y - y, this.z - z);
    }

    public Vector3{{ E }} mul(final {{ EOverload }} a) {
        return this.mul({{ EFloorFunc }}(a));
    }

    @Override
    public Vector3{{ E }} mul(final {{ e }} a) {
        return this.mul(a, a, a);
    }

    public Vector3{{ E }} mul(final Vector3{{ E }} v) {
        return this.mul(v.x, v.y, v.z);
    }

    public Vector3{{ E }} mul(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.mul({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} mul(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(this.x * x, this.y * y, this.z * z);
    }

    public Vector3{{ E }} div(final {{ EOverload }} a) {
        return this.div({{ EFloorFunc }}(a));
    }

    @Override
    public Vector3{{ E }} div(final {{ e }} a) {
        return this.div(a, a, a);
    }

    public Vector3{{ E }} div(final Vector3{{ E }} v) {
        return this.div(v.x, v.y, v.z);
    }

    public Vector3{{ E }} div(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.div({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} div(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(this.x / x, this.y / y, this.z / z);
    }

    public {{ e }} dot(final Vector3{{ E }} v) {
        return this.dot(v.x, v.y, v.z);
    }

    public {{ e }} dot(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.dot({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public {{ e }} dot(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return this.x * x + this.y * y + this.z * z;
    }

    public Vector3{{ E }} project(final Vector3{{ E }} v) {
        return this.project(v.x, v.y, v.z);
    }

    public Vector3{{ E }} project(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.project({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} project(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        final {{ e }} lengthSquared = x * x + y * y + z * z;
        if (lengthSquared == 0) {
            throw new ArithmeticException("Cannot project onto the zero vector");
        }
        final {{ EDecEqui }} a = ({{ EDecEqui }}) this.dot(x, y, z) / lengthSquared;
        return new Vector3{{ E }}(a * x, a * y, a * z);
    }

    public Vector3{{ E }} cross(final Vector3{{ E }} v) {
        return this.cross(v.x, v.y, v.z);
    }

    public Vector3{{ E }} cross(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.cross({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} cross(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(this.y * z - this.z * y, this.z * x - this.x * z, this.x * y - this.y * x);
    }

    public Vector3{{ E }} pow(final {{ EOverload }} pow) {
        return this.pow({{ EFloorFunc }}(pow));
    }

    @Override
    public Vector3{{ E }} pow(final {{ e }} power) {
        return new Vector3{{ E }}(Math.pow(this.x, power), Math.pow(this.y, power), Math.pow(this.z, power));
    }

    @Override
    public Vector3{{ E }} abs() {
        return new Vector3{{ E }}(Math.abs(this.x), Math.abs(this.y), Math.abs(this.z));
    }

    @Override
    public Vector3{{ E }} negate() {
        return new Vector3{{ E }}(-this.x, -this.y, -this.z);
    }

    public Vector3{{ E }} min(final Vector3{{ E }} v) {
        return this.min(v.x, v.y, v.z);
    }

    public Vector3{{ E }} min(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.min({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} min(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(Math.min(this.x, x), Math.min(this.y, y), Math.min(this.z, z));
    }

    public Vector3{{ E }} max(final Vector3{{ E }} v) {
        return this.max(v.x, v.y, v.z);
    }

    public Vector3{{ E }} max(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.max({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public Vector3{{ E }} max(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return new Vector3{{ E }}(Math.max(this.x, x), Math.max(this.y, y), Math.max(this.z, z));
    }

    public {{ e }} distanceSquared(final Vector3{{ E }} v) {
        return this.distanceSquared(v.x, v.y, v.z);
    }

    public {{ e }} distanceSquared(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.distanceSquared({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public {{ e }} distanceSquared(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        final {{ e }} dx = this.x - x;
        final {{ e }} dy = this.y - y;
        final {{ e }} dz = this.z - z;
        return dx * dx + dy * dy + dz * dz;
    }

    public {{ EDecEqui }} distance(final Vector3{{ E }} v) {
        return this.distance(v.x, v.y, v.z);
    }

    public {{ EDecEqui }} distance(final {{ EOverload }} x, final {{ EOverload }} y, final {{ EOverload }} z) {
        return this.distance({{ EFloorFunc }}(x), {{ EFloorFunc }}(y), {{ EFloorFunc }}(z));
    }

    public {{ EDecEqui }} distance(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
        return ({{ EDecEqui }}) Math.sqrt(this.distanceSquared(x, y, z));
    }

    @Override
    public {{ e }} lengthSquared() {
        return this.x * this.x + this.y * this.y + this.z * this.z;
    }

    @Override
    public {{ EDecEqui }} length() {
        return ({{ EDecEqui }}) Math.sqrt(this.lengthSquared());
    }

    /**
     * Returns the axis with the minimal value.
     *
     * @return {@link int} axis with minimal value
     */
    @Override
    public int minAxis() {
        return this.x < this.y ? (this.x < this.z ? 0 : 2) : (this.y < this.z ? 1 : 2);
    }

    /**
     * Returns the axis with the maximum value.
     *
     * @return {@link int} axis with maximum value
     */
    @Override
    public int maxAxis() {
        return this.x < this.y ? (this.y < this.z ? 2 : 1) : (this.x < this.z ? 2 : 0);
    }

    public Vector2{{ E }} toVector2() {
        return new Vector2{{ E }}(this);
    }

    public Vector2{{ E }} toVector2(final boolean useZ) {
        return new Vector2{{ E }}(this.x, useZ ? this.z : this.y);
    }

    public Vector4{{ E }} toVector4() {
        return this.toVector4(0);
    }

    public Vector4{{ E }} toVector4(final {{ EOverload }} w) {
        return this.toVector4({{ EFloorFunc }}(w));
    }

    public Vector4{{ E }} toVector4(final {{ e }} w) {
        return new Vector4{{ E }}(this, w);
    }

    public VectorN{{ E }} toVectorN() {
        return new VectorN{{ E }}(this);
    }

    @Override
    public {{ e }}[] toArray() {
        return new {{ e }}[]{this.x, this.y, this.z};
    }

    @Override
    public Vector3i toInt() {
        return new Vector3i(this.x, this.y, this.z);
    }

    @Override
    public Vector3l toLong() {
        return new Vector3l(this.x, this.y, this.z);
    }

    @Override
    public Vector3f toFloat() {
        return new Vector3f(this.x, this.y, this.z);
    }

    @Override
    public Vector3d toDouble() {
        return new Vector3d(this.x, this.y, this.z);
    }

    @Override
    public int compareTo(final Vector3{{ E }} v) {
        return {{ ET }}.compare(this.lengthSquared(), v.lengthSquared());
    }

    @Override
    public boolean equals(final Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Vector3{{ E }})) {
            return false;
        }
        final Vector3{{ E }} that = (Vector3{{ E }}) other;
        if (that.x != this.x) {
            return false;
        }
        if (that.y != this.y) {
            return false;
        }
        if (that.z != this.z) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        if (!this.hashed) {
            this.hashCode = (({{ ET }}.hashCode(this.x) * 211 + {{ ET }}.hashCode(this.y)) * 97 + {{ ET }}.hashCode(this.z));
            this.hashed = true;
        }
        return this.hashCode;
    }

    @Override
    public String toString() {
        return "(" + this.x + ", " + this.y + ", " + this.z + ")";
    }

    public static Vector3{{ E }} from(final {{ e }} n) {
         return n == 0 ? Vector3{{ E }}.ZERO : new Vector3{{ E }}(n, n, n);
    }

    public static Vector3{{ E }} from(final {{ e }} x, final {{ e }} y, final {{ e }} z) {
         return x == 0 && y == 0 && z == 0 ? Vector3{{ E }}.ZERO : new Vector3{{ E }}(x, y, z);
    }

}