mathlib.h 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200
  1. /*----------------------------------------------------------------------------*/
  2. /**
  3. * This confidential and proprietary software may be used only as
  4. * authorised by a licensing agreement from ARM Limited
  5. * (C) COPYRIGHT 2011-2012, 2018 ARM Limited
  6. * ALL RIGHTS RESERVED
  7. *
  8. * The entire notice above must be reproduced on all authorised
  9. * copies and copies may only be made to the extent permitted
  10. * by a licensing agreement from ARM Limited.
  11. *
  12. * @brief Internal math library declarations for ASTC codec.
  13. */
  14. /*----------------------------------------------------------------------------*/
  15. #ifndef MATHLIB_H_INCLUDED
  16. #define MATHLIB_H_INCLUDED
  17. #include "vectypes.h"
  18. // basic OpenCL functions
  19. float inversesqrt(float p);
  20. float acospi(float p);
  21. float sinpi(float p);
  22. float cospi(float p);
  23. float nan(int p);
  24. #if !defined(_MSC_VER) && (__cplusplus < 201103L)
  25. float fmax(float p, float q);
  26. float fmin(float p, float q);
  27. #endif // C++11
  28. float2 fmax(float2 p, float2 q);
  29. float3 fmax(float3 p, float3 q);
  30. float4 fmax(float4 p, float4 q);
  31. float2 fmin(float2 p, float2 q);
  32. float3 fmin(float3 p, float3 q);
  33. float4 fmin(float4 p, float4 q);
  34. /*
  35. float dot( float2 p, float2 q );
  36. float dot( float3 p, float3 q );
  37. float dot( float4 p, float4 q );
  38. */
  39. static inline float dot(float2 p, float2 q)
  40. {
  41. return p.x * q.x + p.y * q.y;
  42. }
  43. static inline float dot(float3 p, float3 q)
  44. {
  45. return p.x * q.x + p.y * q.y + p.z * q.z;
  46. }
  47. static inline float dot(float4 p, float4 q)
  48. {
  49. return p.x * q.x + p.y * q.y + p.z * q.z + p.w * q.w;
  50. }
  51. float3 cross(float3 p, float3 q);
  52. float4 cross(float4 p, float4 q);
  53. float length(float2 p);
  54. float length(float3 p);
  55. float length(float4 p);
  56. float length_sqr(float2 p);
  57. float length_sqr(float3 p);
  58. float length_sqr(float4 p);
  59. float distance(float2 p, float2 q);
  60. float distance(float3 p, float3 q);
  61. float distance(float4 p, float4 q);
  62. float distance_sqr(float2 p, float2 q);
  63. float distance_sqr(float3 p, float3 q);
  64. float distance_sqr(float4 p, float4 q);
  65. float2 normalize(float2 p);
  66. float3 normalize(float3 p);
  67. float4 normalize(float4 p);
  68. // functions other than just basic OpenCL functions
  69. float4 gcross(float4 p, float4 q, float4 r);
  70. struct mat2
  71. {
  72. float2 v[2];
  73. };
  74. struct mat3
  75. {
  76. float3 v[3];
  77. };
  78. struct mat4
  79. {
  80. float4 v[4];
  81. };
  82. float trace(mat2 p);
  83. float trace(mat3 p);
  84. float trace(mat4 p);
  85. float determinant(mat2 p);
  86. float determinant(mat3 p);
  87. float determinant(mat4 p);
  88. float2 characteristic_poly(mat2 p);
  89. float3 characteristic_poly(mat3 p);
  90. float4 characteristic_poly(mat4 p);
  91. float2 solve_monic(float2 p);
  92. float3 solve_monic(float3 p);
  93. float4 solve_monic(float4 p);
  94. float2 transform(mat2 p, float2 q);
  95. float3 transform(mat3 p, float3 q);
  96. float4 transform(mat4 p, float4 q);
  97. mat2 adjugate(mat2 p);
  98. mat3 adjugate(mat3 p);
  99. mat4 adjugate(mat4 p);
  100. mat2 invert(mat2 p);
  101. mat3 invert(mat3 p);
  102. mat4 invert(mat4 p);
  103. float2 eigenvalues(mat2 p);
  104. float3 eigenvalues(mat3 p);
  105. float4 eigenvalues(mat4 p);
  106. float2 eigenvector(mat2 p, float eigvl);
  107. float3 eigenvector(mat3 p, float eigvl);
  108. float4 eigenvector(mat4 p, float eigvl);
  109. mat2 operator *(mat2 a, mat2 b);
  110. mat3 operator *(mat3 a, mat3 b);
  111. mat4 operator *(mat4 a, mat4 b);
  112. // parametric line, 2D: The line is given by line = a + b*t.
  113. struct line2
  114. {
  115. float2 a;
  116. float2 b;
  117. };
  118. // parametric line, 3D
  119. struct line3
  120. {
  121. float3 a;
  122. float3 b;
  123. };
  124. struct line4
  125. {
  126. float4 a;
  127. float4 b;
  128. };
  129. // plane/hyperplane defined by a point and a normal vector
  130. struct plane_3d
  131. {
  132. float3 root_point;
  133. float3 normal; // normalized
  134. };
  135. struct hyperplane_4d
  136. {
  137. float4 root_point;
  138. float4 normal; // normalized
  139. };
  140. float param_nearest_on_line(float2 point, line2 line);
  141. float param_nearest_on_line(float3 point, line3 line);
  142. float param_nearest_on_line(float4 point, line4 line);
  143. float point_line_distance(float2 point, line2 line);
  144. float point_line_distance(float3 point, line3 line);
  145. float point_line_distance(float4 point, line4 line);
  146. float point_line_distance_sqr(float2 point, line2 line);
  147. float point_line_distance_sqr(float3 point, line3 line);
  148. float point_line_distance_sqr(float4 point, line4 line);
  149. float point_plane_3d_distance(float3 point, plane_3d plane);
  150. float point_hyperplane_4d_distance(float4 point, hyperplane_4d plane);
  151. plane_3d generate_plane_from_points(float3 point0, float3 point1, float3 point2);
  152. hyperplane_4d generate_hyperplane_from_points(float4 point0, float4 point1, float4 point2, float4 point3);
  153. #endif