public TestingCompoundVertexInfo(Vector springForce, Vector repulsionForce, Vector gravityForce, Vector applicationForce)
 {
     SpringForce = springForce;
     RepulsionForce = repulsionForce;
     GravityForce = gravityForce;
     ApplicationForce = applicationForce;
 }

        public NodeViewModel(Node node, Vector location, IControlTypesResolver controlTypesResolver)
        {
            Node = node;
            Title = node.Title;
            Location = new CanvasPoint(location);
            ControlTypesResolver = controlTypesResolver;

            foreach (var pin in node.InputPins)
            {
                AddInputPin(pin);
            }

            foreach (var pin in node.OutputPins)
            {
                AddOutputPin(pin);
            }

            node.Processed += OnNodeProcessed;
            node.PinsChanged += OnNodePinsChanged;

            _disposable = Disposable.Create(() =>
            {
                node.PinsChanged -= OnNodePinsChanged;
                node.Processed -= OnNodeProcessed;
            });
        }

        public void TestBoundingCirclePushBackLeftTop()
        {
            //Preconfig
            int radius = 20;
            Vector position = new Vector(100f, 100f);
            Vector ballPos = new Vector(100, 100);
            Vector hitPoint = new Vector(120 - 14.1421f, 120 - 14.1421f);

            Vector ballSpeed = hitPoint - ballPos;

            Vector expectedPushBack = (radius * 2 / 1.9f) * ((hitPoint - (position + new Vector(radius, radius)))).AsNormalized();

            Vector pushBackVec;

            //Creation
            Bumper parent = new Bumper();
            BoundingCircle bC2 = new BoundingCircle(radius, position);
            BoundingContainer bCont = new BoundingContainer(parent);
            bCont.AddBoundingBox(bC2);

            //Operation
            parent.Location = (new Vector(0, 0));
            pushBackVec = bC2.GetOutOfAreaPush(radius * 2, hitPoint, ballSpeed, ballPos);

            //Assertion
            Assert.AreEqual(expectedPushBack, pushBackVec);
        }

		public override void ApplyFilter(int[] pixels, int width, int height, Vector[,] field)
		{
			double maxLength = Double.NegativeInfinity;
			double minLength = Double.PositiveInfinity;

			for (int ix = 0; ix < width; ix++)
			{
				for (int iy = 0; iy < height; iy++)
				{
					var length = field[ix, iy].Length;
					if (length > maxLength) maxLength = length;
					if (length < minLength) minLength = length;
				}
			}

			for (int i = 0; i < width * height; i++)
			{
				HsbColor color = HsbColor.FromArgb(pixels[i]);

				int ix = i % width;
				int iy = i / width;
				var length = field[ix, iy].Length;

				var ratio = (length - minLength) / (maxLength - minLength);
				if (ratio.IsNaN())
					ratio = 0;

				var paletteColor = Palette.GetColor(ratio).ToHsbColor();

				color.Hue = paletteColor.Hue;
				color.Saturation = paletteColor.Saturation;

				pixels[i] = color.ToArgb();
			}
		}

		public IrregularCell(Vector leftBottom, Vector rightBottom, Vector rightTop, Vector leftTop)
		{
			this.leftBottom = leftBottom;
			this.rightBottom = rightBottom;
			this.rightTop = rightTop;
			this.leftTop = leftTop;
		}

 // Constructor function
 public Vertex(int id, Vector position, HashSet<int> connections)
 {
     this.ID = id;
     this.PositionVector = position;
     this.connectedVertexIDs = connections;
     this.mass = 1;
 }

        /// <summary>
        /// Play with the NonlinearRandom tester to come up with values
        /// </summary>
        public RandomBellArgs(double leftArmLength, double leftArmAngle, double rightArmLength, double rightArmAngle)
        {
            List<Point3D> controlPoints = new List<Point3D>();

            // Arm1
            if (!leftArmLength.IsNearZero())
            {
                Vector arm1 = new Vector(1, 1).ToUnit() * leftArmLength;

                controlPoints.Add(arm1.ToVector3D().GetRotatedVector(new Vector3D(0, 0, -1), leftArmAngle).ToPoint());
            }

            // Arm2
            if (!rightArmLength.IsNearZero())
            {
                Vector arm2 = new Vector(-1, -1).ToUnit() * rightArmLength;

                Vector3D arm2Rotated = arm2.
                    ToVector3D().
                    GetRotatedVector(new Vector3D(0, 0, -1), rightArmAngle);

                controlPoints.Add(new Point3D(1 + arm2Rotated.X, 1 + arm2Rotated.Y, 0));
            }

            // Bezier
            this.Bezier = new BezierSegment3D(0, 1, controlPoints.ToArray(), new[] { new Point3D(0, 0, 0), new Point3D(1, 1, 0) });
        }

 /// <summary>
 /// Initializes a new character instance.
 /// </summary>
 /// <param name="p0">Lower left character position.</param>
 /// <param name="size">Size of the character.</param>
 /// <param name="uiTaskSchedule">Scheduler associated with the UI thread.</param>
 public Character(Point p0, Vector size, TaskScheduler uiTaskSchedule)
     : base(uiTaskSchedule)
 {
     this.Position = new Quadrilateral(p0, size);
     this.Gravity = CharacterGravityState.Down;
     this.Animation = CharacterAnimationState.Down;
 }

        public override Point GetWaypoint()
        {
            // update collided point status
            _me.SetStatus(_mo.X, _mo.Y, MapElementStatus.Collided);

            Vector vector = new Vector(_mo.X - _posX, _mo.Y - _posY);
            
            // opposite direction
            vector.Negate();

            // normalize vector (length = 1)
            vector.Normalize();

            // calculate distances to every border
            double tLeft = (-_posX) / vector.X;
            double tRight = (800 - _posX) / vector.X;
            double tTop = (-_posY) / vector.Y;
            double tBottom = (600 - _posY) / vector.Y;

            vector *= 20;

            _point.X = (int)_posX + (int)vector.X;
            _point.Y = (int)_posY + (int)vector.Y;

            _point.Status = MapElementStatus.Waypoint;

            return _point;
        }

		public void Equals ()
		{
			Vector v = new Vector (4, 5);
			Assert.IsTrue (v.Equals (new Vector (4, 5)));
			Assert.IsFalse (v.Equals (new Vector (5, 4)));
			Assert.IsFalse (v.Equals (new object()));
		}

 /// <summary>
 /// Private constructor.
 /// </summary>
 /// <param name="physicalCenterOffsetFromTag"></param>
 /// <param name="orientationOffsetFromTag"></param>
 private ByteTagDefinition(
     Vector physicalCenterOffsetFromTag,
     double orientationOffsetFromTag)
 {
     this.physicalCenterOffsetFromTag = physicalCenterOffsetFromTag;
     this.orientationOffsetFromTag = orientationOffsetFromTag;
 }

        public Component GetClosestComponent(int x, int y, ComponentFilter cf)
        {
            Component result = null;
            int componentType = cf.Type;
            List<Component> components = m_vComponents[componentType];
            Vector v = new Vector(x,y);
            double maxLengthSquared = 0;

            if (components.Count > 0)
            {
                foreach(var c in components)
                {
                    if(cf.TestComponent(c))
                    {
                        GameObject go = c.GetParent();
                        double lengthSquared = (v - go.GetPosition()).LengthSquared; 
                        if(lengthSquared < maxLengthSquared || result == null)
                        {
                            maxLengthSquared = lengthSquared;
                            result = c;
                        }
                    }
                }
            }
            return result;
        }

        public void TestBoundingLineReflect270Left()
        {
            //Preconfig
            Vector position1 = new Vector(0f, 50f);
            Vector target1 = new Vector(50f, 50f);

            Vector ballSpeed = new Vector(5, 0);
            Vector ballPos = new Vector(-20, 50);

            Vector hitPoint = new Vector(0, 50);
            Vector expectedReflection = -ballSpeed;
            expectedReflection.Normalize();
            Vector reflection;

            //Creation
            Line parent = new Line();
            BoundingContainer bCont = new BoundingContainer(parent);
            BoundingLine bL1 = new BoundingLine(position1, target1);
            bCont.AddBoundingBox(bL1);
            parent.Location = (new Vector(0, 0));

            //Operation
            reflection = bL1.Reflect(ballSpeed, hitPoint, ballPos);
            reflection.Normalize();

            //Assertion
            Assert.AreEqual(expectedReflection, reflection);
        }

 public Physics(GameObject gameObject, double topSpeed, Vector velocity)
 {
     _lastUpdate = DateTime.Now.Ticks;
     GameObject = gameObject;
     _topSpeed = topSpeed;
     Velocity = velocity;
 }

        public static Tuple<Point[], Point[], Point[]> Subdivide(Point[] l1, Point[] l2)
        {
            var allPoints = l1.Concat(l2).ToArray();
            var pcaLine = PCALine.Compute(allPoints);

            var minPoint = allPoints.Minimizer(p => ProjectedLinePosition(p, pcaLine.Item1, pcaLine.Item2)).ProjectOnLine(pcaLine);
            var maxPoint = allPoints.Minimizer(p => -ProjectedLinePosition(p, pcaLine.Item1, pcaLine.Item2)).ProjectOnLine(pcaLine);

            var samples = SampleSegment(minPoint, maxPoint);

            var points1 = new List<Point>();
            var points2 = new List<Point>();
            var centers = new List<Point>();
            var perp = new Vector(-pcaLine.Item2.Y, pcaLine.Item2.X);
            for (int i = 0; i < samples.Length; ++i)
            {
                var p1 = DirectionalProject(samples[i], perp, l1);
                var p2 = DirectionalProject(samples[i], perp, l2);
                if (p1 != null && p2 != null)
                {
                    points1.Add(p1.Value);
                    points2.Add(p2.Value);
                    centers.Add(samples[i]);
                }
            }

            return Tuple.Create(points1.ToArray(), points2.ToArray(), centers.ToArray());
        }

        /// <summary>
        /// Hit-tests a linear segment against a convex polygon. 
        /// </summary>
        /// <param name="vertices">Vertices of the polygon (in clockwise order)</param>
        /// <param name="hitBegin">an end point of the hitting segment</param>
        /// <param name="hitEnd">an end point of the hitting segment</param> 
        /// <returns>true if hit; false otherwise</returns>
        internal static bool HitTestPolygonSegment(Vector[] vertices, Vector hitBegin, Vector hitEnd) 
        { 
            System.Diagnostics.Debug.Assert((null != vertices) && (2 < vertices.Length));
 
            HitResult hitResult = HitResult.Right, firstResult = HitResult.Right, prevResult = HitResult.Right;
            int count = vertices.Length;
            Vector vertex = vertices[count - 1];
            for (int i = 0; i < count; i++) 
            {
                Vector nextVertex = vertices[i]; 
                hitResult = WhereIsSegmentAboutSegment(hitBegin, hitEnd, vertex, nextVertex); 
                if (HitResult.Hit == hitResult)
                { 
                    return true;
                }
                if (IsOutside(hitResult, prevResult))
                { 
                    return false;
                } 
                if (i == 0) 
                {
                    firstResult = hitResult; 
                }
                prevResult = hitResult;
                vertex = nextVertex;
            } 
            return (false == IsOutside(firstResult, hitResult));
        } 

        private static bool LineIntersectSegment(Point p, Vector v, Point segStart, Point segEnd, out Point result)
        {
            var a11 = v.X;
            var a12 = segStart.X - segEnd.X;
            var a21 = v.Y;
            var a22 = segStart.Y - segEnd.Y;
            var b1 = segStart.X - p.X;
            var b2 = segStart.Y - p.Y;

            var solution = LinearSolve(a11, a12, a21, a22, b1, b2);
            if (solution != null)
            {
                var beta = solution.Value.Y;
                result = segStart + beta * (segEnd - segStart);
                if (beta < 0 || beta > 1)
                    return false;
                else
                    return true;

            }
            else
            {
                result = default(Point);
                return false;
            }
        }

        // TODO: Change to less case-specific methods (e.g. have vectors in input)
        // Angle between two vectors: one from a MovingEntity (origin to planned position), one with a new point (origin to a detected point)
        public static double AngleBetweenVectors(MovingEntity entity, MovingEntity newEntity)
        {
            Vector originalVector = new Vector(entity.DeltaX, entity.DeltaY);
            Vector newVector = new Vector(newEntity.Position.X - entity.Position.X, newEntity.Position.Y - entity.Position.Y);

            return Vector.AngleBetween(originalVector, newVector);
        }

        private void h_changePosition()
        {
            Point playerPosition = Info.GetPlayerPosition();

            Vector distance = new Vector(playerPosition.X - Position.X, playerPosition.Y - Position.Y);
            double coef = distance.X / MaxSpeed;

            Vector movement = Vector.Divide(distance, coef);

            Size levelSize = Info.GetLevelSize();

            if(movement.X > levelSize.Width)
              movement = new Vector(levelSize.Width, movement.Y);

            if(movement.X < 0 || double.IsNaN(movement.X))
              movement = new Vector(0, movement.Y);

            if(movement.Y > levelSize.Height)
              movement = new Vector(movement.X, levelSize.Height);

            if(movement.Y < 0 ||  double.IsNaN(movement.Y))
              movement = new Vector(movement.X, 0);

            Position = new Point((int) (Position.X + movement.X), (int) (Position.Y + movement.Y));

            Position = new Point((int)(Position.X+ 1), (int)(Position.Y + 1));
        }

 /// <summary>
 ///     Creates a new instance of this object.
 /// </summary>
 public ManipulationDelta(Vector translation, double rotation, Vector scale, Vector expansion)
 {
     Translation = translation;
     Rotation = rotation;
     Scale = scale;
     Expansion = expansion;
 }