private void rbAddVector_Click(object sender, EventArgs e)
{
if (sender is RadioButton)
{
if (!btnUpdate.Enabled)
{
btnUpdate.Enabled = true;
}
string tag = (string)((RadioButton)sender).Tag;
operation = (VectorOperations)Enum.Parse(typeof(VectorOperations), tag);
foreach (TextBox txb in txbCoords)
{
txbX1_TextChanged(txb, null);
}
for (int i = 0; i < srcData.GetLength(0); ++i)
{
for (int j = 0; j < srcData.GetLength(1); j += 2)
{
Point2D p = new Point2D(srcData[i, j], srcData[i, j + 1]);
if (j < 2)
{
vectors[i].StartPoint = p;
}
else
{
vectors[i].EndPoint = p;
}
}
}
object result = VectorUtils.ProcessVectorOperation(operation, vectors);
lbResult.Text = string.Format("Result: {0}", result);
}
}
public void TestInner()
{
Vector a = Vector.Create(1.0, 2.0);
Vector b = Vector.Create(-1.0, 3.0);
Assert.IsTrue(FloatComparison.Close(VectorOperations.Inner(a, b), 5.0, FloatComparison.DefaultEps));
}
public void CalculateVectorConstantOperationsTest()
{
VectorHelper vectorHelper = new VectorHelper();
VectorOperations vectorOperations = new VectorOperations(vectorHelper);
List <VectorEquation> vectors = new List <VectorEquation>();
VectorEquation eq1 = new VectorEquation(new Dictionary <string, double> {
{ "x1", 2 },
{ "x2", 4 }
}, 3);
double pivot = 5;
VectorEquation resultAdd = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Addition, pivot);
Assert.Equal(resultAdd.Constant, eq1.Constant + pivot);
VectorEquation resultSubt = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Subtraction, pivot);
Assert.Equal(resultSubt.Constant, eq1.Constant - pivot);
VectorEquation resultMult = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Multiplication, pivot);
Assert.Equal(resultMult.Constant, eq1.Constant * pivot);
VectorEquation resultDiv = vectorOperations.CalculateVectorConstantOperations(eq1, EOperation.Division, pivot);
Assert.Equal(resultDiv.Constant, eq1.Constant / pivot);
}
public void DotProduct()
{
var tuple = Tuple.Vector(1, 2, 3);
var tuple2 = Tuple.Vector(2, 3, 4);
Assert.Equal(20, VectorOperations.Dot(tuple, tuple2));
}
static int ProcessOperation(VectorOperations operation, params Vector2D[] vectors)
{
object result = Vector2DLib.VectorUtils.ProcessVectorOperation(operation, vectors);
int ret = 0;
switch (operation)
{
case VectorOperations.AddVectors:
Console.WriteLine("Sum of vectors: {0}", result);
break;
case VectorOperations.SubsVectors:
Console.WriteLine("Subs of vectors: {0}", result);
break;
case VectorOperations.ScalarProdVectors:
Console.WriteLine("Scalar prod of vectors: {0}", result);
break;
default:
ret = -1;
break;
}
return(ret);
}
public void TestVectorOperations()
{
VectorOperations.Sub(_a, _b, ref _dest);
Assert.AreEqual(-2.0, _dest[0], FloatComparison.DefaultEps);
Assert.AreEqual(-2.0, _dest[1], FloatComparison.DefaultEps);
VectorOperations.Add(_a, _b, ref _dest);
Assert.AreEqual(4.0, _dest[0], FloatComparison.DefaultEps);
Assert.AreEqual(6.0, _dest[1], FloatComparison.DefaultEps);
VectorOperations.ScalarMul(_a, 2, ref _dest);
Assert.AreEqual(2.0, _dest[0], FloatComparison.DefaultEps);
Assert.AreEqual(4.0, _dest[1], FloatComparison.DefaultEps);
VectorOperations.Copy(_a, ref _dest);
Assert.AreEqual(1.0, _dest[0], FloatComparison.DefaultEps);
Assert.AreEqual(2.0, _dest[1], FloatComparison.DefaultEps);
VectorOperations.Normalize(_a, ref _dest);
Assert.AreEqual(0.44721359549995793, _dest[0], FloatComparison.DefaultEps);
Assert.AreEqual(0.89442719099991586, _dest[1], FloatComparison.DefaultEps);
VectorOperations.Fill(ref _dest, 5.0);
Assert.AreEqual(5.0, _dest[0], FloatComparison.DefaultEps);
Assert.AreEqual(5.0, _dest[1], FloatComparison.DefaultEps);
}
public static Matrix Transpose(Matrix matrix)
{
#if SIMD
Vector4f xmm0 = matrix.r1, xmm1 = matrix.r2, xmm2 = matrix.r3, xmm3 = matrix.r4;
Vector4f xmm4 = xmm0;
xmm0 = VectorOperations.InterleaveLow(xmm0, xmm2);
xmm4 = VectorOperations.InterleaveHigh(xmm4, xmm2);
xmm2 = xmm1;
xmm1 = VectorOperations.InterleaveLow(xmm1, xmm3);
xmm2 = VectorOperations.InterleaveHigh(xmm2, xmm3);
xmm3 = xmm0;
xmm0 = VectorOperations.InterleaveLow(xmm0, xmm1);
xmm3 = VectorOperations.InterleaveHigh(xmm3, xmm1);
xmm1 = xmm4;
xmm1 = VectorOperations.InterleaveLow(xmm1, xmm2);
xmm4 = VectorOperations.InterleaveHigh(xmm4, xmm2);
return(new Matrix(xmm0, xmm3, xmm1, xmm4));
#else
return(new Matrix(
matrix.m11, matrix.m21, matrix.m31, matrix.m41,
matrix.m12, matrix.m22, matrix.m32, matrix.m42,
matrix.m13, matrix.m23, matrix.m33, matrix.m43,
matrix.m14, matrix.m24, matrix.m34, matrix.m44));
#endif
}
void IPostSetArrow.PostSetArrow()
{
IPostSetArrow p = relative as IPostSetArrow;
p.PostSetArrow();
transform = VectorOperations.CreateTransformer(Copy, this);
}
public void TestScalarMul()
{
Vector a = Vector.Create(1.0, 2.0);
VectorOperations.ScalarMul(a, 0.5, ref a);
Assert.IsTrue(VectorComparison.Close(a, Vector.Create(0.5, 1.0), FloatComparison.DefaultEps));
}
public void TestFill()
{
Vector a = new Vector(2);
VectorOperations.Fill(ref a, 2.0);
Assert.AreEqual(2.0, a[0], FloatComparison.DefaultEps);
Assert.AreEqual(2.0, a[1], FloatComparison.DefaultEps);
}
public void TestCopy()
{
Vector a = Vector.Create(3.0, 4.0);
Vector b = new Vector(2);
VectorOperations.Copy(a, ref b);
Assert.IsTrue(VectorComparison.Close(a, b, FloatComparison.DefaultEps));
}
public void CrossProduct()
{
var tuple = Tuple.Vector(1, 2, 3);
var tuple2 = Tuple.Vector(2, 3, 4);
Assert.Equal(Tuple.Vector(-1, 2, -1), VectorOperations.Cross(tuple, tuple2));
Assert.Equal(Tuple.Vector(1, -2, 1), VectorOperations.Cross(tuple2, tuple));
}
public void Apply(Individual <double>[] population)
{
foreach (var individual in population)
{
double[] chromosome = individual.Chromosome;
individual.Chromosome = VectorOperations.Add(individual.Chromosome, ComputePerturbations());
}
}
public void TestSub()
{
Vector a = Vector.Create(1.0, 2.0);
Vector b = Vector.Create(-1.0, 3.0);
VectorOperations.Sub(a, b, ref a);
Assert.IsTrue(VectorComparison.Close(a, Vector.Create(2.0, -1.0), FloatComparison.DefaultEps));
}
public static void Clamp(ref Vector2 value1, ref Vector2 min, ref Vector2 max, out Vector2 result)
{
var v4 = VectorOperations.Min(VectorOperations.Max(
new Vector4f(value1.X, value1.Y, 0f, 0f),
new Vector4f(min.X, min.Y, 0f, 0f)),
new Vector4f(max.X, max.Y, 0f, 0f));
result = new Vector2(v4.X, v4.Y);
}
public void TestNormalize()
{
Vector a = Vector.Create(1.0, 2.0);
Vector na = new Vector(2);
double old_len = VectorOperations.Normalize(a, ref na);
Assert.AreEqual((double)Math.Sqrt(5.0), old_len, FloatComparison.DefaultEps);
double new_len = VectorReductions.L2Norm(na);
Assert.AreEqual(1.0, new_len, FloatComparison.DefaultEps);
}
List <Vector3Int> CreateTunnelFromRoom(Rect room)
{
int maxLength = 12;
int lengthBeforeChangingDirection = (int)(Random.value * 5) + 2;
Directions dir;
bool connected = false;
int length = 0;
int changeDirectionCounter = 0;
Vector3Int cursor = VectorOperations.GenerateRandomPositionOnBorder(room);
dir = DirectonsOperations.GetTunnelDirectionFromRoom(cursor, room);
map.structures.SetTile(cursor, null);
List <Vector3Int> tunnelTiles = new List <Vector3Int>();
while (!connected)
{
if (cursor.x > -map.sizeX / 2 + 1 && cursor.x < map.sizeX / 2 - 1 && cursor.y > -map.sizeY / 2 + 1 && cursor.y < map.sizeY / 2 - 1)
{
map.ground.SetTile(cursor, tiles.GetIndoorTile());
tunnelTiles.Add(cursor);
cursor = VectorOperations.MoveCursor(cursor, dir);
}
else
{
connected = true;
}
if (tiles.GetIndoorTiles().Contains(map.ground.GetTile(cursor)))
{
//merge into another tunnel
connected = true;
}
if (changeDirectionCounter == lengthBeforeChangingDirection)
{
//random direction change
lengthBeforeChangingDirection = (int)(Random.value * 5) + 2;
dir = DirectonsOperations.ChangeDirection(dir);
changeDirectionCounter = 0;
}
length++;
changeDirectionCounter++;
if (length == maxLength)
{
// end of tunnel
map.ground.SetTile(cursor, tiles.GetIndoorTile());
connected = true;
}
}
return(tunnelTiles);
}
public async Task <SortedList <long, int> > Get(long key)
{
var buffer = _db.Get(BitConverter.GetBytes(key));
if (buffer != null)
{
return(await VectorOperations.DeserializeVectorAsync(0, new MemoryStream(buffer)));
}
return(null);
}
public Vector128 <float> Normalize_Inline()
{
JohnVector x = _value;
for (var i = 0; i < _iter; i++)
{
x = VectorOperations.Normalize3D_NewTest(x);
}
return(x);
}
/// <summary>
/// Post operation
/// </summary>
public void Post()
{
cons = this;
transform = VectorOperations.CreateTransformer(InerialAcceleration, this);
for (int i = 0; i < measuresAcc.Length; i++)
{
string s = meas[i];
IMeasurement m = this.FindMeasurement(s, false);
measuresAcc[i] = m;
}
}
static void Main(string[] args)
{
int ret = 0;
while (ret == 0)
{
Vector2D v1, v2;
EnterVectors(out v1, out v2);
VectorOperations op = Menu();
ret = ProcessOperation(op, v1, v2);
}
}
private void CreateWalls(List <Vector3Int> tunnelTiles)
{
foreach (Vector3Int tile in tunnelTiles)
{
foreach (Vector3Int surrTile in VectorOperations.GetSurroundingTiles(tile))
{
if (!tiles.GetIndoorTiles().Contains(mapOperations.GetGroundTile(surrTile)))
{
map.structures.SetTile(surrTile, tiles.GetStructureTile());
}
}
}
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
// ===============================================================================================
// Read input parameters
// ===============================================================================================
//string info;
double minVelocity = 4;
double maxVelocity = 8;
List <Point3d> points = new List <Point3d>();
var agents = new List <FlockAgent>();
const double xMin = 0;
const double xMax = 30;
const double yMin = 0;
const double yMax = 30;
//Get values from grasshopper
DA.GetData("Minimum velocity", ref minVelocity);
DA.GetData("Maximum velocity", ref maxVelocity);
DA.GetDataList("Start point for agent", points);
// ===============================================================================================
// Applying Values to Class
// ===============================================================================================
BoundingBox box = new BoundingBox(points);
//Assign velocity to points
foreach (Point3d point in points)
{
var nu = NumberOperations.remap(box.Min.X,
box.Max.X, xMin, xMax, point.X);
var nv = NumberOperations.remap(box.Min.Y,
box.Max.Y, yMin, yMax, point.Y);
var remappedPoint = new Point3d(nu, nv, 0);
FlockAgent agent =
new FlockAgent(remappedPoint, VectorOperations.GetRandomUnitVectorXY() * minVelocity)
{
StartPosition = remappedPoint,
MinVelocity = minVelocity,
MaxVelocity = maxVelocity
};
agents.Add(agent);
}
// ===============================================================================================
// Exporting Data to Grasshopper
// ===============================================================================================
//assigning data for export
var a = agents;
//Export data to grasshopper
DA.SetDataList(0, a);
}
public static void Transpose(ref Matrix matrix, out Matrix result)
{
#if SIMD
//algorithm from public domain - http://0x80.pl/snippets/asm/sse-transpose.c
Vector4f xmm0 = matrix.r1; // xmm0 = a0 a1 a2 a3
Vector4f xmm1 = matrix.r2; // xmm1 = b0 b1 b2 b3
Vector4f xmm2 = matrix.r3; // xmm2 = c0 c1 c2 c3
Vector4f xmm3 = matrix.r4; // xmm3 = d0 d1 d2 d3
Vector4f xmm4 = xmm0;
xmm0 = VectorOperations.InterleaveLow(xmm0, xmm2); // xmm0 = a0 c0 a1 c1
xmm4 = VectorOperations.InterleaveHigh(xmm4, xmm2); // xmm4 = a2 c2 a3 c3
xmm2 = xmm1;
xmm1 = VectorOperations.InterleaveLow(xmm1, xmm3); // xmm1 = b0 d0 b1 d1
xmm2 = VectorOperations.InterleaveHigh(xmm2, xmm3); // xmm2 = b2 d2 b3 d3
xmm3 = xmm0;
xmm0 = VectorOperations.InterleaveLow(xmm0, xmm1); // xmm0 = a0 b0 c0 d0
xmm3 = VectorOperations.InterleaveHigh(xmm3, xmm1); // xmm3 = a1 b1 c1 d1
xmm1 = xmm4;
xmm1 = VectorOperations.InterleaveLow(xmm1, xmm2); // xmm1 = a2 b2 c2 d2
xmm4 = VectorOperations.InterleaveHigh(xmm4, xmm2); // xmm4 = a3 b3 c3 d3
result.r1 = xmm0;
result.r2 = xmm3;
result.r3 = xmm1;
result.r4 = xmm4;
#else
result.m11 = matrix.m11;
result.m12 = matrix.m21;
result.m13 = matrix.m31;
result.m14 = matrix.m41;
result.m21 = matrix.m12;
result.m22 = matrix.m22;
result.m23 = matrix.m32;
result.m24 = matrix.m42;
result.m31 = matrix.m13;
result.m32 = matrix.m23;
result.m33 = matrix.m33;
result.m34 = matrix.m43;
result.m41 = matrix.m14;
result.m42 = matrix.m24;
result.m43 = matrix.m34;
result.m44 = matrix.m44;
#endif
}
public void GenerateDecorations(Rect area, float appearRate = 0.05f)
{
List <Vector3Int> listOfDecoCoordinates = VectorOperations.GetRandomCoordinatesInArea(area, appearRate);
foreach (Vector3Int coord in listOfDecoCoordinates)
{
bool isIndoor = true;
if (tiles.GetGroundTiles().Contains(mapOperations.GetGroundTile(coord)))
{
isIndoor = false;
}
decorationsModifier.SetTile(coord, tiles.GetDecorationTile(isIndoor));
}
}
private void UpdatePositionAndVelocity()
{
for (int i = 0; i < swarmSize; i++)
{
int rp = randomNumberGenerator.Next(dimension);
int rg = randomNumberGenerator.Next(dimension);
individuals[i].Velocity = VectorOperations.Add(VectorOperations.Add(VectorOperations.Scale(omega, individuals[i].Velocity),
VectorOperations.Scale(phip, VectorOperations.Scale(rp, VectorOperations.Subtract(BestPosition, individuals[i].Position)))),
VectorOperations.Scale(phig, VectorOperations.Scale(rg, VectorOperations.Subtract(individuals[i].PersonalBestPosition, individuals[i].Position))));
individuals[i].Position = VectorOperations.Add(individuals[i].Position, individuals[i].Velocity);
}
}
/// <summary>
/// проверяет, видим ли источник света L из данной точки P
/// </summary>
/// <param name="L"></param>
/// <param name="P"></param>
/// <returns>
/// true - источник L виден из точки P
/// false - источник L не виден из точки P
/// </returns>
private bool IsVisible(Light L, Point3D P)
{
Vector3D v = new Vector3D(P, L.Position);
//для упрощения: если источник закрыт прозрачным предметом, то считаем, что он в тени
IntersectionInfo info = this.GetFirstIntersection(new Ray(P, v));
if (info == null)
{
return(true);
}
else
{
return(VectorOperations.Distance(P, L.Position) < VectorOperations.Distance(P, info.CrossPoint));
}
}
/// <summary>
/// Performs mutation of the population according to de/rand/1/bin scheme
/// </summary>
private void Mutation()
{
offsprings = new Individual[populationSize];
for (int i = 0; i < populationSize; i++)
{
int r1 = randomNumberGenerator.Next(populationSize);
int r2 = randomNumberGenerator.Next(populationSize);
int r3 = randomNumberGenerator.Next(populationSize);
double[] donorVector = VectorOperations.Add(individuals[r1].Position, VectorOperations.Scale(mutationFactor, VectorOperations.Subtract(individuals[r2].Position, individuals[r3].Position)));
offsprings[i] = new Individual(donorVector, double.MaxValue);
}
}
public static Matrix Transpose(Matrix matrix)
{
Vector4f xmm0 = matrix.r1, xmm1 = matrix.r2, xmm2 = matrix.r3, xmm3 = matrix.r4;
Vector4f xmm4 = xmm0;
xmm0 = VectorOperations.InterleaveLow(xmm0, xmm2);
xmm4 = VectorOperations.InterleaveHigh(xmm4, xmm2);
xmm2 = xmm1;
xmm1 = VectorOperations.InterleaveLow(xmm1, xmm3);
xmm2 = VectorOperations.InterleaveHigh(xmm2, xmm3);
xmm3 = xmm0;
xmm0 = VectorOperations.InterleaveLow(xmm0, xmm1);
xmm3 = VectorOperations.InterleaveHigh(xmm3, xmm1);
xmm1 = xmm4;
xmm1 = VectorOperations.InterleaveLow(xmm1, xmm2);
xmm4 = VectorOperations.InterleaveHigh(xmm4, xmm2);
return(new Matrix(xmm0, xmm3, xmm1, xmm4));
}
public virtual IntersectionInfo Intersection(Ray r)
{
double epsilon = 0.01;
Vector3D v = new Vector3D(r.Origin.X - center.X, r.Origin.Y - center.Y, r.Origin.Z - center.Z);
double A = r.Direction.LengthSquare;
double B = VectorOperations.ScalarProduct(r.Direction, v);
double C = v.LengthSquare - radius * radius;
double D = B * B - A * C;
if (D <= 0.0)
{
return(null);
}
double t1 = (-B - Math.Sqrt(D)) / A;
double t2 = (-B + Math.Sqrt(D)) / A;
double t = t1;
if (t2 <= epsilon)
{
return(null);
}
if (t1 <= epsilon) //луч идет из шара
{
t = t2;
}
Point3D P = new Point3D(r.Origin.X + r.Direction.X * t,
r.Origin.Y + r.Direction.Y * t,
r.Origin.Z + r.Direction.Z * t); //первая точка пересечения
Vector3D N = new Vector3D(center, P); //вектор нормали единичной длины
N *= (1 / N.Length);
if (t1 <= epsilon) //луч идет из шара
{
N *= (-1.0);
}
return(new IntersectionInfo(P, N, material));
}
