/// <summary>
 /// Returns min (max (x, minVal), maxVal)
 /// Results are undefined if minVal > maxVal.
 /// </summary>
 /// <param name="x"></param>
 /// <param name="minVal"></param>
 /// <param name="maxVal"></param>
 /// <returns></returns>
 protected genType clamp(genType x,
 float minVal,
 float maxVal) { throw new NotImplementedException(); }

        //--------------------------------------------------
        private void expSingleGeneration_Expanded(object sender, RoutedEventArgs e)
        {
            if (!initializeComponentIsCompleted) return;

            if (disableExpandersEvents) return;
            disableExpandersEvents = true;

            if (lockExpanders)
            {
                expSingleGeneration.IsExpanded = false;
                disableExpandersEvents = false;
                return;
            }

            lastExpanded_GenType = genType.Single;
            if (expPassword.IsExpanded == false && expWPA.IsExpanded == false)
                switch (lastExpanded_PswType)
                {
                    case pswType.Password:
                        expPassword.IsExpanded = true;
                        break;
                    case pswType.WPA:
                        expWPA.IsExpanded = true;
                        break;
                }
            expBulkGeneration.IsExpanded = false;
            expCmdline.IsExpanded = false;
            expAbout.IsExpanded = false;

            disableExpandersEvents = false;
        }

 public __vec3(genType x, genType y, genType z)
 {
     this._x = x;
     this._y = y;
     this._z = z;
 }

 /// <summary>
 /// Converts radians to degrees,
 /// </summary>
 /// <param name="radians"></param>
 /// <returns></returns>
 protected genType degrees(genType radians) { throw new NotImplementedException(); }

 /// <summary>
 /// Arc cosine. Returns an angle whose cosine is x.
 /// </summary>
 /// <param name="x"></param>
 /// <returns></returns>
 protected genType acos(genType x) { throw new NotImplementedException(); }

 /// <summary>
 /// <summary>
 /// Returns 0.0 if x &lt;= edge0 and 1.0 if x &gt;= edge1 and
 /// performs smooth Hermite interpolation between 0 and 1
 /// when edge0 &lt; x &lt; edge1. This is useful in cases where
 /// you would want a threshold function with a smooth
 /// transition. This is equivalent to:
 /// genType t;
 /// t = clamp ((x – edge0) / (edge1 – edge0), 0, 1);
 /// return t * t * (3 – 2 * t);
 /// Results are undefined if edge0 &gt;= edge1.
 /// </summary>
 /// </summary>
 protected genType smoothstep(float edge0,
         float edge1,
         genType x) { throw new NotImplementedException(); }

 /// <summary>
 /// Modulus. Returns x – y * floor (x/y)
 /// </summary>
 /// <param name="x"></param>
 /// <param name="y"></param>
 /// <returns></returns>
 protected genType mod(genType x, genType y) { throw new NotImplementedException(); }

 /// <summary>
 /// Returns the length of vector x,
 /// </summary>
 /// <param name="x"></param>
 /// <returns></returns>
 protected float length(genType x) { throw new NotImplementedException(); }

 /// <summary>
 /// Returns the distance between p0 and p1,
 /// </summary>
 /// <param name="p0"></param>
 /// <param name="p1"></param>
 /// <returns></returns>
 protected float distance(genType p0, genType p1) { throw new NotImplementedException(); }

 /// <summary>
 /// Returns a value equal to the nearest integer that is less than or equal to x
 /// </summary>
 public genType floor(genType x) { throw new NotImplementedException(); }

 /// <summary>
 /// Modulus (modulo). Returns x – y * floor (x/y)
 /// </summary>
 /// <param name="x"></param>
 /// <param name="y"></param>
 /// <returns></returns>
 public genType mod(genType x, float y) { throw new NotImplementedException(); }

 protected genType inversesqrt(genType x) { throw new NotImplementedException(); }

 public __vec2(genType x, genType y)
 {
     this._x = x;
     this._y = y;
 }

 public vec3(genType x, genType y, genType z)
 {
     throw new NotImplementedException();
 }

 /// <summary>
 /// Returns the linear blend of x and y, i.e. x
 /// </summary>
 /// <param name="x"></param>
 /// <param name="y"></param>
 /// <param name="a"></param>
 /// <returns></returns>
 protected genType mix(genType x,
 genType y,
 float a) { throw new NotImplementedException(); }

 /// <summary>
 /// Returns the dot product of x and y,
 /// </summary>
 /// <param name="x"></param>
 /// <param name="y"></param>
 /// <returns></returns>
 protected float dot(genType x, genType y) { throw new NotImplementedException(); }

 /// <summary>
 /// Returns 0.0 if x < edge, otherwise it returns 1.0
 /// </summary>
 /// <param name="edge0"></param>
 /// <param name="edge1"></param>
 /// <param name="x"></param>
 /// <returns></returns>
 protected genType step(float edge, genType x) { throw new NotImplementedException(); }

 /// <summary>
 /// Returns a vector in the same direction as x but with a
 /// length of 1.
 /// </summary>
 /// <param name="x"></param>
 /// <returns></returns>
 protected genType normalize(genType x) { throw new NotImplementedException(); }

 /// <summary>
 /// dFdx, dFdy — return the partial derivative of an argument with respect to x or y
 /// </summary>
 /// <param name="p"></param>
 /// <returns></returns>
 protected genType dFdy(genType p) { throw new NotImplementedException(); }

 /// <summary>
 /// If dot(Nref, I) &lt; 0 return N, otherwise return –N.
 /// </summary>
 /// <param name="N"></param>
 /// <param name="I"></param>
 /// <param name="Nref"></param>
 /// <returns></returns>
 protected genType faceforward(genType N, genType I, genType Nref) { throw new NotImplementedException(); }