/// <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;
}
