BaseValues.hpp

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: BaseValues
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/LibAssert.h>
#include <limits>
#include <cinttypes>
/**--------------------------------------------------------------------------------------------------
Namespace: Parke
Namespace that wraps all Logic created by Tyler Parke
 *-----------------------------------------------------------------------------------------------**/
 
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    Class: BaseValues
    \brief Dummy class to ensure creation of an include file around core root values
     *-----------------------------------------------------------------------------------------------**/
    class BaseValues
    {};
    /**--------------------------------------------------------------------------------------------------
    Typedef: int8_t sint01
    
    \brief -Defines an alias representing a 1 byte, signed integer. 
    -Can represent exact integer values -127 through 127.
    -Byte value 0XFF (integer value: -128) is considered invalid and reserved.
     *-----------------------------------------------------------------------------------------------**/
    typedef int8_t sint01;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: int16_t sint02
    
    \brief -Defines an alias representing a 2 byte, signed integer.
    -Can represent exact integer values -32767 through 32767.
    -Byte value 0XFFFF (integer value: -32768) is considered invalid and reserved.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef int16_t sint02;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: int32_t sint04
    
    \brief -Defines an alias representing a 4 byte, signed integer.
    -Can represent exact integer values -2147483647 through 2147483647.
    -Byte value 0XFFFFFFFF (integer value: -2147483648) is considered invalid and reserved.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef int32_t sint04;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: int64_t sint08
    
    \brief -Defines an alias representing an 8 byte, signed integer
    -Can represent exact integer values -9223372036854775807 through 9223372036854775807.
    -Byte value 0XFFFFFFFFFFFFFFFF (integer value: -9223372036854775808) is considered invalid and reserved.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef int64_t sint08;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: uint8_t uint01
    
    \brief -Defines an alias representing a 1 byte, unsigned integer
    -Can represent exact integer values 0 through 254.
    -Byte value 0XFF (integer value: 255) is considered invalid and should normally be reserved. Note that
    it can be used with caution.
    -Note that subtracting 1 from 0 will result in 0xFF, the reserved invalid value. 
     *-----------------------------------------------------------------------------------------------**/
 
    typedef uint8_t uint01;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: uint16_t uint02
    
    \brief -Defines an alias representing a 2 byte, unsigned integer
    -Can represent exact integer values 0 through 65534.
    -Byte value 0xFFFF (integer value: 65535) is considered invalid and reserved.
    -Note that subtracting 1 from 0 will result in 0xFFFF, the reserved invalid value.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef uint16_t uint02;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: uint32_t uint04
    
    \brief -Defines an alias representing a 4 byte, unsigned integer
    -Can represent exact integer values 0 through 4294967294.
    -Byte value 0xFFFFFFFF (integer value: 4294967295) is considered invalid and reserved.
    -Note that subtracting 1 from 0 will result in 0xFFFFFFFF, the reserved invalid value.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef uint32_t uint04;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: uint64_t uint08
    
    \brief -Defines an alias representing an 8 byte, unsigned integer
    -Can represent exact integer values 0 through 18446744073709551614.
    -Byte value 0XFFFFFFFFFFFFFFFF (integer value: 18446744073709551615) is considered invalid and 
     reserved.
    -Note that subtracting 1 from 0 will result in 0XFFFFFFFFFFFFFFFF, the reserved invalid value.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef uint64_t uint08;
 
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: float fltp04
    
    \brief Defines an alias representing a 4 byte floating-point number
 
    -Bit layout is as follows: 
        -Sign: 1 bit at position 31 determines whether or not the value is positive or negative.
         0 denotes a positive number, and 1 denotes a negative number
        -Exponent: 8 bits stored in position 30–23 The exponent field needs to represent both positive 
         and negative exponents. To do this, a bias is added to the actual exponent in order to get 
         the stored exponent. This value is 127. 
         Thus, an exponent of zero means that 127 is stored in the exponent field.
         A stored value of 200 indicates an exponent of (200–127), or 73. For reasons 
         exponents of −127 (all 0s) and +128 (all 1s) are reserved for special numbers.
        -Fraction: 23 bits stored in positions 22–00. The mantissa, also known as the significand, 
         represents the precision bits of the number.  It is composed of an implicit leading bit 
         (left of the radix point) and the fraction bits (to the right of the radix point).
    -Note that positive and negative infinity are reserved as max and min. However precision changes
     for large and small numbers. Precision is greatest around 0.
    - Note that NaN is reserved as invalid values. Using == will not work for these values.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef float       fltp04;
 
    /**--------------------------------------------------------------------------------------------------
    Typedef: double fltp08
 
    \brief Defines an alias representing an 8 byte floating-point number
 
    -Bit layout is as follows: 
        -Sign: 1 bit at position 63 determines whether or not the value is positive or negative.
         0 denotes a positive number, and 1 denotes a negative number
        -Exponent: 11 bits stored in position 62–52. The exponent field needs to represent both positive 
         and negative exponents. To do this, a bias is added to the actual exponent in order to get 
         the stored exponent. This value is 1023. 
         Thus, an exponent of zero means that 1023 is stored in the exponent field.
         A stored value of 200 indicates an exponent of (200–1023), or -823. For reasons 
         exponents of all 0s and all 1s are reserved for special numbers.
        -Fraction: 52 bits stored in positions 51–00. The mantissa, also known as the significand, 
         represents the precision bits of the number.  It is composed of an implicit leading bit 
         (left of the radix point) and the fraction bits (to the right of the radix point).
    -Note that positive and negative infinity are reserved as max and min. However precision changes
     for large and small numbers. Precision is greatest around 0.
    - Note that NaN is reserved as invalid values. Using == will not work for these values.
     *-----------------------------------------------------------------------------------------------**/
 
    typedef double      fltp08;
 
 
    typedef wchar_t wchar;
 
 
    /**--------------------------------------------------------------------------------------------------
    Enum: DimensionValues
    
    \brief Values that represent dimension values. 
 
    -Note these are used throughout the code to make things more readable. For example, for a vertex
     we can access it via vertex[Z] instead of vertex[2] which overall contributes to total readability.
     Typically for shapes (Triangles, LineSegments, etc) we access the nodes via A, B, C. triangle.vertex(A)
     for example. For points we typically use X, Y, Z triangle.vertex(A)[X] = triangle.vertex(B)[X]
     *-----------------------------------------------------------------------------------------------**/
 
    enum DimensionValues : uint01
    {
          X = 0
        , A = 0
        , Y = 1
        , B = 1
        , Z = 2
        , C = 2
        , W = 3
        , D = 3
    };
 
    enum GeodeticValues : uint01
    {
        LAT = 0,
        LON = 1,
        ALT = 2
    };
    /**--------------------------------------------------------------------------------------------------
    Enum: LocationValues
    
    \brief Values that represent location values.
    -Note these are used throughout the code to make things more readable as above. For example, for example
     in point pairs with a max and a min, or in a bounds object.
     *-----------------------------------------------------------------------------------------------**/
 
    enum LocationValues : uint01
    {
          MIN = 0
        , MAX = 1
    };
 
    /**--------------------------------------------------------------------------------------------------
    Enum: AreaValues
    
    \brief Used for classifying shape intersections. 
    - Outside means completely outside the other shape.
    - Inside means entirely inside (or touching the boundary) of the shape.
    - Mixed means the shape is neither completely inside or outside the shape. This is used heavily 
      in the intersection class.
     *-----------------------------------------------------------------------------------------------**/
 
    enum IntersectionTypes
    {
          outside = 0
        , inside
        , mixed
    };
 
    /**--------------------------------------------------------------------------------------------------
    Enum: InterpolationValues
    
    \brief Values that represent interpolation functions. Useful in large or complicated geological or time
    based data sets.
     *-----------------------------------------------------------------------------------------------**/
 
    enum InterpolationValues
    {
          nearest_neighbor
        , e_linear
        , bicubic
    };
 
    /**--------------------------------------------------------------------------------------------------
    Struct: Constant
    
    A constant.
    
    Author: Tyler Parke
    
    Date: 2017-11-05
     *-----------------------------------------------------------------------------------------------**/
    template<class t_type>
    struct Constant
    {
        /** The NaN. */
        static const t_type NaN;
        /** The minimum. */
        static const t_type Min;
        /** The maximum. */
        static const t_type Max;
    };
    
    /** . */
    template<> constexpr const bool Constant<bool>::NaN = false;
    /** . */
    template<> constexpr const bool Constant<bool>::Max = true;
    /** . */
    template<> constexpr const bool Constant<bool>::Min = false;
 
    /** . */
    template<> constexpr const sint01 Constant<sint01>::NaN = -128;
    /** . */
    template<> constexpr const sint01 Constant<sint01>::Max =  127;
    /** . */
    template<> constexpr const sint01 Constant<sint01>::Min = -127;
 
    /** . */
    template<> constexpr const uint01 Constant<uint01>::NaN = 255;
    /** . */
    template<> constexpr const uint01 Constant<uint01>::Max = 254;
    /** . */
    template<> constexpr const uint01 Constant<uint01>::Min = 0;
 
    /** . */
    template<> constexpr const sint02 Constant<sint02>::NaN = -32768;
    /** . */
    template<> constexpr const sint02 Constant<sint02>::Max =  32767;
    /** . */
    template<> constexpr const sint02 Constant<sint02>::Min = -32767;
 
    /** . */
    template<> constexpr const uint02 Constant<uint02>::NaN = 65535;
    /** . */
    template<> constexpr const uint02 Constant<uint02>::Max = 65534;
    /** . */
    template<> constexpr const uint02 Constant<uint02>::Min = 0;
 
 
    /** . */
    template<> constexpr const sint04 Constant<sint04>::NaN = 0x80000000;
    /** . */
    template<> constexpr const sint04 Constant<sint04>::Max =  2147483647;
    /** . */
    template<> constexpr const sint04 Constant<sint04>::Min = -2147483647;
 
 
    /** . */
    template<> constexpr const uint04 Constant<uint04>::NaN = 4294967295UL;
    /** . */
    template<> constexpr const uint04 Constant<uint04>::Max = 4294967294UL;
    /** . */
    template<> constexpr const uint04 Constant<uint04>::Min = 0;
 
 
    /** . */
    template<> constexpr const sint08 Constant<sint08>::NaN = 0x8000000000000000;
    /** . */
    template<> constexpr const sint08 Constant<sint08>::Max =  9223372036854775807LL;
    /** . */
    template<> constexpr const sint08 Constant<sint08>::Min = -9223372036854775807LL;
 
    /** . */
    template<> constexpr const uint08 Constant<uint08>::NaN = 18446744073709551615ULL;
    /** . */
    template<> constexpr const uint08 Constant<uint08>::Max = 18446744073709551614ULL;
    /** . */
    template<> constexpr const uint08 Constant<uint08>::Min = 0;
 
    /** . */
    template<> constexpr const fltp04 Constant<fltp04>::NaN = std::numeric_limits<fltp04>::quiet_NaN();
    /** . */
    template<> constexpr const fltp04 Constant<fltp04>::Max = std::numeric_limits<fltp04>::infinity();
    /** . */
    template<> constexpr const fltp04 Constant<fltp04>::Min = -std::numeric_limits<fltp04>::infinity();
    /** . */
    template<> constexpr const fltp08 Constant<fltp08>::NaN = std::numeric_limits<fltp08>::quiet_NaN();
    /** . */
    template<> constexpr const fltp08 Constant<fltp08>::Max = std::numeric_limits<fltp08>::infinity();
    /** . */
    template<> constexpr const fltp08 Constant<fltp08>::Min = -std::numeric_limits<fltp08>::infinity();
    
    /**--------------------------------------------------------------------------------------------------
    Fn: constexpr t_to cast(t_from value)
 
    Casts the given value. Is equivalent to static_cast except allows for the option of special cases by
    specializing the template
    static_cast is used for cases where you basically want to reverse an implicit conversion,
    with a few restrictions and additions. static_cast performs no runtime checks.
    This should be used if you know that you refer to an object of a specific type,
    and thus a check would be unnecessary.
 
    Author: Tyler Parke
 
    Date: 2017-09-04
 
    Param:
    value -  The value to cast.
 
    Returns: The value cast to the specified type.
    *-----------------------------------------------------------------------------------------------**/
 
    template<class t_to, class t_from>
    constexpr t_to cast(t_from value)
    {
        return static_cast<t_to>(value);
    }
    template<>
    constexpr uint04 cast(fltp04 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    template<>
    constexpr uint04 cast(fltp08 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    template<>
    constexpr uint04 cast(sint04 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    template<>
    constexpr uint04 cast(sint08 value)
    {
        lib_assert(value >= 0, "Bad value");
        return static_cast<uint04>(value);
    }
    /**--------------------------------------------------------------------------------------------------
    Fn: constexpr t_to rcast(t_from value)
 
    Casts the given value. Is equivalent to reinterpret_cast except allows for the option of special cases by
    specializing the template
    Allows any pointer to be converted into any other pointer type. Also allows any integral type to be
    converted into any pointer type and vice versa.
 
    Author: Tyler Parke
 
    Date: 2017-09-04
 
    Param:
    value -  The value to cast.
 
    Returns: The value cast to the specified type.
    *-----------------------------------------------------------------------------------------------**/
    template<class t_to, class t_from>
    constexpr t_to rcast(t_from value)
    {
        static_assert(sizeof(t_to) <= sizeof(t_from), "Bad rcast conversion");
        return *((t_to*)(&value));
    }
 
    #define UNUSED(expr) do { (void)(expr); } while (0)
 
 
    static_assert(sizeof(bool) == 1, "Bad bool size");
    static_assert(sizeof(char) == 1, "Bad char size");
    //static_assert(sizeof(wchar) == 4, "Bad bool size");
    static_assert(sizeof(float) == 4, "Bad float size");
    static_assert(sizeof(double) == 8, "Bad double size");
 
    static_assert(sizeof(fltp04) == 4, "Bad fltp04 size");
    static_assert(sizeof(fltp08) == 8, "Bad fltp08 size");
 
    static_assert(sizeof(uint01) == 1, "Bad int size");
    static_assert(sizeof(uint02) == 2, "Bad int size");
    static_assert(sizeof(uint04) == 4, "Bad int size");
    static_assert(sizeof(uint08) == 8, "Bad int size");
 
    static_assert(sizeof(sint01) == 1, "Bad int size");
    static_assert(sizeof(sint02) == 2, "Bad int size");
    static_assert(sizeof(sint04) == 4, "Bad int size");
    static_assert(sizeof(sint08) == 8, "Bad int size");
};
 
#include "BaseFunctions.hpp"