Re: efficient vector math...
On 12/1/2010 11:58 PM, BGB wrote:
(below is untested, just assuming that javac will not barf...).
grr...
more than a few obvious problems in this one...
oh well, fixed a few of them after copy/paste/edit/compile...
well, alas, these sorts of errors are typical and expected...
idly thinking here:
public class Vec3
public class Vec3 extends Object
{
protected static final double EPSILON=0.000001;
(epsilon is arbitrary but should work...)
private static final int MAX=1024;
private static Vec3[] cache;
private static int nCache;
(still private: subclass has its own cache)
private double x, y, z;
protected double x, y, z;
(because subclass needs to see it...).
static {
cache=new Vec3[MAX];
nCache=0;
}
public Vec3()
{ this(0, 0, 0); }
public Vec3(double x, double y, double z)
{ this.x=x; this.y=y; this.z=z; }
public float x() { return x; }
public float y() { return y; }
public float z() { return z; }
public double x() { return x; }
public double y() { return y; }
public double z() { return z; }
(note: getX()/... would be a bit much added typing...).
public void x(double v) { x=v; }
public void y(double v) { y=v; }
public void z(double v) { z=v; }
public void set(double x, double y, double z)
{ this.x=x; this.y=y; this.z=z; }
public void set(Vec3 v)
{ x=v.x; y=v.y; z=v.z; }
public void addn(Vec3 v)
{ x+=v.x; y+=v.y; z+=v.z; }
public void subn(Vec3 v)
{ x-=v.x; y-=v.y; z-=v.z; }
public Vec3 add(Vec3 v)
{ return Vec3.at(x+v.x, y+v.y, z+v.z); }
public Vec3 sub(Vec3 v)
{ return Vec3.at(x-v.x, y-v.y, z-v.z); }
(I don't figure having both destructive and non-destructive ops hurts
too much here...).
public double dot(Vec3 v)
{ return x*v.x + y*v.y + z*v.z; }
...
public Vec3 at(double x, double y, double z)
public static Vec3 at(double x, double y, double z)
{
Vec3 tmp;
if(nCache>0)
{
tmp=cache[--nCache];
tmp.set(x, y, z);
return tmp;
}
return new Vec3(x, y, z);
}
public void free()
{
if(nCache<MAX)
cache[nCache++]=this;
}
'free()' is decidedly "dangerous", but anyways if cache gets full extras
fall to GC... this is mostly for cases where one knows the vector is
garbage. this operation is no-op for ImmutableVec3.
}
an immutable case (implicit subclass?) could possibly disallow the
destructive methods (they are no-op or throw an exception), and probably
an 'Vec3.at(x, y, z)' method could be used to cache immutable vectors
(likely merged by epsilon and hashed).
something like:
public int hash()
public static int hash(double x, double y, double z)
{
long ix, iy, iz, i; //long is overkill?...
(still dunno, long is slow and possibly overkill, but dividing by
EPSILON will give large numbers, and it is preferable to be able to hash
as many bits as reasonable, even despite a lot of these bits being
discarded anyways...).
ix=(long)(x/EPSILON);
iy=(long)(y/EPSILON);
iz=(long)(z/EPSILON);
i=((ix*4294967291L+iy)*4294967291L+iz)*4294967291L;
return (int)(i>>>32);
}
public int hash()
{ return hash(x, y, z); }
both above merged into Vec3.
for clarity:
public boolean isAt(double x, double y, double z)
{
if(Math.abs(this.x-x)>EPSILON)return false;
if(Math.abs(this.y-y)>EPSILON)return false;
if(Math.abs(this.z-z)>EPSILON)return false;
return true;
}
below is for ImmutableVec3:
public Vec3 at(double x, double y, double z)
public static Vec3 at(double x, double y, double z)
{
Vec3 tmp;
int h;
h=hash()&1023;
h=hash(x, y, z)&1023;
(errm... yeah...)
tmp=cache[h];
tmp=immCache[h];
(renamed for clarity...).
if(tmp && tmp.isAt(x, y, z))
if(tmp!=null && tmp.isAt(x, y, z))
return tmp;
tmp=new ImmutableVec3(x, y, z);
cache[h]=tmp;
immCache[h]=tmp;
return tmp;
}
ImmutableVec3 currently makes destructive operations no-op, but
preferable would be to throw something (since if one tries to modify an
immutable vector something is obviously wrong...).
would likely have to make a new exception though as there don't appear
to be any obvious choices.
yes, conceptually awkward, but likely most workable...
or such...