Uses of Class
core.math.Vec2

Packages that use Vec2

core.dflic	This package contains classes which create and evolve the individual FLIC images making up a movie of a given experiment.
core.field	This package contains a number of classes used to create and manipulate the images generated for a given animation of an experiment as it evolves.
core.image	This package creates and evolves the individual FLIC images making up a movie of a given experiment.
core.math	This package contains a variety of classes which handle vector manipulations and the evolution of a given experiment as it evolves.
core.postprocessing	This package performs various operations on the images created by a given simulation of an experiment after the images are created by the classes in core.dflic.
simulations.experiments.electrostatics	This package contains all the experiments for the various electrostatic experiments.

Uses of Vec2 in core.dflic

Fields in core.dflic declared as Vec2

private Vec2	Streamline.x
private Vec2	Streamline.v
private Vec2	Streamline.dx
private Vec2	Streamline.odx
private Vec2	Streamline.nx
private Vec2	Streamline.tx
private Vec2	Streamline.A
private Vec2	Streamline.B
private Vec2	Streamline.C
private Vec2	Streamline.D
private Vec2	Streamline.cx
private Vec2	Streamline.cx2
private Vec2	Streamline.cx3
private Vec2	Streamline.cdx
private Vec2[]	FLIC.samplev
private Vec2	FLIC.p
private Vec2	FLIC.op
private Vec2	DFLIC.elp

Methods in core.dflic that return Vec2

Vec2	Streamline.Next() Returns the next point along the streamline.
Vec2	DFLIC.ElementIterator.next()

Methods in core.dflic with parameters of type Vec2

void	Streamline.AddSingularity(Vec2 v) Adds a singularity where streamlines are terminated when they come within the singularity limit.
void	Streamline.Start(Vec2 p) Begins the streamline computation at point "p" with the default length.
void	Streamline.Start(Vec2 p, double length) Begins the streamline computation at point "p" with a length "length".
private void	Streamline.ComputeStart(Vec2 x0)
void	FLIC.AddSingularity(Vec2 v) Adds a singularity, where streamlines are always terminated.
private void	FLIC.ComputeStream(Vec2 p0) Performs a FLIC (or LIC) streamline computation with the seed point "p0".
private void	FLIC.ContribAdd(Vec2 p)
private void	FLIC.ContribDel(Vec2 p)
private void	FLIC.ContribClear(Vec2 p)
void	DFLIC.AddSingularity(Vec2 v) Adds a singularity.

Uses of Vec2 in core.field

Fields in core.field declared as Vec2

private Vec2	Vec2FieldCache.p1
private Vec2	Vec2FieldCache.p2
private Vec2	ScanlineGridIterator.v
private Vec2	RandomGridIterator.v

Methods in core.field that return Vec2

Vec2	Vec2UnitField.get(Vec2 p, Vec2 f) Sets 'f' to the value of the field at 'p', scaled to unit magnitude.
Vec2	Vec2Iterator.next() Returns: null if there are no more points in the sequence, else a Vec2 whose value is the next point.
Vec2	Vec2FieldCache.get(Vec2 p, Vec2 f) Sets "f" to an approximate value of the field at "p".
abstract Vec2	Vec2Field.get(Vec2 p, Vec2 f) Sets 'f' to the value of the field at 'p'.
Vec2	Vec2Field.get(Vec2 p) Returns: a new Vec2 with the value of the field at 'p'.
Vec2	ScanlineGridIterator.next() Returns: null if there are no more points in the sequence, else a Vec2 whose value is the next point.
Vec2	RandomGridIterator.next() Returns: null if there are no more points in the sequence, else a Vec2 whose value is the next point.
Vec2	EMVec2Field.transform(Vec3 x)
Vec2	EMVec2Field.transformV(Vec3 dx)
Vec2	EMVec2Field.get(Vec2 p, Vec2 f) Sets "f" to the value of the EM field at "p".

Methods in core.field with parameters of type Vec2

abstract Vec3	Vec3Field.get(Vec3 p, Vec2 xpos, Vec3 f) Sets 'f' to the value of the field at 'p'.
abstract Vec3	Vec2Vec3Field.get(Vec2 p, Vec3 f) Sets 'f' to the value of the field at 'p'.
Vec3	Vec2Vec3Field.get(Vec2 p) Returns: a new Vec3 with the value of the field at 'p'.
Vec2	Vec2UnitField.get(Vec2 p, Vec2 f) Sets 'f' to the value of the field at 'p', scaled to unit magnitude.
Vec2	Vec2FieldCache.get(Vec2 p, Vec2 f) Sets "f" to an approximate value of the field at "p".
abstract Vec2	Vec2Field.get(Vec2 p, Vec2 f) Sets 'f' to the value of the field at 'p'.
Vec2	Vec2Field.get(Vec2 p) Returns: a new Vec2 with the value of the field at 'p'.
Vec2	EMVec2Field.get(Vec2 p, Vec2 f) Sets "f" to the value of the EM field at "p".

Constructors in core.field with parameters of type Vec2

Vec2FieldCache(Vec2Field field, Vec2 p1, Vec2 p2, int width, int height)
Constructs a new Vec2FieldCache that approximates "field" inside the rectangular region whose corners are given by "p1" and "p2".

Uses of Vec2 in core.image

Methods in core.image with parameters of type Vec2

boolean	ScalarImage.inBounds(Vec2 v) Returns: true if "v" is within the domain of "this" when viewed as a continuous field.
double	ScalarImage.getBilinear(Vec2 v) Returns: the bilinearly-interpolated value of the continuous field at "v".
void	ScalarImage.AccumulateBilinear(Vec2 v, double s) Bilinearly accumulates "s" to the four integer grid points surrounding the continuous coordinate "v".
void	AccumImage.AccumulateBilinear(Vec2 v, double s) Bilinearly accumulates "s" to the four integer grid points surrounding the continuous coordinate "v", weighting the alpha accumulation bilinearly as well.

Uses of Vec2 in core.math

Fields in core.math declared as Vec2

protected Vec2	Vec2Transform.origin origin = o, the translation
static Vec2	Vec2.Zero do not modify Zero = the zero vector
static Vec2	Vec2.Xhat do not modify Xhat = the unit x-axis
static Vec2	Vec2.Yhat do not modify Yhat = the unit y-axis
static Vec2[]	Vec2.Cartesian do not modify Cartesian an array of the cartesian axes
static Vec2	Vec2.Invalid do not modify Invalid = an invalid Vec

Methods in core.math that return Vec2

Vec2	Vec2Transform.v(Vec2 p) Returns: a new Vec2 that is 'p' transformed by 'this'
Vec2	Vec2Transform.V(Vec2 p) Transforms 'p' y 'this' Returns: resulting 'p'
Vec2	Vec2Transform.V(Vec2 p, Vec2 v) Sets v to the transformation of 'p' by 'this' Returns: resulting 'v'
Vec2	Vec2.getNew() Returns a new Vec2 = (0, 0)
Vec2	Vec2.copy() Returns a copy of "this"
Vec2	Vec2.Set(Vec2 v) Sets the value of "this" to that of "v" Returns: resulting "this"
Vec2	Vec2.Set(double x, double y) Sets "this" to (x, y) Returns: resulting "this"
Vec2	Vec2.Set(Vec v) Sets "this" to "v" Returns: resulting "this" Requires: "v" has dimension 2
Vec2	Vec2.SetZero() Sets "this" to zero Returns: resulting "this"
Vec2	Vec2.Add(Vec2 v) Adds "v" to "this" Returns: resulting "this"
Vec2	Vec2.Add(double x, double y) Adds (x, y) to "this" Returns: resulting "this"
Vec2	Vec2.add(Vec2 v) Returns: a new Vec2 that is the sum of "this" and "v"
Vec2	Vec2.add(double x, double y) Returns: a new Vec2 that is the sum of "this" and (x, y)
Vec2	Vec2.AddScaled(Vec2 v, double s) Adds "s*v" to "this" Returns: resulting "this"
Vec2	Vec2.AddScaled(double x, double y, double s) Adds "s * (x, y)" to "this" Returns: resulting "this"
Vec2	Vec2.addscaled(Vec2 v, double s) Returns: a new Vec2 that is the sum of "this" and "s*v"
Vec2	Vec2.addscaled(double x, double y, double s) Returns: a new Vec2 that is the sum of "this" and "s * (x, y)"
Vec2	Vec2.Sub(Vec2 v) Subtracts "v" from "this" Returns: resulting "this"
Vec2	Vec2.Sub(double x, double y) Subtracts (x, y) from "this" Returns: resulting "this"
Vec2	Vec2.sub(Vec2 v) Returns: a new Vec2 that is the difference between "this" and "v"
Vec2	Vec2.sub(double x, double y) Returns: a new Vec2 that is the difference between "this" and (x, y)
Vec2	Vec2.Neg() Negates "this" Returns: resulting "this"
Vec2	Vec2.neg() Returns: a new Vec2 that is the opposite of "this"
Vec2	Vec2.Scale(double s) Scales "this" by "s" Returns: resulting "this"
Vec2	Vec2.scale(double s) Returns: a new Vec2 that is "s*this"
Vec2	Vec2.Scale(Vec2 v) Scales each component of "this" by the corresponding component of "v" Returns: resulting "this"
Vec2	Vec2.scale(Vec2 v) Returns: a new Vec2 that is "this" with its components scaled by "v"
Vec2	Vec2.Unit() Rescales "this" to be of unit magnitude Returns: resulting "this" Requires: "this" is not zero
Vec2	Vec2.unit() Returns: a new Vec2 that is "this" scaled to unit magnitude Requires: "this" is not zero
Vec2	Vec2.Para(Vec2 d) Isolates the component of "this" parallel to "d" Returns: resulting "this" Requires: "d" is not zero
Vec2	Vec2.para(Vec2 d) Returns: a new Vec2 that is the component of "this" parallel to "d" Requires: "d" is not zero
Vec2	Vec2.ParaUnit(Vec2 d) Isolates the component of "this" parallel to "d" Returns: resulting "this" Requires: "d" has unit magnitude
Vec2	Vec2.paraunit(Vec2 d) Returns: a new Vec2 that is the component of "this" parallel to "d" Requires: "d" has unit magnitude
Vec2	Vec2.Perp(Vec2 d) Isolates the component of "this" perpendicular to "d" Returns: resulting "this" Requires: "d" is not zero
Vec2	Vec2.perp(Vec2 d) Returns: a new Vec2 that is the component of "this" perpendicular to "d" Requires: "d" is not zero
Vec2	Vec2.PerpUnit(Vec2 d) Isolates the component of "this" perpendicular to "d" Returns: resulting "this" Requires: "d" has unit magnitude
Vec2	Vec2.perpunit(Vec2 d) Returns: a new Vec2 that is the component of "this" perpendicular to "d" Requires: "d" has unit magnitude
Vec2	Vec2.Mul(Mat2 m) Multiplies "this" to the left by "m" Returns: resulting "this"
Vec2	Vec2.mul(Mat2 m) Returns: a new Vec2 that is "m*this"
Vec2	Vec2.RMul(Mat2 m) Multiplies "this" to the right by "m" Returns: resulting "this"
Vec2	Vec2.rmul(Mat2 m) Returns: a new Vec2 that is "this*m"
Vec2	Vec.toVec2() Returns: a new Vec2 that is equal to "this" Requires: "this" is 2-dimensional
Vec2	Mat2.mul(Vec2 v) Returns: a new Vec2 that is "this*v"
Vec2	Mat2.lmul(Vec2 v) Returns: a new Vec2 that is "v*this"
Vec2	Mat2.xaxis() Returns: a new Vec2 containing the x-axis of "this" when it is used as a linear transform left-multiplying a vector
Vec2	Mat2.yaxis()

Methods in core.math with parameters of type Vec2

Vec2Transform	Vec2Transform.translate(Vec2 origin) Returns: a new Vec2Transform that is 'this' translated by 'origin'
Vec2Transform	Vec2Transform.reflect(Vec2 d) Returns: a new Vec2Transform that is 'this' reflected across 'd'
Vec2	Vec2Transform.v(Vec2 p) Returns: a new Vec2 that is 'p' transformed by 'this'
Vec2	Vec2Transform.V(Vec2 p) Transforms 'p' y 'this' Returns: resulting 'p'
Vec2	Vec2Transform.V(Vec2 p, Vec2 v) Sets v to the transformation of 'p' by 'this' Returns: resulting 'v'
Vec2	Vec2.Set(Vec2 v) Sets the value of "this" to that of "v" Returns: resulting "this"
boolean	Vec2.equals(Vec2 v) Returns: true if "this" equals "v", false otherwise
Vec2	Vec2.Add(Vec2 v) Adds "v" to "this" Returns: resulting "this"
Vec2	Vec2.add(Vec2 v) Returns: a new Vec2 that is the sum of "this" and "v"
Vec2	Vec2.AddScaled(Vec2 v, double s) Adds "s*v" to "this" Returns: resulting "this"
Vec2	Vec2.addscaled(Vec2 v, double s) Returns: a new Vec2 that is the sum of "this" and "s*v"
Vec2	Vec2.Sub(Vec2 v) Subtracts "v" from "this" Returns: resulting "this"
Vec2	Vec2.sub(Vec2 v) Returns: a new Vec2 that is the difference between "this" and "v"
double	Vec2.dot(Vec2 v) Returns: the dot product of "this" and "v"
Vec2	Vec2.Scale(Vec2 v) Scales each component of "this" by the corresponding component of "v" Returns: resulting "this"
Vec2	Vec2.scale(Vec2 v) Returns: a new Vec2 that is "this" with its components scaled by "v"
double	Vec2.cross(Vec2 b) Returns: the magnitude of cross product of "this" and "b"
Vec2	Vec2.Para(Vec2 d) Isolates the component of "this" parallel to "d" Returns: resulting "this" Requires: "d" is not zero
Vec2	Vec2.para(Vec2 d) Returns: a new Vec2 that is the component of "this" parallel to "d" Requires: "d" is not zero
Vec2	Vec2.ParaUnit(Vec2 d) Isolates the component of "this" parallel to "d" Returns: resulting "this" Requires: "d" has unit magnitude
Vec2	Vec2.paraunit(Vec2 d) Returns: a new Vec2 that is the component of "this" parallel to "d" Requires: "d" has unit magnitude
Vec2	Vec2.Perp(Vec2 d) Isolates the component of "this" perpendicular to "d" Returns: resulting "this" Requires: "d" is not zero
Vec2	Vec2.perp(Vec2 d) Returns: a new Vec2 that is the component of "this" perpendicular to "d" Requires: "d" is not zero
Vec2	Vec2.PerpUnit(Vec2 d) Isolates the component of "this" perpendicular to "d" Returns: resulting "this" Requires: "d" has unit magnitude
Vec2	Vec2.perpunit(Vec2 d) Returns: a new Vec2 that is the component of "this" perpendicular to "d" Requires: "d" has unit magnitude
Vec2	Mat2.mul(Vec2 v) Returns: a new Vec2 that is "this*v"
Vec2	Mat2.lmul(Vec2 v) Returns: a new Vec2 that is "v*this"

Constructors in core.math with parameters of type Vec2

Vec2Transform(Vec2 origin, double scale)
Constructs a new Vec2Transform = < scale*I, origin >

Vec2Transform(Vec2 origin, Mat2 matrix)
Constructs a new Vec2Transform = < matrix, origin >

Vec2Transform(Vec2 origin, Vec2 xaxis, Vec2 yaxis)
Constructs a new Vec2Transform = < [ xaxis, yaxis ], origin >

Vec2(Vec2 v)
Constructs a new Vec2 = "v"

Uses of Vec2 in core.postprocessing

Methods in core.postprocessing with parameters of type Vec2

Vec3	Colorizer.get(Vec3 p, Vec2 xpos, Vec3 f) Takes the input p which codes the x and y field components at this point in the array and the image value, and returns an RGB color f for the pixel at this point in the array.

Uses of Vec2 in simulations.experiments.electrostatics

Methods in simulations.experiments.electrostatics with parameters of type Vec2

double

ColorTestExperiment.getHue(double TargetHue, Vec2 xpos, Vec RegionColor, Vec RegionParameter)