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);

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))]

3219Vector2 currentOffset = default; // Offset of current context. 3220Vector2 totalOffset = default; // Absolute coordinate offset of top context. 3364Vector2 translation = cumulativeTransform.Translation; 3378Vector2 translation = cumulativeTransform.Translation;

42public Vector2 TransformOffset { get; private set; }

13internal static void Translate(this ref Matrix3x2 matrix, Vector2 offset) 20internal static bool IsEmpty(this Vector2 vector) => vector.X == 0 && vector.Y == 0;

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))]

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

47public Vector2 X; 48public Vector2 Y; 49public Vector2 Z; 100get => Create(Vector2.UnitX, Vector2.UnitY, Vector2.Zero); 112return (impl.X == Vector2.UnitX) 113&& (impl.Y == Vector2.UnitY) 114&& (impl.Z == Vector2.Zero); 120public Vector2 Translation 131public Vector2 X 142public Vector2 Y 153public Vector2 Z 166public Vector2 this[int row] 430result.Z = Vector2.Transform(left.Z.AsVector128Unsafe(), in right).AsVector2(); 512Vector2 vector = Vector2.Create(value); 527public static Matrix3x2 Create(Vector2 value) 544public static Matrix3x2 Create(Vector2 x, Vector2 y, Vector2 z) 570result.X = Vector2.Create(m11, m12); 571result.Y = Vector2.Create(m21, m22); 572result.Z = Vector2.Create(m31, m32); 624result.X = Vector2.Create(c, s); 625result.Y = Vector2.Create(-s, c); 626result.Z = Vector2.Zero; 636public static Matrix3x2 CreateRotation(float radians, Vector2 centerPoint) 681result.X = Vector2.Create(c, s); 682result.Y = Vector2.Create(-s, c); 683result.Z = Vector2.Create(x, y); 692public static Matrix3x2 CreateScale(Vector2 scales) 696result.X = Vector2.CreateScalar(scales.X); 697result.Y = Vector2.Create(0, scales.Y); 698result.Z = Vector2.Zero; 712result.X = Vector2.CreateScalar(xScale); 713result.Y = Vector2.Create(0, yScale); 714result.Z = Vector2.Zero; 725public static Matrix3x2 CreateScale(float xScale, float yScale, Vector2 centerPoint) 729result.X = Vector2.CreateScalar(xScale); 730result.Y = Vector2.Create(0, yScale); 731result.Z = centerPoint * (Vector2.One - Vector2.Create(xScale, yScale)); 741public static Matrix3x2 CreateScale(Vector2 scales, Vector2 centerPoint) 745result.X = Vector2.CreateScalar(scales.X); 746result.Y = Vector2.Create(0, scales.Y); 747result.Z = centerPoint * (Vector2.One - scales); 760result.X = Vector2.CreateScalar(scale); 761result.Y = Vector2.Create(0, scale); 762result.Z = Vector2.Zero; 772public static Matrix3x2 CreateScale(float scale, Vector2 centerPoint) 776result.X = Vector2.CreateScalar(scale); 777result.Y = Vector2.Create(0, scale); 792result.X = Vector2.Create(1, float.Tan(radiansY)); 793result.Y = Vector2.Create(float.Tan(radiansX), 1); 794result.Z = Vector2.Zero; 805public static Matrix3x2 CreateSkew(float radiansX, float radiansY, Vector2 centerPoint) 815result.X = Vector2.Create(1, yTan); 816result.Y = Vector2.Create(xTan, 1); 817result.Z = Vector2.Create(tx, ty); 826public static Matrix3x2 CreateTranslation(Vector2 position) 830result.X = Vector2.UnitX; 831result.Y = Vector2.UnitY; 846result.X = Vector2.UnitX; 847result.Y = Vector2.UnitY; 848result.Z = Vector2.Create(xPosition, yPosition); 866Vector2 vNaN = Vector2.NaN; 877resultImpl.X = Vector2.Create( 881resultImpl.Y = Vector2.Create( 885resultImpl.Z = Vector2.Create( 906result.X = Vector2.Lerp(left.X, right.X, amount); 907result.Y = Vector2.Lerp(left.Y, right.Y, amount); 908result.Z = Vector2.Lerp(left.Z, right.Z, amount); 1010public readonly Vector2 GetRow(int index) => this[index]; 1050public readonly Matrix3x2 WithRow(int index, Vector2 value)

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> 75public static Vector2 AllBitsSet 83public static Vector2 E 91public static Vector2 Epsilon 99public static Vector2 NaN 107public static Vector2 NegativeInfinity 115public static Vector2 NegativeZero 123public static Vector2 One 131public static Vector2 Pi 139public static Vector2 PositiveInfinity 147public static Vector2 Tau 156public static Vector2 UnitX 165public static Vector2 UnitY 173public static Vector2 Zero 202/// <remarks>The <see cref="op_Addition" /> method defines the addition operation for <see cref="Vector2" /> objects.</remarks> 205public static Vector2 operator +(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() + right.AsVector128Unsafe()).AsVector2(); 211/// <remarks>The <see cref="Vector2.op_Division" /> method defines the division operation for <see cref="Vector2" /> objects.</remarks> 214public static Vector2 operator /(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() / right.AsVector128Unsafe()).AsVector2(); 220/// <remarks>The <see cref="Vector2.op_Division" /> method defines the division operation for <see cref="Vector2" /> objects.</remarks> 223public static Vector2 operator /(Vector2 value1, float value2) => (value1.AsVector128Unsafe() / value2).AsVector2(); 229/// <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> 232public static bool operator ==(Vector2 left, Vector2 right) => left.AsVector128() == right.AsVector128(); 240public static bool operator !=(Vector2 left, Vector2 right) => left.AsVector128() != right.AsVector128(); 246/// <remarks>The <see cref="Vector2.op_Multiply" /> method defines the multiplication operation for <see cref="Vector2" /> objects.</remarks> 249public static Vector2 operator *(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() * right.AsVector128Unsafe()).AsVector2(); 255/// <remarks>The <see cref="Vector2.op_Multiply" /> method defines the multiplication operation for <see cref="Vector2" /> objects.</remarks> 258public static Vector2 operator *(Vector2 left, float right) => (left.AsVector128Unsafe() * right).AsVector2(); 264/// <remarks>The <see cref="Vector2.op_Multiply" /> method defines the multiplication operation for <see cref="Vector2" /> objects.</remarks> 267public static Vector2 operator *(float left, Vector2 right) => (right.AsVector128Unsafe() * left).AsVector2(); 273/// <remarks>The <see cref="op_Subtraction" /> method defines the subtraction operation for <see cref="Vector2" /> objects.</remarks> 276public static Vector2 operator -(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() - right.AsVector128Unsafe()).AsVector2(); 281/// <remarks>The <see cref="op_UnaryNegation" /> method defines the unary negation operation for <see cref="Vector2" /> objects.</remarks> 284public static Vector2 operator -(Vector2 value) => (-value.AsVector128Unsafe()).AsVector2(); 289public static Vector2 operator &(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() & right.AsVector128Unsafe()).AsVector2(); 294public static Vector2 operator |(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() | right.AsVector128Unsafe()).AsVector2(); 299public static Vector2 operator ^(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() ^ right.AsVector128Unsafe()).AsVector2(); 304public static Vector2 operator <<(Vector2 value, int shiftAmount) => (value.AsVector128Unsafe() << shiftAmount).AsVector2(); 309public static Vector2 operator ~(Vector2 value) => (~value.AsVector128Unsafe()).AsVector2(); 314public static Vector2 operator >>(Vector2 value, int shiftAmount) => (value.AsVector128Unsafe() >> shiftAmount).AsVector2(); 319public static Vector2 operator +(Vector2 value) => value; 324public static Vector2 operator >>>(Vector2 value, int shiftAmount) => (value.AsVector128Unsafe() >>> shiftAmount).AsVector2(); 331public static Vector2 Abs(Vector2 value) => Vector128.Abs(value.AsVector128Unsafe()).AsVector2(); 339public static Vector2 Add(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() + right.AsVector128Unsafe()).AsVector2(); 344public static bool All(Vector2 vector, float value) => Vector128.All(vector, value); 349public static bool AllWhereAllBitsSet(Vector2 vector) => Vector128.AllWhereAllBitsSet(vector); 354public static Vector2 AndNot(Vector2 left, Vector2 right) => Vector128.AndNot(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 359public static bool Any(Vector2 vector, float value) => Vector128.Any(vector, value); 364public static bool AnyWhereAllBitsSet(Vector2 vector) => Vector128.AnyWhereAllBitsSet(vector); 369public static Vector2 BitwiseAnd(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() & right.AsVector128Unsafe()).AsVector2(); 374public static Vector2 BitwiseOr(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() | right.AsVector128Unsafe()).AsVector2(); 379public static Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max) => Vector128.Clamp(value1.AsVector128Unsafe(), min.AsVector128Unsafe(), max.AsVector128Unsafe()).AsVector2(); 384public static Vector2 ClampNative(Vector2 value1, Vector2 min, Vector2 max) => Vector128.ClampNative(value1.AsVector128Unsafe(), min.AsVector128Unsafe(), max.AsVector128Unsafe()).AsVector2(); 389public static Vector2 ConditionalSelect(Vector2 condition, Vector2 left, Vector2 right) => Vector128.ConditionalSelect(condition.AsVector128Unsafe(), left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 394public static Vector2 CopySign(Vector2 value, Vector2 sign) => Vector128.CopySign(value.AsVector128Unsafe(), sign.AsVector128Unsafe()).AsVector2(); 398public static Vector2 Cos(Vector2 vector) => Vector128.Cos(vector.AsVector128()).AsVector2(); 403public static int Count(Vector2 vector, float value) => Vector128.Count(vector, value); 408public static int CountWhereAllBitsSet(Vector2 vector) => Vector128.CountWhereAllBitsSet(vector); 410/// <summary>Creates a new <see cref="Vector2" /> object whose two elements have the same value.</summary> 412/// <returns>A new <see cref="Vector2" /> whose two elements have the same value.</returns> 415public static Vector2 Create(float value) => Vector128.Create(value).AsVector2(); 420/// <returns>A new <see cref="Vector2" /> whose elements have the specified values.</returns> 423public static Vector2 Create(float x, float y) => Vector128.Create(x, y, 0.0f, 0.0f).AsVector2(); 427/// <returns>A new <see cref="Vector2" /> whose elements have the specified values.</returns> 430public static Vector2 Create(ReadOnlySpan<float> values) 436return Unsafe.As<float, Vector2>(ref MemoryMarshal.GetReference(values)); 441/// <returns>A new <see cref="Vector2" /> with <see cref="X" /> initialized <paramref name="x" /> and the remaining elements initialized to zero.</returns> 444public static Vector2 CreateScalar(float x) => Vector128.CreateScalar(x).AsVector2(); 448/// <returns>A new <see cref="Vector2" /> with <see cref="X" /> initialized <paramref name="x" /> and the remaining elements left uninitialized.</returns> 451public static Vector2 CreateScalarUnsafe(float x) => Vector128.CreateScalarUnsafe(x).AsVector2(); 466public static float Cross(Vector2 value1, Vector2 value2) 476public static Vector2 DegreesToRadians(Vector2 degrees) => Vector128.DegreesToRadians(degrees.AsVector128Unsafe()).AsVector2(); 484public static float Distance(Vector2 value1, Vector2 value2) => Vector128.Distance(value1.AsVector128(), value2.AsVector128()); 492public static float DistanceSquared(Vector2 value1, Vector2 value2) => Vector128.DistanceSquared(value1.AsVector128(), value2.AsVector128()); 500public static Vector2 Divide(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() / right.AsVector128Unsafe()).AsVector2(); 508public static Vector2 Divide(Vector2 left, float divisor) => (left.AsVector128Unsafe() / divisor).AsVector2(); 516public static float Dot(Vector2 value1, Vector2 value2) => Vector128.Dot(value1.AsVector128(), value2.AsVector128()); 520public static Vector2 Exp(Vector2 vector) => Vector128.Exp(vector.AsVector128()).AsVector2(); 525public static Vector2 Equals(Vector2 left, Vector2 right) => Vector128.Equals(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 530public static bool EqualsAll(Vector2 left, Vector2 right) => Vector128.EqualsAll(left.AsVector128(), right.AsVector128()); 535public static bool EqualsAny(Vector2 left, Vector2 right) => Vector128.EqualsAny(Vector128.Equals(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 540public static Vector2 FusedMultiplyAdd(Vector2 left, Vector2 right, Vector2 addend) => Vector128.FusedMultiplyAdd(left.AsVector128Unsafe(), right.AsVector128Unsafe(), addend.AsVector128Unsafe()).AsVector2(); 545public static Vector2 GreaterThan(Vector2 left, Vector2 right) => Vector128.GreaterThan(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 550public static bool GreaterThanAll(Vector2 left, Vector2 right) => Vector128.EqualsAll(Vector128.GreaterThan(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 555public static bool GreaterThanAny(Vector2 left, Vector2 right) => Vector128.EqualsAny(Vector128.GreaterThan(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 560public static Vector2 GreaterThanOrEqual(Vector2 left, Vector2 right) => Vector128.GreaterThanOrEqual(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 565public static bool GreaterThanOrEqualAll(Vector2 left, Vector2 right) => Vector128.EqualsAll(Vector128.GreaterThanOrEqual(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128<int>.AllBitsSet); 570public static bool GreaterThanOrEqualAny(Vector2 left, Vector2 right) => Vector128.EqualsAny(Vector128.GreaterThanOrEqual(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 575public static Vector2 Hypot(Vector2 x, Vector2 y) => Vector128.Hypot(x.AsVector128Unsafe(), y.AsVector128Unsafe()).AsVector2(); 580public static int IndexOf(Vector2 vector, float value) => Vector128.IndexOf(vector, value); 585public static int IndexOfWhereAllBitsSet(Vector2 vector) => Vector128.IndexOfWhereAllBitsSet(vector); 590public static Vector2 IsEvenInteger(Vector2 vector) => Vector128.IsEvenInteger(vector.AsVector128Unsafe()).AsVector2(); 595public static Vector2 IsFinite(Vector2 vector) => Vector128.IsFinite(vector.AsVector128Unsafe()).AsVector2(); 600public static Vector2 IsInfinity(Vector2 vector) => Vector128.IsInfinity(vector.AsVector128Unsafe()).AsVector2(); 605public static Vector2 IsInteger(Vector2 vector) => Vector128.IsInteger(vector.AsVector128Unsafe()).AsVector2(); 610public static Vector2 IsNaN(Vector2 vector) => Vector128.IsNaN(vector.AsVector128Unsafe()).AsVector2(); 615public static Vector2 IsNegative(Vector2 vector) => Vector128.IsNegative(vector.AsVector128Unsafe()).AsVector2(); 620public static Vector2 IsNegativeInfinity(Vector2 vector) => Vector128.IsNegativeInfinity(vector.AsVector128Unsafe()).AsVector2(); 625public static Vector2 IsNormal(Vector2 vector) => Vector128.IsNormal(vector.AsVector128Unsafe()).AsVector2(); 630public static Vector2 IsOddInteger(Vector2 vector) => Vector128.IsOddInteger(vector.AsVector128Unsafe()).AsVector2(); 635public static Vector2 IsPositive(Vector2 vector) => Vector128.IsPositive(vector.AsVector128Unsafe()).AsVector2(); 640public static Vector2 IsPositiveInfinity(Vector2 vector) => Vector128.IsPositiveInfinity(vector.AsVector128Unsafe()).AsVector2(); 645public static Vector2 IsSubnormal(Vector2 vector) => Vector128.IsSubnormal(vector.AsVector128Unsafe()).AsVector2(); 650public static Vector2 IsZero(Vector2 vector) => Vector128.IsZero(vector.AsVector128Unsafe()).AsVector2(); 655public static int LastIndexOf(Vector2 vector, float value) => Vector128.LastIndexOf(vector, value); 660public static int LastIndexOfWhereAllBitsSet(Vector2 vector) => Vector128.LastIndexOfWhereAllBitsSet(vector); 665public static Vector2 Lerp(Vector2 value1, Vector2 value2, float amount) => Vector128.Lerp(value1.AsVector128Unsafe(), value2.AsVector128Unsafe(), Vector128.Create(amount)).AsVector2(); 670public static Vector2 Lerp(Vector2 value1, Vector2 value2, Vector2 amount) => Vector128.Lerp(value1.AsVector128Unsafe(), value2.AsVector128Unsafe(), amount.AsVector128Unsafe()).AsVector2(); 675public static Vector2 LessThan(Vector2 left, Vector2 right) => Vector128.LessThan(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 680public static bool LessThanAll(Vector2 left, Vector2 right) => Vector128.EqualsAll(Vector128.LessThan(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 685public static bool LessThanAny(Vector2 left, Vector2 right) => Vector128.EqualsAny(Vector128.LessThan(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 690public static Vector2 LessThanOrEqual(Vector2 left, Vector2 right) => Vector128.LessThanOrEqual(left.AsVector128Unsafe(), right.AsVector128Unsafe()).AsVector2(); 695public static bool LessThanOrEqualAll(Vector2 left, Vector2 right) => Vector128.EqualsAll(Vector128.LessThanOrEqual(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128<int>.AllBitsSet); 700public static bool LessThanOrEqualAny(Vector2 left, Vector2 right) => Vector128.EqualsAny(Vector128.LessThanOrEqual(left.AsVector128(), right.AsVector128()).AsInt32(), Vector128.Create(-1, -1, 0, 0)); 706public static unsafe Vector2 Load(float* source) => *(Vector2*)source; 712public static unsafe Vector2 LoadAligned(float* source) 718return *(Vector2*)source; 725public static unsafe Vector2 LoadAlignedNonTemporal(float* source) => LoadAligned(source); 730public static Vector2 LoadUnsafe(ref readonly float source) => Unsafe.As<float, Vector2>(ref Unsafe.AsRef(in source)); 736public static Vector2 LoadUnsafe(ref readonly float source, nuint elementOffset) => Unsafe.As<float, Vector2>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset)); 740public static Vector2 Log(Vector2 vector) => Vector128.Log(Vector4.Create(vector, 1.0f, 1.0f).AsVector128()).AsVector2(); 744public static Vector2 Log2(Vector2 vector) => Vector128.Log2(Vector4.Create(vector, 1.0f, 1.0f).AsVector128()).AsVector2(); 749public static Vector2 Max(Vector2 value1, Vector2 value2) => Vector128.Max(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 754public static Vector2 MaxMagnitude(Vector2 value1, Vector2 value2) => Vector128.MaxMagnitude(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 759public static Vector2 MaxMagnitudeNumber(Vector2 value1, Vector2 value2) => Vector128.MaxMagnitudeNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 764public static Vector2 MaxNative(Vector2 value1, Vector2 value2) => Vector128.MaxNative(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 769public static Vector2 MaxNumber(Vector2 value1, Vector2 value2) => Vector128.MaxNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 774public static Vector2 Min(Vector2 value1, Vector2 value2) => Vector128.Min(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 779public static Vector2 MinMagnitude(Vector2 value1, Vector2 value2) => Vector128.MinMagnitude(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 784public static Vector2 MinMagnitudeNumber(Vector2 value1, Vector2 value2) => Vector128.MinMagnitudeNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 789public static Vector2 MinNative(Vector2 value1, Vector2 value2) => Vector128.MinNative(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 794public static Vector2 MinNumber(Vector2 value1, Vector2 value2) => Vector128.MinNumber(value1.AsVector128Unsafe(), value2.AsVector128Unsafe()).AsVector2(); 802public static Vector2 Multiply(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() * right.AsVector128Unsafe()).AsVector2(); 810public static Vector2 Multiply(Vector2 left, float right) => (left.AsVector128Unsafe() * right).AsVector2(); 818public static Vector2 Multiply(float left, Vector2 right) => (right.AsVector128Unsafe() * left).AsVector2(); 823public static Vector2 MultiplyAddEstimate(Vector2 left, Vector2 right, Vector2 addend) => Vector128.MultiplyAddEstimate(left.AsVector128Unsafe(), right.AsVector128Unsafe(), addend.AsVector128Unsafe()).AsVector2(); 830public static Vector2 Negate(Vector2 value) => (-value.AsVector128Unsafe()).AsVector2(); 835public static bool None(Vector2 vector, float value) => Vector128.None(vector, value); 840public static bool NoneWhereAllBitsSet(Vector2 vector) => Vector128.NoneWhereAllBitsSet(vector); 847public static Vector2 Normalize(Vector2 value) => Vector128.Normalize(value.AsVector128()).AsVector2(); 852public static Vector2 OnesComplement(Vector2 value) => (~value.AsVector128Unsafe()).AsVector2(); 857public static Vector2 RadiansToDegrees(Vector2 radians) => Vector128.RadiansToDegrees(radians.AsVector128Unsafe()).AsVector2(); 864public static Vector2 Reflect(Vector2 vector, Vector2 normal) 879public static Vector2 Round(Vector2 vector) => Vector128.Round(vector.AsVector128Unsafe()).AsVector2(); 884public static Vector2 Round(Vector2 vector, MidpointRounding mode) => Vector128.Round(vector.AsVector128Unsafe(), mode).AsVector2(); 892public static Vector2 Shuffle(Vector2 vector, byte xIndex, byte yIndex) 901public static Vector2 Sin(Vector2 vector) => Vector128.Sin(vector.AsVector128()).AsVector2(); 905public static (Vector2 Sin, Vector2 Cos) SinCos(Vector2 vector) 916public static Vector2 SquareRoot(Vector2 value) => Vector128.Sqrt(value.AsVector128Unsafe()).AsVector2(); 924public static Vector2 Subtract(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() - right.AsVector128Unsafe()).AsVector2(); 929public static float Sum(Vector2 value) => Vector128.Sum(value.AsVector128()); 936public static Vector2 Transform(Vector2 position, Matrix3x2 matrix) => Transform(position.AsVector128Unsafe(), in matrix.AsROImpl()).AsVector2(); 951public static Vector2 Transform(Vector2 position, Matrix4x4 matrix) => Transform(position.AsVector128Unsafe(), in matrix.AsROImpl()).AsVector2(); 969public static Vector2 Transform(Vector2 value, Quaternion rotation) => Vector4.Transform(value.AsVector128().WithElement(3, 1.0f), rotation.AsVector128()).AsVector2(); 976public static Vector2 TransformNormal(Vector2 normal, Matrix3x2 matrix) => TransformNormal(normal.AsVector128Unsafe(), in matrix.AsROImpl()).AsVector2(); 991public static Vector2 TransformNormal(Vector2 normal, Matrix4x4 matrix) => TransformNormal(normal.AsVector128Unsafe(), in matrix.AsROImpl()).AsVector2(); 1004public static Vector2 Truncate(Vector2 vector) => Vector128.Truncate(vector.AsVector128Unsafe()).AsVector2(); 1009public static Vector2 Xor(Vector2 left, Vector2 right) => (left.AsVector128Unsafe() ^ right.AsVector128Unsafe()).AsVector2(); 1026Unsafe.As<float, Vector2>(ref array[0]) = this; 1054Unsafe.As<float, Vector2>(ref array[index]) = this; 1067Unsafe.As<float, Vector2>(ref MemoryMarshal.GetReference(destination)) = this; 1081Unsafe.As<float, Vector2>(ref MemoryMarshal.GetReference(destination)) = this; 1088/// <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> 1089public override readonly bool Equals([NotNullWhen(true)] object? obj) => (obj is Vector2 other) && Equals(other); 1096public readonly bool Equals(Vector2 other) => this.AsVector128().Equals(other.AsVector128());

11/// <summary>Reinterprets a <see cref="Vector2" /> to a new <see cref="Vector3" /> with the new elements zeroed.</summary> 14public static Vector3 AsVector3(this Vector2 value) => value.AsVector128().AsVector3(); 16/// <summary>Reinterprets a <see cref="Vector2" /> to a new <see cref="Vector3" /> with the new elements undefined.</summary> 19public static Vector3 AsVector3Unsafe(this Vector2 value) => value.AsVector128Unsafe().AsVector3(); 21/// <summary>Reinterprets a <see cref="Vector2" /> to a new <see cref="Vector4" /> with the new elements zeroed.</summary> 24public static Vector4 AsVector4(this Vector2 value) => value.AsVector128().AsVector4(); 26/// <summary>Reinterprets a <see cref="Vector2" /> to a new <see cref="Vector4" /> with the new elements undefined.</summary> 29public static Vector4 AsVector4Unsafe(this Vector2 value) => value.AsVector128Unsafe().AsVector4(); 34public static uint ExtractMostSignificantBits(this Vector2 vector) => vector.AsVector128().ExtractMostSignificantBits(); 38public static float GetElement(this Vector2 vector, int index) 40if ((uint)index >= Vector2.ElementCount) 51public static void Store(this Vector2 source, float* destination) 53*(Vector2*)destination = source; 62public static void StoreAligned(this Vector2 source, float* destination) 64if (((nuint)destination % (uint)(Vector2.Alignment)) != 0) 68*(Vector2*)destination = source; 77public static void StoreAlignedNonTemporal(this Vector2 source, float* destination) 79if (((nuint)destination % (uint)(Vector2.Alignment)) != 0) 83*(Vector2*)destination = source; 90public static void StoreUnsafe(this Vector2 source, ref float destination) 92Unsafe.As<float, Vector2>(ref destination) = source; 101public static void StoreUnsafe(this Vector2 source, ref float destination, nuint elementOffset) 103Unsafe.As<float, Vector2>(ref Unsafe.Add(ref destination, (nint)elementOffset)) = source; 108public static float ToScalar(this Vector2 vector) => vector.AsVector128Unsafe().ToScalar(); 112public static Vector2 WithElement(this Vector2 vector, int index, float value) 114if ((uint)index >= Vector2.ElementCount)

58/// <summary>Creates a new <see cref="Vector3" /> object from the specified <see cref="Vector2" /> object and the specified value.</summary> 63public Vector3(Vector2 value, float z) 440/// <summary>Creates a new <see cref="Vector3" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 443/// <returns>A new <see cref="Vector3" /> from the specified <see cref="Vector2" /> object and a Z and a W component.</returns> 446public static Vector3 Create(Vector2 vector, float z)

11/// <summary>Reinterprets a <see cref="Vector3" /> as a new <see cref="Vector2" />.</summary> 13/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector2" />.</returns> 14public static Vector2 AsVector2(this Vector3 value) => value.AsVector128Unsafe().AsVector2();

61/// <summary>Creates a new <see cref="Vector4" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 67public Vector4(Vector2 value, float z, float w) 475/// <summary>Creates a new <see cref="Vector4" /> object from the specified <see cref="Vector2" /> object and a Z and a W component.</summary> 479/// <returns>A new <see cref="Vector4" /> from the specified <see cref="Vector2" /> object and a Z and a W component.</returns> 482public static Vector4 Create(Vector2 vector, float z, float w) 1022public static Vector4 Transform(Vector2 position, Matrix4x4 matrix) => Vector2.Transform(position.AsVector128Unsafe(), in matrix.AsROImpl()).AsVector4(); 1029public static Vector4 Transform(Vector2 value, Quaternion rotation) => Transform(value.AsVector128().WithElement(3, 1.0f), rotation.AsVector128()).AsVector4();

23/// <summary>Reinterprets a <see cref="Vector4" /> as a new <see cref="Vector2" />.</summary> 25/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector2" />.</returns> 26public 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); 80public static Vector128<float> AsVector128(this Vector2 value) => Vector4.Create(value, 0, 0).AsVector128(); 114public static Vector128<float> AsVector128Unsafe(this Vector2 value) 138/// <summary>Reinterprets a <see langword="Vector128&lt;Single&gt;" /> as a new <see cref="Vector2" />.</summary> 140/// <returns><paramref name="value" /> reinterpreted as a new <see cref="Vector2" />.</returns> 143public static Vector2 AsVector2(this Vector128<float> value) 146return Unsafe.ReadUnaligned<Vector2>(ref address); 186internal static int Count(Vector2 vector, float value) => CountMatches(Equals(vector.AsVector128(), Create(value, value, -1, -1))); 196internal static int CountWhereAllBitsSet(Vector2 vector) => CountWhereAllBitsSet(vector.AsVector128()); 224internal static int IndexOf(Vector2 vector, float value) => IndexOfFirstMatch(Equals(vector.AsVector128(), Create(value, value, -1, -1))); 234internal static int IndexOfWhereAllBitsSet(Vector2 vector) => IndexOfWhereAllBitsSet(vector.AsVector128()); 244internal static int LastIndexOf(Vector2 vector, float value) => IndexOfLastMatch(Equals(vector.AsVector128(), Create(value, value, -1, -1))); 254internal static int LastIndexOfWhereAllBitsSet(Vector2 vector) => LastIndexOfWhereAllBitsSet(vector.AsVector128()); 274internal static bool None(Vector2 vector, float value) => !EqualsAny(vector.AsVector128(), Create(value, value, -1, -1)); 284internal static bool NoneWhereAllBitsSet(Vector2 vector) => !EqualsAny(vector.AsVector128().AsInt32(), Vector128<int>.AllBitsSet);