// 注：本内容为作者原创，禁止在其他网站复述内容以及用于商业盈利，如需引用，请标明出处：http://www.cnblogs.com/lv_anchoret/

Preface

　　为了支持光线追踪的学习，决定写一个3D泛型数学库。

　　我采用的是windows平台以及C++Template技术

　　

　　我的库文件组织目录如下

　　--lvgm

　　----test

　　------testVec.cpp

　　----type_vec

　　------lv_vec2.h

　　------lv_vec3.h

　　------type_vec.h

　　------vec_inout.h

　　----lv_precision.h

　　----lvgm.h

Ready

　　这一篇，需要您了解C++Template的基本语法

　　　　　　需要您了解向量的运算

　　该向量库文件解释：

　　　　　　二维向量模板类

　　　　　　三维向量模板类

　　　　　　数据精度设定

　　　　　　本库提供的向量相关的默认输出形式设置文件

　　该向量库文件暂时没有四元组lv_vec4，我将在之后添加并单独写一篇进行陈述

　　该向量库能为您提供的功能：

　　　　　　对向量内部数据方便自由地调取和设定

　　　　　　向量的正负

　　　　　　向量的加减乘除

　　　　　　向量的自增自减

　　　　　　向量的索引

　　　　　　向量判等

　　　　　　向量的赋值以及复合运算赋值

　　　　　　向量的范数

　　　　　　向量的范数平方

　　　　　　向量的自身单位化

　　　　　　返回该向量的高精度单位化向量

　　　　　　向量的内积和外积运算（·、×）

　　　　　　向量判空

Design

　　由于二维和三维的设计相仿，故此处以三维为例进行描述

<1>类型相关

本类中公开定义数据值类型为模板参T，范数精度类型为经外部宏设定的类型——precision， 默认为double

　　设计问题：一开始我们可能想到在模板类里面利用宏控制数据存储精度，但你可能会遇到问题。例如：

  1. #    ifdef HIGHPRECISION        //set the high precision
  2. using norm_t = long double;
  3.  
  4. #    elif(defined LOWPRECISION)    //set the low preciion
  5. using norm_t = float;
  6.  
  7. #    else
  8. using norm_t = double;                //default precision
  9.  
  10. #    endif                        //set precision

假设我现在有一个int的三维向量，我想要返回一个实数精度（norm_t）的单位化向量，于是我们写了一个成员函数vec3<norm_t> ret_unit()const,我们在主函数中需要创建一个vec3去接收ret_unit的返回值

那么，我们两手一摊，无可奈何你可能这样做：

  1.     vec3<？？> normal = intV.ret_unit();

你可能做不到，？？可能是vec3::norm_t 吗，显然不是，vec3是一个模板，只能先将vec3<T>中的T特化。突然觉得，模板类中公开公布了精度类型norm_t，但是却用不上？？

　　解决方案

综合考量到其他类可能也需要精度设定，所以干脆把这设置部分代码单独出来，然后将norm_t 改名为precision，于是问题就解决了

模板类中只需要提前预处理precision文件即可进行如下简单定义：

  1.         using norm_t = precision;

而主函数中也方便多了

  1.     vec3<precision> normal = intV.ret_unit();

<2>参数类型

我看过glm数学库的源码有一类函数是这么实现的

  1. template <typename T, precision P>
  2. template <typename U>
  3.     GLM_FUNC_QUALIFIER tvec3<T, P> & tvec3<T, P>::operator+=(tvec3<U, P> const & v)
  4.     {
  5.         this->x += static_cast<T>(v.x);
  6.         this->y += static_cast<T>(v.y);
  7.         this->z += static_cast<T>(v.z);
  8.         return *this;
  9.     }

其实，意思就是它允许+=另外一种类型的向量，然后我都强转到自身类型T之后进行运算

　　解决方案

个人有一拙见，我是下面这样实现的，如果有什么漏洞请邮件或者评论留言。

我可以通过“重载”static_cast，或者进行一些操作使得vec3模板类能够实现类似内置整型之间的隐式自动类型转换

那么，我就不需要设定多个模板参在内部static_cast了。

好，我们这么做就可以了：

  1.         template<typename E>
  2.         vec3(const vec3<E>& vec);        //static_cast

我在定义构造函数的时候支持其他类型的vec3，哪里需要vec3值传递，我就调用它。

<3>对数据进行方便自由的操作

很多数学库貌似可以直接v.x  v.y ，很多C-struct设计，但作为C++党，用C++语言写代码，要严格遵守数据隐藏，在不失语言原则的情况下做到最方便。

1）很多库支持 v.x = 3;

于是我定义：

  1.         inline T& x()        { return _x; }

但我还是重载了常量版本

  1.         inline const T& x()const    { return _x; }

我希望对内部数据的修改的禁止令可以通过参数来实现，比如：

  1. template<typename T>
  2.         inline vec3<T> operator/(const vec3<T>& v1, const vec3<T>& v2)
  3.             {
  4.             //the operator of / ,example 3 * 5 -> 15 , (1,2,3) * (2,3,4) -> (1/2,2/3,3/4)
  5.             assert(v2.isnull());
  6.             return operator/<T, T> (v1, v2);
  7.             }

所以，我仅仅去重载v.x()的const版本，而不去禁止x()可修改

2）GLSL中还支持这种骚操作：v.rgb = v.gbr; or v.rg = v1.rg

我看了glm库，它暂时没有实现上述的操作支持

而GLSL库我还没研读

所以，凭着自身粗浅的技术，只能实现获取数据元组，而不能实现修改：

  1. inline vec2<T> xy() { return vec2<T>{_x, _y}; }

<4>运算符设计

按照C++operator普遍的设计原则，依旧是将单目和（复合）赋值运算符重载定义为成员函数，而将双目运算符定义为友元或者外部函数，在本库中采用STL设计原则，定义为命名空间内的类外函数，为了不破坏C++类的封装性

++、--等单目运算符请参见我的另外一篇专门解说运算符重载的文章

此处，我只陈述与vec3类相关的设计细节

关于加减法，从数学角度讲，一个向量加减一个标量是非法的，所以，本库中不支持向量和标量的加减法，对于将每一个元素加同一个值，请用偏移向量进行。

而乘法和除法则支持与标量进行运算，因为一个标量乘以一个向量，只是把向量长度延伸了，在数学上也是合法的。

除此之外，考虑到两个vec3对象进行乘除法，如果this是int其他是另外一个是实数的话，我觉得还是进行精度提升的好，所以有专门的重载，且应用了C++11的自动追踪返回值类型技术

关于%以及%=，从数学角度讲，实数并不支持%运算，只有integer才有，而在图形运算过程中，大多是实数，尽管本库不全应用于图形计算，但是%合法运算在工程项目中占得也并不多，所以，如果需要，请自行将每一个元素进行%，库设计中不会因为极小部分的应用而使库变得臃肿

向量范数以及单位化（标准化）

一个类型设计点：利用用户设定精度类型norm_t定义范数的值类型以及返回的标准化向量模板参。

关于向量单位化，我写了两个，一个是自身单位化，此时遵循本身类型进行，意思就是int进行单位化仍然里面的元素是int。

另一个是返回单位化向量，这个时候是实数向量。

我想陈述的本库相关的设计原则基本完毕。

TEST

测试效果：

  1. △--****************** CONSTRUCTOR TEST ******************
  2.  
  3.  ******* ivec3 test *********
  4. there are two ivec3s as intV{ ,-, } and intV2{ , }, the value of which as follows
  5.  
  6. [ , -,  ]
  7.  
  8. [ , ,  ]
  9.  
  10. there is a ivec2 : _2ivec{,}, and a integer  to construct a ivec3 as follows
  11.  
  12. the vec2 in front of the integer of : [ , ,  ]
  13.  
  14. the number of  in front of vec2: [ , ,  ]
  15.  
  16.  ******* fvec3 test **********
  17.  
  18. there is a fvec3 as fV{ .f,2.1f, }, the value of which as follows
  19.  
  20. [ , 2.1,  ]
  21.  
  22. there is a fvec2 : t{1.2f,}, and a value  to construct a ivec3 as follows
  23.  
  24. f2to3 : [ 1.2, ,  ]
  25.  
  26. △--******************* FUNCTIONS TEST ********************
  27.  
  28. there is a ivec3{, -, }
  29. the operator + or - of ivec3 as follows:
  30.  
  31. + : [ , -,  ]
  32. - :[ -, , - ]
  33.  
  34. -----------------------------------------------------------
  35.  
  36. there is a ivec3{, -, }
  37.  
  38. ++ivec3:        the val of expression:[ , -,  ]      the val of ivec3:[ , -,  ]
  39.  
  40. ivec3++:        the val of expression:[ , -,  ]      the val of ivec3:[ , -,  ]
  41.  
  42. the operator of -- is the same as above
  43.  
  44. -----------------------------------------------------------
  45.  
  46. the operator[] of ivec3 as follows:
  47.  
  48. the intV[] is
  49. -----------------------------------------------------------
  50.  
  51. there are two ivec3s as intV{ ,-, } and intV2{ , }, the value of which as follows
  52.  
  53. intV is not equ to intV2
  54.  
  55. the operator = such that: intV2 = intV; the result as follows:
  56. intV2 is [ , -,  ]
  57. intV is equ to intV2
  58.  
  59. there are two ivec3s as intV{ ,-, } and intV2{ , }, the value of which as follows
  60.  
  61. the operator += such that: intV += intV2, the result of which as follows:
  62.  
  63. intV is: [ , -,  ]
  64.  
  65. the operator -= such that: intV -= intV2, the result of which as follows:
  66.  
  67. intV is: [ , -,  ]
  68.  
  69. the value of intV is to become the original value
  70.  
  71. there are two ivec3s as intV{ ,-, } and intV2{ ,, }, the value of which as follows
  72.  
  73. the operator *= such that: intV *= intV2, the result of which as follows:
  74.  
  75. intV is: [ , -,  ]
  76.  
  77. the operator /= such that: intV /= intV2, the result of which as follows:
  78.  
  79. intV is: [ , -,  ]
  80.  
  81. the value of intV is to become the original value
  82.  
  83. -----------------------------------------------------------
  84.  
  85. the operator *= (number)such that: intV *= , the result of which as follows:
  86.  
  87. intV is: [ , -,  ]
  88.  
  89. the operator /= (number) such that: intV /= , the result of which as follows:
  90.  
  91. intV is: [ , -,  ]
  92.  
  93. the value of intV is to become the original value
  94.  
  95. the operator + 、 -、 * 、/ (ivec3 or number) is the same as above
  96.  
  97. -----------------------------------------------------------
  98.  
  99. the operator* between ivec3 and fvec3 as follows:
  100.  
  101. there is a ivec3: intV{,-,}, there is a fvec3: fV{1.1f,2.3f,3.8f}, and the result of ivec3*fvec3 as follows:
  102.  
  103. res is: [ 1.1, -4.6, 11.4 ]
  104.  
  105. the result of * is up to the higher precision of both
  106.  
  107. the operator* between ivec3 and float as follows:
  108.  
  109. there is a ivec3: intV{,-,}, there is a float: 3.14, and the result of ivec3*3.14 as follows:
  110.  
  111. res2 is: [ , -,  ]
  112.  
  113. the type of ivec3 * float is not fvec3 but ivec3, and the factor is just a factor that shouldn't change the vec's precision
  114. if you need the result's type to become fvec3,you should use static_cast<fvec3>(intV) * float
  115.  
  116. res3 is: [ 3.14, -6.28, 9.42 ]
  117.  
  118. the operator/ between different type is the same as above
  119.  
  120. -----------------------------------------------------------
  121.  
  122. the normal() test as follows:
  123.  
  124. there is a ivec3: intV{,-,}
  125.  
  126. the Norm of intV is: 3.74166
  127.  
  128. there is a fvec3: fV{ 1.1, 2.3, 3.5}
  129.  
  130. the Norm of fV is: 4.57602
  131.  
  132. -----------------------------------------------------------
  133.  
  134. there is a ivec3: intV{, , }
  135.  
  136. the unitization of intV is: [ , 0.8, 0.6 ]
  137.  
  138. -----------------------------------------------------------
  139.  
  140. there is a ivec3: intV{,-,}, there is a fvec3: fV{1.1f,2.3f,3.8f}, and the result of ivec3·fvec3 as follows:
  141.  
  142. the dotval is: 7.9
  143.  
  144. crossVec is: [ -14.5, -0.5, 4.5 ]

test result

  1. #define LOWPRECISION        //开启低精度
  2. #define VEC3_OUT            //开启vec3输出
  3.  
  4. #include <lvgm\lvgm.h>
  5. #define stds std::
  6. #define enter stds endl << stds endl
  7.  
  8. using lvgm::ivec2;
  9. using lvgm::ivec3;
  10. using lvgm::fvec3;
  11. using lvgm::fvec2;
  12.  
  13. int main()
  14. {
  15.     ivec3 intV{ ,-, }, intV2{ , }, null;
  16.     //null.self_unitization();
  17.     ivec3 b;
  18.     ivec2 _2ivec{ , };
  19.     fvec3 fV{ .f,2.1f, };
  20.     stds cout << "△--****************** CONSTRUCTOR TEST ******************" << enter;
  21.     stds cout << " ******* ivec3 test *********" << stds endl;
  22.     stds cout << "there are two ivec3s as intV{ 1,-2,3 } and intV2{ 1, }, the value of which as follows" << enter;
  23.     stds cout << intV << enter;
  24.     stds cout << intV2 << enter;
  25.     stds cout << "there is a ivec2 : _2ivec{1,2}, and a integer 7 to construct a ivec3 as follows" << enter;
  26.     ivec3 _2to3{ _2ivec,  };
  27.     stds cout << "the vec2 in front of the integer of 7: " << _2to3 << enter;
  28.     _2to3 = ivec3{ , _2ivec };
  29.     stds cout << "the number of 7 in front of vec2: " << _2to3 << enter << enter;
  30.  
  31.     stds cout << " ******* fvec3 test **********" << enter;
  32.     stds cout << "there is a fvec3 as fV{ 1.f,2.1f, }, the value of which as follows" << enter;
  33.     stds cout << fV << enter;
  34.     stds cout << "there is a fvec2 : t{1.2f,}, and a value 3 to construct a ivec3 as follows" << enter;
  35.     fvec2 t{ 1.2f };
  36.     fvec3 f2to3{ t, };
  37.     stds cout << "f2to3 : " << f2to3 << enter;
  38.  
  39.     stds cout << "△--******************* FUNCTIONS TEST ********************" << enter;
  40.     stds cout << "there is a ivec3{1, -2, 3}" << stds endl;
  41.     stds cout << "the operator + or - of ivec3 as follows:" << enter;
  42.     intV = +intV;
  43.     stds cout << "+ : " << intV << stds endl;
  44.     intV = -intV;
  45.     stds cout << "- :" << intV << enter;
  46.     intV = -intV;
  47.     stds cout << "-----------------------------------------------------------" << enter;
  48.  
  49.     stds cout << "there is a ivec3{1, -2, 3}" << enter;
  50.     auto re = ++intV;
  51.     stds cout << "++ivec3:    the val of expression:" << re << "\tthe val of ivec3:" << intV << enter;
  52.     --intV;
  53.     re = intV++;
  54.     stds cout << "ivec3++:    the val of expression:" << re << "\tthe val of ivec3:" << intV << enter;
  55.     stds cout << "the operator of -- is the same as above" << enter;
  56.     stds cout << "-----------------------------------------------------------" << enter;
  57.  
  58.     stds cout << "the operator[] of ivec3 as follows:" << enter;
  59.     stds cout << "the intV[2] is " << intV[] << stds endl;
  60.     //stds cout << "the intV[4] is " << intV[4] << stds endl;
  61.     stds cout << "-----------------------------------------------------------" << enter;
  62.  
  63.     stds cout << "there are two ivec3s as intV{ 1,-2,3 } and intV2{ 1, }, the value of which as follows" << enter;
  64.     if (intV != intV2)stds cout << "intV is not equ to intV2" << enter;
  65.     stds cout << "the operator = such that: intV2 = intV; the result as follows:" << stds endl;
  66.     intV2 = intV;
  67.     stds cout << "intV2 is " << intV2 << stds endl;
  68.     if (intV2 == intV)stds cout << "intV is equ to intV2" << enter;
  69.     stds cout << stds endl << "there are two ivec3s as intV{ 1,-2,3 } and intV2{ 1, }, the value of which as follows" << enter;
  70.     stds cout << "the operator += such that: intV += intV2, the result of which as follows:" << enter;
  71.     intV2 = { , };
  72.     intV += intV2;
  73.     stds cout << "intV is: " << intV << enter;
  74.     stds cout << "the operator -= such that: intV -= intV2, the result of which as follows:" << enter;
  75.     intV -= intV2;
  76.     stds cout << "intV is: " << intV << enter;
  77.     stds cout << "the value of intV is to become the original value" << enter;
  78.     stds cout << stds endl << "there are two ivec3s as intV{ 1,-2,3 } and intV2{ 2,1,3 }, the value of which as follows" << enter;
  79.     stds cout << "the operator *= such that: intV *= intV2, the result of which as follows:" << enter;
  80.     intV2 = { ,, };
  81.     intV *= intV2;
  82.     stds cout << "intV is: " << intV << enter;
  83.     intV /= intV2;
  84.     stds cout << "the operator /= such that: intV /= intV2, the result of which as follows:" << enter;
  85.     stds cout << "intV is: " << intV << enter;
  86.     stds cout << "the value of intV is to become the original value" << enter;
  87.  
  88.     stds cout << "-----------------------------------------------------------" << enter;
  89.  
  90.     stds cout << "the operator *= (number)such that: intV *= 5, the result of which as follows:" << enter;
  91.     intV *= ;
  92.     stds cout << "intV is: " << intV << enter;
  93.     stds cout << "the operator /= (number) such that: intV /= 5, the result of which as follows:" << enter;
  94.     intV /= ;
  95.     stds cout << "intV is: " << intV << enter;
  96.     stds cout << "the value of intV is to become the original value" << enter;
  97.     stds cout << "the operator + 、 -、 * 、/ (ivec3 or number) is the same as above" << enter;
  98.     stds cout << "-----------------------------------------------------------" << enter;
  99.  
  100.     stds cout << "the operator* between ivec3 and fvec3 as follows:" << enter;
  101.     stds cout << "there is a ivec3: intV{1,-2,3}, there is a fvec3: fV{1.1f,2.3f,3.8f}, and the result of ivec3*fvec3 as follows:" << enter;
  102.     intV = { ,-, };
  103.     fV = { 1.1f,2.3f,3.8f };
  104.     auto res = intV*fV;
  105.     stds cout << "res is: " << res << enter;
  106.     stds cout << "the result of * is up to the higher precision of both" << enter;
  107.  
  108.     stds cout << "the operator* between ivec3 and float as follows:" << enter;
  109.     stds cout << "there is a ivec3: intV{1,-2,3}, there is a float: 3.14, and the result of ivec3*3.14 as follows:" << enter;
  110.     intV = { ,-, };
  111.     auto res2 = intV*3.14;
  112.     stds cout << "res2 is: " << res2 << enter;
  113.     stds cout << "the type of ivec3 * float is not fvec3 but ivec3, and the factor is just a factor that shouldn't change the vec's precision" << stds endl
  114.         << "if you need the result's type to become fvec3,you should use static_cast<fvec3>(intV) * float" << enter;
  115.     intV = { ,-, };
  116.     auto res3 = (static_cast<fvec3>(intV))*3.14;
  117.     stds cout << "res3 is: " << res3 << enter;
  118.     stds cout << "the operator/ between different type is the same as above" << enter;
  119.     stds cout << "-----------------------------------------------------------" << enter;
  120.  
  121.     stds cout << "the normal() test as follows: " << enter;
  122.     stds cout << "there is a ivec3: intV{1,-2,3}" << enter;
  123.     stds cout << "the Norm of intV is: " << intV.normal() << enter;
  124.     stds cout << "there is a fvec3: fV{ 1.1, 2.3, 3.5}" << enter;
  125.     stds cout << "the Norm of fV is: " << fV.normal() << enter;
  126.     stds cout << "-----------------------------------------------------------" << enter;
  127.  
  128.     stds cout << "there is a ivec3: intV{0, 4, 3}" << enter;
  129.     intV = { ,, };
  130.     lvgm::vec3<lvgm::precision> normal = intV.ret_unitization();
  131.     stds cout << "the unitization of intV is: " << normal << enter;
  132.     stds cout << "-----------------------------------------------------------" << enter;
  133.  
  134.     stds cout << "there is a ivec3: intV{1,-2,3}, there is a fvec3: fV{1.1f,2.3f,3.8f}, and the result of ivec3·fvec3 as follows:" << enter;
  135.     intV = { ,-, };
  136.     fV = { 1.1f,2.3f,3.8f };
  137.     lvgm::precision dotval = lvgm::dot(intV, fV);
  138.     stds cout << "the dotval is: " << dotval << enter;
  139.     auto crossVec = cross(intV, fV);
  140.     stds cout << "crossVec is: " << crossVec << enter;
  141. }

test code

库文件代码

  1. /// lvgm.h
  2.  
  3. // -----------------------------------------------------
  4. // [author]        lv
  5. // [ time ]        2018.12 ~ 2018.12
  6. // [brief ]        include all of the mymath's head files
  7. // -----------------------------------------------------
  8.  
  9. #ifndef LVGM_H
  10. #define LVGM_H
  11.  
  12. #include <lvgm\type_vec\type_vec.h>
  13.  
  14. #endif  //LVGM_H

lvgm.h

  1. /// precision.h
  2.  
  3. // -----------------------------------------------------
  4. // [author]        lv
  5. // [ time ]        2018.12 ~ 2018.12
  6. // [brief ]        control the precision of data
  7. // -----------------------------------------------------
  8.  
  9. #ifndef LV_PRECISION_H
  10. #define LV_PRECISION_H
  11.  
  12. namespace lvgm
  13. {
  14.  
  15. #    ifdef HIGHPRECISION            //set the high precision
  16. using precision = long double;
  17.  
  18. #    elif(defined LOWPRECISION)    //set the low preciion
  19. using precision = float;
  20.  
  21. #    else
  22. using precision = double;        //default precision
  23.  
  24. #    endif                        //set precision
  25.  
  26. }    //namespace lvgm
  27.  
  28. #endif        //LV_PRECISION_H

precision.h

  1. /// myVec2.h
  2.  
  3. // -----------------------------------------------------
  4. // [author]        lv
  5. // [ time ]        2018.12 ~ 2018.12
  6. // [brief ]        the definition of two-dimensional vector
  7. // -----------------------------------------------------
  8.  
  9. #ifndef LV_VEC2_H
  10. #define LV_VEC2_H
  11.  
  12. namespace lvgm
  13. {
  14.  
  15. template<typename T>
  16.     class vec2
  17.         {
  18.     public:
  19.         using value_type = T;
  20.  
  21.         using norm_t = precision;
  22.  
  23.     public:
  24.  
  25.         template<typename E>
  26.         vec2(const vec2<E>& vec);        //static_cast
  27.  
  28.         vec2(const T x = T(), const T y = T())noexcept;
  29.  
  30.         vec2(const vec2&);
  31.  
  32.         ~vec2() {  }
  33.  
  34.     public:
  35.         //inline get function
  36.         inline T& x() { return _x; }
  37.  
  38.         inline T& y() { return _y; }
  39.  
  40.         inline T& u() { return _x; }
  41.  
  42.         inline T& v() { return _y; }
  43.  
  44.         inline T& r() { return _x; }
  45.  
  46.         inline T& g() { return _y; }
  47.  
  48.         inline T& s() { return _x; }
  49.  
  50.         inline T& t() { return _y; }
  51.  
  52.         inline vec2 xy() { return vec2<T>{_x, _y}; }
  53.  
  54.         inline vec2 yx() { return vec2<T>{_y, _x}; }
  55.  
  56.         inline vec2 rg() { return vec2<T>{_x, _y}; }
  57.  
  58.         inline vec2 gr() { return vec2<T>{_y, _x}; }
  59.  
  60.         inline vec2 uv() { return vec2<T>{_x, _y}; }
  61.  
  62.         inline vec2 vu() { return vec2<T>{_y, _x}; }
  63.  
  64.         inline vec2 st() { return vec2<T>{_x, _y}; }
  65.  
  66.         inline vec2 ts() { return vec2<T>{_y, _x}; }
  67.  
  68.         inline const T& x()const { return _x; }
  69.  
  70.         inline const T& y()const { return _y; }
  71.  
  72.         inline const T& u()const { return _x; }
  73.  
  74.         inline const T& v()const { return _y; }
  75.  
  76.         inline const T& r()const { return _x; }
  77.  
  78.         inline const T& g()const { return _y; }
  79.  
  80.         inline const T& s()const { return _x; }
  81.  
  82.         inline const T& t()const { return _y; }
  83.  
  84.         //inline operator function
  85.         inline const vec2& operator+()const;
  86.  
  87.         inline vec2 operator-()const;
  88.  
  89.         inline vec2& operator++();
  90.  
  91.         inline vec2& operator--();
  92.  
  93.         inline const vec2 operator++(int);
  94.  
  95.         inline const vec2 operator--(int);
  96.  
  97.         inline const T& operator[](const int index)const;
  98.  
  99.         inline T& operator[](const int index);
  100.  
  101.         inline vec2& operator=(const vec2& rhs);
  102.  
  103.         inline vec2& operator+=(const vec2& rhs);
  104.  
  105.         inline vec2& operator-=(const vec2& rhs);
  106.  
  107.         inline vec2& operator*=(const vec2& rhs);
  108.  
  109.         inline vec2& operator/=(const vec2& rhs);
  110.  
  111.         inline vec2& operator*=(const T factor);
  112.  
  113.         inline vec2& operator/=(const T factor);
  114.  
  115.     public:
  116.         //return the Norm of vec2
  117.         inline norm_t normal()const;
  118.  
  119.         inline norm_t squar()const;
  120.  
  121.         //let self become to the unit vector of vec_type
  122.         inline void self_unitization();
  123.  
  124.         //return a non-integer three-dimensional unit vector [the type is norm_t]
  125.         inline vec2<precision> ret_unitization()const;
  126.  
  127.         inline bool isnull()const;
  128.  
  129.     private:
  130.         T _x, _y;
  131.  
  132.         };
  133.  
  134. //constructor functions
  135.  
  136.     template<typename T>
  137.         vec2<T>::vec2(const T x, const T y)noexcept
  138.             :_x(x)
  139.             , _y(y)
  140.     {    }
  141.  
  142.     template<typename T>
  143.         template<typename E>
  144.         vec2<T>::vec2(const vec2<E>& rhs)
  145.             :_x(static_cast<T>(rhs.x()))
  146.             , _y(static_cast<T>(rhs.y()))
  147.     {    }
  148.  
  149.     template<typename T>
  150.         vec2<T>::vec2(const vec2<T>& rhs)
  151.             : _x(rhs._x)
  152.             , _y(rhs._y)
  153.     {    }
  154.  
  155. // Binary operator functions [non-mem]
  156.  
  157.     template<typename T>
  158.         inline vec2<T> operator+(const vec2<T>& v1, const vec2<T>& v2)
  159.             {
  160.             return vec2<T>(v1[] + v2[], v1[] + v2[]);
  161.             }
  162.  
  163.     template<typename T>
  164.         inline vec2<T> operator-(const vec2<T>& v1, const vec2<T>& v2)
  165.             {
  166.             //the operator of - ,example  (5,4) - (2,2) -> (3,2)
  167.             return v1 + (-v2);
  168.             }
  169.  
  170.     template<typename A, typename B>
  171.         inline auto operator*(const vec2<A>& v1, const vec2<B>& v2)
  172.             {
  173.             //the operator of * ,example  (1.1, 2.1) * (2, 3) -> (2.2, 6.3)
  174.             using type = decltype(v1[] * v2[]);
  175.             return vec2<type>((type)v1[] * v2[], (type)v1[] * v2[]);
  176.             }
  177.  
  178.     template<typename T>
  179.         inline vec2<T> operator*(const vec2<T>& v1, const vec2<T>& v2)
  180.             {
  181.             //the operator of * ,example (1,2) * (2,3) -> (2,6)
  182.             return vec2<T>(v1[] * v2[], v1[] * v2[]);
  183.             }
  184.  
  185.     template<typename T, typename E>
  186.         inline vec2<T> operator*(const vec2<T>& v, const E factor)
  187.             {
  188.             return vec2<T>(v.x() * factor, v.y() * factor);
  189.             }
  190.  
  191.     template<typename T, typename E>
  192.         inline vec2<T> operator*(const E factor, const vec2<T>& v)
  193.             {
  194.             return vec2<T>(v.x() * factor, v.y() * factor);
  195.             }
  196.  
  197.     template<typename A, typename B>
  198.         inline auto operator/(const vec2<A>& v1, const vec2<B>& v2)
  199.             {
  200.             //the operator of / ,example  (1.1, 2.1) * (2, 3) -> (0.55, 0.7)
  201.             assert(v2.isnull());
  202.             using type = decltype(v1[] / v2[]);
  203.             return vec2<type>((type)v1[] / v2[], (type)v1[] / v2[]);
  204.             }
  205.  
  206.     template<typename T>
  207.         inline vec2<T> operator/(const vec2<T>& v1, const vec2<T>& v2)
  208.             {
  209.             //the operator of / ,example 3 * 5 -> 15 , (1,2) * (2,3) -> (1/2,2/3)
  210.             assert(v2.isnull());
  211.             return operator/<T, T> (v1, v2);
  212.             }
  213.  
  214.     template<typename T, typename E>
  215.         inline vec2<T> operator/(const vec2<T>& v, const E factor)
  216.             {
  217.             assert(factor !=  && factor != .);
  218.             return vec2<T>(v.x() / factor, v.y() / factor);
  219.             }
  220.  
  221.     template<typename T>
  222.         inline bool operator==(const vec2<T>& v1, const vec2<T>& v2)
  223.             {
  224.             return v1.x() == v2.x() && v1.y() == v2.y();
  225.             }
  226.  
  227.     template<typename T>
  228.         inline bool operator!=(const vec2<T>& v1, const vec2<T>& v2)
  229.             {
  230.             return !(v1 == v2);
  231.             }
  232.  
  233.     // Unary operator functions [mem]
  234.  
  235.     template<typename T>
  236.         inline const vec2<T>& vec2<T>::operator+() const
  237.             {
  238.             //the operator of + ,example 5 -> +5,  +(1,-2) -> (1,-2)
  239.             return *this;
  240.             }
  241.  
  242.     template<typename T>
  243.         inline vec2<T> vec2<T>::operator-() const
  244.             {
  245.             //the operator of - ,example 5 -> -5,  -(1,-2) -> (-1,2)
  246.             return vec2<T>(-_x, -_y);
  247.             }
  248.  
  249.     template<typename T>
  250.         inline vec2<T>& vec2<T>::operator++()
  251.             {
  252.             ++this->_x;
  253.             ++this->_y;
  254.             return *this;
  255.             }
  256.  
  257.     template<typename T>
  258.         inline const vec2<T> vec2<T>::operator++(int)
  259.             {
  260.             vec2<T>ori(*this);
  261.             ++*this;
  262.             return ori;
  263.             }
  264.  
  265.     template<typename T>
  266.         inline vec2<T>& vec2<T>::operator--()
  267.             {
  268.             --this->_x;
  269.             --this->_y;
  270.             return *this;
  271.             }
  272.  
  273.     template<typename T>
  274.         inline const vec2<T> vec2<T>::operator--(int)
  275.             {
  276.             vec2<T>ori(*this);
  277.             --*this;
  278.             return ori;
  279.             }
  280.  
  281.     template<typename T>
  282.         inline const T& vec2<T>::operator[](const int index)const
  283.             {
  284.             if (index == )return _x;
  285.             else if (index == )return _y;
  286.             else throw "the index is error";
  287.             }
  288.  
  289.     template<typename T>
  290.         inline T& vec2<T>::operator[](const int index)
  291.             {
  292.             if (index == )return _x;
  293.             else if (index == )return _y;
  294.             else throw "the index is error";
  295.             }
  296.  
  297. // member functions
  298.  
  299.     template<typename T>
  300.         inline vec2<T>& vec2<T>::operator=(const vec2<T>& rhs)
  301.             {
  302.             if (this != &rhs)
  303.                 {
  304.                 _x = rhs._x;
  305.                 _y = rhs._y;
  306.                 }
  307.             return *this;
  308.             }
  309.  
  310.     template<typename T>
  311.         inline vec2<T>& vec2<T>::operator+=(const vec2& rhs)
  312.             {
  313.             this->_x += rhs._x;
  314.             this->_y += rhs._y;
  315.             return *this;
  316.             }
  317.  
  318.     template<typename T>
  319.         inline vec2<T>& vec2<T>::operator-=(const vec2& rhs)
  320.             {
  321.             return *this += (-rhs);
  322.             }
  323.  
  324.     template<typename T>
  325.         inline vec2<T>& vec2<T>::operator/=(const vec2<T>& rhs)
  326.             {
  327.             assert(!rhs.isnull());
  328.             this->_x /= rhs._x;
  329.             this->_y /= rhs._y;
  330.             return *this;
  331.             }
  332.  
  333.     template<typename T>
  334.         inline vec2<T>& vec2<T>::operator*=(const vec2<T>& rhs)
  335.             {
  336.             this->_x *= rhs._x;
  337.             this->_y *= rhs._y;
  338.             return *this;
  339.             }
  340.  
  341.     template<typename T>
  342.         inline vec2<T>& vec2<T>::operator*=(const T factor)
  343.             {
  344.             this->_x *= factor;
  345.             this->_y *= factor;
  346.             return *this;
  347.             }
  348.  
  349.     template<typename T>
  350.         inline vec2<T>& vec2<T>::operator/=(const T factor)
  351.             {
  352.             assert(factor != );
  353.             this->_x /= factor;
  354.             this->_y /= factor;
  355.             return *this;
  356.             }
  357.  
  358.     template<typename T>
  359.         inline typename vec2<T>::norm_t vec2<T>::normal()const
  360.             {
  361.             return sqrt(squar());
  362.             }
  363.  
  364.     template<typename T>
  365.         inline typename vec2<T>::norm_t vec2<T>::squar()const
  366.             {
  367.             return _x*_x + _y*_y;
  368.             }
  369.  
  370.     template<typename T>
  371.         inline void vec2<T>::self_unitization()
  372.             {
  373.             *this /= normal();
  374.             }
  375.  
  376.     template<typename T>
  377.         inline vec2<precision> vec2<T>::ret_unitization()const
  378.             {
  379.             norm_t div = normal();
  380.             return vec2<norm_t>{ (norm_t)this->_x / div, (norm_t)this->_y / div, (norm_t)this->_z / div };
  381.             }
  382.  
  383.     template<typename T, typename E>
  384.         inline auto dot(const vec2<T>& v1, const vec2<E>& v2) //-> decltype(v1.x() * v2.x() + v1.y() * v2.y()
  385.             {// x1 * x2 + y1 * y2
  386.             return v1.x() * v2.x() + v1.y() * v2.y();
  387.             }
  388.  
  389.     template<typename T, typename E>
  390.         inline auto cross(const vec2<T> v1, const vec2<E>& v2)
  391.             {// v1 × v2
  392.             return    v1[] * v2[] - v1[] * v2[];
  393.             }
  394.  
  395.     template<typename T>
  396.         inline bool vec2<T>::isnull()const
  397.             {
  398.             return *this == vec2<T>();
  399.             }
  400.  
  401. }    //namespace lvgm
  402.  
  403. #endif    //LV_VEC2_H

lv_vec2.h

  1. /// myVec3.h
  2.  
  3. // -----------------------------------------------------
  4. // [author]        lv
  5. // [ time ]        2018.12 ~ 2018.12
  6. // [brief ]        the definition of Three-dimensional vector
  7. // -----------------------------------------------------
  8.  
  9. #ifndef LV_VEC3_H
  10. #define LV_VEC3_H
  11.  
  12. namespace lvgm
  13. {
  14.  
  15. template<typename T>
  16.     class vec3
  17.         {
  18.     public:
  19.         using value_type = T;
  20.  
  21.         using norm_t = precision;
  22.  
  23.     public:
  24.  
  25.         template<typename E>
  26.         vec3(const vec3<E>& vec);        //static_cast
  27.  
  28.         vec3(const T e1 = T(), const T e2 = T(), const T e3 = T())noexcept;
  29.  
  30.         explicit vec3(const vec2<T>& v2, const T e3 = T())noexcept;
  31.  
  32.         explicit vec3(const T e1, const vec2<T>& v)noexcept;
  33.  
  34.         explicit vec3(const vec3&);
  35.  
  36.         ~vec3() {  }
  37.  
  38.     public:
  39.  
  40.         inline T& x()        { return _x; }
  41.  
  42.         inline T& y()        { return _y; }
  43.  
  44.         inline T& z()        { return _z; }
  45.  
  46.         inline T& r()        { return _x; }
  47.  
  48.         inline T& g()        { return _y; }
  49.  
  50.         inline T& b()        { return _z; }
  51.  
  52.         inline vec2<T> xy() { return vec2<T>{_x, _y}; }
  53.  
  54.         inline vec2<T> yx()    { return vec2<T>{_y, _x}; }
  55.  
  56.         inline vec2<T> xz()    { return vec2<T>{_x, _z}; }
  57.  
  58.         inline vec2<T> zx()    { return vec2<T>{_z, _x}; }
  59.  
  60.         inline vec2<T> yz()    { return vec2<T>{_y, _z}; }
  61.  
  62.         inline vec2<T> zy()    { return vec2<T>{_z, _y}; }
  63.  
  64.         inline vec2<T> rg()    { return vec2<T>{_x, _y}; }
  65.  
  66.         inline vec2<T> gr()    { return vec2<T>{_y, _x}; }
  67.  
  68.         inline vec2<T> rb()    { return vec2<T>{_x, _z}; }
  69.  
  70.         inline vec2<T> br()    { return vec2<T>{_z, _x}; }
  71.  
  72.         inline vec2<T> gb()    { return vec2<T>{_y, _z}; }
  73.  
  74.         inline vec2<T> bg()    { return vec2<T>{_z, _y}; }
  75.  
  76.         inline vec3 rgb()    { return vec3{_x, _y, _z}; }
  77.  
  78.         inline vec3 rbg()    { return vec3{_x, _z, _y}; }
  79.  
  80.         inline vec3 gbr()    { return vec3{_y, _z, _x}; }
  81.  
  82.         inline vec3 grb()    { return vec3{_y, _x, _z}; }
  83.  
  84.         inline vec3 bgr()    { return vec3{_z, _y, _x}; }
  85.  
  86.         inline vec3 brg()    { return vec3{_z, _x, _y}; }
  87.  
  88.         inline const T& x()const    { return _x; }
  89.  
  90.         inline const T& y()const    { return _y; }
  91.  
  92.         inline const T& z()const    { return _z; }
  93.  
  94.         inline const T& r()const    { return _x; }
  95.  
  96.         inline const T& g()const    { return _y; }
  97.  
  98.         inline const T& b()const    { return _z; }
  99.  
  100.         //inline oprator function
  101.         inline const vec3& operator+() const;
  102.  
  103.         inline vec3 operator-()const;
  104.  
  105.         inline vec3& operator++();
  106.  
  107.         inline vec3& operator--();
  108.  
  109.         inline const vec3 operator++(int);
  110.  
  111.         inline const vec3 operator--(int);
  112.  
  113.         inline const T& operator[](const int index)const;
  114.  
  115.         inline T& operator[](const int index);
  116.  
  117.         inline vec3& operator=(const vec3& rhs);
  118.  
  119.         inline vec3& operator+=(const vec3& rhs);
  120.  
  121.         inline vec3& operator-=(const vec3& rhs);
  122.  
  123.         inline vec3& operator*=(const vec3& rhs);
  124.  
  125.         inline vec3& operator/=(const vec3& rhs);
  126.  
  127.         inline vec3& operator*=(const T factor);
  128.  
  129.         inline vec3& operator/=(const T factor);
  130.  
  131.     public:
  132.         //return the Norm of vec3
  133.         inline norm_t normal()const;
  134.  
  135.         inline norm_t squar()const;
  136.  
  137.         //let self become to the unit vector of vec_type
  138.         inline void self_unitization();
  139.  
  140.         //return a non-integer three-dimensional unit vector [the type is norm_t]
  141.         inline vec3<precision> ret_unitization()const;
  142.  
  143.         inline bool isnull()const;
  144.  
  145.     private:
  146.         T _x, _y, _z;
  147.  
  148.         };
  149.  
  150. //constructor functions
  151.  
  152.     template<typename T>
  153.         template<typename E>
  154.         vec3<T>::vec3(const vec3<E>& vec)
  155.             :_x(static_cast<T>(vec.x()))
  156.             ,_y(static_cast<T>(vec.y()))
  157.             ,_z(static_cast<T>(vec.z()))
  158.         {    }
  159.  
  160.     template<typename T>
  161.         vec3<T>::vec3(const T e1, const T e2, const T e3)noexcept
  162.             :_x{e1}
  163.             ,_y{e2}
  164.             ,_z{e3}
  165.         {    }
  166.  
  167.     template<typename T>
  168.         vec3<T>::vec3(const vec2<T>& v, const T e3)noexcept
  169.             :_x(v.x())
  170.             ,_y(v.y())
  171.             ,_z(e3)
  172.         {    }
  173.  
  174.     template<typename T>
  175.         vec3<T>::vec3(const T e, const vec2<T>& v)noexcept
  176.             :_x(e)
  177.             ,_y(v.x())
  178.             ,_z(v.y())
  179.         {    }
  180.  
  181.     template<typename T>
  182.         vec3<T>::vec3(const vec3<T>& rhs)
  183.             :_x{rhs._x}
  184.             ,_y{rhs._y}
  185.             ,_z{rhs._z}
  186.         {    }
  187.  
  188. // Binary operator functions [non-mem]
  189.     template<typename T>
  190.         vec3<T> operator+(const vec3<T>& v1, const vec3<T>& v2)
  191.             {
  192.             //the operator of + ,example  (5,4,3) + (2,-2,1) -> (7,2,4)
  193.             return vec3<T>(v1[] + v2[], v1[] + v2[], v1[] + v2[]);
  194.             }
  195.  
  196.     template<typename T>
  197.         inline vec3<T> operator-(const vec3<T>& v1, const vec3<T>& v2)
  198.             {
  199.             //the operator of - ,example  (5,4,3) - (2,2,1) -> (3,2,2)
  200.             return v1 + (-v2);
  201.             }
  202.  
  203.     template<typename A, typename B>
  204.         inline auto operator*(const vec3<A>& v1, const vec3<B>& v2)
  205.             {
  206.             //the operator of * ,example  (1.1, 2.1, 3.1) * (2, 3, 4) -> (2.2, 6.3, 12.4)
  207.             using type = decltype(v1[] * v2[]);
  208.             return vec3<type>((type)v1[] * v2[], (type)v1[] * v2[], (type)v1[] * v2[]);
  209.             }
  210.  
  211.     template<typename T>
  212.         inline vec3<T> operator*(const vec3<T>& v1, const vec3<T>& v2)
  213.             {
  214.             //the operator of * ,example 3 * 5 -> 15 , (1,2,3) * (2,3,4) -> (2,6,12)
  215.             return vec3<T>(v1[] * v2[], v1[] * v2[], v1[] * v2[]);
  216.             }
  217.  
  218.     template<typename T, typename E>
  219.         inline vec3<T> operator*(const vec3<T>& v, const E factor)
  220.             {
  221.             return vec3<T>(v.x() * factor, v.y() * factor, v.z() * factor);
  222.             }
  223.  
  224.     template<typename T, typename E>
  225.         inline vec3<T> operator*(const E factor, const vec3<T>& v)
  226.             {
  227.             return vec3<T>(v.x() * factor, v.y() * factor, v.z() * factor);
  228.             }
  229.  
  230.     template<typename A, typename B>
  231.         inline auto operator/(const vec3<A>& v1, const vec3<B>& v2)
  232.             {
  233.             //the operator of / ,example  (1.1, 2.1, 3.2) * (2, 3, 4) -> (0.55, 0.7, 0.8)
  234.             assert(v2.isnull());
  235.             using type = decltype(v1[] / v2[]);
  236.             return vec3<type>((type)v1[] / v2[], (type)v1[] / v2[], (type)v1[] / v2[]);
  237.             }
  238.  
  239.     template<typename T>
  240.         inline vec3<T> operator/(const vec3<T>& v1, const vec3<T>& v2)
  241.             {
  242.             //the operator of / ,example 3 * 5 -> 15 , (1,2,3) * (2,3,4) -> (1/2,2/3,3/4)
  243.             assert(v2.isnull());
  244.             return operator/<T, T> (v1, v2);
  245.             }
  246.  
  247.     template<typename T, typename E>
  248.         inline vec3<T> operator/(const vec3<T>& v, const E factor)
  249.             {
  250.             assert(factor !=  && factor != .);
  251.             return vec3<T>(v.x() / factor, v.y() / factor, v.z() / factor);
  252.             }
  253.  
  254.     template<typename T>
  255.         inline bool operator==(const vec3<T>& v1, const vec3<T>& v2)
  256.             {
  257.             return v1.x() == v2.x() && v1.y() == v2.y() && v1.z() == v2.z();
  258.             }
  259.  
  260.     template<typename T>
  261.         inline bool operator!=(const vec3<T>& v1, vec3<T>& v2)
  262.             {
  263.             return !(v1 == v2);
  264.             }
  265.  
  266. // Unary operator functions [mem]
  267.     template<typename T>
  268.         inline const vec3<T>& vec3<T>::operator+() const
  269.             {
  270.             //the operator of + ,example 5 -> +5,  +(1,-2,3) -> (1,-2,3)
  271.             return *this;
  272.             }
  273.  
  274.     template<typename T>
  275.         inline vec3<T> vec3<T>::operator-() const
  276.             {
  277.             //the operator of - ,example 5 -> -5,  -(1,-2,3) -> (-1,2,-3)
  278.             return vec3<T>(-_x, -_y, -_z);
  279.             }
  280.  
  281.     template<typename T>
  282.         inline vec3<T>& vec3<T>::operator++()
  283.             {
  284.             ++this->_x;
  285.             ++this->_y;
  286.             ++this->_z;
  287.             return *this;
  288.             }
  289.  
  290.     template<typename T>
  291.         inline const vec3<T> vec3<T>::operator++(int)
  292.             {
  293.             vec3<T>ori(*this);
  294.             ++*this;
  295.             return ori;
  296.             }
  297.  
  298.     template<typename T>
  299.         inline vec3<T>& vec3<T>::operator--()
  300.             {
  301.             --this->_x;
  302.             --this->_y;
  303.             --this->_z;
  304.             return *this;
  305.             }
  306.  
  307.     template<typename T>
  308.         inline const vec3<T> vec3<T>::operator--(int)
  309.             {
  310.             vec3<T>ori(*this);
  311.             --*this;
  312.             return ori;
  313.             }
  314.  
  315.     template<typename T>
  316.         inline const T& vec3<T>::operator[](const int index)const
  317.             {
  318.             if (index == )return _x;
  319.             else if (index == )return _y;
  320.             else if (index == )return _z;
  321.             else throw "the index is error";
  322.             }
  323.  
  324.     template<typename T>
  325.         inline T& vec3<T>::operator[](const int index)
  326.             {
  327.             if (index == )return _x;
  328.             else if (index == )return _y;
  329.             else if (index == )return _z;
  330.             else throw "the index is error";
  331.             }
  332.  
  333. // member functions
  334.     template<typename T>
  335.         inline vec3<T>& vec3<T>::operator=(const vec3<T>& rhs)
  336.             {
  337.             if (this != &rhs)
  338.                 {
  339.                 _x = rhs._x;
  340.                 _y = rhs._y;
  341.                 _z = rhs._z;
  342.                 }
  343.             return *this;
  344.             }
  345.  
  346.     template<typename T>
  347.         inline vec3<T>& vec3<T>::operator+=(const vec3& rhs)
  348.             {
  349.             this->_x += rhs._x;
  350.             this->_y += rhs._y;
  351.             this->_z += rhs._z;
  352.             return *this;
  353.             }
  354.  
  355.     template<typename T>
  356.         inline vec3<T>& vec3<T>::operator-=(const vec3& rhs)
  357.             {
  358.             this->_x -= rhs._x;
  359.             this->_y -= rhs._y;
  360.             this->_z -= rhs._z;
  361.             return *this;
  362.             }
  363.  
  364.     template<typename T>
  365.         inline vec3<T>& vec3<T>::operator/=(const vec3<T>& rhs)
  366.             {
  367.             assert(!rhs.isnull());
  368.             this->_x /= rhs._x;
  369.             this->_y /= rhs._y;
  370.             this->_z /= rhs._z;
  371.             return *this;
  372.             }
  373.  
  374.     template<typename T>
  375.         inline vec3<T>& vec3<T>::operator*=(const vec3<T>& rhs)
  376.             {
  377.             this->_x *= rhs._x;
  378.             this->_y *= rhs._y;
  379.             this->_z *= rhs._z;
  380.             return *this;
  381.             }
  382.  
  383.     template<typename T>
  384.         inline vec3<T>& vec3<T>::operator*=(const T factor)
  385.             {
  386.             this->_x *= factor;
  387.             this->_y *= factor;
  388.             this->_z *= factor;
  389.             return *this;
  390.             }
  391.  
  392.     template<typename T>
  393.         inline vec3<T>& vec3<T>::operator/=(const T factor)
  394.             {
  395.             assert(factor != );
  396.             this->_x /= factor;
  397.             this->_y /= factor;
  398.             this->_z /= factor;
  399.             return *this;
  400.             }
  401.  
  402.     template<typename T>
  403.         inline typename vec3<T>::norm_t vec3<T>::normal()const
  404.             {
  405.             return sqrt(squar());
  406.             }
  407.  
  408.     template<typename T>
  409.         inline typename vec3<T>::norm_t vec3<T>::squar()const
  410.             {
  411.             return _x*_x + _y*_y + _z*_z;
  412.             }
  413.  
  414.     template<typename T>
  415.         inline void vec3<T>::self_unitization()
  416.             {
  417.             *this /= normal();
  418.             }
  419.  
  420.     template<typename T>
  421.         inline vec3<precision> vec3<T>::ret_unitization()const
  422.             {
  423.             norm_t div = normal();
  424.             return vec3<norm_t>{ (norm_t)this->_x / div,(norm_t)this->_y / div,(norm_t)this->_z / div };
  425.             }
  426.  
  427.     template<typename T, typename E>
  428.         inline auto dot(const vec3<T>& v1, const vec3<E>& v2) //-> decltype(v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z())
  429.             {// x1 * x2 + y1 * y2 + z1 * z2
  430.             return v1.x() * v2.x() + v1.y() * v2.y() + v1.z() * v2.z();
  431.             }
  432.  
  433.     template<typename T, typename E>
  434.         inline auto cross(const vec3<T> v1, const vec3<E>& v2)
  435.             {// v1 × v2
  436.             return vec3<decltype(v1[] * v2[] - v1[] * v2[])>
  437.                 (
  438.                 v1[] * v2[] - v1[] * v2[],
  439.                 v1[] * v2[] - v1[] * v2[],
  440.                 v1[] * v2[] - v1[] * v2[]
  441.                 );
  442.             }
  443.  
  444.     template<typename T>
  445.         inline bool vec3<T>::isnull()const
  446.             {
  447.             return *this == vec3<T>();
  448.             }
  449.  
  450. }    //namespace lvgm
  451.  
  452. #endif    //LV_VEC3_H

lv_vec3.h

  1. /// all vectors are in here
  2.  
  3. // -----------------------------------------------------
  4. // [author]        lv
  5. // [ time ]        2018.12 ~ 2018.12
  6. // [brief ]        all vectors are in here
  7. // -----------------------------------------------------
  8.  
  9. #pragma once
  10.  
  11. #include <iostream>
  12. #include <cmath>
  13. #include <cassert>
  14. #include <lvgm\lv_precision.h>
  15.  
  16. #include "lv_vec2.h"
  17. #include "lv_vec3.h"
  18. #include "vec_inout.h"
  19.  
  20. namespace lvgm
  21. {
  22.     template<typename T> class vec2;
  23.  
  24.     template<typename T> class vec3;
  25.  
  26.     template<typename T> class vec4;
  27.  
  28.     typedef vec2<bool> bvec2;
  29.  
  30.     typedef vec2<char> cvec2;
  31.  
  32.     typedef vec2<short> svec2;
  33.  
  34.     typedef vec2<int> ivec2;
  35.  
  36.     typedef vec2<float> fvec2;
  37.  
  38.     typedef vec2<double> dvec2;
  39.  
  40.     typedef vec2<long double> ldvec2;
  41.  
  42.     typedef vec3<bool> bvec3;
  43.  
  44.     typedef vec3<char> cvec3;
  45.  
  46.     typedef vec3<short> svec3;
  47.  
  48.     typedef vec3<int> ivec3;
  49.  
  50.     typedef vec3<float> fvec3;
  51.  
  52.     typedef vec3<double> dvec3;
  53.  
  54.     typedef vec3<long double> ldvec3;
  55.  
  56.     typedef vec4<bool> bvec4;
  57.  
  58.     typedef vec4<char> cvec4;
  59.  
  60.     typedef vec4<short> svec4;
  61.  
  62.     typedef vec4<int> ivec4;
  63.  
  64.     typedef vec4<float> fvec4;
  65.  
  66.     typedef vec4<double> dvec4;
  67.  
  68.     typedef vec4<long double> ldvec4;
  69. }

type_vec.h

  1. ///vec_inout.h
  2.  
  3. // -----------------------------------------------------
  4. // [author]        lv
  5. // [ time ]        2018.12 ~ 2018.12
  6. // [brief ]        control the iostream of vec
  7. // -----------------------------------------------------
  8.  
  9. #pragma once
  10.  
  11. # ifdef    VEC_OUT
  12.  
  13.     template<typename T>
  14.         std::ostream& operator<<(std::ostream& cout, const lvgm::vec2<T>& v)
  15.             {
  16.             cout << "[ " << v.x() << ", " << v.y() << " ]";
  17.             return cout;
  18.             }
  19.  
  20.     template<typename T>
  21.         std::ostream& operator<<(std::ostream& cout, const lvgm::vec3<T>& v)
  22.             {
  23.             cout << "[ " << v.x() << ", " << v.y() << ", " << v.z() << " ]";
  24.             return cout;
  25.             }
  26.  
  27.     template<typename T>
  28.         std::ostream& operator<<(std::ostream& cout, const lvgm::vec4<T>& v)
  29.         {
  30.             cout << "[ " << v.x() << ", " << v.y() << ", " << v.z() << v.w() << " ]";
  31.             return cout;
  32.         }
  33.  
  34. #endif
  35.  
  36. # ifdef VEC2_OUT 
  37.  
  38.     template<typename T>
  39.         std::ostream& operator<<(std::ostream& cout, const lvgm::vec2<T>& v)
  40.             {
  41.             cout << "[ " << v.x() << ", " << v.y() << " ]";
  42.             return cout;
  43.             }
  44.  
  45. #endif
  46.  
  47. # ifdef VEC3_OUT 
  48.  
  49.     template<typename T>
  50.         std::ostream& operator<<(std::ostream& cout, const lvgm::vec3<T>& v)
  51.             {
  52.             cout << "[ " << v.x() << ", " << v.y() << ", " << v.z() << " ]";
  53.             return cout;
  54.             }
  55.  
  56. #endif
  57.  
  58. # ifdef VEC4_OUT 
  59.  
  60.     template<typename T>
  61.         std::ostream& operator<<(std::ostream& cout, const lvgm::vec4<T>& v)
  62.             {
  63.             cout << "[ " << v.x() << ", " << v.y() << ", " << v.z() << v.w() << " ]";
  64.             return cout;
  65.             }
  66.  
  67. #endif

vec_inout.h

如有什么问题，请于评论区留言或者邮箱（^_^）

感谢您的阅读，生活愉快`

<泛> C++3D数学库设计详解 向量篇的更多相关文章

  1. <泛> C++3D数学库设计详解 简单光学几何 && 随机向量生成

    // 注:本内容为作者原创,禁止在其他网站复述内容以及用于商业盈利,如需引用,请标明出处:http://www.cnblogs.com/lv_anchoret/  Preface 当初写这个库,是为了 ...

  2. Dubbo架构设计详解-转

    Dubbo架构设计详解  2013-09-03 21:26:59    Yanjun Dubbo是Alibaba开源的分布式服务框架,它最大的特点是按照分层的方式来架构,使用这种方式可以使各个层之间解 ...

  3. Java生鲜电商平台-Java后端生成Token架构与设计详解

    Java生鲜电商平台-Java后端生成Token架构与设计详解 目的:Java开源生鲜电商平台-Java后端生成Token目的是为了用于校验客户端,防止重复提交. 技术选型:用开源的JWT架构. 1. ...

  4. Python爬虫之selenium库使用详解

    Python爬虫之selenium库使用详解 本章内容如下: 什么是Selenium selenium基本使用 声明浏览器对象 访问页面 查找元素 多个元素查找 元素交互操作 交互动作 执行JavaS ...

  5. STC8H开发(二): 在Linux VSCode中配置和使用FwLib_STC8封装库(图文详解)

    目录 STC8H开发(一): 在Keil5中配置和使用FwLib_STC8封装库(图文详解) STC8H开发(二): 在Linux VSCode中配置和使用FwLib_STC8封装库(图文详解) 前面 ...

  6. [转帖]前端-chromeF12 谷歌开发者工具详解 Console篇

    前端-chromeF12 谷歌开发者工具详解 Console篇 https://blog.csdn.net/qq_39892932/article/details/82655866 趁着搞 cloud ...

  7. bt协议详解 DHT篇（上）

    bt协议详解 DHT篇(上) 最近开发了一个免费教程的网站,突然产生了仔细了解bt协议的想法,这篇文章是bt协议详解系列的第三篇,后续还会写一些关于搜索和索引的东西,都是在开发这个网站的过程中学习到的 ...

  8. [转帖]前端-chromeF12 谷歌开发者工具详解 Network篇

    前端-chromeF12 谷歌开发者工具详解 Network篇 https://blog.csdn.net/qq_39892932/article/details/82493922 blog 也是原作 ...

  9. RocketMQ源码详解 | Broker篇 · 其一：线程模型与接收链路

    概述 在上一节 RocketMQ源码详解 | Producer篇 · 其二:消息组成.发送链路 中,我们终于将消息发送出了 Producer,在短暂的 tcp 握手后,很快它就会进入目的 Broker ...

随机推荐

  1. 线搜索(line search)方法

    在机器学习中, 通常需要求某个函数的最值(比如最大似然中需要求的似然的最大值). 线搜索(line search)是求得一个函数\(f(x)\)的最值的两种常用迭代方法之一(另外一个是trust re ...

  2. window环境下使用sbt编译spark源码

    前些天用maven编译打包spark,搞得焦头烂额的,各种错误,层出不穷,想想也是醉了,于是乎,换种方式,使用sbt编译,看看人品如何! 首先,从官网spark官网下载spark源码包,解压出来.我这 ...

  3. 【leetcode 简单】 第六十四题 翻转二叉树

    翻转一棵二叉树. 示例: 输入: 4 / \ 2 7 / \ / \ 1 3 6 9 输出: 4 / \ 7 2 / \ / \ 9 6 3 1 备注: 这个问题是受到 Max Howell的 原问题 ...

  4. Mysql服务优化

    Mysql服务优化   Mysql服务加速优化的6个阶段 硬件层面优化 操作系统层面优化 Mysql数据库层面优化 网站集群架构层面优化 安全优化 流程.制度控制优化 1.硬件层面优化 CPU     ...

  5. 【译】第二篇 Integration Services：SSIS数据泵

    本篇文章是Integration Services系列的第二篇,详细内容请参考原文. 简介SSIS用于移动数据.数据流任务提供此功能.因为这个原因,当介绍SSIS时我喜欢从数据流任务开始.数据流任务的 ...

  6. es6解构、中括号前加分号

    在写项目的时候,为了方便使用了下对象的解构,无奈又遇到一坑. 为什么会不能解构呢?因为这里的{}会导致歧义,因为 JavaScript 引擎会将{xxxxx}理解成一个代码块,从而发生语法错误.只有不 ...

  7. JavaScript 优雅的实现方式包含你可能不知道的知识点

    有些东西很好用,但是你未必知道:有些东西你可能用过,但是你未必知道原理. 实现一个目的有多种途径,俗话说,条条大路通罗马.很多内容来自平时的一些收集以及过往博客文章底下的精彩评论,收集整理拓展一波,发 ...

  8. linux下的usb抓包方法【转】

    转自:http://blog.chinaunix.net/uid-11848011-id-4508834.html 1.配置内核使能usb monitor: make menuconfig       ...

  9. 【Linux技术】ubuntu常用命令【转】

    转自:http://www.cnblogs.com/lcw/p/3159462.html 查看软件xxx安装内容:dpkg -L xxx查找软件库中的软件:apt-cache search 正则表达式 ...

  10. Mysql_Learning_Notes_mysql系统结构_2

    Mysql_Learning_Notes_mysql系统结构_2 三层体系结构,启动方式,日志类型及解析方法,mysql 升级 连接层 通信协议处理\线程处理\账号认证(用户名和密码认证)\安全检查等 ...