106P16 = new Vector2(1),

53 var sx = matrix.M12 == 0 ? Math.Abs(matrix.M11) : new Vector2(matrix.M11, matrix.M12).Length(); 54 var sy = matrix.M21 == 0 ? Math.Abs(matrix.M22) : new Vector2(matrix.M21, matrix.M22).Length(); 57 return new Vector2(sx, sy); 72 var sx = matrix.M12 == 0 ? Math.Abs(matrix.M11) : new Vector2(matrix.M11, matrix.M12).Length(); 73 var sy = matrix.M21 == 0 ? Math.Abs(matrix.M22) : new Vector2(matrix.M21, matrix.M22).Length(); 76 scale /= new Vector2(sx, sy); 167 scalex = value.M12 == 0 ? MathF.Abs(value.M11) : new Vector2(value.M11, value.M12).Length(); 168 scaley = value.M21 == 0 ? MathF.Abs(value.M22) : new Vector2(value.M21, value.M22).Length();

1607 return new Vector2(point.X, point.Y);

128 public static explicit operator Vector2(PointF p) => new Vector2(p.X, p.Y);

83 return new Vector2(size.Width, size.Height);

171 new Vector2(ox + controlPoint.X * fx, oy + controlPoint.Y * fy), 172 new Vector2(ox + endPoint.X * fx, oy + endPoint.Y * fy)); 180 new Vector2(ox + controlPoint1.X * fx, oy + controlPoint1.Y * fy), 181 new Vector2(ox + controlPoint2.X * fx, oy + controlPoint2.Y * fy), 182 new Vector2(ox + endPoint.X * fx, oy + endPoint.Y * fy)); 226 new Vector2(endPoint.X, endPoint.Y), 293 new Vector2(controlPoint.X * scale, controlPoint.Y * scale), 294 new Vector2(endPoint.X * scale, endPoint.Y * scale)); 306 new Vector2(controlPoint1.X * scale, controlPoint1.Y * scale), 307 new Vector2(controlPoint2.X * scale, controlPoint2.Y * scale), 308 new Vector2(endPoint.X * scale, endPoint.Y * scale)); 344 new Vector2(endPoint.X, endPoint.Y),

198 new Vector2(_point2.X, _point2.Y), 586 new Vector2(_point2.X, _point2.Y),

405 ShadowOffset = new Vector2(offset.Width, offset.Height);

11private static Matrix3x2 s_testMatrix = Matrix3x2.CreateRotation(45) * Matrix3x2.CreateScale(2) * Matrix3x2.CreateTranslation(new Vector2(10, 20));

47public Vector2 ToVector2() => new Vector2(x, y);

58public Vector2 ToVector2() => new Vector2(width, height);

33public Vector2 P16 { get; set; }

12 => sourceType == typeof(string) || sourceType == typeof(Vector2); 28 if (value is Vector2 vec)

12 => sourceType == typeof(string) || sourceType == typeof(Vector2); 28 if (value is Vector2 vec)

51 public static Vector2 GetScale(this in Matrix3x2 matrix) 65 public static Vector2 GetTranslation(this in Matrix3x2 matrix) 70 public static Matrix3x2 WithScale(this Matrix3x2 matrix, Vector2 scale) 91 return matrix.WithScale(Vector2.One); 96 var t = matrix.Translation; 97 var s = matrix.GetScale(); 103 var t = matrix.Translation; 104 var s = matrix.GetScale(); 108 public static Matrix3x2 WithTranslation(this Matrix3x2 matrix, Vector2 translation) 129 internal static Matrix3x2 CreateMatrix3x2(Vector2 scale, float rotation, Vector2 translation)

934 _points[i] = Vector2.Transform((Vector2)_points[i], transform); 1544 var vectors = new Vector2[4]; 1560 var vector = GetPointAsVector(curvePoints, index + 3); 1591 private Vector2 DeCasteljau(List<PointF> curvePoints, int index, float t) 1595 var vector0 = s * GetPointAsVector(curvePoints, index) + t * GetPointAsVector(curvePoints, index + 1); 1596 var vector1 = s * GetPointAsVector(curvePoints, index + 1) + t * GetPointAsVector(curvePoints, index + 2); 1597 var vector2 = s * GetPointAsVector(curvePoints, index + 2) + t * GetPointAsVector(curvePoints, index + 3); 1604 private Vector2 GetPointAsVector(List<PointF> curvePoints, int index)

42 public Point(Vector2 v) 128 public static implicit operator Point(Vector2 v) => new Point(v);

36 public PointF(Vector2 v) 74 return Vector2.Transform((Vector2)this, transform); 126 public static implicit operator PointF(Vector2 v) => new PointF(v); 128 public static explicit operator Vector2(PointF p) => new Vector2(p.X, p.Y);

27 public Size(Vector2 vector)

27 public SizeF(Vector2 vector) 43 return (SizeF)Vector2.TransformNormal((Vector2)this, transform); 81 public static explicit operator Vector2(SizeF size) 86 public static explicit operator SizeF(Vector2 size)

38 private Vector2 _point1; 39 private Vector2 _point2; 40 private Vector2 _linearGradientStartPoint; 41 private Vector2 _linearGradientEndPoint; 42 private Vector2 _radialGradientCenter;

43 private Vector2 _linearGradientStartPoint; 44 private Vector2 _linearGradientEndPoint; 45 private Vector2 _radialGradientCenter; 79 public Vector2 ShadowOffset { get; private set; } 300 public void SetLinearGradient(Paint aPaint, Vector2 startPoint, Vector2 endPoint) 310 public void SetRadialGradient(Paint aPaint, Vector2 center, float radius)

1339[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Numerics.Vector2))]

36/// <see cref="System.Numerics.Vector2"/>. 38public PointF(Vector2 vector) 45/// Creates a new <see cref="System.Numerics.Vector2"/> from this <see cref="System.Drawing.PointF"/>. 47public Vector2 ToVector2() => new Vector2(x, y); 74/// Converts the specified <see cref="System.Drawing.PointF"/> to a <see cref="System.Numerics.Vector2"/>. 76public static explicit operator Vector2(PointF point) => point.ToVector2(); 79/// Converts the specified <see cref="System.Numerics.Vector2"/> to a <see cref="System.Drawing.PointF"/>. 81public static explicit operator PointF(Vector2 vector) => new PointF(vector);

74/// Converts the specified <see cref="System.Numerics.Vector2"/> to a <see cref="System.Drawing.RectangleF"/>.

47/// <see cref="System.Numerics.Vector2"/>. 49public SizeF(Vector2 vector) 56/// Creates a new <see cref="System.Numerics.Vector2"/> from this <see cref="System.Drawing.SizeF"/>. 58public Vector2 ToVector2() => new Vector2(width, height); 70/// Converts the specified <see cref="System.Drawing.SizeF"/> to a <see cref="System.Numerics.Vector2"/>. 72public static explicit operator Vector2(SizeF size) => size.ToVector2(); 75/// Converts the specified <see cref="System.Numerics.Vector2"/> to a <see cref="System.Drawing.SizeF"/>. 77public static explicit operator SizeF(Vector2 vector) => new SizeF(vector);

10[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Numerics.Vector2))]

9[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Numerics.Vector2))]

100public Vector2 Translation 187public static Matrix3x2 CreateRotation(float radians, Vector2 centerPoint) 193public static Matrix3x2 CreateScale(Vector2 scales) 208public static Matrix3x2 CreateScale(float xScale, float yScale, Vector2 centerPoint) 215public static Matrix3x2 CreateScale(Vector2 scales, Vector2 centerPoint) 228public static Matrix3x2 CreateScale(float scale, Vector2 centerPoint) 243public static Matrix3x2 CreateSkew(float radiansX, float radiansY, Vector2 centerPoint) 249public static Matrix3x2 CreateTranslation(Vector2 position)

37public Vector2 X; 38public Vector2 Y; 39public Vector2 Z; 46X = Vector2.Create(m11, m12); 47Y = Vector2.Create(m21, m22); 48Z = Vector2.Create(m31, m32); 58result.X = Vector2.UnitX; 59result.Y = Vector2.UnitY; 60result.Z = Vector2.Zero; 94return (X == Vector2.UnitX) 95&& (Y == Vector2.UnitY) 96&& (Z == Vector2.Zero); 100public Vector2 Translation 148result.X = Vector2.Create( 152result.Y = Vector2.Create( 156result.Z = Vector2.Create( 244result.X = Vector2.Create( c, s); 245result.Y = Vector2.Create(-s, c); 246result.Z = Vector2.Zero; 252public static Impl CreateRotation(float radians, Vector2 centerPoint) 297result.X = Vector2.Create( c, s); 298result.Y = Vector2.Create(-s, c); 299result.Z = Vector2.Create( x, y); 305public static Impl CreateScale(Vector2 scales) 309result.X = Vector2.CreateScalar(scales.X); 310result.Y = Vector2.Create(0, scales.Y); 311result.Z = Vector2.Zero; 321result.X = Vector2.CreateScalar(scaleX); 322result.Y = Vector2.Create(0, scaleY); 323result.Z = Vector2.Zero; 329public static Impl CreateScale(float scaleX, float scaleY, Vector2 centerPoint) 333result.X = Vector2.CreateScalar(scaleX); 334result.Y = Vector2.Create(0, scaleY); 335result.Z = centerPoint * (Vector2.One - Vector2.Create(scaleX, scaleY)); 341public static Impl CreateScale(Vector2 scales, Vector2 centerPoint) 345result.X = Vector2.CreateScalar(scales.X); 346result.Y = Vector2.Create(0, scales.Y); 347result.Z = centerPoint * (Vector2.One - scales); 357result.X = Vector2.CreateScalar(scale); 358result.Y = Vector2.Create(0, scale); 359result.Z = Vector2.Zero; 365public static Impl CreateScale(float scale, Vector2 centerPoint) 369result.X = Vector2.CreateScalar(scale); 370result.Y = Vector2.Create(0, scale); 371result.Z = centerPoint * (Vector2.One - Vector2.Create(scale)); 381result.X = Vector2.Create(1, float.Tan(radiansY)); 382result.Y = Vector2.Create(float.Tan(radiansX), 1); 383result.Z = Vector2.Zero; 389public static Impl CreateSkew(float radiansX, float radiansY, Vector2 centerPoint) 399result.X = Vector2.Create(1, yTan); 400result.Y = Vector2.Create(xTan, 1); 401result.Z = Vector2.Create(tx, ty); 407public static Impl CreateTranslation(Vector2 position) 411result.X = Vector2.UnitX; 412result.Y = Vector2.UnitY; 423result.X = Vector2.UnitX; 424result.Y = Vector2.UnitY; 425result.Z = Vector2.Create(positionX, positionY); 437Vector2 vNaN = Vector2.Create(float.NaN); 448result.X = Vector2.Create( 452result.Y = Vector2.Create( 456result.Z = Vector2.Create( 469result.X = Vector2.Lerp(left.X, right.X, amount); 470result.Y = Vector2.Lerp(left.Y, right.Y, amount); 471result.Z = Vector2.Lerp(left.Z, right.Z, amount);

18public partial struct Vector2 : IEquatable<Vector2>, IFormattable 20/// <summary>Specifies the alignment of the vector as used by the <see cref="LoadAligned(float*)" /> and <see cref="Vector.StoreAligned(Vector2, float*)" /> APIs.</summary> 46/// <summary>Creates a new <see cref="Vector2" /> object whose two elements have the same value.</summary> 72public static Vector2 AllBitsSet 79public static Vector2 E 86public static Vector2 Epsilon 93public static Vector2 NaN 100public static Vector2 NegativeInfinity 107public static Vector2 NegativeZero 114public static Vector2 One 121public static Vector2 Pi 128public static Vector2 PositiveInfinity 135public static Vector2 Tau 143public static Vector2 UnitX 151public static Vector2 UnitY 158public static Vector2 Zero 184/// <remarks>The <see cref="op_Addition" /> method defines the addition operation for <see cref="Vector2" /> objects.</remarks> 187public static Vector2 operator +(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() + right.AsVector128Unsafe()).AsVector2(); 193/// <remarks>The <see cref="Vector2.op_Division" /> method defines the division operation for <see cref="Vector2" /> objects.</remarks> 196public static Vector2 operator /(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() / right.AsVector128Unsafe()).AsVector2(); 202/// <remarks>The <see cref="Vector2.op_Division" /> method defines the division operation for <see cref="Vector2" /> objects.</remarks> 205public static Vector2 operator /(Vector2 value1, float value2) => (value1.AsVector128Unsafe() / value2).AsVector2(); 211/// <remarks>Two <see cref="Vector2" /> objects are equal if each value in <paramref name="left" /> is equal to the corresponding value in <paramref name="right" />.</remarks> 214public static bool operator ==(Vector2 left, Vector2 right) => left.AsVector128() == right.AsVector128(); 221public static bool operator !=(Vector2 left, Vector2 right) => !(left == right); 227/// <remarks>The <see cref="Vector2.op_Multiply" /> method defines the multiplication operation for <see cref="Vector2" /> objects.</remarks> 230public static Vector2 operator *(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() * right.AsVector128Unsafe()).AsVector2(); 236/// <remarks>The <see cref="Vector2.op_Multiply" /> method defines the multiplication operation for <see cref="Vector2" /> objects.</remarks> 239public static Vector2 operator *(Vector2 left, float right) => (left.AsVector128Unsafe() * right).AsVector2(); 245/// <remarks>The <see cref="Vector2.op_Multiply" /> method defines the multiplication operation for <see cref="Vector2" /> objects.</remarks> 247public static Vector2 operator *(float left, Vector2 right) => right * left; 253/// <remarks>The <see cref="op_Subtraction" /> method defines the subtraction operation for <see cref="Vector2" /> objects.</remarks> 256public static Vector2 operator -(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() - right.AsVector128Unsafe()).AsVector2(); 261/// <remarks>The <see cref="op_UnaryNegation" /> method defines the unary negation operation for <see cref="Vector2" /> objects.</remarks> 264public static Vector2 operator -(Vector2 value) => (-value.AsVector128Unsafe()).AsVector2(); 269public static Vector2 operator &(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() & right.AsVector128Unsafe()).AsVector2(); 274public static Vector2 operator |(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() | right.AsVector128Unsafe()).AsVector2(); 279public static Vector2 operator ^(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() ^ right.AsVector128Unsafe()).AsVector2(); 284public static Vector2 operator <<(Vector2 value, int shiftAmount) => (value.AsVector128Unsafe() << shiftAmount).AsVector2(); 289public static Vector2 operator ~(Vector2 value) => (~value.AsVector128Unsafe()).AsVector2(); 294public static Vector2 operator >>(Vector2 value, int shiftAmount) => (value.AsVector128Unsafe() >> shiftAmount).AsVector2(); 299public static Vector2 operator +(Vector2 value) => value; 304public static Vector2 operator >>>(Vector2 value, int shiftAmount) => (value.AsVector128Unsafe() >>> shiftAmount).AsVector2(); 311public static Vector2 Abs(Vector2 value) => Vector128.Abs(value.AsVector128Unsafe()).AsVector2(); 318public static Vector2 Add(Vector2 left, Vector2 right) => left + right; 323public static bool All(Vector2 vector, float value) => Vector128.All(vector, value); 328public static bool AllWhereAllBitsSet(Vector2 vector) => Vector128.AllWhereAllBitsSet(vector); 333public static Vector2 AndNot(Vector2 left, Vector2 right) => Vector128.AndNot(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 338public static bool Any(Vector2 vector, float value) => Vector128.Any(vector, value); 343public static bool AnyWhereAllBitsSet(Vector2 vector) => Vector128.AnyWhereAllBitsSet(vector); 347public static Vector2 BitwiseAnd(Vector2 left, Vector2 right) => left & right; 351public static Vector2 BitwiseOr(Vector2 left, Vector2 right) => left | right; 356public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max) => Vector128.Clamp(value1.AsVector128Unsafe(), min.AsVector128Unsafe(), max.AsVector128Unsafe()).AsVector2(); 361public static Vector2 ClampNative(Vector2 value1, Vector2 min, Vector2 max) => Vector128.ClampNative(value1.AsVector128Unsafe(), min.AsVector128Unsafe(), max.AsVector128Unsafe()).AsVector2(); 366public static Vector2 ConditionalSelect(Vector2 condition, Vector2 left, Vector2 right) => Vector128.ConditionalSelect(condition.AsVector128Unsafe(), left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 371public static Vector2 CopySign(Vector2 value, Vector2 sign) => Vector128.CopySign(value.AsVector128Unsafe(), sign.AsVector128Unsafe()).AsVector2(); 375public static Vector2 Cos(Vector2 vector) => Vector128.Cos(vector.AsVector128()).AsVector2(); 380public static int Count(Vector2 vector, float value) => Vector128.Count(vector, value); 385public static int CountWhereAllBitsSet(Vector2 vector) => Vector128.CountWhereAllBitsSet(vector); 387/// <summary>Creates a new <see cref="Vector2" /> object whose two elements have the same value.</summary> 389/// <returns>A new <see cref="Vector2" /> whose two elements have the same value.</returns> 391public static Vector2 Create(float value) => Vector128.Create(value).AsVector2(); 396/// <returns>A new <see cref="Vector2" /> whose elements have the specified values.</returns> 398public static Vector2 Create(float x, float y) => Vector128.Create(x, y, 0, 0).AsVector2(); 402/// <returns>A new <see cref="Vector2" /> whose elements have the specified values.</returns> 405public static Vector2 Create(ReadOnlySpan<float> values) 411return Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 416/// <returns>A new <see cref="Vector2" /> with <see cref="X" /> initialized <paramref name="x" /> and the remaining elements initialized to zero.</returns> 418internal static Vector2 CreateScalar(float x) => Vector128.CreateScalar(x).AsVector2(); 422/// <returns>A new <see cref="Vector2" /> with <see cref="X" /> initialized <paramref name="x" /> and the remaining elements left uninitialized.</returns> 424internal static Vector2 CreateScalarUnsafe(float x) => Vector128.CreateScalarUnsafe(x).AsVector2(); 439public static float Cross(Vector2 value1, Vector2 value2) 453public static Vector2 DegreesToRadians(Vector2 degrees) => Vector128.DegreesToRadians(degrees.AsVector128Unsafe()).AsVector2(); 460public static float Distance(Vector2 value1, Vector2 value2) => float.Sqrt(DistanceSquared(value1, value2)); 467public static float DistanceSquared(Vector2 value1, Vector2 value2) => (value1 - value2).LengthSquared(); 474public static Vector2 Divide(Vector2 left, Vector2 right) => left / right; 481public static Vector2 Divide(Vector2 left, float divisor) => left / divisor; 489public static float Dot(Vector2 value1, Vector2 value2) => Vector128.Dot(value1.AsVector128(), value2.AsVector128()); 493public static Vector2 Exp(Vector2 vector) => Vector128.Exp(vector.AsVector128()).AsVector2(); 498public static Vector2 Equals(Vector2 left, Vector2 right) => Vector128.Equals(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 503public static bool EqualsAll(Vector2 left, Vector2 right) => Vector128.EqualsAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 508public static bool EqualsAny(Vector2 left, Vector2 right) => Vector128.EqualsAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 513public static Vector2 FusedMultiplyAdd(Vector2 left, Vector2 right, Vector2 addend) => Vector128.FusedMultiplyAdd(left.AsVector128Unsafe(), right.AsVector128Unsafe(), addend.AsVector128Unsafe()).AsVector2(); 518public static Vector2 GreaterThan(Vector2 left, Vector2 right) => Vector128.GreaterThan(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 523public static bool GreaterThanAll(Vector2 left, Vector2 right) => Vector128.GreaterThanAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 528public static bool GreaterThanAny(Vector2 left, Vector2 right) => Vector128.GreaterThanAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 533public static Vector2 GreaterThanOrEqual(Vector2 left, Vector2 right) => Vector128.GreaterThanOrEqual(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 538public static bool GreaterThanOrEqualAll(Vector2 left, Vector2 right) => Vector128.GreaterThanOrEqualAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 543public static bool GreaterThanOrEqualAny(Vector2 left, Vector2 right) => Vector128.GreaterThanOrEqualAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 548public static Vector2 Hypot(Vector2 x, Vector2 y) => Vector128.Hypot(x.AsVector128Unsafe(), y.AsVector128Unsafe()).AsVector2(); 553public static int IndexOf(Vector2 vector, float value) => Vector128.IndexOf(vector, value); 558public static int IndexOfWhereAllBitsSet(Vector2 vector) => Vector128.IndexOfWhereAllBitsSet(vector); 563public static Vector2 IsEvenInteger(Vector2 vector) => Vector128.IsEvenInteger(vector.AsVector128()).AsVector2(); 568public static Vector2 IsFinite(Vector2 vector) => Vector128.IsFinite(vector.AsVector128()).AsVector2(); 573public static Vector2 IsInfinity(Vector2 vector) => Vector128.IsInfinity(vector.AsVector128()).AsVector2(); 578public static Vector2 IsInteger(Vector2 vector) => Vector128.IsInteger(vector.AsVector128()).AsVector2(); 583public static Vector2 IsNaN(Vector2 vector) => Vector128.IsNaN(vector.AsVector128()).AsVector2(); 588public static Vector2 IsNegative(Vector2 vector) => Vector128.IsNegative(vector.AsVector128()).AsVector2(); 593public static Vector2 IsNegativeInfinity(Vector2 vector) => Vector128.IsNegativeInfinity(vector.AsVector128()).AsVector2(); 598public static Vector2 IsNormal(Vector2 vector) => Vector128.IsNormal(vector.AsVector128()).AsVector2(); 603public static Vector2 IsOddInteger(Vector2 vector) => Vector128.IsOddInteger(vector.AsVector128()).AsVector2(); 608public static Vector2 IsPositive(Vector2 vector) => Vector128.IsPositive(vector.AsVector128()).AsVector2(); 613public static Vector2 IsPositiveInfinity(Vector2 vector) => Vector128.IsPositiveInfinity(vector.AsVector128()).AsVector2(); 618public static Vector2 IsSubnormal(Vector2 vector) => Vector128.IsSubnormal(vector.AsVector128()).AsVector2(); 623public static Vector2 IsZero(Vector2 vector) => Vector128.IsZero(vector.AsVector128()).AsVector2(); 628public static int LastIndexOf(Vector2 vector, float value) => Vector128.LastIndexOf(vector, value); 633public static int LastIndexOfWhereAllBitsSet(Vector2 vector) => Vector128.LastIndexOfWhereAllBitsSet(vector); 638public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount) => Lerp(value1, value2, Create(amount)); 643public static Vector2 Lerp(Vector2 value1, Vector2 value2, Vector2 amount) => Vector128.Lerp(value1.AsVector128Unsafe(), value2.AsVector128Unsafe(), amount.AsVector128Unsafe()).AsVector2(); 648public static Vector2 LessThan(Vector2 left, Vector2 right) => Vector128.LessThan(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 653public static bool LessThanAll(Vector2 left, Vector2 right) => Vector128.LessThanAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 658public static bool LessThanAny(Vector2 left, Vector2 right) => Vector128.LessThanAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 663public static Vector2 LessThanOrEqual(Vector2 left, Vector2 right) => Vector128.LessThanOrEqual(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 668public static bool LessThanOrEqualAll(Vector2 left, Vector2 right) => Vector128.LessThanOrEqualAll(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 673public static bool LessThanOrEqualAny(Vector2 left, Vector2 right) => Vector128.LessThanOrEqualAny(left.AsVector128Unsafe(), right.AsVector128Unsafe()); 678public static unsafe Vector2 Load(float* source) => LoadUnsafe(in *source); 684public static unsafe Vector2 LoadAligned(float* source) 691return *(Vector2*)source; 697public static unsafe Vector2 LoadAlignedNonTemporal(float* source) => LoadAligned(source); 702public static Vector2 LoadUnsafe(ref readonly float source) 705return Unsafe.ReadUnaligned<Vector2>(in address); 712public static Vector2 LoadUnsafe(ref readonly float source, nuint elementOffset) 715return Unsafe.ReadUnaligned<Vector2>(in address); 720public static Vector2 Log(Vector2 vector) => Vector128.Log(Vector4.Create(vector, 1.0f, 1.0f).AsVector128()).AsVector2(); 724public static Vector2 Log2(Vector2 vector) => Vector128.Log2(Vector4.Create(vector, 1.0f, 1.0f).AsVector128()).AsVector2(); 729public static Vector2 Max(Vector2 value1, Vector2 value2) => Vector128.Max(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 734public static Vector2 MaxMagnitude(Vector2 value1, Vector2 value2) => Vector128.MaxMagnitude(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 739public static Vector2 MaxMagnitudeNumber(Vector2 value1, Vector2 value2) => Vector128.MaxMagnitudeNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 744public static Vector2 MaxNative(Vector2 value1, Vector2 value2) => Vector128.MaxNative(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 749public static Vector2 MaxNumber(Vector2 value1, Vector2 value2) => Vector128.MaxNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 754public static Vector2 Min(Vector2 value1, Vector2 value2) => Vector128.Min(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 759public static Vector2 MinMagnitude(Vector2 value1, Vector2 value2) => Vector128.MinMagnitude(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 764public static Vector2 MinMagnitudeNumber(Vector2 value1, Vector2 value2) => Vector128.MinMagnitudeNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 769public static Vector2 MinNative(Vector2 value1, Vector2 value2) => Vector128.MinNative(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 774public static Vector2 MinNumber(Vector2 value1, Vector2 value2) => Vector128.MinNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 781public static Vector2 Multiply(Vector2 left, Vector2 right) => left * right; 788public static Vector2 Multiply(Vector2 left, float right) => left * right; 795public static Vector2 Multiply(float left, Vector2 right) => left * right; 800public static Vector2 MultiplyAddEstimate(Vector2 left, Vector2 right, Vector2 addend) => Vector128.MultiplyAddEstimate(left.AsVector128Unsafe(), right.AsVector128Unsafe(), addend.AsVector128Unsafe()).AsVector2(); 806public static Vector2 Negate(Vector2 value) => -value; 811public static bool None(Vector2 vector, float value) => Vector128.None(vector, value); 816public static bool NoneWhereAllBitsSet(Vector2 vector) => Vector128.NoneWhereAllBitsSet(vector); 822public static Vector2 Normalize(Vector2 value) => value / value.Length(); 826public static Vector2 OnesComplement(Vector2 value) => ~value; 831public static Vector2 RadiansToDegrees(Vector2 radians) => Vector128.RadiansToDegrees(radians.AsVector128Unsafe()).AsVector2(); 838public static Vector2 Reflect(Vector2 vector, Vector2 normal) 843Vector2 tmp = Create(Dot(vector, normal)); 850public static Vector2 Round(Vector2 vector) => Vector128.Round(vector.AsVector128Unsafe()).AsVector2(); 854public static Vector2 Round(Vector2 vector, MidpointRounding mode) => Vector128.Round(vector.AsVector128Unsafe(), mode).AsVector2(); 862public static Vector2 Shuffle(Vector2 vector, byte xIndex, byte yIndex) 871public static Vector2 Sin(Vector2 vector) => Vector128.Sin(vector.AsVector128()).AsVector2(); 875public static (Vector2 Sin, Vector2 Cos) SinCos(Vector2 vector) 886public static Vector2 SquareRoot(Vector2 value) => Vector128.Sqrt(value.AsVector128Unsafe()).AsVector2(); 893public static Vector2 Subtract(Vector2 left, Vector2 right) => left - right; 898public static float Sum(Vector2 value) => Vector128.Sum(value.AsVector128()); 904public static Vector2 Transform(Vector2 position, Matrix3x2 matrix) => Transform(position, in matrix.AsImpl()); 907internal static Vector2 Transform(Vector2 position, in Matrix3x2.Impl matrix) 909Vector2 result = matrix.X * position.X; 919public static Vector2 Transform(Vector2 position, Matrix4x4 matrix) => Vector4.Transform(position, in matrix.AsImpl()).AsVector128().AsVector2(); 926public static Vector2 Transform(Vector2 value, Quaternion rotation) => Vector4.Transform(value, rotation).AsVector2(); 932public static Vector2 TransformNormal(Vector2 normal, Matrix3x2 matrix) => TransformNormal(normal, in matrix.AsImpl()); 935internal static Vector2 TransformNormal(Vector2 normal, in Matrix3x2.Impl matrix) 937Vector2 result = matrix.X * normal.X; 946public static Vector2 TransformNormal(Vector2 normal, Matrix4x4 matrix) => TransformNormal(normal, in matrix.AsImpl()); 949internal static Vector2 TransformNormal(Vector2 normal, in Matrix4x4.Impl matrix) 958public static Vector2 Truncate(Vector2 vector) => Vector128.Truncate(vector.AsVector128Unsafe()).AsVector2(); 962public static Vector2 Xor(Vector2 left, Vector2 right) => left ^ right; 1043/// <remarks>The current instance and <paramref name="obj" /> are equal if <paramref name="obj" /> is a <see cref="Vector2" /> object and their <see cref="X" /> and <see cref="Y" /> elements are equal.</remarks> 1044public override readonly bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector2 other) && Equals(other); 1051public readonly bool Equals(Vector2 other) => this.AsVector128().Equals(other.AsVector128());

12/// <summary>Reinterprets a <see cref="Vector2" /> to a new <see cref="Vector4" /> with the new elements zeroed.</summary> 15public static Vector4 AsVector4(this Vector2 value) => value.AsVector128().AsVector4(); 17/// <summary>Reinterprets a <see cref="Vector2" /> to a new <see cref="Vector4" /> with the new elements undefined.</summary> 20public static Vector4 AsVector4Unsafe(this Vector2 value) => value.AsVector128Unsafe().AsVector4(); 25public static uint ExtractMostSignificantBits(this Vector2 vector) => vector.AsVector128().ExtractMostSignificantBits(); 29public static float GetElement(this Vector2 vector, int index) 31if ((uint)index >= Vector2.ElementCount) 42public static void Store(this Vector2 source, float* destination) => source.StoreUnsafe(ref *destination); 50public static void StoreAligned(this Vector2 source, float* destination) 52if (((nuint)destination % (uint)(Vector2.Alignment)) != 0) 57*(Vector2*)destination = source; 66public static void StoreAlignedNonTemporal(this Vector2 source, float* destination) => source.StoreAligned(destination); 72public static void StoreUnsafe(this Vector2 source, ref float destination) 84public static void StoreUnsafe(this Vector2 source, ref float destination, nuint elementOffset) 92public static float ToScalar(this Vector2 vector) => vector.AsVector128Unsafe().ToScalar(); 96public static Vector2 WithElement(this Vector2 vector, int index, float value) 98if ((uint)index >= Vector2.ElementCount)

57/// <summary>Creates a new <see cref="Vector3" /> object from the specified <see cref="Vector2" /> object and the specified value.</summary> 61public Vector3(Vector2 value, float z) 414/// <summary>Creates a new <see cref="Vector3" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 417/// <returns>A new <see cref="Vector3" /> from the specified <see cref="Vector2" /> object and a Z and a W component.</returns> 420public static Vector3 Create(Vector2 vector, float z)

59/// <summary>Creates a new <see cref="Vector4" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 64public Vector4(Vector2 value, float z, float w) 446/// <summary>Creates a new <see cref="Vector4" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 450/// <returns>A new <see cref="Vector4" /> from the specified <see cref="Vector2" /> object and a Z and a W component.</returns> 453public static Vector4 Create(Vector2 vector, float z, float w) 969public static Vector4 Transform(Vector2 position, Matrix4x4 matrix) => Transform(position, in matrix.AsImpl()); 972internal static Vector4 Transform(Vector2 position, in Matrix4x4.Impl matrix) 987public static Vector4 Transform(Vector2 value, Quaternion rotation) => Transform(Create(value, 0.0f, 1.0f), rotation);

36/// <summary>Reinterprets a <see cref="Vector4" /> as a new <see cref="Vector2" />.</summary> 38/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector2" />.</returns> 39public static Vector2 AsVector2(this Vector4 value) => value.AsVector128().AsVector2();

15internal static bool All(Vector2 vector, float value) => vector.AsVector128() == Vector2.Create(value).AsVector128(); 25internal static bool AllWhereAllBitsSet(Vector2 vector) => vector.AsVector128().AsInt32() == Vector2.AllBitsSet.AsVector128().AsInt32(); 35internal static bool Any(Vector2 vector, float value) => EqualsAny(vector.AsVector128(), Create(value, value, -1, -1)); 45internal static bool AnyWhereAllBitsSet(Vector2 vector) => EqualsAny(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet); 108public static Vector128<float> AsVector128(this Vector2 value) => Vector4.Create(value, 0, 0).AsVector128(); 149public static Vector128<float> AsVector128Unsafe(this Vector2 value) 173/// <summary>Reinterprets a <see langword="Vector128&lt;Single&gt;" /> as a new <see cref="Vector2" />.</summary> 175/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector2" />.</returns> 178public static Vector2 AsVector2(this Vector128<float> value) 181return Unsafe.ReadUnaligned<Vector2>(ref address); 228internal static int Count(Vector2 vector, float value) => BitOperations.PopCount(Equals(vector.AsVector128(), Create(value, value, -1, -1)).ExtractMostSignificantBits()); 238internal static int CountWhereAllBitsSet(Vector2 vector) => BitOperations.PopCount(Equals(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet).ExtractMostSignificantBits()); 248internal static int IndexOf(Vector2 vector, float value) 266internal static int IndexOfWhereAllBitsSet(Vector2 vector) 284internal static int LastIndexOf(Vector2 vector, float value) => 31 - BitOperations.LeadingZeroCount(Equals(vector.AsVector128(), Create(value, value, -1, -1)).ExtractMostSignificantBits()); 294internal static int LastIndexOfWhereAllBitsSet(Vector2 vector) => 31 - BitOperations.LeadingZeroCount(Equals(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet).ExtractMostSignificantBits()); 304internal static bool None(Vector2 vector, float value) => !EqualsAny(vector.AsVector128(), Create(value, value, -1, -1)); 314internal static bool NoneWhereAllBitsSet(Vector2 vector) => !EqualsAny(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet);