/// <summary> /// Returns a dvec4 from component-wise application of Modulo (lhs % rhs). /// </summary> public static dvec4 Modulo(dvec4 lhs, dvec4 rhs) => dvec4.Modulo(lhs, rhs);
/// <summary> /// Returns the euclidean length of this vector. /// </summary> public static double Length(dvec4 v) => v.Length;
/// <summary> /// Returns a string representation of this vector using a provided seperator. /// </summary> public static string ToString(dvec4 v, string sep) => v.ToString(sep);
/// <summary> /// Returns a dvec4 from component-wise application of Sinh ((double)Math.Sinh((double)v)). /// </summary> public static dvec4 Sinh(dvec4 v) => dvec4.Sinh(v);
/// <summary> /// Returns a dvec4 from component-wise application of Fract ((double)(v - Math.Floor(v))). /// </summary> public static dvec4 Fract(dvec4 v) => dvec4.Fract(v);
/// <summary> /// Returns a dvec4 from component-wise application of Cosh ((double)Math.Cosh((double)v)). /// </summary> public static dvec4 Cosh(dvec4 v) => dvec4.Cosh(v);
/// <summary> /// Returns a dvec4 from component-wise application of Log10 ((double)Math.Log10((double)v)). /// </summary> public static dvec4 Log10(dvec4 v) => dvec4.Log10(v);
/// <summary>Returns the reciprocal square root of x, i.e: 1/Sqrt(x) /// Results are undefined if x <= 0 </summary> protected internal static dvec4 InverseSqrt(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Treats the first parameter c as a column vector (matrix with one column) /// and the second parameter r as a row vector (matrix with one row) /// and does a linear algebraic matrix multiply c * r, yielding a matrix /// whose number of rows is the number of components in c and whose number /// of columns is the number of components in r. /// </summary> /// <param name="c">left side column vector</param> /// <param name="r">right side row vector</param> /// <returns></returns> protected dmat3x4 outerProduct(dvec4 c, dvec3 r) { throw _invalidAccess; }
/// <summary>For the incident vector I and surface normal N, and the ratio of indices /// of refraction eta, return the refraction vector. /// The result is computed by /// <code> /// k = 1.0 - eta * eta * (1.0 - Dot(N, I) * Dot(N, I)) /// if (k < 0.0) /// return genType(0.0) // or genDType(0.0) /// else /// return eta * I - (eta * Dot(N, I) + Sqrt(k)) * N /// </code> /// The input parameters for the incident vector I and the surface normal N must /// already be normalized to get thedesired results.</summary> protected internal static dvec4 Refract(dvec4 I, dvec4 N, double eta) { throw _invalidAccess; }
/// <summary>Returns the distance between p0 and p1, i.e., Length (p0 – p1)</summary> protected internal static double Distance(dvec4 p0, dvec4 p1) { throw _invalidAccess; }
/// <summary>For the incident vector I and surface orientation N, /// returns the reflection direction: /// I – 2 * Dot(N, I) * N /// N must already be normalized in order to achieve the desired result..</summary> /// <param name="I">The incident vector</param> /// <param name="N">The normal to reflect around</param> /// <returns>The reflected vector</returns> protected internal static dvec4 Reflect(dvec4 I, dvec4 N) { throw _invalidAccess; }
/// <summary>Returns a vector in the same direction as x but with a length of 1.</summary> protected internal static dvec4 Normalize(dvec4 x) { throw _invalidAccess; }
/// <summary>Returns the length of vector x</summary> protected internal static double Length(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Radians (Degrees-To-Radians Conversion). /// </summary> public static dvec4 Radians(dvec4 v) => dvec4.Radians(v);
/// <summary> /// Treats the first parameter c as a column vector (matrix with one column) /// and the second parameter r as a row vector (matrix with one row) /// and does a linear algebraic matrix multiply c * r, yielding a matrix /// whose number of rows is the number of components in c and whose number /// of columns is the number of components in r. /// </summary> /// <param name="c">left side column vector</param> /// <param name="r">right side row vector</param> /// <returns></returns> protected dmat4x3 outerProduct(dvec3 c, dvec4 r) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Asin ((double)Math.Asin((double)v)). /// </summary> public static dvec4 Asin(dvec4 v) => dvec4.Asin(v);
/// <summary>Returns a value equal to the nearest integer to x. /// A fractional part of 0.5 will round toward the nearest even integer. /// (Both 3.5 and 4.5 for x will return 4.0.)</summary> protected internal static dvec4 RoundEven(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns an enumerator that iterates through all components. /// </summary> public static IEnumerator <double> GetEnumerator(dvec4 v) => v.GetEnumerator();
/// <summary>Returns 0.0 if x < edge0 and 1.0 if x >= edge1 and /// performs smooth Hermite interpolation between 0 and 1 when edge0 < x < edge1. /// This is useful in cases where you would want a threshold function with a smooth /// transition.</summary> protected internal static dvec4 SmoothStep(dvec4 edge0, dvec4 edge1, dvec4 y) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Ceiling ((double)Math.Ceiling(v)). /// </summary> public static dvec4 Ceiling(dvec4 v) => dvec4.Ceiling(v);
/// <summary>Returns a value equal to the nearest integer that is greater than or equal to x.</summary> protected internal static dvec4 Ceiling(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns a string representation of this vector using ', ' as a seperator. /// </summary> public static string ToString(dvec4 v) => v.ToString();
/// <summary>Returns 0.0 if x < edge, otherwise it returns 1.0.</summary> protected internal static dvec4 Step(dvec4 edge, dvec4 y) { throw _invalidAccess; }
/// <summary> /// Returns the minimal component of this vector. /// </summary> public static double MinElement(dvec4 v) => v.MinElement;
/// <summary> /// Splits x into a floating-point significand in the range [0.5, 1.0) /// and an integral exponent of two, such that: x=significand⋅2**exponent /// The significand is returned by the function and the exponent is returned in the parameter exp. /// For a floating-point value of zero, the significant and exponent are both zero. /// For a floating-point value that is an infinity or is not a number, the results are undefined. /// </summary> protected static dvec4 frexp(dvec4 x, out ivec4 exp) { throw _invalidAccess; }
/// <summary> /// Returns the sum of all components. /// </summary> public static double Sum(dvec4 v) => v.Sum;
/// <summary> /// Builds a floating-point number from x and the corresponding integral exponent of two in exp, /// returning: significand⋅2*+exponent /// If this product is too large to be represented in the floating-point type, the result is undefined. /// </summary> protected static dvec4 ldexp(dvec4 x, ivec4 exp) { throw _invalidAccess; }
/// <summary>If Dot(Nref, I) < 0 return N, otherwise return –N.</summary> protected internal static dvec4 FaceForward(dvec4 N, dvec4 I, dvec4 Nref) { throw _invalidAccess; }
protected static dvec4 mod(dvec4 x, double y) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Degrees (Radians-To-Degrees Conversion). /// </summary> public static dvec4 Degrees(dvec4 v) => dvec4.Degrees(v);
/// <summary>Returns the fractional part of x and sets i to the integer part /// (as a whole number floating point value). /// Both the return value and the output parameter will have the same sign as x..</summary> protected static dvec4 mod(dvec4 x, out dvec4 y) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Acos ((double)Math.Acos((double)v)). /// </summary> public static dvec4 Acos(dvec4 v) => dvec4.Acos(v);
/// <summary>Returns 1.0 if x > 0, 0.0 if x = 0, or –1.0 if x < 0.</summary> /// <returns>The sign of x</returns> protected static dvec4 sign(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Atan ((double)Math.Atan((double)v)). /// </summary> public static dvec4 Atan(dvec4 v) => dvec4.Atan(v);
/// <summary>Returns Min (Max (x, minVal), maxVal). Results are undefined if minVal > maxVal.</summary> protected internal static dvec4 Clamp(dvec4 x, dvec4 minVal, dvec4 maxVal) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Exp ((double)Math.Exp((double)v)). /// </summary> public static dvec4 Exp(dvec4 v) => dvec4.Exp(v);
/// <summary>Returns x – Floor (x).</summary> protected internal static dvec4 Fraction(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Log2 ((double)Math.Log((double)v, 2)). /// </summary> public static dvec4 Log2(dvec4 v) => dvec4.Log2(v);
/// <summary>Computes and returns a*b + c.</summary> protected internal static dvec4 FusedMultiplyAdd(dvec4 a, dvec4 b, dvec4 c) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Floor ((double)Math.Floor(v)). /// </summary> public static dvec4 Floor(dvec4 v) => dvec4.Floor(v);
/// <summary>Returns true if x holds a positive infinity or negative infinity. /// Returns false otherwise.</summary> protected internal static bvec4 IsInfinity(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Round ((double)Math.Round(v)). /// </summary> public static dvec4 Round(dvec4 v) => dvec4.Round(v);
/// <summary>Returns true if x holds a NaN. Returns false otherwise.</summary> protected internal static bvec4 IsNaN(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Tanh ((double)Math.Tanh((double)v)). /// </summary> public static dvec4 Tanh(dvec4 v) => dvec4.Tanh(v);
/// <summary> /// Selects which vector each returned component comes from. For a component of a that is false, /// the corresponding component of x is returned. For a component of a that is true, /// the corresponding component of y is returned. Components of x and y that are not selected /// are allowed to be invalid floating point values and will have no effect on the results. /// Thus, this provides different functionality than, for example, /// genType Lerp(genType x, genType y, genType(a)) where a is a Boolean vector. /// </summary> protected internal static dvec4 Lerp(dvec4 x, dvec4 y, bvec4 a) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Truncate ((double)Math.Truncate((double)v)). /// </summary> public static dvec4 Truncate(dvec4 v) => dvec4.Truncate(v);
/// <summary>Returns y if x < y, otherwise it returns x.</summary> protected internal static dvec4 Max(dvec4 x, double y) { throw _invalidAccess; }
/// <summary> /// Returns a dvec4 from component-wise application of Trunc ((long)(v)). /// </summary> public static dvec4 Trunc(dvec4 v) => dvec4.Trunc(v);
/// <summary>Returns x if x >= 0, otherwise it returns –x.</summary> /// <returns>The absolute value of x</returns> protected internal static dvec4 Abs(dvec4 x) { throw _invalidAccess; }
/// <summary> /// Returns the maximal component of this vector. /// </summary> public static double MaxElement(dvec4 v) => v.MaxElement;
/// <summary>Returns y if y < x, otherwise it returns x.</summary> protected internal static dvec4 Min(dvec4 x, dvec4 y) { throw _invalidAccess; }
/// <summary> /// Returns the squared euclidean length of this vector. /// </summary> public static double LengthSqr(dvec4 v) => v.LengthSqr;
/// <summary> /// Returns an array with all values /// </summary> public static double[] Values(dvec4 v) => v.Values;
/// <summary> /// Returns the one-norm of this vector. /// </summary> public static double Norm1(dvec4 v) => v.Norm1;
/// <summary> /// Returns a dvec4 from component-wise application of Div (lhs / rhs). /// </summary> public static dvec4 Div(dvec4 lhs, dvec4 rhs) => dvec4.Div(lhs, rhs);
/// <summary> /// Returns the two-norm (euclidean length) of this vector. /// </summary> public static double Norm2(dvec4 v) => v.Norm2;
/// <summary>Returns the dot product of x and y</summary> protected internal static double Dot(dvec4 x, dvec4 y) { throw _invalidAccess; }