sequence.h

/*
    NanoGUI was developed by Wenzel Jakob <[email protected]>.
    The widget drawing code is based on the NanoVG demo application
    by Mikko Mononen.
 
    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE.txt file.
*/
// Merge with estamira/particle/vec4:minimum_maximum_rand
#pragma once
 
 
//#include "common.h"
//#include "traits.h"
//#include <cassert>
#include <cmath>
//#include <iosfwd>
//#include <string.h> // ::memory_set
 
 
template<prototype_number NUMBER, ::i32 t_iSize >
struct sequence_t_type
{
 
 
   using sequence_tag = sequence_t;
   using sequence_size = sequence_size_t<t_iSize>;
   using COORDINATE = NUMBER;
   using UNIT_TYPE = NUMBER;
   static const ::i32 SIZE = t_iSize;
 
 
};
 
 
template<prototype_number NUMBER>
struct sequence_t_type<NUMBER, 1>
{
 
 
   using COORDINATE = NUMBER;
   using UNIT_TYPE = NUMBER;
   static const ::i32 SIZE = 1;
 
 
   union
   {
      struct
      {
         union
         {
            COORDINATE x, r, s;
         };
      };
      COORDINATE m_coordinatea[SIZE];
   };
 
 
};
 
 
template<prototype_number NUMBER>
struct std::hash<::sequence_t_type<NUMBER, 1>>
{
   std::size_t operator()(const ::sequence_t_type<NUMBER, 1> &s) const noexcept
   {
      std::size_t h1 = std::hash<NUMBER>{}(s.x);
      return h1;
   }
};
 
 
 
template < prototype_number NUMBER >
struct sequence_t_type<NUMBER, 2>
{
 
 
   using COORDINATE = NUMBER;
   using UNIT_TYPE = NUMBER;
   static const ::i32 SIZE = 2;
 
   union
   {
      struct
      {
         union
         {
            COORDINATE x, r, s, cx, width;
         };
         union
         {
            COORDINATE y, g, t, cy, height;
         };
      };
      COORDINATE m_coordinatea[SIZE];
   };
 
 
};
 
 
template<prototype_number NUMBER>
struct std::hash<::sequence_t_type<NUMBER, 2>>
{
   std::size_t operator()(const ::sequence_t_type<NUMBER, 2> &s) const noexcept
   {
      std::size_t h1 = std::hash<NUMBER>{}(s.x);
      std::size_t h2 = std::hash<NUMBER>{}(s.y);
      return h1 ^ (h2 << 1);
   }
};
 
 
 
template<prototype_number NUMBER>
struct sequence_t_type<NUMBER, 3>
{
 
 
   using COORDINATE = NUMBER;
   using UNIT_TYPE = NUMBER;
   static const ::i32 SIZE = 3;
 
 
   union
   {
      struct
      {
         union
         {
            COORDINATE x, r, s, red;
         };
         union
         {
            COORDINATE y, g, t, green;
         };
         union
         {
            COORDINATE z, b, p, blue;
         };
      };
      COORDINATE m_coordinatea[SIZE];
   };
 
 
};
 
 
template<prototype_number NUMBER>
struct std::hash<::sequence_t_type<NUMBER, 3>>
{
   std::size_t operator()(const ::sequence_t_type<NUMBER, 3> &s) const noexcept
   {
      std::size_t h1 = std::hash<NUMBER>{}(s.x);
      std::size_t h2 = std::hash<NUMBER>{}(s.y);
      std::size_t h3 = std::hash<NUMBER>{}(s.z);
      return h1 ^ (h2 << 1) ^ (h3 << 2);
   }
};
 
 
template<prototype_number NUMBER>
struct sequence_t_type<NUMBER, 4>
{
 
 
   using COORDINATE = NUMBER;
   using UNIT_TYPE = NUMBER;
   static const ::i32 SIZE = 4;
 
 
   union
   {
      struct
      {
         union
         {
            COORDINATE x, r, s, left, red;
         };
         union
         {
            COORDINATE y, g, t, top, green;
         };
         union
         {
            COORDINATE z, b, p, right, blue;
         };
         union
         {
            COORDINATE w, a, q, bottom, opacity;
         };
      };
      COORDINATE m_coordinatea[SIZE];
   };
 
};
 
template<prototype_number NUMBER>
struct std::hash<::sequence_t_type<NUMBER, 4>>
{
   std::size_t operator()(const ::sequence_t_type<NUMBER, 4> &s) const noexcept
   {
      std::size_t h1 = std::hash<NUMBER>{}(s.x);
      std::size_t h2 = std::hash<NUMBER>{}(s.y);
      std::size_t h3 = std::hash<NUMBER>{}(s.z);
      std::size_t h4 = std::hash<NUMBER>{}(s.w);
      return h1 ^ (h2 << 1) ^ (h3 << 2) ^ (h4 << 2);
   }
};
 
using i32_sequence2_t = sequence_t_type<::i32, 2>;
using i32_sequence3_t = sequence_t_type<::i32, 3>;
using i32_sequence4_t = sequence_t_type<::i32, 4>;
 
 
using i64_sequence2_t = sequence_t_type<::i64, 2>;
using i64_sequence3_t = sequence_t_type<::i64, 3>;
using i64_sequence4_t = sequence_t_type<::i64, 4>;
 
 
using f32_sequence2_t = sequence_t_type<::f32, 2>;
using f32_sequence3_t = sequence_t_type<::f32, 3>;
using f32_sequence4_t = sequence_t_type<::f32, 4>;
 
 
using f64_sequence2_t = sequence_t_type<::f64, 2>;
using f64_sequence3_t = sequence_t_type<::f64, 3>;
using f64_sequence4_t = sequence_t_type<::f64, 4>;
 
 
 
template < prototype_number NUMBER, ::i32 t_iSize >
struct sequence_type :
   public sequence_t_type<NUMBER, t_iSize>
{
 
   using sequence_tag = sequence_t;
   using sequence_size = sequence_size_t < t_iSize >;
   using SEQUENCE_T = sequence_t_type< NUMBER, t_iSize >;
   using COORDINATE = typename SEQUENCE_T::COORDINATE;
   using UNIT_TYPE = typename SEQUENCE_T::COORDINATE;
   static const ::i32 SIZE = t_iSize;
 
 
   static constexpr bool IS_MATRIX = false;
 
 
   constexpr sequence_type()
   {
   
      set_null();
      
   }
 
   sequence_type(no_initialize_t)
   {
      
      
   }
 
 
   constexpr sequence_type(UNIT_TYPE n)
   {
 
     set_all(n);
 
   }
 
 
   template < prototype_sequence2 S2 >
   constexpr sequence_type(const S2 & s2)
      requires(SIZE == 2)
   {
      this->m_coordinatea[0] = (UNIT_TYPE) s2.x;
      this->m_coordinatea[1] = (UNIT_TYPE) s2.y;
   }
 
   
   template < prototype_sequence3 S3 >
   constexpr sequence_type(const S3 & s3)
      requires(SIZE == 3)
   {
      this->m_coordinatea[0] = (UNIT_TYPE) s3.x;
      this->m_coordinatea[1] = (UNIT_TYPE) s3.y;
      this->m_coordinatea[2] = (UNIT_TYPE) s3.z;
   }
 
 
   template<prototype_sequence4 S4>
   constexpr sequence_type(const S4 &s4)
      requires(SIZE >= 4)
   {
      this->m_coordinatea[0] = (UNIT_TYPE)s4.x;
      this->m_coordinatea[1] = (UNIT_TYPE)s4.y;
      this->m_coordinatea[2] = (UNIT_TYPE)s4.z;
      this->m_coordinatea[3] = (UNIT_TYPE)s4.w;
   }
 
   template<prototype_number NUMBER1>
   constexpr sequence_type(const NUMBER1 *p) // expects p to point to an array of at least SIZE elements
   {
      for (::collection::count i = 0; i < SIZE; ++i)
         this->m_coordinatea[i] = (UNIT_TYPE)p[i];
   }
 
 
   template < prototype_number NUMBER1 >
   constexpr sequence_type(const sequence_t_type < NUMBER1, 4 > & sequence)
      requires(SIZE >= 4)
   {
      this->m_coordinatea[0] = (UNIT_TYPE) sequence.m_coordinatea[0];
      this->m_coordinatea[1] = (UNIT_TYPE) sequence.m_coordinatea[1];
      this->m_coordinatea[2] = (UNIT_TYPE) sequence.m_coordinatea[2];
      this->m_coordinatea[3] = (UNIT_TYPE) sequence.m_coordinatea[3];
   }
 
 
   template<prototype_number NUMBER0, prototype_number NUMBER1>
   constexpr sequence_type(NUMBER0 coordinate0, NUMBER1 coordinate1)
      requires(SIZE == 2)
   {
      this->m_coordinatea[0] = (UNIT_TYPE)coordinate0;
      this->m_coordinatea[1] = (UNIT_TYPE)coordinate1;
   }
 
   
   template<prototype_number NUMBER0, prototype_number NUMBER1, prototype_number NUMBER2>
   constexpr sequence_type(NUMBER0 coordinate0, NUMBER1 coordinate1, NUMBER2 coordinate2)
      requires(SIZE == 3)
   {
      this->m_coordinatea[0] = (UNIT_TYPE)coordinate0;
      this->m_coordinatea[1] = (UNIT_TYPE)coordinate1;
      this->m_coordinatea[2] = (UNIT_TYPE)coordinate2;
   }
 
   template<prototype_number NUMBER0, prototype_number NUMBER1, prototype_number NUMBER2, prototype_number NUMBER3>
   constexpr sequence_type(NUMBER0 coordinate0, NUMBER1 coordinate1, NUMBER2 coordinate2, NUMBER3 coordinate3)
      requires(SIZE == 4)
   {
      this->m_coordinatea[0] = (UNIT_TYPE)coordinate0;
      this->m_coordinatea[1] = (UNIT_TYPE)coordinate1;
      this->m_coordinatea[2] = (UNIT_TYPE)coordinate2;
      this->m_coordinatea[3] = (UNIT_TYPE)coordinate3;
   }
 
   template<prototype_number NUMBER0, prototype_number NUMBER3>
   constexpr sequence_type(const sequence_type<NUMBER0, 3> &seq3, NUMBER3 coordinate3)
      requires(SIZE == 4)
   {
      this->m_coordinatea[0] = (UNIT_TYPE)seq3[0];
      this->m_coordinatea[1] = (UNIT_TYPE)seq3[1];
      this->m_coordinatea[2] = (UNIT_TYPE)seq3[2];
      this->m_coordinatea[3] = (UNIT_TYPE) coordinate3;
   }
 
   template<prototype_number NUMBER0, prototype_number NUMBER1>
   constexpr sequence_type(NUMBER0 coordinate0, const sequence_type<NUMBER1, 3> &seq3)
      requires(SIZE == 4)
   {
      this->m_coordinatea[0] = (UNIT_TYPE)coordinate0;
      this->m_coordinatea[1] = (UNIT_TYPE)seq3[0];
      this->m_coordinatea[2] = (UNIT_TYPE)seq3[1];
      this->m_coordinatea[3] = (UNIT_TYPE)seq3[2];
   }
 
   constexpr ::collection::count get_size() const { return SIZE; }
   constexpr ::collection::count get_count() const { return this->get_size(); }
   
 
   
 
   void set_null() { set_all(0); }
 
 
   sequence_type &null()
   {
 
      set_null();
 
      return *this;
   }
 
   static sequence_type Null() { return {}; }
   
   constexpr COORDINATE & set_coordinate(::collection::index i, COORDINATE coordinate)
   {
 
      return this->m_coordinatea[i] = coordinate;
 
   }
 
 
   constexpr COORDINATE coordinate(::collection::index i) const
   {
 
      return this->m_coordinatea[i];
 
   }
 
   
   constexpr COORDINATE & coordinate(::collection::index i)
   {
 
      return this->m_coordinatea[i];
 
   }
 
 
   void set_all(COORDINATE coordinate)
   {
      
      for (::collection::count i = 0; i < SIZE; ++i)
      {
         
         this->m_coordinatea[i] = coordinate;
         
      }
      
   }
   
   bool is_all(COORDINATE coordinate) const
   {
      
      for (::collection::count i = 0; i < SIZE; ++i)
      {
         
         if(this->m_coordinatea[i] != coordinate)
         {
          
            return false;
            
         }
         
      }
      
      return true;
      
   }
 
 
 
   // simple menthods: operates on x, y
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 2, ::i32> = 0 >
   inline void add2(const sequence_type & a)
   {
      this->x += a.x;
      this->y += a.y;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 2, ::i32> = 0 >
   inline void sub2(const sequence_type & a)
   {
      this->x -= a.x;
      this->y -= a.y;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 2, ::i32> = 0 >
   inline void mul2(UNIT_TYPE n)
   {
      this->x *= n;
      this->y *= n;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 2, ::i32> = 0 >
   inline void set2(UNIT_TYPE a, UNIT_TYPE b)
   {
      this->x = a;
      this->y = b;
   }
 
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 2, ::i32> = 0 >
   static inline void mix2(const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
   {
      c.x = a.x*((UNIT_TYPE)1.0 - t) + b.x*t;
      c.y = a.y*((UNIT_TYPE)1.0 - t) + b.y*t;
   }
 
   // simple menthods: operates on x, y, z
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 3, ::i32> = 0 >
   inline void add3(const sequence_type & a)
   {
      this->x += a.x;
      this->y += a.y;
      this->z += a.z;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 3, ::i32> = 0 >
   inline void sub3(const sequence_type & a)
   {
      this->x -= a.x;
      this->y -= a.y;
      this->z -= a.z;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 3, ::i32> = 0 >
   inline void mul3(UNIT_TYPE n)
   {
      this->x *= n;
      this->y *= n;
      this->z *= n;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 3, ::i32> = 0 >
   inline void set3(UNIT_TYPE a, UNIT_TYPE b, UNIT_TYPE c)
   {
      this->x = a;
      this->y = b;
      this->z = c;
   }
 
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 3, ::i32> = 0 >
   static inline void mix3(const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
   {
      c.x = a.x*((UNIT_TYPE)1.0 - t) + b.x*t;
      c.y = a.y*((UNIT_TYPE)1.0 - t) + b.y*t;
      c.z = a.z*((UNIT_TYPE)1.0 - t) + b.z*t;
   }
 
   // simple menthods: operates on x, y, z, w
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 4, ::i32> = 0 >
   inline void add4(const sequence_type & q)
   {
      this->x += q.x;
      this->y += q.y;
      this->z += q.z;
      this->w += q.w;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 4, ::i32> = 0 >
   inline void sub4(const sequence_type & q)
   {
      this->x -= q.x;
      this->y -= q.y;
      this->w -= q.w;
      this->z -= q.z;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 4, ::i32> = 0 >
   inline void mul4(UNIT_TYPE n)
   {
      this->x *= n;
      this->y *= n;
      this->w *= n;
      this->z *= n;
   }
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 4, ::i32> = 0 >
   inline void set4(UNIT_TYPE a, UNIT_TYPE b, UNIT_TYPE c, UNIT_TYPE d)
   {
      this->x = a;
      this->y = b;
      this->y = c;
      this->z = d;
   }
 
   template < ::collection::count S = SIZE, std::enable_if_t<S <= 4, ::i32> = 0 >
   static inline void mix4(const sequence_type &a, const sequence_type &b, UNIT_TYPE t, sequence_type &c)
   {
      c.x = a.x*((UNIT_TYPE)1.0 - t) + b.x*t;
      c.y = a.y*((UNIT_TYPE)1.0 - t) + b.y*t;
      c.w = a.z*((UNIT_TYPE)1.0 - t) + b.z*t;
      c.z = a.w*((UNIT_TYPE)1.0 - t) + b.w*t;
   }
 
 
   sequence_type operator-() const
   {
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = -this->m_coordinatea[i];
      return result;
   }
 
   
   sequence_type operator +(const sequence_type& b) const
   {
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = this->m_coordinatea[i] + b.m_coordinatea[i];
      return result;
   }
 
   sequence_type& operator +=(const sequence_type& a) {
      for (::collection::count i = 0; i < SIZE; ++i)
         this->m_coordinatea[i] += a.m_coordinatea[i];
      return *this;
   }
 
   friend sequence_type operator-(const sequence_type& a, const sequence_type& b) {
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = a.m_coordinatea[i] - b.m_coordinatea[i];
      return result;
   }
 
   sequence_type& operator-=(const sequence_type& a) {
      for (::collection::count i = 0; i < SIZE; ++i)
         this->m_coordinatea[i] -= a.m_coordinatea[i];
      return *this;
   }
 
   sequence_type operator *(const sequence_type& b) const {
      const sequence_type &a = *this;
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = a.m_coordinatea[i] * b.m_coordinatea[i];
      return result;
   }
 
   template<prototype_floating FLOATING1>
   inline sequence_type operator*(const matrix_type<FLOATING1, 3> &M) const
      requires(t_iSize == 3 && ::std::is_same_v<FLOATING1, NUMBER>);
 
   template<prototype_floating FLOATING1>
   inline sequence_type operator*(const matrix_type<FLOATING1, 4> &M) const
      requires(t_iSize == 4 && ::std::is_same_v<FLOATING1, NUMBER>);
 
   template < prototype_number NUMBER1 >
   sequence_type < largest_number < UNIT_TYPE, NUMBER1 >, SIZE > operator *(NUMBER1 n) const
   {
      sequence_type < largest_number < UNIT_TYPE, NUMBER1 >, SIZE > result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = (largest_number < UNIT_TYPE, NUMBER1 >) (this->m_coordinatea[i] * n);
      return result;
   }
 
 
   sequence_type& operator*=(const sequence_type& a) {
      for (::collection::count i = 0; i < SIZE; ++i)
         this->m_coordinatea[i] *= a.m_coordinatea[i];
      return *this;
   }
 
   
   friend sequence_type operator/(const sequence_type& a, const sequence_type& b) {
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = a.m_coordinatea[i] / b.m_coordinatea[i];
      return result;
   }
   
   
   template < prototype_number NUMBER1 >
   sequence_type < largest_number < UNIT_TYPE, NUMBER1 >, SIZE > operator /(NUMBER1 n) const
   {
      sequence_type < largest_number < UNIT_TYPE, NUMBER1 >, SIZE > result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = (largest_number < UNIT_TYPE, NUMBER1 >) (this->m_coordinatea[i] / n);
      return result;
   }
 
 
   sequence_type& operator/=(const sequence_type& a) {
      for (::collection::count i = 0; i < SIZE; ++i)
         this->m_coordinatea[i] /= a.m_coordinatea[i];
      return *this;
   }
 
   template < prototype_number NUMBER1 >
   sequence_type &operator/=(const NUMBER1 &n)
   {
      for (::collection::count i = 0; i < SIZE; ++i)
         this->m_coordinatea[i] = (UNIT_TYPE) ((largest_number < UNIT_TYPE, NUMBER1 >)this->m_coordinatea[i] / (largest_number < UNIT_TYPE, NUMBER1 >)n);
      return *this;
   }
 
   bool operator==(const sequence_type& a) const {
      for (::collection::count i = 0; i < SIZE; ++i) {
         if (this->m_coordinatea[i] != a.m_coordinatea[i])
            return false;
      }
      return true;
   }
 
 
 
 
   template < typename PREDICATE >
   bool is_every(PREDICATE predicate) const
   {
 
      for (::collection::count i = 0; i < SIZE; ++i)
      {
 
         if (!predicate(this->m_coordinatea[i]))
         {
 
            return false;
 
         }
 
      }
 
      return true;
 
   }
 
   
   bool is_empty() const
   {
 
      return is_every([](auto coordinate) {return coordinate == COORDINATE{}; });
 
   }
 
 
   bool is_set() const
   {
 
      return !is_empty();
 
   }
 
 
   bool is_all_set() const
   {
 
      return is_every([](auto coordinate) {return coordinate != COORDINATE{}; });
 
   }
 
 
   bool is_all_positive() const
   {
 
      return is_every([](auto coordinate) {return coordinate > COORDINATE{}; });
 
   }
 
 
   template < typename PREDICATE >
   sequence_type prefer_self_coordinate_if(const sequence_type &vectorOther, PREDICATE predicate) const
   {
 
      sequence_type vector;
 
      for (::collection::count i = 0; i < SIZE; ++i)
      {
 
         if (predicate(this->m_coordinatea[i]))
         {
 
            vector[i] = this->m_coordinatea[i];
 
         }
         else
         {
 
            vector[i] = vectorOther.m_coordinatea[i];
 
         }
 
      }
 
      return vector;
 
   }
 
 
   sequence_type prefer_self_coordinate_if_set(const sequence_type& vectorOther) const
   {
 
      return prefer_self_coordinate_if(vectorOther, [](auto coordinate) {return coordinate != 0; });
 
   }
 
 
   sequence_type prefer_self_coordinate_if_positive(const sequence_type& vectorOther) const
   {
 
      return prefer_self_coordinate_if(vectorOther, [](auto coordinate) {return coordinate > COORDINATE{}; });
 
   }
 
 
   template < typename PREDICATE, typename SOURCE_PREDICATE >
   sequence_type pred_prefer_self_coordinate_if(PREDICATE predicate, SOURCE_PREDICATE sourcepredicate) const
   {
 
      if (is_every(predicate))
      {
 
         return *this;
 
      }
 
      auto vectorOther = sourcepredicate();
 
      return prefer_self_coordinate_if(vectorOther, predicate);
 
   }
 
 
   template < typename SOURCE_PREDICATE >
   sequence_type pred_prefer_self_coordinate_if_set(SOURCE_PREDICATE sourcepredicate) const
   {
 
      return pred_prefer_self_coordinate_if([](auto coordinate) {return coordinate != COORDINATE{}; }, sourcepredicate);
 
   }
 
 
   template < typename SOURCE_PREDICATE >
   sequence_type pred_prefer_self_coordinate_if_positive(SOURCE_PREDICATE sourcepredicate) const
   {
 
      return pred_prefer_self_coordinate_if([](auto coordinate) {return coordinate > COORDINATE{}; }, sourcepredicate);
 
   }
 
 
 
   constexpr bool operator!=(const sequence_type& a) const { return !operator==(a); }
 
   constexpr const COORDINATE& operator[](::collection::count i) const { return this->m_coordinatea[i]; }
 
   constexpr COORDINATE& operator[](::collection::count i) { return this->m_coordinatea[i]; }
 
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 1), ::i32> = 0>
   //constexpr const COORDINATE& a const { return this->m_coordinatea[0]; }
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 1), ::i32> = 0>
   //COORDINATE& a { return this->m_coordinatea[0]; }
 
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 2), ::i32> = 0>
   //constexpr const COORDINATE& b const { return this->m_coordinatea[1]; }
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 2), ::i32> = 0>
   //COORDINATE& b { return this->m_coordinatea[1]; }
 
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 3), ::i32> = 0>
   //constexpr const COORDINATE& c const { return this->m_coordinatea[2]; }
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 3), ::i32> = 0>
   //COORDINATE& c { return this->m_coordinatea[2]; }
 
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 4), ::i32> = 0>
   //constexpr const COORDINATE& d const { return this->m_coordinatea[3]; }
   //template <::collection::count S = SIZE, std::enable_if_t<(S >= 4), ::i32> = 0>
   //COORDINATE& d { return this->m_coordinatea[3]; }
   
   
   template <::collection::count S = SIZE, std::enable_if_t<(S == 2), ::i32> = 0>
   COORDINATE dot_with_left_perpendicular_of(const sequence_type & b)
   {
 
      return (this->y * b.x) - (this->x * b.y);
 
   }
 
   
   template <::collection::count S = SIZE, std::enable_if_t<(S == 2), ::i32> = 0>
   COORDINATE angle(const sequence_type & b)
   {
 
      return ::std::atan2(this->dot_with_left_perpendicular_of(b), this->dotted(b));
 
   }
 
 
   sequence_type maximum(const sequence_type & vector) const
   {
 
      sequence_type result;
 
      for (::collection::count i = 0; i < SIZE; ++i)
      {
 
         result.m_coordinatea[i] = ::maximum(this->m_coordinatea[i], vector.m_coordinatea[i]);
 
      }
 
      return result;
 
   }
 
   sequence_type minimum(const sequence_type& vector) const
   {
 
      sequence_type result;
 
      for (::collection::count i = 0; i < SIZE; ++i)
      {
 
         result.m_coordinatea[i] = ::minimum(this->m_coordinatea[i], vector.m_coordinatea[i]);
 
      }
 
      return result;
 
   }
 
   sequence_type & operator =(const sequence_type & sequence)
   {
 
      if (this != &sequence)
      {
 
         for (::collection::count i = 0; i < SIZE; ++i)
         {
 
            this->m_coordinatea[i] = sequence.m_coordinatea[i];
 
         }
 
      }
 
      return *this;
   }
 
 
   UNIT_TYPE minimum() const
   {
 
      UNIT_TYPE nMinimum = this->m_coordinatea[0];
 
      for (::collection::count i = 1; i < SIZE; ++i)
      {
 
         nMinimum = ::minimum(nMinimum, this->m_coordinatea[i]);
 
      }
 
      return nMinimum;
 
   }
 
 
   UNIT_TYPE maximum() const
   {
 
      UNIT_TYPE nMaximum = this->m_coordinatea[0];
 
      for (::collection::count i = 1; i < SIZE; ++i)
      {
 
         nMaximum = ::maximum(nMaximum, this->m_coordinatea[i]);
 
      }
 
      return nMaximum;
 
   }
 
 
 
   
   COORDINATE dotted(const sequence_type & vector) const
   {
 
      COORDINATE result = this->m_coordinatea[0] * vector.m_coordinatea[0];
 
      for (::collection::count i = 1; i < SIZE; ++i)
      {
 
         result += this->m_coordinatea[i] * vector.m_coordinatea[i];
 
      }
 
      return result;
 
   }
 
 
 
   sequence_type make_unitary() const
   {
 
      return *this / modulus();
 
   }
 
 
   const UNIT_TYPE & get_dimension(enum_orientation eorientation) const
   {
      
      return this->m_coordinatea[eorientation];
      
   }
 
   UNIT_TYPE & get_dimension(enum_orientation eorientation)
   {
      
      return this->m_coordinatea[eorientation];
      
   }
 
   
   template < ::collection::count S = SIZE, std::enable_if_t<S == 2, ::i32> = 0 >
   const UNIT_TYPE & get_normal_dimension(enum_orientation eorientation) const
   {
      
      return this->m_coordinatea[orthogonal2_index_of(eorientation)];
   
   }
 
   
   template < ::collection::count S = SIZE, std::enable_if_t<S == 2, ::i32> = 0 >
   UNIT_TYPE & get_normal_dimension(enum_orientation eorientation)
   {
      
      return this->m_coordinatea[orthogonal2_index_of(eorientation)];
   
   }
   
   
   inline UNIT_TYPE & set_dimension(enum_orientation eorientation, UNIT_TYPE l) noexcept
   {
      
      return this->m_coordinatea[eorientation] = l;
      
   }
   
   
   inline UNIT_TYPE & set_orthogonal_dimension(enum_orientation eorientation, UNIT_TYPE l) noexcept
   {
      
      return this->m_coordinatea[orthogonal2_index_of(eorientation)] = l;
      
   }
 
   sequence_type<COORDINATE, 3> crossed(const sequence_type<COORDINATE, 3> &b) const
      requires(SIZE == 3)
   {
      const auto &a = *this;
      return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
   }
 
   inline NUMBER squared_modulus() const
      requires(SIZE == 2)
   {
      return 
         this->x * this->x +
         this->y * this->y;
   }
 
   inline NUMBER squared_modulus() const
      requires(SIZE == 3)
   {
      return 
         this->x * this->x +
         this->y * this->y + 
         this->z * this->z;
   }
 
   inline NUMBER squared_modulus() const
      requires(SIZE == 4)
   {
      return 
         this->x * this->x + 
         this->y * this->y + 
         this->z * this->z + 
         this->w * this->w; 
   }
 
   inline NUMBER modulus() const
   { 
      return ::std::sqrt(squared_modulus()); 
   }
 
 
   inline NUMBER length() const
   {
      
      return modulus(); 
 
   }  
 
 
   inline NUMBER distance(const sequence_type & b) const 
   {
      
      return (b - *this).modulus(); 
   
   }  
 
 
   sequence_type &normalize()
   {
 
      auto modulus = this->modulus();
 
      if (modulus > 0.0f)
      {
 
         return *this /= modulus;
 
      }
      else
      {
 
         return null();
 
      }
 
   }
 
 
   sequence_type normalized() const
   {
 
      sequence_type sequence = *this;
 
      return sequence.normalize();
 
   }
 
 
   template<prototype_floating FLOATING>
   inline sequence_type mix(const sequence_type &b, FLOATING t) const
   {
      
      return *this * ((FLOATING)1 - t) + b * t;
 
   }
 
 
   constexpr sequence_type front_right(const sequence_type & sequence3WorldUp)
      requires(SIZE == 3 && prototype_floating<UNIT_TYPE>)
   {
 
      return this->crossed(sequence3WorldUp).normalized();
 
   }
 
 
   constexpr sequence_type right_up(const sequence_type &front)
      requires(SIZE == 3 && prototype_floating<UNIT_TYPE>)
   {
 
      return this->crossed(front).normalized();
 
   }
 
   
   sequence_type cos() const
   {
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = ::std::cos(this->m_coordinatea[i]);
      return result;
   }
 
 
   sequence_type sin() const
   {
      sequence_type result;
      for (::collection::count i = 0; i < SIZE; ++i)
         result[i] = ::std::sin(this->m_coordinatea[i]);
      return result;
   }
 
   
   auto as_translation_matrix() const
      requires(t_iSize == 3 && prototype_floating<UNIT_TYPE>);
 
   auto as_scaling_matrix() const
      requires(t_iSize == 3 && prototype_floating<UNIT_TYPE>);
 
 
};
 
 
 
 
 
//template <typename COORDINATE, ::collection::count SIZE>
//sequence_type<COORDINATE, SIZE> min(const sequence_type<COORDINATE, SIZE>& a1, const sequence_type<COORDINATE, SIZE>& a2) {
//   sequence_type<COORDINATE, SIZE> result;
//   for (::collection::count i = 0; i < SIZE; ++i)
//      result.m_coordinatea[i] = std::min(a1.m_coordinatea[i], a2.m_coordinatea[i]);
//   return result;
//}
//
//template < prototype_number NUMBER >
//class sequence2_type :
//   public sequence_type < NUMBER, 2 >
//{
//public:
//
//
//   using sequence_type < NUMBER, 2 >::sequence_type;
//
//
//   NUMBER dot_with_left_perpendicular_of(const sequence2_type & b)
//   {
//
//      return (this->y * b.x) - (this->x * b.y);
//
//   }
//
//
//   NUMBER angle(const sequence2_type & b)
//   {
//
//      return atan2f(this->dot_with_left_perpendicular_of(b), this->dot(b));
//
//   }
//
//
//
//};
 
// Import some common Enoki types
using i32_sequence2 = sequence_type<::i32, 2>;
using i32_sequence3 = sequence_type<::i32, 3>;
using i32_sequence4 = sequence_type<::i32, 4>;
 
using i64_sequence2 = sequence_type<::i64, 2>;
using i64_sequence3 = sequence_type<::i64, 3>;
using i64_sequence4 = sequence_type<::i64, 4>;
 
using f32_sequence2 = sequence_type<::f32, 2>;
using f32_sequence3 = sequence_type<::f32, 3>;
using f32_sequence4 = sequence_type<::f32, 4>;
 
using f64_sequence2 = sequence_type<::f64, 2>;
using f64_sequence3 = sequence_type<::f64, 3>;
using f64_sequence4 = sequence_type<::f64, 4>;
 
 
 

//inline Color::operator const ::color::color & () const {
//   return reinterpret_cast<const ::color::color &>(*(this->m_coordinatea));
//}
 
template < prototype_sequence SEQUENCE, typename COORDINATE_TRANSFORM >
auto transform(const SEQUENCE& sequence, COORDINATE_TRANSFORM coordinatetransform)
{
 
   SEQUENCE sequenceResult(no_initialize_t{});
 
   for (::collection::count i = 0; i < sequence.get_size(); ++i)
   {
 
      sequenceResult.set_coordinate(i, coordinatetransform(sequence.coordinate(i)));
 
   }
 
   return sequenceResult;
 
}
 
 
template < prototype_sequence SEQUENCE >
auto floor(const SEQUENCE& sequence)
{
 
   return transform(sequence, [](auto a) {return floor(a); });
 
}
 
 
template < prototype_sequence SEQUENCE >
auto ceil(const SEQUENCE& sequence)
{
 
   return transform(sequence, [](auto a) {return ceil(a); });
 
}
 
 
 
//
//template<prototype_number COORDINATE, ::collection::count t_iDimension>
//struct matrix_type
//{
//
//   using matrix_tag = matrix_t;
//   using BASE_COORDINATE = COORDINATE;
//   using UNIT_TYPE = COORDINATE;
//
//
//   COORDINATE this->m_coordinatea[t_iDimension * t_iDimension];
//
//
//};
//
 
 
 
template<prototype_number NUMBER, ::i32 t_iSize>
struct std::hash<::sequence_type<NUMBER, t_iSize>>
{
   std::size_t operator()(const ::sequence_type<NUMBER, t_iSize> &s) const noexcept
   {
      return std::hash<::sequence_t_type<NUMBER, t_iSize>>{}(
         (const ::sequence_t_type<NUMBER, t_iSize> & )(s));
   }
};
 
//
//namespace geometry
//{
//
//
//   template<prototype_number NUMBER>
//   sequence_type<NUMBER, 3> normalize(const sequence_type<NUMBER, 3> &v)
//   {
//      
//      ::f32 length = std::sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
//      
//      if (length > 0.0f)
//      {
//
//         return v / length;
//
//      }
//      else
//      {
//
//         return sequence_type<NUMBER, 3>(0.0f); // or return v (undefined direction)
//
//      }
//
//
//   }
//
//
//} // namespace geometry
//
 
 
template < prototype_number NUMBER, prototype_number NUMBER1, ::i32 t_iSize >
inline sequence_type<largest_number<NUMBER, NUMBER1>, t_iSize>
operator *(NUMBER n, const sequence_type< NUMBER1, t_iSize> & s)
{
   sequence_type<largest_number<NUMBER, NUMBER1>, t_iSize> result;
   for (::collection::count i = 0; i < t_iSize; ++i)
      result[i] = (largest_number<NUMBER, NUMBER1>)(n * s.m_coordinatea[i]);
   return result;
}