A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1//------------------------------------------------------------------------------
2// <auto-generated>
3// This code was generated by a tool.
4//
5// Changes to this file may cause incorrect behavior and will be lost if
6// the code is regenerated. To update the generation of this file, modify and re-run Unity.Mathematics.CodeGen.
7// </auto-generated>
8//------------------------------------------------------------------------------
9using System;
10using System.Runtime.CompilerServices;
11
12namespace Unity.Mathematics
13{
14 partial class math
15 {
16 /// <summary>Returns the float value result of a matrix multiplication between a float value and a float value.</summary>
17 /// <param name="a">Left hand side argument of the matrix multiply.</param>
18 /// <param name="b">Right hand side argument of the matrix multiply.</param>
19 /// <returns>The computed matrix multiplication.</returns>
20 [MethodImpl(MethodImplOptions.AggressiveInlining)]
21 public static float mul(float a, float b)
22 {
23 return a * b;
24 }
25
26 /// <summary>Returns the float value result of a matrix multiplication between a float2 row vector and a float2 column vector.</summary>
27 /// <param name="a">Left hand side argument of the matrix multiply.</param>
28 /// <param name="b">Right hand side argument of the matrix multiply.</param>
29 /// <returns>The computed matrix multiplication.</returns>
30 [MethodImpl(MethodImplOptions.AggressiveInlining)]
31 public static float mul(float2 a, float2 b)
32 {
33 return a.x * b.x + a.y * b.y;
34 }
35
36 /// <summary>Returns the float2 row vector result of a matrix multiplication between a float2 row vector and a float2x2 matrix.</summary>
37 /// <param name="a">Left hand side argument of the matrix multiply.</param>
38 /// <param name="b">Right hand side argument of the matrix multiply.</param>
39 /// <returns>The computed matrix multiplication.</returns>
40 [MethodImpl(MethodImplOptions.AggressiveInlining)]
41 public static float2 mul(float2 a, float2x2 b)
42 {
43 return float2(
44 a.x * b.c0.x + a.y * b.c0.y,
45 a.x * b.c1.x + a.y * b.c1.y);
46 }
47
48 /// <summary>Returns the float3 row vector result of a matrix multiplication between a float2 row vector and a float2x3 matrix.</summary>
49 /// <param name="a">Left hand side argument of the matrix multiply.</param>
50 /// <param name="b">Right hand side argument of the matrix multiply.</param>
51 /// <returns>The computed matrix multiplication.</returns>
52 [MethodImpl(MethodImplOptions.AggressiveInlining)]
53 public static float3 mul(float2 a, float2x3 b)
54 {
55 return float3(
56 a.x * b.c0.x + a.y * b.c0.y,
57 a.x * b.c1.x + a.y * b.c1.y,
58 a.x * b.c2.x + a.y * b.c2.y);
59 }
60
61 /// <summary>Returns the float4 row vector result of a matrix multiplication between a float2 row vector and a float2x4 matrix.</summary>
62 /// <param name="a">Left hand side argument of the matrix multiply.</param>
63 /// <param name="b">Right hand side argument of the matrix multiply.</param>
64 /// <returns>The computed matrix multiplication.</returns>
65 [MethodImpl(MethodImplOptions.AggressiveInlining)]
66 public static float4 mul(float2 a, float2x4 b)
67 {
68 return float4(
69 a.x * b.c0.x + a.y * b.c0.y,
70 a.x * b.c1.x + a.y * b.c1.y,
71 a.x * b.c2.x + a.y * b.c2.y,
72 a.x * b.c3.x + a.y * b.c3.y);
73 }
74
75 /// <summary>Returns the float value result of a matrix multiplication between a float3 row vector and a float3 column vector.</summary>
76 /// <param name="a">Left hand side argument of the matrix multiply.</param>
77 /// <param name="b">Right hand side argument of the matrix multiply.</param>
78 /// <returns>The computed matrix multiplication.</returns>
79 [MethodImpl(MethodImplOptions.AggressiveInlining)]
80 public static float mul(float3 a, float3 b)
81 {
82 return a.x * b.x + a.y * b.y + a.z * b.z;
83 }
84
85 /// <summary>Returns the float2 row vector result of a matrix multiplication between a float3 row vector and a float3x2 matrix.</summary>
86 /// <param name="a">Left hand side argument of the matrix multiply.</param>
87 /// <param name="b">Right hand side argument of the matrix multiply.</param>
88 /// <returns>The computed matrix multiplication.</returns>
89 [MethodImpl(MethodImplOptions.AggressiveInlining)]
90 public static float2 mul(float3 a, float3x2 b)
91 {
92 return float2(
93 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
94 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z);
95 }
96
97 /// <summary>Returns the float3 row vector result of a matrix multiplication between a float3 row vector and a float3x3 matrix.</summary>
98 /// <param name="a">Left hand side argument of the matrix multiply.</param>
99 /// <param name="b">Right hand side argument of the matrix multiply.</param>
100 /// <returns>The computed matrix multiplication.</returns>
101 [MethodImpl(MethodImplOptions.AggressiveInlining)]
102 public static float3 mul(float3 a, float3x3 b)
103 {
104 return float3(
105 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
106 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
107 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z);
108 }
109
110 /// <summary>Returns the float4 row vector result of a matrix multiplication between a float3 row vector and a float3x4 matrix.</summary>
111 /// <param name="a">Left hand side argument of the matrix multiply.</param>
112 /// <param name="b">Right hand side argument of the matrix multiply.</param>
113 /// <returns>The computed matrix multiplication.</returns>
114 [MethodImpl(MethodImplOptions.AggressiveInlining)]
115 public static float4 mul(float3 a, float3x4 b)
116 {
117 return float4(
118 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
119 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
120 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z,
121 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z);
122 }
123
124 /// <summary>Returns the float value result of a matrix multiplication between a float4 row vector and a float4 column vector.</summary>
125 /// <param name="a">Left hand side argument of the matrix multiply.</param>
126 /// <param name="b">Right hand side argument of the matrix multiply.</param>
127 /// <returns>The computed matrix multiplication.</returns>
128 [MethodImpl(MethodImplOptions.AggressiveInlining)]
129 public static float mul(float4 a, float4 b)
130 {
131 return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
132 }
133
134 /// <summary>Returns the float2 row vector result of a matrix multiplication between a float4 row vector and a float4x2 matrix.</summary>
135 /// <param name="a">Left hand side argument of the matrix multiply.</param>
136 /// <param name="b">Right hand side argument of the matrix multiply.</param>
137 /// <returns>The computed matrix multiplication.</returns>
138 [MethodImpl(MethodImplOptions.AggressiveInlining)]
139 public static float2 mul(float4 a, float4x2 b)
140 {
141 return float2(
142 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
143 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w);
144 }
145
146 /// <summary>Returns the float3 row vector result of a matrix multiplication between a float4 row vector and a float4x3 matrix.</summary>
147 /// <param name="a">Left hand side argument of the matrix multiply.</param>
148 /// <param name="b">Right hand side argument of the matrix multiply.</param>
149 /// <returns>The computed matrix multiplication.</returns>
150 [MethodImpl(MethodImplOptions.AggressiveInlining)]
151 public static float3 mul(float4 a, float4x3 b)
152 {
153 return float3(
154 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
155 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
156 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w);
157 }
158
159 /// <summary>Returns the float4 row vector result of a matrix multiplication between a float4 row vector and a float4x4 matrix.</summary>
160 /// <param name="a">Left hand side argument of the matrix multiply.</param>
161 /// <param name="b">Right hand side argument of the matrix multiply.</param>
162 /// <returns>The computed matrix multiplication.</returns>
163 [MethodImpl(MethodImplOptions.AggressiveInlining)]
164 public static float4 mul(float4 a, float4x4 b)
165 {
166 return float4(
167 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
168 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
169 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w,
170 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w);
171 }
172
173 /// <summary>Returns the float2 column vector result of a matrix multiplication between a float2x2 matrix and a float2 column vector.</summary>
174 /// <param name="a">Left hand side argument of the matrix multiply.</param>
175 /// <param name="b">Right hand side argument of the matrix multiply.</param>
176 /// <returns>The computed matrix multiplication.</returns>
177 [MethodImpl(MethodImplOptions.AggressiveInlining)]
178 public static float2 mul(float2x2 a, float2 b)
179 {
180 return a.c0 * b.x + a.c1 * b.y;
181 }
182
183 /// <summary>Returns the float2x2 matrix result of a matrix multiplication between a float2x2 matrix and a float2x2 matrix.</summary>
184 /// <param name="a">Left hand side argument of the matrix multiply.</param>
185 /// <param name="b">Right hand side argument of the matrix multiply.</param>
186 /// <returns>The computed matrix multiplication.</returns>
187 [MethodImpl(MethodImplOptions.AggressiveInlining)]
188 public static float2x2 mul(float2x2 a, float2x2 b)
189 {
190 return float2x2(
191 a.c0 * b.c0.x + a.c1 * b.c0.y,
192 a.c0 * b.c1.x + a.c1 * b.c1.y);
193 }
194
195 /// <summary>Returns the float2x3 matrix result of a matrix multiplication between a float2x2 matrix and a float2x3 matrix.</summary>
196 /// <param name="a">Left hand side argument of the matrix multiply.</param>
197 /// <param name="b">Right hand side argument of the matrix multiply.</param>
198 /// <returns>The computed matrix multiplication.</returns>
199 [MethodImpl(MethodImplOptions.AggressiveInlining)]
200 public static float2x3 mul(float2x2 a, float2x3 b)
201 {
202 return float2x3(
203 a.c0 * b.c0.x + a.c1 * b.c0.y,
204 a.c0 * b.c1.x + a.c1 * b.c1.y,
205 a.c0 * b.c2.x + a.c1 * b.c2.y);
206 }
207
208 /// <summary>Returns the float2x4 matrix result of a matrix multiplication between a float2x2 matrix and a float2x4 matrix.</summary>
209 /// <param name="a">Left hand side argument of the matrix multiply.</param>
210 /// <param name="b">Right hand side argument of the matrix multiply.</param>
211 /// <returns>The computed matrix multiplication.</returns>
212 [MethodImpl(MethodImplOptions.AggressiveInlining)]
213 public static float2x4 mul(float2x2 a, float2x4 b)
214 {
215 return float2x4(
216 a.c0 * b.c0.x + a.c1 * b.c0.y,
217 a.c0 * b.c1.x + a.c1 * b.c1.y,
218 a.c0 * b.c2.x + a.c1 * b.c2.y,
219 a.c0 * b.c3.x + a.c1 * b.c3.y);
220 }
221
222 /// <summary>Returns the float2 column vector result of a matrix multiplication between a float2x3 matrix and a float3 column vector.</summary>
223 /// <param name="a">Left hand side argument of the matrix multiply.</param>
224 /// <param name="b">Right hand side argument of the matrix multiply.</param>
225 /// <returns>The computed matrix multiplication.</returns>
226 [MethodImpl(MethodImplOptions.AggressiveInlining)]
227 public static float2 mul(float2x3 a, float3 b)
228 {
229 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
230 }
231
232 /// <summary>Returns the float2x2 matrix result of a matrix multiplication between a float2x3 matrix and a float3x2 matrix.</summary>
233 /// <param name="a">Left hand side argument of the matrix multiply.</param>
234 /// <param name="b">Right hand side argument of the matrix multiply.</param>
235 /// <returns>The computed matrix multiplication.</returns>
236 [MethodImpl(MethodImplOptions.AggressiveInlining)]
237 public static float2x2 mul(float2x3 a, float3x2 b)
238 {
239 return float2x2(
240 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
241 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
242 }
243
244 /// <summary>Returns the float2x3 matrix result of a matrix multiplication between a float2x3 matrix and a float3x3 matrix.</summary>
245 /// <param name="a">Left hand side argument of the matrix multiply.</param>
246 /// <param name="b">Right hand side argument of the matrix multiply.</param>
247 /// <returns>The computed matrix multiplication.</returns>
248 [MethodImpl(MethodImplOptions.AggressiveInlining)]
249 public static float2x3 mul(float2x3 a, float3x3 b)
250 {
251 return float2x3(
252 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
253 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
254 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
255 }
256
257 /// <summary>Returns the float2x4 matrix result of a matrix multiplication between a float2x3 matrix and a float3x4 matrix.</summary>
258 /// <param name="a">Left hand side argument of the matrix multiply.</param>
259 /// <param name="b">Right hand side argument of the matrix multiply.</param>
260 /// <returns>The computed matrix multiplication.</returns>
261 [MethodImpl(MethodImplOptions.AggressiveInlining)]
262 public static float2x4 mul(float2x3 a, float3x4 b)
263 {
264 return float2x4(
265 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
266 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
267 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
268 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
269 }
270
271 /// <summary>Returns the float2 column vector result of a matrix multiplication between a float2x4 matrix and a float4 column vector.</summary>
272 /// <param name="a">Left hand side argument of the matrix multiply.</param>
273 /// <param name="b">Right hand side argument of the matrix multiply.</param>
274 /// <returns>The computed matrix multiplication.</returns>
275 [MethodImpl(MethodImplOptions.AggressiveInlining)]
276 public static float2 mul(float2x4 a, float4 b)
277 {
278 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
279 }
280
281 /// <summary>Returns the float2x2 matrix result of a matrix multiplication between a float2x4 matrix and a float4x2 matrix.</summary>
282 /// <param name="a">Left hand side argument of the matrix multiply.</param>
283 /// <param name="b">Right hand side argument of the matrix multiply.</param>
284 /// <returns>The computed matrix multiplication.</returns>
285 [MethodImpl(MethodImplOptions.AggressiveInlining)]
286 public static float2x2 mul(float2x4 a, float4x2 b)
287 {
288 return float2x2(
289 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
290 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
291 }
292
293 /// <summary>Returns the float2x3 matrix result of a matrix multiplication between a float2x4 matrix and a float4x3 matrix.</summary>
294 /// <param name="a">Left hand side argument of the matrix multiply.</param>
295 /// <param name="b">Right hand side argument of the matrix multiply.</param>
296 /// <returns>The computed matrix multiplication.</returns>
297 [MethodImpl(MethodImplOptions.AggressiveInlining)]
298 public static float2x3 mul(float2x4 a, float4x3 b)
299 {
300 return float2x3(
301 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
302 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
303 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
304 }
305
306 /// <summary>Returns the float2x4 matrix result of a matrix multiplication between a float2x4 matrix and a float4x4 matrix.</summary>
307 /// <param name="a">Left hand side argument of the matrix multiply.</param>
308 /// <param name="b">Right hand side argument of the matrix multiply.</param>
309 /// <returns>The computed matrix multiplication.</returns>
310 [MethodImpl(MethodImplOptions.AggressiveInlining)]
311 public static float2x4 mul(float2x4 a, float4x4 b)
312 {
313 return float2x4(
314 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
315 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
316 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
317 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
318 }
319
320 /// <summary>Returns the float3 column vector result of a matrix multiplication between a float3x2 matrix and a float2 column vector.</summary>
321 /// <param name="a">Left hand side argument of the matrix multiply.</param>
322 /// <param name="b">Right hand side argument of the matrix multiply.</param>
323 /// <returns>The computed matrix multiplication.</returns>
324 [MethodImpl(MethodImplOptions.AggressiveInlining)]
325 public static float3 mul(float3x2 a, float2 b)
326 {
327 return a.c0 * b.x + a.c1 * b.y;
328 }
329
330 /// <summary>Returns the float3x2 matrix result of a matrix multiplication between a float3x2 matrix and a float2x2 matrix.</summary>
331 /// <param name="a">Left hand side argument of the matrix multiply.</param>
332 /// <param name="b">Right hand side argument of the matrix multiply.</param>
333 /// <returns>The computed matrix multiplication.</returns>
334 [MethodImpl(MethodImplOptions.AggressiveInlining)]
335 public static float3x2 mul(float3x2 a, float2x2 b)
336 {
337 return float3x2(
338 a.c0 * b.c0.x + a.c1 * b.c0.y,
339 a.c0 * b.c1.x + a.c1 * b.c1.y);
340 }
341
342 /// <summary>Returns the float3x3 matrix result of a matrix multiplication between a float3x2 matrix and a float2x3 matrix.</summary>
343 /// <param name="a">Left hand side argument of the matrix multiply.</param>
344 /// <param name="b">Right hand side argument of the matrix multiply.</param>
345 /// <returns>The computed matrix multiplication.</returns>
346 [MethodImpl(MethodImplOptions.AggressiveInlining)]
347 public static float3x3 mul(float3x2 a, float2x3 b)
348 {
349 return float3x3(
350 a.c0 * b.c0.x + a.c1 * b.c0.y,
351 a.c0 * b.c1.x + a.c1 * b.c1.y,
352 a.c0 * b.c2.x + a.c1 * b.c2.y);
353 }
354
355 /// <summary>Returns the float3x4 matrix result of a matrix multiplication between a float3x2 matrix and a float2x4 matrix.</summary>
356 /// <param name="a">Left hand side argument of the matrix multiply.</param>
357 /// <param name="b">Right hand side argument of the matrix multiply.</param>
358 /// <returns>The computed matrix multiplication.</returns>
359 [MethodImpl(MethodImplOptions.AggressiveInlining)]
360 public static float3x4 mul(float3x2 a, float2x4 b)
361 {
362 return float3x4(
363 a.c0 * b.c0.x + a.c1 * b.c0.y,
364 a.c0 * b.c1.x + a.c1 * b.c1.y,
365 a.c0 * b.c2.x + a.c1 * b.c2.y,
366 a.c0 * b.c3.x + a.c1 * b.c3.y);
367 }
368
369 /// <summary>Returns the float3 column vector result of a matrix multiplication between a float3x3 matrix and a float3 column vector.</summary>
370 /// <param name="a">Left hand side argument of the matrix multiply.</param>
371 /// <param name="b">Right hand side argument of the matrix multiply.</param>
372 /// <returns>The computed matrix multiplication.</returns>
373 [MethodImpl(MethodImplOptions.AggressiveInlining)]
374 public static float3 mul(float3x3 a, float3 b)
375 {
376 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
377 }
378
379 /// <summary>Returns the float3x2 matrix result of a matrix multiplication between a float3x3 matrix and a float3x2 matrix.</summary>
380 /// <param name="a">Left hand side argument of the matrix multiply.</param>
381 /// <param name="b">Right hand side argument of the matrix multiply.</param>
382 /// <returns>The computed matrix multiplication.</returns>
383 [MethodImpl(MethodImplOptions.AggressiveInlining)]
384 public static float3x2 mul(float3x3 a, float3x2 b)
385 {
386 return float3x2(
387 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
388 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
389 }
390
391 /// <summary>Returns the float3x3 matrix result of a matrix multiplication between a float3x3 matrix and a float3x3 matrix.</summary>
392 /// <param name="a">Left hand side argument of the matrix multiply.</param>
393 /// <param name="b">Right hand side argument of the matrix multiply.</param>
394 /// <returns>The computed matrix multiplication.</returns>
395 [MethodImpl(MethodImplOptions.AggressiveInlining)]
396 public static float3x3 mul(float3x3 a, float3x3 b)
397 {
398 return float3x3(
399 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
400 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
401 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
402 }
403
404 /// <summary>Returns the float3x4 matrix result of a matrix multiplication between a float3x3 matrix and a float3x4 matrix.</summary>
405 /// <param name="a">Left hand side argument of the matrix multiply.</param>
406 /// <param name="b">Right hand side argument of the matrix multiply.</param>
407 /// <returns>The computed matrix multiplication.</returns>
408 [MethodImpl(MethodImplOptions.AggressiveInlining)]
409 public static float3x4 mul(float3x3 a, float3x4 b)
410 {
411 return float3x4(
412 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
413 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
414 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
415 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
416 }
417
418 /// <summary>Returns the float3 column vector result of a matrix multiplication between a float3x4 matrix and a float4 column vector.</summary>
419 /// <param name="a">Left hand side argument of the matrix multiply.</param>
420 /// <param name="b">Right hand side argument of the matrix multiply.</param>
421 /// <returns>The computed matrix multiplication.</returns>
422 [MethodImpl(MethodImplOptions.AggressiveInlining)]
423 public static float3 mul(float3x4 a, float4 b)
424 {
425 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
426 }
427
428 /// <summary>Returns the float3x2 matrix result of a matrix multiplication between a float3x4 matrix and a float4x2 matrix.</summary>
429 /// <param name="a">Left hand side argument of the matrix multiply.</param>
430 /// <param name="b">Right hand side argument of the matrix multiply.</param>
431 /// <returns>The computed matrix multiplication.</returns>
432 [MethodImpl(MethodImplOptions.AggressiveInlining)]
433 public static float3x2 mul(float3x4 a, float4x2 b)
434 {
435 return float3x2(
436 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
437 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
438 }
439
440 /// <summary>Returns the float3x3 matrix result of a matrix multiplication between a float3x4 matrix and a float4x3 matrix.</summary>
441 /// <param name="a">Left hand side argument of the matrix multiply.</param>
442 /// <param name="b">Right hand side argument of the matrix multiply.</param>
443 /// <returns>The computed matrix multiplication.</returns>
444 [MethodImpl(MethodImplOptions.AggressiveInlining)]
445 public static float3x3 mul(float3x4 a, float4x3 b)
446 {
447 return float3x3(
448 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
449 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
450 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
451 }
452
453 /// <summary>Returns the float3x4 matrix result of a matrix multiplication between a float3x4 matrix and a float4x4 matrix.</summary>
454 /// <param name="a">Left hand side argument of the matrix multiply.</param>
455 /// <param name="b">Right hand side argument of the matrix multiply.</param>
456 /// <returns>The computed matrix multiplication.</returns>
457 [MethodImpl(MethodImplOptions.AggressiveInlining)]
458 public static float3x4 mul(float3x4 a, float4x4 b)
459 {
460 return float3x4(
461 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
462 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
463 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
464 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
465 }
466
467 /// <summary>Returns the float4 column vector result of a matrix multiplication between a float4x2 matrix and a float2 column vector.</summary>
468 /// <param name="a">Left hand side argument of the matrix multiply.</param>
469 /// <param name="b">Right hand side argument of the matrix multiply.</param>
470 /// <returns>The computed matrix multiplication.</returns>
471 [MethodImpl(MethodImplOptions.AggressiveInlining)]
472 public static float4 mul(float4x2 a, float2 b)
473 {
474 return a.c0 * b.x + a.c1 * b.y;
475 }
476
477 /// <summary>Returns the float4x2 matrix result of a matrix multiplication between a float4x2 matrix and a float2x2 matrix.</summary>
478 /// <param name="a">Left hand side argument of the matrix multiply.</param>
479 /// <param name="b">Right hand side argument of the matrix multiply.</param>
480 /// <returns>The computed matrix multiplication.</returns>
481 [MethodImpl(MethodImplOptions.AggressiveInlining)]
482 public static float4x2 mul(float4x2 a, float2x2 b)
483 {
484 return float4x2(
485 a.c0 * b.c0.x + a.c1 * b.c0.y,
486 a.c0 * b.c1.x + a.c1 * b.c1.y);
487 }
488
489 /// <summary>Returns the float4x3 matrix result of a matrix multiplication between a float4x2 matrix and a float2x3 matrix.</summary>
490 /// <param name="a">Left hand side argument of the matrix multiply.</param>
491 /// <param name="b">Right hand side argument of the matrix multiply.</param>
492 /// <returns>The computed matrix multiplication.</returns>
493 [MethodImpl(MethodImplOptions.AggressiveInlining)]
494 public static float4x3 mul(float4x2 a, float2x3 b)
495 {
496 return float4x3(
497 a.c0 * b.c0.x + a.c1 * b.c0.y,
498 a.c0 * b.c1.x + a.c1 * b.c1.y,
499 a.c0 * b.c2.x + a.c1 * b.c2.y);
500 }
501
502 /// <summary>Returns the float4x4 matrix result of a matrix multiplication between a float4x2 matrix and a float2x4 matrix.</summary>
503 /// <param name="a">Left hand side argument of the matrix multiply.</param>
504 /// <param name="b">Right hand side argument of the matrix multiply.</param>
505 /// <returns>The computed matrix multiplication.</returns>
506 [MethodImpl(MethodImplOptions.AggressiveInlining)]
507 public static float4x4 mul(float4x2 a, float2x4 b)
508 {
509 return float4x4(
510 a.c0 * b.c0.x + a.c1 * b.c0.y,
511 a.c0 * b.c1.x + a.c1 * b.c1.y,
512 a.c0 * b.c2.x + a.c1 * b.c2.y,
513 a.c0 * b.c3.x + a.c1 * b.c3.y);
514 }
515
516 /// <summary>Returns the float4 column vector result of a matrix multiplication between a float4x3 matrix and a float3 column vector.</summary>
517 /// <param name="a">Left hand side argument of the matrix multiply.</param>
518 /// <param name="b">Right hand side argument of the matrix multiply.</param>
519 /// <returns>The computed matrix multiplication.</returns>
520 [MethodImpl(MethodImplOptions.AggressiveInlining)]
521 public static float4 mul(float4x3 a, float3 b)
522 {
523 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
524 }
525
526 /// <summary>Returns the float4x2 matrix result of a matrix multiplication between a float4x3 matrix and a float3x2 matrix.</summary>
527 /// <param name="a">Left hand side argument of the matrix multiply.</param>
528 /// <param name="b">Right hand side argument of the matrix multiply.</param>
529 /// <returns>The computed matrix multiplication.</returns>
530 [MethodImpl(MethodImplOptions.AggressiveInlining)]
531 public static float4x2 mul(float4x3 a, float3x2 b)
532 {
533 return float4x2(
534 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
535 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
536 }
537
538 /// <summary>Returns the float4x3 matrix result of a matrix multiplication between a float4x3 matrix and a float3x3 matrix.</summary>
539 /// <param name="a">Left hand side argument of the matrix multiply.</param>
540 /// <param name="b">Right hand side argument of the matrix multiply.</param>
541 /// <returns>The computed matrix multiplication.</returns>
542 [MethodImpl(MethodImplOptions.AggressiveInlining)]
543 public static float4x3 mul(float4x3 a, float3x3 b)
544 {
545 return float4x3(
546 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
547 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
548 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
549 }
550
551 /// <summary>Returns the float4x4 matrix result of a matrix multiplication between a float4x3 matrix and a float3x4 matrix.</summary>
552 /// <param name="a">Left hand side argument of the matrix multiply.</param>
553 /// <param name="b">Right hand side argument of the matrix multiply.</param>
554 /// <returns>The computed matrix multiplication.</returns>
555 [MethodImpl(MethodImplOptions.AggressiveInlining)]
556 public static float4x4 mul(float4x3 a, float3x4 b)
557 {
558 return float4x4(
559 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
560 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
561 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
562 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
563 }
564
565 /// <summary>Returns the float4 column vector result of a matrix multiplication between a float4x4 matrix and a float4 column vector.</summary>
566 /// <param name="a">Left hand side argument of the matrix multiply.</param>
567 /// <param name="b">Right hand side argument of the matrix multiply.</param>
568 /// <returns>The computed matrix multiplication.</returns>
569 [MethodImpl(MethodImplOptions.AggressiveInlining)]
570 public static float4 mul(float4x4 a, float4 b)
571 {
572 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
573 }
574
575 /// <summary>Returns the float4x2 matrix result of a matrix multiplication between a float4x4 matrix and a float4x2 matrix.</summary>
576 /// <param name="a">Left hand side argument of the matrix multiply.</param>
577 /// <param name="b">Right hand side argument of the matrix multiply.</param>
578 /// <returns>The computed matrix multiplication.</returns>
579 [MethodImpl(MethodImplOptions.AggressiveInlining)]
580 public static float4x2 mul(float4x4 a, float4x2 b)
581 {
582 return float4x2(
583 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
584 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
585 }
586
587 /// <summary>Returns the float4x3 matrix result of a matrix multiplication between a float4x4 matrix and a float4x3 matrix.</summary>
588 /// <param name="a">Left hand side argument of the matrix multiply.</param>
589 /// <param name="b">Right hand side argument of the matrix multiply.</param>
590 /// <returns>The computed matrix multiplication.</returns>
591 [MethodImpl(MethodImplOptions.AggressiveInlining)]
592 public static float4x3 mul(float4x4 a, float4x3 b)
593 {
594 return float4x3(
595 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
596 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
597 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
598 }
599
600 /// <summary>Returns the float4x4 matrix result of a matrix multiplication between a float4x4 matrix and a float4x4 matrix.</summary>
601 /// <param name="a">Left hand side argument of the matrix multiply.</param>
602 /// <param name="b">Right hand side argument of the matrix multiply.</param>
603 /// <returns>The computed matrix multiplication.</returns>
604 [MethodImpl(MethodImplOptions.AggressiveInlining)]
605 public static float4x4 mul(float4x4 a, float4x4 b)
606 {
607 return float4x4(
608 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
609 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
610 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
611 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
612 }
613
614 /// <summary>Returns the double value result of a matrix multiplication between a double value and a double value.</summary>
615 /// <param name="a">Left hand side argument of the matrix multiply.</param>
616 /// <param name="b">Right hand side argument of the matrix multiply.</param>
617 /// <returns>The computed matrix multiplication.</returns>
618 [MethodImpl(MethodImplOptions.AggressiveInlining)]
619 public static double mul(double a, double b)
620 {
621 return a * b;
622 }
623
624 /// <summary>Returns the double value result of a matrix multiplication between a double2 row vector and a double2 column vector.</summary>
625 /// <param name="a">Left hand side argument of the matrix multiply.</param>
626 /// <param name="b">Right hand side argument of the matrix multiply.</param>
627 /// <returns>The computed matrix multiplication.</returns>
628 [MethodImpl(MethodImplOptions.AggressiveInlining)]
629 public static double mul(double2 a, double2 b)
630 {
631 return a.x * b.x + a.y * b.y;
632 }
633
634 /// <summary>Returns the double2 row vector result of a matrix multiplication between a double2 row vector and a double2x2 matrix.</summary>
635 /// <param name="a">Left hand side argument of the matrix multiply.</param>
636 /// <param name="b">Right hand side argument of the matrix multiply.</param>
637 /// <returns>The computed matrix multiplication.</returns>
638 [MethodImpl(MethodImplOptions.AggressiveInlining)]
639 public static double2 mul(double2 a, double2x2 b)
640 {
641 return double2(
642 a.x * b.c0.x + a.y * b.c0.y,
643 a.x * b.c1.x + a.y * b.c1.y);
644 }
645
646 /// <summary>Returns the double3 row vector result of a matrix multiplication between a double2 row vector and a double2x3 matrix.</summary>
647 /// <param name="a">Left hand side argument of the matrix multiply.</param>
648 /// <param name="b">Right hand side argument of the matrix multiply.</param>
649 /// <returns>The computed matrix multiplication.</returns>
650 [MethodImpl(MethodImplOptions.AggressiveInlining)]
651 public static double3 mul(double2 a, double2x3 b)
652 {
653 return double3(
654 a.x * b.c0.x + a.y * b.c0.y,
655 a.x * b.c1.x + a.y * b.c1.y,
656 a.x * b.c2.x + a.y * b.c2.y);
657 }
658
659 /// <summary>Returns the double4 row vector result of a matrix multiplication between a double2 row vector and a double2x4 matrix.</summary>
660 /// <param name="a">Left hand side argument of the matrix multiply.</param>
661 /// <param name="b">Right hand side argument of the matrix multiply.</param>
662 /// <returns>The computed matrix multiplication.</returns>
663 [MethodImpl(MethodImplOptions.AggressiveInlining)]
664 public static double4 mul(double2 a, double2x4 b)
665 {
666 return double4(
667 a.x * b.c0.x + a.y * b.c0.y,
668 a.x * b.c1.x + a.y * b.c1.y,
669 a.x * b.c2.x + a.y * b.c2.y,
670 a.x * b.c3.x + a.y * b.c3.y);
671 }
672
673 /// <summary>Returns the double value result of a matrix multiplication between a double3 row vector and a double3 column vector.</summary>
674 /// <param name="a">Left hand side argument of the matrix multiply.</param>
675 /// <param name="b">Right hand side argument of the matrix multiply.</param>
676 /// <returns>The computed matrix multiplication.</returns>
677 [MethodImpl(MethodImplOptions.AggressiveInlining)]
678 public static double mul(double3 a, double3 b)
679 {
680 return a.x * b.x + a.y * b.y + a.z * b.z;
681 }
682
683 /// <summary>Returns the double2 row vector result of a matrix multiplication between a double3 row vector and a double3x2 matrix.</summary>
684 /// <param name="a">Left hand side argument of the matrix multiply.</param>
685 /// <param name="b">Right hand side argument of the matrix multiply.</param>
686 /// <returns>The computed matrix multiplication.</returns>
687 [MethodImpl(MethodImplOptions.AggressiveInlining)]
688 public static double2 mul(double3 a, double3x2 b)
689 {
690 return double2(
691 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
692 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z);
693 }
694
695 /// <summary>Returns the double3 row vector result of a matrix multiplication between a double3 row vector and a double3x3 matrix.</summary>
696 /// <param name="a">Left hand side argument of the matrix multiply.</param>
697 /// <param name="b">Right hand side argument of the matrix multiply.</param>
698 /// <returns>The computed matrix multiplication.</returns>
699 [MethodImpl(MethodImplOptions.AggressiveInlining)]
700 public static double3 mul(double3 a, double3x3 b)
701 {
702 return double3(
703 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
704 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
705 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z);
706 }
707
708 /// <summary>Returns the double4 row vector result of a matrix multiplication between a double3 row vector and a double3x4 matrix.</summary>
709 /// <param name="a">Left hand side argument of the matrix multiply.</param>
710 /// <param name="b">Right hand side argument of the matrix multiply.</param>
711 /// <returns>The computed matrix multiplication.</returns>
712 [MethodImpl(MethodImplOptions.AggressiveInlining)]
713 public static double4 mul(double3 a, double3x4 b)
714 {
715 return double4(
716 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
717 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
718 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z,
719 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z);
720 }
721
722 /// <summary>Returns the double value result of a matrix multiplication between a double4 row vector and a double4 column vector.</summary>
723 /// <param name="a">Left hand side argument of the matrix multiply.</param>
724 /// <param name="b">Right hand side argument of the matrix multiply.</param>
725 /// <returns>The computed matrix multiplication.</returns>
726 [MethodImpl(MethodImplOptions.AggressiveInlining)]
727 public static double mul(double4 a, double4 b)
728 {
729 return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
730 }
731
732 /// <summary>Returns the double2 row vector result of a matrix multiplication between a double4 row vector and a double4x2 matrix.</summary>
733 /// <param name="a">Left hand side argument of the matrix multiply.</param>
734 /// <param name="b">Right hand side argument of the matrix multiply.</param>
735 /// <returns>The computed matrix multiplication.</returns>
736 [MethodImpl(MethodImplOptions.AggressiveInlining)]
737 public static double2 mul(double4 a, double4x2 b)
738 {
739 return double2(
740 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
741 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w);
742 }
743
744 /// <summary>Returns the double3 row vector result of a matrix multiplication between a double4 row vector and a double4x3 matrix.</summary>
745 /// <param name="a">Left hand side argument of the matrix multiply.</param>
746 /// <param name="b">Right hand side argument of the matrix multiply.</param>
747 /// <returns>The computed matrix multiplication.</returns>
748 [MethodImpl(MethodImplOptions.AggressiveInlining)]
749 public static double3 mul(double4 a, double4x3 b)
750 {
751 return double3(
752 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
753 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
754 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w);
755 }
756
757 /// <summary>Returns the double4 row vector result of a matrix multiplication between a double4 row vector and a double4x4 matrix.</summary>
758 /// <param name="a">Left hand side argument of the matrix multiply.</param>
759 /// <param name="b">Right hand side argument of the matrix multiply.</param>
760 /// <returns>The computed matrix multiplication.</returns>
761 [MethodImpl(MethodImplOptions.AggressiveInlining)]
762 public static double4 mul(double4 a, double4x4 b)
763 {
764 return double4(
765 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
766 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
767 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w,
768 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w);
769 }
770
771 /// <summary>Returns the double2 column vector result of a matrix multiplication between a double2x2 matrix and a double2 column vector.</summary>
772 /// <param name="a">Left hand side argument of the matrix multiply.</param>
773 /// <param name="b">Right hand side argument of the matrix multiply.</param>
774 /// <returns>The computed matrix multiplication.</returns>
775 [MethodImpl(MethodImplOptions.AggressiveInlining)]
776 public static double2 mul(double2x2 a, double2 b)
777 {
778 return a.c0 * b.x + a.c1 * b.y;
779 }
780
781 /// <summary>Returns the double2x2 matrix result of a matrix multiplication between a double2x2 matrix and a double2x2 matrix.</summary>
782 /// <param name="a">Left hand side argument of the matrix multiply.</param>
783 /// <param name="b">Right hand side argument of the matrix multiply.</param>
784 /// <returns>The computed matrix multiplication.</returns>
785 [MethodImpl(MethodImplOptions.AggressiveInlining)]
786 public static double2x2 mul(double2x2 a, double2x2 b)
787 {
788 return double2x2(
789 a.c0 * b.c0.x + a.c1 * b.c0.y,
790 a.c0 * b.c1.x + a.c1 * b.c1.y);
791 }
792
793 /// <summary>Returns the double2x3 matrix result of a matrix multiplication between a double2x2 matrix and a double2x3 matrix.</summary>
794 /// <param name="a">Left hand side argument of the matrix multiply.</param>
795 /// <param name="b">Right hand side argument of the matrix multiply.</param>
796 /// <returns>The computed matrix multiplication.</returns>
797 [MethodImpl(MethodImplOptions.AggressiveInlining)]
798 public static double2x3 mul(double2x2 a, double2x3 b)
799 {
800 return double2x3(
801 a.c0 * b.c0.x + a.c1 * b.c0.y,
802 a.c0 * b.c1.x + a.c1 * b.c1.y,
803 a.c0 * b.c2.x + a.c1 * b.c2.y);
804 }
805
806 /// <summary>Returns the double2x4 matrix result of a matrix multiplication between a double2x2 matrix and a double2x4 matrix.</summary>
807 /// <param name="a">Left hand side argument of the matrix multiply.</param>
808 /// <param name="b">Right hand side argument of the matrix multiply.</param>
809 /// <returns>The computed matrix multiplication.</returns>
810 [MethodImpl(MethodImplOptions.AggressiveInlining)]
811 public static double2x4 mul(double2x2 a, double2x4 b)
812 {
813 return double2x4(
814 a.c0 * b.c0.x + a.c1 * b.c0.y,
815 a.c0 * b.c1.x + a.c1 * b.c1.y,
816 a.c0 * b.c2.x + a.c1 * b.c2.y,
817 a.c0 * b.c3.x + a.c1 * b.c3.y);
818 }
819
820 /// <summary>Returns the double2 column vector result of a matrix multiplication between a double2x3 matrix and a double3 column vector.</summary>
821 /// <param name="a">Left hand side argument of the matrix multiply.</param>
822 /// <param name="b">Right hand side argument of the matrix multiply.</param>
823 /// <returns>The computed matrix multiplication.</returns>
824 [MethodImpl(MethodImplOptions.AggressiveInlining)]
825 public static double2 mul(double2x3 a, double3 b)
826 {
827 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
828 }
829
830 /// <summary>Returns the double2x2 matrix result of a matrix multiplication between a double2x3 matrix and a double3x2 matrix.</summary>
831 /// <param name="a">Left hand side argument of the matrix multiply.</param>
832 /// <param name="b">Right hand side argument of the matrix multiply.</param>
833 /// <returns>The computed matrix multiplication.</returns>
834 [MethodImpl(MethodImplOptions.AggressiveInlining)]
835 public static double2x2 mul(double2x3 a, double3x2 b)
836 {
837 return double2x2(
838 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
839 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
840 }
841
842 /// <summary>Returns the double2x3 matrix result of a matrix multiplication between a double2x3 matrix and a double3x3 matrix.</summary>
843 /// <param name="a">Left hand side argument of the matrix multiply.</param>
844 /// <param name="b">Right hand side argument of the matrix multiply.</param>
845 /// <returns>The computed matrix multiplication.</returns>
846 [MethodImpl(MethodImplOptions.AggressiveInlining)]
847 public static double2x3 mul(double2x3 a, double3x3 b)
848 {
849 return double2x3(
850 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
851 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
852 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
853 }
854
855 /// <summary>Returns the double2x4 matrix result of a matrix multiplication between a double2x3 matrix and a double3x4 matrix.</summary>
856 /// <param name="a">Left hand side argument of the matrix multiply.</param>
857 /// <param name="b">Right hand side argument of the matrix multiply.</param>
858 /// <returns>The computed matrix multiplication.</returns>
859 [MethodImpl(MethodImplOptions.AggressiveInlining)]
860 public static double2x4 mul(double2x3 a, double3x4 b)
861 {
862 return double2x4(
863 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
864 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
865 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
866 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
867 }
868
869 /// <summary>Returns the double2 column vector result of a matrix multiplication between a double2x4 matrix and a double4 column vector.</summary>
870 /// <param name="a">Left hand side argument of the matrix multiply.</param>
871 /// <param name="b">Right hand side argument of the matrix multiply.</param>
872 /// <returns>The computed matrix multiplication.</returns>
873 [MethodImpl(MethodImplOptions.AggressiveInlining)]
874 public static double2 mul(double2x4 a, double4 b)
875 {
876 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
877 }
878
879 /// <summary>Returns the double2x2 matrix result of a matrix multiplication between a double2x4 matrix and a double4x2 matrix.</summary>
880 /// <param name="a">Left hand side argument of the matrix multiply.</param>
881 /// <param name="b">Right hand side argument of the matrix multiply.</param>
882 /// <returns>The computed matrix multiplication.</returns>
883 [MethodImpl(MethodImplOptions.AggressiveInlining)]
884 public static double2x2 mul(double2x4 a, double4x2 b)
885 {
886 return double2x2(
887 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
888 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
889 }
890
891 /// <summary>Returns the double2x3 matrix result of a matrix multiplication between a double2x4 matrix and a double4x3 matrix.</summary>
892 /// <param name="a">Left hand side argument of the matrix multiply.</param>
893 /// <param name="b">Right hand side argument of the matrix multiply.</param>
894 /// <returns>The computed matrix multiplication.</returns>
895 [MethodImpl(MethodImplOptions.AggressiveInlining)]
896 public static double2x3 mul(double2x4 a, double4x3 b)
897 {
898 return double2x3(
899 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
900 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
901 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
902 }
903
904 /// <summary>Returns the double2x4 matrix result of a matrix multiplication between a double2x4 matrix and a double4x4 matrix.</summary>
905 /// <param name="a">Left hand side argument of the matrix multiply.</param>
906 /// <param name="b">Right hand side argument of the matrix multiply.</param>
907 /// <returns>The computed matrix multiplication.</returns>
908 [MethodImpl(MethodImplOptions.AggressiveInlining)]
909 public static double2x4 mul(double2x4 a, double4x4 b)
910 {
911 return double2x4(
912 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
913 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
914 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
915 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
916 }
917
918 /// <summary>Returns the double3 column vector result of a matrix multiplication between a double3x2 matrix and a double2 column vector.</summary>
919 /// <param name="a">Left hand side argument of the matrix multiply.</param>
920 /// <param name="b">Right hand side argument of the matrix multiply.</param>
921 /// <returns>The computed matrix multiplication.</returns>
922 [MethodImpl(MethodImplOptions.AggressiveInlining)]
923 public static double3 mul(double3x2 a, double2 b)
924 {
925 return a.c0 * b.x + a.c1 * b.y;
926 }
927
928 /// <summary>Returns the double3x2 matrix result of a matrix multiplication between a double3x2 matrix and a double2x2 matrix.</summary>
929 /// <param name="a">Left hand side argument of the matrix multiply.</param>
930 /// <param name="b">Right hand side argument of the matrix multiply.</param>
931 /// <returns>The computed matrix multiplication.</returns>
932 [MethodImpl(MethodImplOptions.AggressiveInlining)]
933 public static double3x2 mul(double3x2 a, double2x2 b)
934 {
935 return double3x2(
936 a.c0 * b.c0.x + a.c1 * b.c0.y,
937 a.c0 * b.c1.x + a.c1 * b.c1.y);
938 }
939
940 /// <summary>Returns the double3x3 matrix result of a matrix multiplication between a double3x2 matrix and a double2x3 matrix.</summary>
941 /// <param name="a">Left hand side argument of the matrix multiply.</param>
942 /// <param name="b">Right hand side argument of the matrix multiply.</param>
943 /// <returns>The computed matrix multiplication.</returns>
944 [MethodImpl(MethodImplOptions.AggressiveInlining)]
945 public static double3x3 mul(double3x2 a, double2x3 b)
946 {
947 return double3x3(
948 a.c0 * b.c0.x + a.c1 * b.c0.y,
949 a.c0 * b.c1.x + a.c1 * b.c1.y,
950 a.c0 * b.c2.x + a.c1 * b.c2.y);
951 }
952
953 /// <summary>Returns the double3x4 matrix result of a matrix multiplication between a double3x2 matrix and a double2x4 matrix.</summary>
954 /// <param name="a">Left hand side argument of the matrix multiply.</param>
955 /// <param name="b">Right hand side argument of the matrix multiply.</param>
956 /// <returns>The computed matrix multiplication.</returns>
957 [MethodImpl(MethodImplOptions.AggressiveInlining)]
958 public static double3x4 mul(double3x2 a, double2x4 b)
959 {
960 return double3x4(
961 a.c0 * b.c0.x + a.c1 * b.c0.y,
962 a.c0 * b.c1.x + a.c1 * b.c1.y,
963 a.c0 * b.c2.x + a.c1 * b.c2.y,
964 a.c0 * b.c3.x + a.c1 * b.c3.y);
965 }
966
967 /// <summary>Returns the double3 column vector result of a matrix multiplication between a double3x3 matrix and a double3 column vector.</summary>
968 /// <param name="a">Left hand side argument of the matrix multiply.</param>
969 /// <param name="b">Right hand side argument of the matrix multiply.</param>
970 /// <returns>The computed matrix multiplication.</returns>
971 [MethodImpl(MethodImplOptions.AggressiveInlining)]
972 public static double3 mul(double3x3 a, double3 b)
973 {
974 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
975 }
976
977 /// <summary>Returns the double3x2 matrix result of a matrix multiplication between a double3x3 matrix and a double3x2 matrix.</summary>
978 /// <param name="a">Left hand side argument of the matrix multiply.</param>
979 /// <param name="b">Right hand side argument of the matrix multiply.</param>
980 /// <returns>The computed matrix multiplication.</returns>
981 [MethodImpl(MethodImplOptions.AggressiveInlining)]
982 public static double3x2 mul(double3x3 a, double3x2 b)
983 {
984 return double3x2(
985 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
986 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
987 }
988
989 /// <summary>Returns the double3x3 matrix result of a matrix multiplication between a double3x3 matrix and a double3x3 matrix.</summary>
990 /// <param name="a">Left hand side argument of the matrix multiply.</param>
991 /// <param name="b">Right hand side argument of the matrix multiply.</param>
992 /// <returns>The computed matrix multiplication.</returns>
993 [MethodImpl(MethodImplOptions.AggressiveInlining)]
994 public static double3x3 mul(double3x3 a, double3x3 b)
995 {
996 return double3x3(
997 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
998 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
999 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
1000 }
1001
1002 /// <summary>Returns the double3x4 matrix result of a matrix multiplication between a double3x3 matrix and a double3x4 matrix.</summary>
1003 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1004 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1005 /// <returns>The computed matrix multiplication.</returns>
1006 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1007 public static double3x4 mul(double3x3 a, double3x4 b)
1008 {
1009 return double3x4(
1010 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1011 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1012 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
1013 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
1014 }
1015
1016 /// <summary>Returns the double3 column vector result of a matrix multiplication between a double3x4 matrix and a double4 column vector.</summary>
1017 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1018 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1019 /// <returns>The computed matrix multiplication.</returns>
1020 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1021 public static double3 mul(double3x4 a, double4 b)
1022 {
1023 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
1024 }
1025
1026 /// <summary>Returns the double3x2 matrix result of a matrix multiplication between a double3x4 matrix and a double4x2 matrix.</summary>
1027 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1028 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1029 /// <returns>The computed matrix multiplication.</returns>
1030 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1031 public static double3x2 mul(double3x4 a, double4x2 b)
1032 {
1033 return double3x2(
1034 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1035 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
1036 }
1037
1038 /// <summary>Returns the double3x3 matrix result of a matrix multiplication between a double3x4 matrix and a double4x3 matrix.</summary>
1039 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1040 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1041 /// <returns>The computed matrix multiplication.</returns>
1042 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1043 public static double3x3 mul(double3x4 a, double4x3 b)
1044 {
1045 return double3x3(
1046 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1047 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1048 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
1049 }
1050
1051 /// <summary>Returns the double3x4 matrix result of a matrix multiplication between a double3x4 matrix and a double4x4 matrix.</summary>
1052 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1053 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1054 /// <returns>The computed matrix multiplication.</returns>
1055 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1056 public static double3x4 mul(double3x4 a, double4x4 b)
1057 {
1058 return double3x4(
1059 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1060 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1061 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
1062 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
1063 }
1064
1065 /// <summary>Returns the double4 column vector result of a matrix multiplication between a double4x2 matrix and a double2 column vector.</summary>
1066 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1067 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1068 /// <returns>The computed matrix multiplication.</returns>
1069 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1070 public static double4 mul(double4x2 a, double2 b)
1071 {
1072 return a.c0 * b.x + a.c1 * b.y;
1073 }
1074
1075 /// <summary>Returns the double4x2 matrix result of a matrix multiplication between a double4x2 matrix and a double2x2 matrix.</summary>
1076 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1077 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1078 /// <returns>The computed matrix multiplication.</returns>
1079 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1080 public static double4x2 mul(double4x2 a, double2x2 b)
1081 {
1082 return double4x2(
1083 a.c0 * b.c0.x + a.c1 * b.c0.y,
1084 a.c0 * b.c1.x + a.c1 * b.c1.y);
1085 }
1086
1087 /// <summary>Returns the double4x3 matrix result of a matrix multiplication between a double4x2 matrix and a double2x3 matrix.</summary>
1088 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1089 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1090 /// <returns>The computed matrix multiplication.</returns>
1091 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1092 public static double4x3 mul(double4x2 a, double2x3 b)
1093 {
1094 return double4x3(
1095 a.c0 * b.c0.x + a.c1 * b.c0.y,
1096 a.c0 * b.c1.x + a.c1 * b.c1.y,
1097 a.c0 * b.c2.x + a.c1 * b.c2.y);
1098 }
1099
1100 /// <summary>Returns the double4x4 matrix result of a matrix multiplication between a double4x2 matrix and a double2x4 matrix.</summary>
1101 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1102 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1103 /// <returns>The computed matrix multiplication.</returns>
1104 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1105 public static double4x4 mul(double4x2 a, double2x4 b)
1106 {
1107 return double4x4(
1108 a.c0 * b.c0.x + a.c1 * b.c0.y,
1109 a.c0 * b.c1.x + a.c1 * b.c1.y,
1110 a.c0 * b.c2.x + a.c1 * b.c2.y,
1111 a.c0 * b.c3.x + a.c1 * b.c3.y);
1112 }
1113
1114 /// <summary>Returns the double4 column vector result of a matrix multiplication between a double4x3 matrix and a double3 column vector.</summary>
1115 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1116 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1117 /// <returns>The computed matrix multiplication.</returns>
1118 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1119 public static double4 mul(double4x3 a, double3 b)
1120 {
1121 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
1122 }
1123
1124 /// <summary>Returns the double4x2 matrix result of a matrix multiplication between a double4x3 matrix and a double3x2 matrix.</summary>
1125 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1126 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1127 /// <returns>The computed matrix multiplication.</returns>
1128 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1129 public static double4x2 mul(double4x3 a, double3x2 b)
1130 {
1131 return double4x2(
1132 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1133 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
1134 }
1135
1136 /// <summary>Returns the double4x3 matrix result of a matrix multiplication between a double4x3 matrix and a double3x3 matrix.</summary>
1137 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1138 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1139 /// <returns>The computed matrix multiplication.</returns>
1140 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1141 public static double4x3 mul(double4x3 a, double3x3 b)
1142 {
1143 return double4x3(
1144 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1145 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1146 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
1147 }
1148
1149 /// <summary>Returns the double4x4 matrix result of a matrix multiplication between a double4x3 matrix and a double3x4 matrix.</summary>
1150 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1151 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1152 /// <returns>The computed matrix multiplication.</returns>
1153 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1154 public static double4x4 mul(double4x3 a, double3x4 b)
1155 {
1156 return double4x4(
1157 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1158 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1159 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
1160 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
1161 }
1162
1163 /// <summary>Returns the double4 column vector result of a matrix multiplication between a double4x4 matrix and a double4 column vector.</summary>
1164 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1165 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1166 /// <returns>The computed matrix multiplication.</returns>
1167 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1168 public static double4 mul(double4x4 a, double4 b)
1169 {
1170 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
1171 }
1172
1173 /// <summary>Returns the double4x2 matrix result of a matrix multiplication between a double4x4 matrix and a double4x2 matrix.</summary>
1174 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1175 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1176 /// <returns>The computed matrix multiplication.</returns>
1177 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1178 public static double4x2 mul(double4x4 a, double4x2 b)
1179 {
1180 return double4x2(
1181 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1182 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
1183 }
1184
1185 /// <summary>Returns the double4x3 matrix result of a matrix multiplication between a double4x4 matrix and a double4x3 matrix.</summary>
1186 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1187 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1188 /// <returns>The computed matrix multiplication.</returns>
1189 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1190 public static double4x3 mul(double4x4 a, double4x3 b)
1191 {
1192 return double4x3(
1193 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1194 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1195 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
1196 }
1197
1198 /// <summary>Returns the double4x4 matrix result of a matrix multiplication between a double4x4 matrix and a double4x4 matrix.</summary>
1199 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1200 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1201 /// <returns>The computed matrix multiplication.</returns>
1202 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1203 public static double4x4 mul(double4x4 a, double4x4 b)
1204 {
1205 return double4x4(
1206 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1207 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1208 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
1209 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
1210 }
1211
1212 /// <summary>Returns the int value result of a matrix multiplication between an int value and an int value.</summary>
1213 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1214 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1215 /// <returns>The computed matrix multiplication.</returns>
1216 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1217 public static int mul(int a, int b)
1218 {
1219 return a * b;
1220 }
1221
1222 /// <summary>Returns the int value result of a matrix multiplication between an int2 row vector and an int2 column vector.</summary>
1223 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1224 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1225 /// <returns>The computed matrix multiplication.</returns>
1226 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1227 public static int mul(int2 a, int2 b)
1228 {
1229 return a.x * b.x + a.y * b.y;
1230 }
1231
1232 /// <summary>Returns the int2 row vector result of a matrix multiplication between an int2 row vector and an int2x2 matrix.</summary>
1233 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1234 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1235 /// <returns>The computed matrix multiplication.</returns>
1236 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1237 public static int2 mul(int2 a, int2x2 b)
1238 {
1239 return int2(
1240 a.x * b.c0.x + a.y * b.c0.y,
1241 a.x * b.c1.x + a.y * b.c1.y);
1242 }
1243
1244 /// <summary>Returns the int3 row vector result of a matrix multiplication between an int2 row vector and an int2x3 matrix.</summary>
1245 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1246 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1247 /// <returns>The computed matrix multiplication.</returns>
1248 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1249 public static int3 mul(int2 a, int2x3 b)
1250 {
1251 return int3(
1252 a.x * b.c0.x + a.y * b.c0.y,
1253 a.x * b.c1.x + a.y * b.c1.y,
1254 a.x * b.c2.x + a.y * b.c2.y);
1255 }
1256
1257 /// <summary>Returns the int4 row vector result of a matrix multiplication between an int2 row vector and an int2x4 matrix.</summary>
1258 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1259 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1260 /// <returns>The computed matrix multiplication.</returns>
1261 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1262 public static int4 mul(int2 a, int2x4 b)
1263 {
1264 return int4(
1265 a.x * b.c0.x + a.y * b.c0.y,
1266 a.x * b.c1.x + a.y * b.c1.y,
1267 a.x * b.c2.x + a.y * b.c2.y,
1268 a.x * b.c3.x + a.y * b.c3.y);
1269 }
1270
1271 /// <summary>Returns the int value result of a matrix multiplication between an int3 row vector and an int3 column vector.</summary>
1272 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1273 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1274 /// <returns>The computed matrix multiplication.</returns>
1275 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1276 public static int mul(int3 a, int3 b)
1277 {
1278 return a.x * b.x + a.y * b.y + a.z * b.z;
1279 }
1280
1281 /// <summary>Returns the int2 row vector result of a matrix multiplication between an int3 row vector and an int3x2 matrix.</summary>
1282 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1283 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1284 /// <returns>The computed matrix multiplication.</returns>
1285 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1286 public static int2 mul(int3 a, int3x2 b)
1287 {
1288 return int2(
1289 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
1290 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z);
1291 }
1292
1293 /// <summary>Returns the int3 row vector result of a matrix multiplication between an int3 row vector and an int3x3 matrix.</summary>
1294 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1295 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1296 /// <returns>The computed matrix multiplication.</returns>
1297 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1298 public static int3 mul(int3 a, int3x3 b)
1299 {
1300 return int3(
1301 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
1302 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
1303 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z);
1304 }
1305
1306 /// <summary>Returns the int4 row vector result of a matrix multiplication between an int3 row vector and an int3x4 matrix.</summary>
1307 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1308 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1309 /// <returns>The computed matrix multiplication.</returns>
1310 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1311 public static int4 mul(int3 a, int3x4 b)
1312 {
1313 return int4(
1314 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
1315 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
1316 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z,
1317 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z);
1318 }
1319
1320 /// <summary>Returns the int value result of a matrix multiplication between an int4 row vector and an int4 column vector.</summary>
1321 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1322 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1323 /// <returns>The computed matrix multiplication.</returns>
1324 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1325 public static int mul(int4 a, int4 b)
1326 {
1327 return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
1328 }
1329
1330 /// <summary>Returns the int2 row vector result of a matrix multiplication between an int4 row vector and an int4x2 matrix.</summary>
1331 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1332 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1333 /// <returns>The computed matrix multiplication.</returns>
1334 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1335 public static int2 mul(int4 a, int4x2 b)
1336 {
1337 return int2(
1338 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
1339 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w);
1340 }
1341
1342 /// <summary>Returns the int3 row vector result of a matrix multiplication between an int4 row vector and an int4x3 matrix.</summary>
1343 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1344 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1345 /// <returns>The computed matrix multiplication.</returns>
1346 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1347 public static int3 mul(int4 a, int4x3 b)
1348 {
1349 return int3(
1350 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
1351 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
1352 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w);
1353 }
1354
1355 /// <summary>Returns the int4 row vector result of a matrix multiplication between an int4 row vector and an int4x4 matrix.</summary>
1356 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1357 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1358 /// <returns>The computed matrix multiplication.</returns>
1359 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1360 public static int4 mul(int4 a, int4x4 b)
1361 {
1362 return int4(
1363 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
1364 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
1365 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w,
1366 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w);
1367 }
1368
1369 /// <summary>Returns the int2 column vector result of a matrix multiplication between an int2x2 matrix and an int2 column vector.</summary>
1370 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1371 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1372 /// <returns>The computed matrix multiplication.</returns>
1373 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1374 public static int2 mul(int2x2 a, int2 b)
1375 {
1376 return a.c0 * b.x + a.c1 * b.y;
1377 }
1378
1379 /// <summary>Returns the int2x2 matrix result of a matrix multiplication between an int2x2 matrix and an int2x2 matrix.</summary>
1380 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1381 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1382 /// <returns>The computed matrix multiplication.</returns>
1383 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1384 public static int2x2 mul(int2x2 a, int2x2 b)
1385 {
1386 return int2x2(
1387 a.c0 * b.c0.x + a.c1 * b.c0.y,
1388 a.c0 * b.c1.x + a.c1 * b.c1.y);
1389 }
1390
1391 /// <summary>Returns the int2x3 matrix result of a matrix multiplication between an int2x2 matrix and an int2x3 matrix.</summary>
1392 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1393 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1394 /// <returns>The computed matrix multiplication.</returns>
1395 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1396 public static int2x3 mul(int2x2 a, int2x3 b)
1397 {
1398 return int2x3(
1399 a.c0 * b.c0.x + a.c1 * b.c0.y,
1400 a.c0 * b.c1.x + a.c1 * b.c1.y,
1401 a.c0 * b.c2.x + a.c1 * b.c2.y);
1402 }
1403
1404 /// <summary>Returns the int2x4 matrix result of a matrix multiplication between an int2x2 matrix and an int2x4 matrix.</summary>
1405 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1406 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1407 /// <returns>The computed matrix multiplication.</returns>
1408 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1409 public static int2x4 mul(int2x2 a, int2x4 b)
1410 {
1411 return int2x4(
1412 a.c0 * b.c0.x + a.c1 * b.c0.y,
1413 a.c0 * b.c1.x + a.c1 * b.c1.y,
1414 a.c0 * b.c2.x + a.c1 * b.c2.y,
1415 a.c0 * b.c3.x + a.c1 * b.c3.y);
1416 }
1417
1418 /// <summary>Returns the int2 column vector result of a matrix multiplication between an int2x3 matrix and an int3 column vector.</summary>
1419 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1420 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1421 /// <returns>The computed matrix multiplication.</returns>
1422 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1423 public static int2 mul(int2x3 a, int3 b)
1424 {
1425 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
1426 }
1427
1428 /// <summary>Returns the int2x2 matrix result of a matrix multiplication between an int2x3 matrix and an int3x2 matrix.</summary>
1429 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1430 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1431 /// <returns>The computed matrix multiplication.</returns>
1432 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1433 public static int2x2 mul(int2x3 a, int3x2 b)
1434 {
1435 return int2x2(
1436 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1437 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
1438 }
1439
1440 /// <summary>Returns the int2x3 matrix result of a matrix multiplication between an int2x3 matrix and an int3x3 matrix.</summary>
1441 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1442 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1443 /// <returns>The computed matrix multiplication.</returns>
1444 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1445 public static int2x3 mul(int2x3 a, int3x3 b)
1446 {
1447 return int2x3(
1448 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1449 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1450 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
1451 }
1452
1453 /// <summary>Returns the int2x4 matrix result of a matrix multiplication between an int2x3 matrix and an int3x4 matrix.</summary>
1454 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1455 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1456 /// <returns>The computed matrix multiplication.</returns>
1457 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1458 public static int2x4 mul(int2x3 a, int3x4 b)
1459 {
1460 return int2x4(
1461 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1462 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1463 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
1464 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
1465 }
1466
1467 /// <summary>Returns the int2 column vector result of a matrix multiplication between an int2x4 matrix and an int4 column vector.</summary>
1468 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1469 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1470 /// <returns>The computed matrix multiplication.</returns>
1471 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1472 public static int2 mul(int2x4 a, int4 b)
1473 {
1474 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
1475 }
1476
1477 /// <summary>Returns the int2x2 matrix result of a matrix multiplication between an int2x4 matrix and an int4x2 matrix.</summary>
1478 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1479 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1480 /// <returns>The computed matrix multiplication.</returns>
1481 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1482 public static int2x2 mul(int2x4 a, int4x2 b)
1483 {
1484 return int2x2(
1485 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1486 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
1487 }
1488
1489 /// <summary>Returns the int2x3 matrix result of a matrix multiplication between an int2x4 matrix and an int4x3 matrix.</summary>
1490 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1491 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1492 /// <returns>The computed matrix multiplication.</returns>
1493 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1494 public static int2x3 mul(int2x4 a, int4x3 b)
1495 {
1496 return int2x3(
1497 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1498 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1499 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
1500 }
1501
1502 /// <summary>Returns the int2x4 matrix result of a matrix multiplication between an int2x4 matrix and an int4x4 matrix.</summary>
1503 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1504 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1505 /// <returns>The computed matrix multiplication.</returns>
1506 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1507 public static int2x4 mul(int2x4 a, int4x4 b)
1508 {
1509 return int2x4(
1510 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1511 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1512 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
1513 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
1514 }
1515
1516 /// <summary>Returns the int3 column vector result of a matrix multiplication between an int3x2 matrix and an int2 column vector.</summary>
1517 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1518 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1519 /// <returns>The computed matrix multiplication.</returns>
1520 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1521 public static int3 mul(int3x2 a, int2 b)
1522 {
1523 return a.c0 * b.x + a.c1 * b.y;
1524 }
1525
1526 /// <summary>Returns the int3x2 matrix result of a matrix multiplication between an int3x2 matrix and an int2x2 matrix.</summary>
1527 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1528 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1529 /// <returns>The computed matrix multiplication.</returns>
1530 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1531 public static int3x2 mul(int3x2 a, int2x2 b)
1532 {
1533 return int3x2(
1534 a.c0 * b.c0.x + a.c1 * b.c0.y,
1535 a.c0 * b.c1.x + a.c1 * b.c1.y);
1536 }
1537
1538 /// <summary>Returns the int3x3 matrix result of a matrix multiplication between an int3x2 matrix and an int2x3 matrix.</summary>
1539 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1540 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1541 /// <returns>The computed matrix multiplication.</returns>
1542 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1543 public static int3x3 mul(int3x2 a, int2x3 b)
1544 {
1545 return int3x3(
1546 a.c0 * b.c0.x + a.c1 * b.c0.y,
1547 a.c0 * b.c1.x + a.c1 * b.c1.y,
1548 a.c0 * b.c2.x + a.c1 * b.c2.y);
1549 }
1550
1551 /// <summary>Returns the int3x4 matrix result of a matrix multiplication between an int3x2 matrix and an int2x4 matrix.</summary>
1552 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1553 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1554 /// <returns>The computed matrix multiplication.</returns>
1555 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1556 public static int3x4 mul(int3x2 a, int2x4 b)
1557 {
1558 return int3x4(
1559 a.c0 * b.c0.x + a.c1 * b.c0.y,
1560 a.c0 * b.c1.x + a.c1 * b.c1.y,
1561 a.c0 * b.c2.x + a.c1 * b.c2.y,
1562 a.c0 * b.c3.x + a.c1 * b.c3.y);
1563 }
1564
1565 /// <summary>Returns the int3 column vector result of a matrix multiplication between an int3x3 matrix and an int3 column vector.</summary>
1566 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1567 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1568 /// <returns>The computed matrix multiplication.</returns>
1569 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1570 public static int3 mul(int3x3 a, int3 b)
1571 {
1572 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
1573 }
1574
1575 /// <summary>Returns the int3x2 matrix result of a matrix multiplication between an int3x3 matrix and an int3x2 matrix.</summary>
1576 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1577 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1578 /// <returns>The computed matrix multiplication.</returns>
1579 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1580 public static int3x2 mul(int3x3 a, int3x2 b)
1581 {
1582 return int3x2(
1583 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1584 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
1585 }
1586
1587 /// <summary>Returns the int3x3 matrix result of a matrix multiplication between an int3x3 matrix and an int3x3 matrix.</summary>
1588 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1589 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1590 /// <returns>The computed matrix multiplication.</returns>
1591 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1592 public static int3x3 mul(int3x3 a, int3x3 b)
1593 {
1594 return int3x3(
1595 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1596 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1597 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
1598 }
1599
1600 /// <summary>Returns the int3x4 matrix result of a matrix multiplication between an int3x3 matrix and an int3x4 matrix.</summary>
1601 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1602 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1603 /// <returns>The computed matrix multiplication.</returns>
1604 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1605 public static int3x4 mul(int3x3 a, int3x4 b)
1606 {
1607 return int3x4(
1608 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1609 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1610 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
1611 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
1612 }
1613
1614 /// <summary>Returns the int3 column vector result of a matrix multiplication between an int3x4 matrix and an int4 column vector.</summary>
1615 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1616 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1617 /// <returns>The computed matrix multiplication.</returns>
1618 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1619 public static int3 mul(int3x4 a, int4 b)
1620 {
1621 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
1622 }
1623
1624 /// <summary>Returns the int3x2 matrix result of a matrix multiplication between an int3x4 matrix and an int4x2 matrix.</summary>
1625 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1626 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1627 /// <returns>The computed matrix multiplication.</returns>
1628 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1629 public static int3x2 mul(int3x4 a, int4x2 b)
1630 {
1631 return int3x2(
1632 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1633 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
1634 }
1635
1636 /// <summary>Returns the int3x3 matrix result of a matrix multiplication between an int3x4 matrix and an int4x3 matrix.</summary>
1637 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1638 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1639 /// <returns>The computed matrix multiplication.</returns>
1640 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1641 public static int3x3 mul(int3x4 a, int4x3 b)
1642 {
1643 return int3x3(
1644 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1645 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1646 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
1647 }
1648
1649 /// <summary>Returns the int3x4 matrix result of a matrix multiplication between an int3x4 matrix and an int4x4 matrix.</summary>
1650 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1651 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1652 /// <returns>The computed matrix multiplication.</returns>
1653 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1654 public static int3x4 mul(int3x4 a, int4x4 b)
1655 {
1656 return int3x4(
1657 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1658 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1659 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
1660 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
1661 }
1662
1663 /// <summary>Returns the int4 column vector result of a matrix multiplication between an int4x2 matrix and an int2 column vector.</summary>
1664 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1665 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1666 /// <returns>The computed matrix multiplication.</returns>
1667 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1668 public static int4 mul(int4x2 a, int2 b)
1669 {
1670 return a.c0 * b.x + a.c1 * b.y;
1671 }
1672
1673 /// <summary>Returns the int4x2 matrix result of a matrix multiplication between an int4x2 matrix and an int2x2 matrix.</summary>
1674 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1675 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1676 /// <returns>The computed matrix multiplication.</returns>
1677 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1678 public static int4x2 mul(int4x2 a, int2x2 b)
1679 {
1680 return int4x2(
1681 a.c0 * b.c0.x + a.c1 * b.c0.y,
1682 a.c0 * b.c1.x + a.c1 * b.c1.y);
1683 }
1684
1685 /// <summary>Returns the int4x3 matrix result of a matrix multiplication between an int4x2 matrix and an int2x3 matrix.</summary>
1686 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1687 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1688 /// <returns>The computed matrix multiplication.</returns>
1689 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1690 public static int4x3 mul(int4x2 a, int2x3 b)
1691 {
1692 return int4x3(
1693 a.c0 * b.c0.x + a.c1 * b.c0.y,
1694 a.c0 * b.c1.x + a.c1 * b.c1.y,
1695 a.c0 * b.c2.x + a.c1 * b.c2.y);
1696 }
1697
1698 /// <summary>Returns the int4x4 matrix result of a matrix multiplication between an int4x2 matrix and an int2x4 matrix.</summary>
1699 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1700 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1701 /// <returns>The computed matrix multiplication.</returns>
1702 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1703 public static int4x4 mul(int4x2 a, int2x4 b)
1704 {
1705 return int4x4(
1706 a.c0 * b.c0.x + a.c1 * b.c0.y,
1707 a.c0 * b.c1.x + a.c1 * b.c1.y,
1708 a.c0 * b.c2.x + a.c1 * b.c2.y,
1709 a.c0 * b.c3.x + a.c1 * b.c3.y);
1710 }
1711
1712 /// <summary>Returns the int4 column vector result of a matrix multiplication between an int4x3 matrix and an int3 column vector.</summary>
1713 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1714 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1715 /// <returns>The computed matrix multiplication.</returns>
1716 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1717 public static int4 mul(int4x3 a, int3 b)
1718 {
1719 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
1720 }
1721
1722 /// <summary>Returns the int4x2 matrix result of a matrix multiplication between an int4x3 matrix and an int3x2 matrix.</summary>
1723 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1724 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1725 /// <returns>The computed matrix multiplication.</returns>
1726 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1727 public static int4x2 mul(int4x3 a, int3x2 b)
1728 {
1729 return int4x2(
1730 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1731 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
1732 }
1733
1734 /// <summary>Returns the int4x3 matrix result of a matrix multiplication between an int4x3 matrix and an int3x3 matrix.</summary>
1735 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1736 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1737 /// <returns>The computed matrix multiplication.</returns>
1738 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1739 public static int4x3 mul(int4x3 a, int3x3 b)
1740 {
1741 return int4x3(
1742 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1743 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1744 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
1745 }
1746
1747 /// <summary>Returns the int4x4 matrix result of a matrix multiplication between an int4x3 matrix and an int3x4 matrix.</summary>
1748 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1749 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1750 /// <returns>The computed matrix multiplication.</returns>
1751 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1752 public static int4x4 mul(int4x3 a, int3x4 b)
1753 {
1754 return int4x4(
1755 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
1756 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
1757 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
1758 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
1759 }
1760
1761 /// <summary>Returns the int4 column vector result of a matrix multiplication between an int4x4 matrix and an int4 column vector.</summary>
1762 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1763 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1764 /// <returns>The computed matrix multiplication.</returns>
1765 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1766 public static int4 mul(int4x4 a, int4 b)
1767 {
1768 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
1769 }
1770
1771 /// <summary>Returns the int4x2 matrix result of a matrix multiplication between an int4x4 matrix and an int4x2 matrix.</summary>
1772 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1773 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1774 /// <returns>The computed matrix multiplication.</returns>
1775 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1776 public static int4x2 mul(int4x4 a, int4x2 b)
1777 {
1778 return int4x2(
1779 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1780 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
1781 }
1782
1783 /// <summary>Returns the int4x3 matrix result of a matrix multiplication between an int4x4 matrix and an int4x3 matrix.</summary>
1784 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1785 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1786 /// <returns>The computed matrix multiplication.</returns>
1787 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1788 public static int4x3 mul(int4x4 a, int4x3 b)
1789 {
1790 return int4x3(
1791 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1792 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1793 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
1794 }
1795
1796 /// <summary>Returns the int4x4 matrix result of a matrix multiplication between an int4x4 matrix and an int4x4 matrix.</summary>
1797 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1798 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1799 /// <returns>The computed matrix multiplication.</returns>
1800 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1801 public static int4x4 mul(int4x4 a, int4x4 b)
1802 {
1803 return int4x4(
1804 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
1805 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
1806 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
1807 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
1808 }
1809
1810 /// <summary>Returns the uint value result of a matrix multiplication between a uint value and a uint value.</summary>
1811 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1812 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1813 /// <returns>The computed matrix multiplication.</returns>
1814 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1815 public static uint mul(uint a, uint b)
1816 {
1817 return a * b;
1818 }
1819
1820 /// <summary>Returns the uint value result of a matrix multiplication between a uint2 row vector and a uint2 column vector.</summary>
1821 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1822 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1823 /// <returns>The computed matrix multiplication.</returns>
1824 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1825 public static uint mul(uint2 a, uint2 b)
1826 {
1827 return a.x * b.x + a.y * b.y;
1828 }
1829
1830 /// <summary>Returns the uint2 row vector result of a matrix multiplication between a uint2 row vector and a uint2x2 matrix.</summary>
1831 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1832 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1833 /// <returns>The computed matrix multiplication.</returns>
1834 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1835 public static uint2 mul(uint2 a, uint2x2 b)
1836 {
1837 return uint2(
1838 a.x * b.c0.x + a.y * b.c0.y,
1839 a.x * b.c1.x + a.y * b.c1.y);
1840 }
1841
1842 /// <summary>Returns the uint3 row vector result of a matrix multiplication between a uint2 row vector and a uint2x3 matrix.</summary>
1843 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1844 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1845 /// <returns>The computed matrix multiplication.</returns>
1846 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1847 public static uint3 mul(uint2 a, uint2x3 b)
1848 {
1849 return uint3(
1850 a.x * b.c0.x + a.y * b.c0.y,
1851 a.x * b.c1.x + a.y * b.c1.y,
1852 a.x * b.c2.x + a.y * b.c2.y);
1853 }
1854
1855 /// <summary>Returns the uint4 row vector result of a matrix multiplication between a uint2 row vector and a uint2x4 matrix.</summary>
1856 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1857 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1858 /// <returns>The computed matrix multiplication.</returns>
1859 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1860 public static uint4 mul(uint2 a, uint2x4 b)
1861 {
1862 return uint4(
1863 a.x * b.c0.x + a.y * b.c0.y,
1864 a.x * b.c1.x + a.y * b.c1.y,
1865 a.x * b.c2.x + a.y * b.c2.y,
1866 a.x * b.c3.x + a.y * b.c3.y);
1867 }
1868
1869 /// <summary>Returns the uint value result of a matrix multiplication between a uint3 row vector and a uint3 column vector.</summary>
1870 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1871 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1872 /// <returns>The computed matrix multiplication.</returns>
1873 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1874 public static uint mul(uint3 a, uint3 b)
1875 {
1876 return a.x * b.x + a.y * b.y + a.z * b.z;
1877 }
1878
1879 /// <summary>Returns the uint2 row vector result of a matrix multiplication between a uint3 row vector and a uint3x2 matrix.</summary>
1880 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1881 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1882 /// <returns>The computed matrix multiplication.</returns>
1883 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1884 public static uint2 mul(uint3 a, uint3x2 b)
1885 {
1886 return uint2(
1887 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
1888 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z);
1889 }
1890
1891 /// <summary>Returns the uint3 row vector result of a matrix multiplication between a uint3 row vector and a uint3x3 matrix.</summary>
1892 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1893 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1894 /// <returns>The computed matrix multiplication.</returns>
1895 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1896 public static uint3 mul(uint3 a, uint3x3 b)
1897 {
1898 return uint3(
1899 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
1900 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
1901 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z);
1902 }
1903
1904 /// <summary>Returns the uint4 row vector result of a matrix multiplication between a uint3 row vector and a uint3x4 matrix.</summary>
1905 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1906 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1907 /// <returns>The computed matrix multiplication.</returns>
1908 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1909 public static uint4 mul(uint3 a, uint3x4 b)
1910 {
1911 return uint4(
1912 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z,
1913 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z,
1914 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z,
1915 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z);
1916 }
1917
1918 /// <summary>Returns the uint value result of a matrix multiplication between a uint4 row vector and a uint4 column vector.</summary>
1919 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1920 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1921 /// <returns>The computed matrix multiplication.</returns>
1922 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1923 public static uint mul(uint4 a, uint4 b)
1924 {
1925 return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
1926 }
1927
1928 /// <summary>Returns the uint2 row vector result of a matrix multiplication between a uint4 row vector and a uint4x2 matrix.</summary>
1929 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1930 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1931 /// <returns>The computed matrix multiplication.</returns>
1932 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1933 public static uint2 mul(uint4 a, uint4x2 b)
1934 {
1935 return uint2(
1936 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
1937 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w);
1938 }
1939
1940 /// <summary>Returns the uint3 row vector result of a matrix multiplication between a uint4 row vector and a uint4x3 matrix.</summary>
1941 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1942 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1943 /// <returns>The computed matrix multiplication.</returns>
1944 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1945 public static uint3 mul(uint4 a, uint4x3 b)
1946 {
1947 return uint3(
1948 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
1949 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
1950 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w);
1951 }
1952
1953 /// <summary>Returns the uint4 row vector result of a matrix multiplication between a uint4 row vector and a uint4x4 matrix.</summary>
1954 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1955 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1956 /// <returns>The computed matrix multiplication.</returns>
1957 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1958 public static uint4 mul(uint4 a, uint4x4 b)
1959 {
1960 return uint4(
1961 a.x * b.c0.x + a.y * b.c0.y + a.z * b.c0.z + a.w * b.c0.w,
1962 a.x * b.c1.x + a.y * b.c1.y + a.z * b.c1.z + a.w * b.c1.w,
1963 a.x * b.c2.x + a.y * b.c2.y + a.z * b.c2.z + a.w * b.c2.w,
1964 a.x * b.c3.x + a.y * b.c3.y + a.z * b.c3.z + a.w * b.c3.w);
1965 }
1966
1967 /// <summary>Returns the uint2 column vector result of a matrix multiplication between a uint2x2 matrix and a uint2 column vector.</summary>
1968 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1969 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1970 /// <returns>The computed matrix multiplication.</returns>
1971 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1972 public static uint2 mul(uint2x2 a, uint2 b)
1973 {
1974 return a.c0 * b.x + a.c1 * b.y;
1975 }
1976
1977 /// <summary>Returns the uint2x2 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x2 matrix.</summary>
1978 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1979 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1980 /// <returns>The computed matrix multiplication.</returns>
1981 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1982 public static uint2x2 mul(uint2x2 a, uint2x2 b)
1983 {
1984 return uint2x2(
1985 a.c0 * b.c0.x + a.c1 * b.c0.y,
1986 a.c0 * b.c1.x + a.c1 * b.c1.y);
1987 }
1988
1989 /// <summary>Returns the uint2x3 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x3 matrix.</summary>
1990 /// <param name="a">Left hand side argument of the matrix multiply.</param>
1991 /// <param name="b">Right hand side argument of the matrix multiply.</param>
1992 /// <returns>The computed matrix multiplication.</returns>
1993 [MethodImpl(MethodImplOptions.AggressiveInlining)]
1994 public static uint2x3 mul(uint2x2 a, uint2x3 b)
1995 {
1996 return uint2x3(
1997 a.c0 * b.c0.x + a.c1 * b.c0.y,
1998 a.c0 * b.c1.x + a.c1 * b.c1.y,
1999 a.c0 * b.c2.x + a.c1 * b.c2.y);
2000 }
2001
2002 /// <summary>Returns the uint2x4 matrix result of a matrix multiplication between a uint2x2 matrix and a uint2x4 matrix.</summary>
2003 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2004 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2005 /// <returns>The computed matrix multiplication.</returns>
2006 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2007 public static uint2x4 mul(uint2x2 a, uint2x4 b)
2008 {
2009 return uint2x4(
2010 a.c0 * b.c0.x + a.c1 * b.c0.y,
2011 a.c0 * b.c1.x + a.c1 * b.c1.y,
2012 a.c0 * b.c2.x + a.c1 * b.c2.y,
2013 a.c0 * b.c3.x + a.c1 * b.c3.y);
2014 }
2015
2016 /// <summary>Returns the uint2 column vector result of a matrix multiplication between a uint2x3 matrix and a uint3 column vector.</summary>
2017 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2018 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2019 /// <returns>The computed matrix multiplication.</returns>
2020 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2021 public static uint2 mul(uint2x3 a, uint3 b)
2022 {
2023 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
2024 }
2025
2026 /// <summary>Returns the uint2x2 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x2 matrix.</summary>
2027 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2028 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2029 /// <returns>The computed matrix multiplication.</returns>
2030 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2031 public static uint2x2 mul(uint2x3 a, uint3x2 b)
2032 {
2033 return uint2x2(
2034 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2035 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
2036 }
2037
2038 /// <summary>Returns the uint2x3 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x3 matrix.</summary>
2039 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2040 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2041 /// <returns>The computed matrix multiplication.</returns>
2042 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2043 public static uint2x3 mul(uint2x3 a, uint3x3 b)
2044 {
2045 return uint2x3(
2046 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2047 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
2048 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
2049 }
2050
2051 /// <summary>Returns the uint2x4 matrix result of a matrix multiplication between a uint2x3 matrix and a uint3x4 matrix.</summary>
2052 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2053 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2054 /// <returns>The computed matrix multiplication.</returns>
2055 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2056 public static uint2x4 mul(uint2x3 a, uint3x4 b)
2057 {
2058 return uint2x4(
2059 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2060 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
2061 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
2062 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
2063 }
2064
2065 /// <summary>Returns the uint2 column vector result of a matrix multiplication between a uint2x4 matrix and a uint4 column vector.</summary>
2066 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2067 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2068 /// <returns>The computed matrix multiplication.</returns>
2069 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2070 public static uint2 mul(uint2x4 a, uint4 b)
2071 {
2072 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
2073 }
2074
2075 /// <summary>Returns the uint2x2 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x2 matrix.</summary>
2076 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2077 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2078 /// <returns>The computed matrix multiplication.</returns>
2079 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2080 public static uint2x2 mul(uint2x4 a, uint4x2 b)
2081 {
2082 return uint2x2(
2083 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2084 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
2085 }
2086
2087 /// <summary>Returns the uint2x3 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x3 matrix.</summary>
2088 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2089 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2090 /// <returns>The computed matrix multiplication.</returns>
2091 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2092 public static uint2x3 mul(uint2x4 a, uint4x3 b)
2093 {
2094 return uint2x3(
2095 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2096 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
2097 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
2098 }
2099
2100 /// <summary>Returns the uint2x4 matrix result of a matrix multiplication between a uint2x4 matrix and a uint4x4 matrix.</summary>
2101 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2102 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2103 /// <returns>The computed matrix multiplication.</returns>
2104 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2105 public static uint2x4 mul(uint2x4 a, uint4x4 b)
2106 {
2107 return uint2x4(
2108 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2109 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
2110 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
2111 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
2112 }
2113
2114 /// <summary>Returns the uint3 column vector result of a matrix multiplication between a uint3x2 matrix and a uint2 column vector.</summary>
2115 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2116 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2117 /// <returns>The computed matrix multiplication.</returns>
2118 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2119 public static uint3 mul(uint3x2 a, uint2 b)
2120 {
2121 return a.c0 * b.x + a.c1 * b.y;
2122 }
2123
2124 /// <summary>Returns the uint3x2 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x2 matrix.</summary>
2125 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2126 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2127 /// <returns>The computed matrix multiplication.</returns>
2128 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2129 public static uint3x2 mul(uint3x2 a, uint2x2 b)
2130 {
2131 return uint3x2(
2132 a.c0 * b.c0.x + a.c1 * b.c0.y,
2133 a.c0 * b.c1.x + a.c1 * b.c1.y);
2134 }
2135
2136 /// <summary>Returns the uint3x3 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x3 matrix.</summary>
2137 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2138 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2139 /// <returns>The computed matrix multiplication.</returns>
2140 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2141 public static uint3x3 mul(uint3x2 a, uint2x3 b)
2142 {
2143 return uint3x3(
2144 a.c0 * b.c0.x + a.c1 * b.c0.y,
2145 a.c0 * b.c1.x + a.c1 * b.c1.y,
2146 a.c0 * b.c2.x + a.c1 * b.c2.y);
2147 }
2148
2149 /// <summary>Returns the uint3x4 matrix result of a matrix multiplication between a uint3x2 matrix and a uint2x4 matrix.</summary>
2150 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2151 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2152 /// <returns>The computed matrix multiplication.</returns>
2153 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2154 public static uint3x4 mul(uint3x2 a, uint2x4 b)
2155 {
2156 return uint3x4(
2157 a.c0 * b.c0.x + a.c1 * b.c0.y,
2158 a.c0 * b.c1.x + a.c1 * b.c1.y,
2159 a.c0 * b.c2.x + a.c1 * b.c2.y,
2160 a.c0 * b.c3.x + a.c1 * b.c3.y);
2161 }
2162
2163 /// <summary>Returns the uint3 column vector result of a matrix multiplication between a uint3x3 matrix and a uint3 column vector.</summary>
2164 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2165 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2166 /// <returns>The computed matrix multiplication.</returns>
2167 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2168 public static uint3 mul(uint3x3 a, uint3 b)
2169 {
2170 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
2171 }
2172
2173 /// <summary>Returns the uint3x2 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x2 matrix.</summary>
2174 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2175 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2176 /// <returns>The computed matrix multiplication.</returns>
2177 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2178 public static uint3x2 mul(uint3x3 a, uint3x2 b)
2179 {
2180 return uint3x2(
2181 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2182 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
2183 }
2184
2185 /// <summary>Returns the uint3x3 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x3 matrix.</summary>
2186 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2187 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2188 /// <returns>The computed matrix multiplication.</returns>
2189 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2190 public static uint3x3 mul(uint3x3 a, uint3x3 b)
2191 {
2192 return uint3x3(
2193 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2194 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
2195 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
2196 }
2197
2198 /// <summary>Returns the uint3x4 matrix result of a matrix multiplication between a uint3x3 matrix and a uint3x4 matrix.</summary>
2199 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2200 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2201 /// <returns>The computed matrix multiplication.</returns>
2202 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2203 public static uint3x4 mul(uint3x3 a, uint3x4 b)
2204 {
2205 return uint3x4(
2206 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2207 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
2208 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
2209 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
2210 }
2211
2212 /// <summary>Returns the uint3 column vector result of a matrix multiplication between a uint3x4 matrix and a uint4 column vector.</summary>
2213 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2214 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2215 /// <returns>The computed matrix multiplication.</returns>
2216 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2217 public static uint3 mul(uint3x4 a, uint4 b)
2218 {
2219 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
2220 }
2221
2222 /// <summary>Returns the uint3x2 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x2 matrix.</summary>
2223 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2224 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2225 /// <returns>The computed matrix multiplication.</returns>
2226 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2227 public static uint3x2 mul(uint3x4 a, uint4x2 b)
2228 {
2229 return uint3x2(
2230 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2231 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
2232 }
2233
2234 /// <summary>Returns the uint3x3 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x3 matrix.</summary>
2235 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2236 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2237 /// <returns>The computed matrix multiplication.</returns>
2238 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2239 public static uint3x3 mul(uint3x4 a, uint4x3 b)
2240 {
2241 return uint3x3(
2242 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2243 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
2244 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
2245 }
2246
2247 /// <summary>Returns the uint3x4 matrix result of a matrix multiplication between a uint3x4 matrix and a uint4x4 matrix.</summary>
2248 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2249 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2250 /// <returns>The computed matrix multiplication.</returns>
2251 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2252 public static uint3x4 mul(uint3x4 a, uint4x4 b)
2253 {
2254 return uint3x4(
2255 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2256 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
2257 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
2258 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
2259 }
2260
2261 /// <summary>Returns the uint4 column vector result of a matrix multiplication between a uint4x2 matrix and a uint2 column vector.</summary>
2262 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2263 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2264 /// <returns>The computed matrix multiplication.</returns>
2265 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2266 public static uint4 mul(uint4x2 a, uint2 b)
2267 {
2268 return a.c0 * b.x + a.c1 * b.y;
2269 }
2270
2271 /// <summary>Returns the uint4x2 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x2 matrix.</summary>
2272 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2273 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2274 /// <returns>The computed matrix multiplication.</returns>
2275 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2276 public static uint4x2 mul(uint4x2 a, uint2x2 b)
2277 {
2278 return uint4x2(
2279 a.c0 * b.c0.x + a.c1 * b.c0.y,
2280 a.c0 * b.c1.x + a.c1 * b.c1.y);
2281 }
2282
2283 /// <summary>Returns the uint4x3 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x3 matrix.</summary>
2284 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2285 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2286 /// <returns>The computed matrix multiplication.</returns>
2287 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2288 public static uint4x3 mul(uint4x2 a, uint2x3 b)
2289 {
2290 return uint4x3(
2291 a.c0 * b.c0.x + a.c1 * b.c0.y,
2292 a.c0 * b.c1.x + a.c1 * b.c1.y,
2293 a.c0 * b.c2.x + a.c1 * b.c2.y);
2294 }
2295
2296 /// <summary>Returns the uint4x4 matrix result of a matrix multiplication between a uint4x2 matrix and a uint2x4 matrix.</summary>
2297 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2298 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2299 /// <returns>The computed matrix multiplication.</returns>
2300 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2301 public static uint4x4 mul(uint4x2 a, uint2x4 b)
2302 {
2303 return uint4x4(
2304 a.c0 * b.c0.x + a.c1 * b.c0.y,
2305 a.c0 * b.c1.x + a.c1 * b.c1.y,
2306 a.c0 * b.c2.x + a.c1 * b.c2.y,
2307 a.c0 * b.c3.x + a.c1 * b.c3.y);
2308 }
2309
2310 /// <summary>Returns the uint4 column vector result of a matrix multiplication between a uint4x3 matrix and a uint3 column vector.</summary>
2311 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2312 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2313 /// <returns>The computed matrix multiplication.</returns>
2314 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2315 public static uint4 mul(uint4x3 a, uint3 b)
2316 {
2317 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z;
2318 }
2319
2320 /// <summary>Returns the uint4x2 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x2 matrix.</summary>
2321 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2322 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2323 /// <returns>The computed matrix multiplication.</returns>
2324 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2325 public static uint4x2 mul(uint4x3 a, uint3x2 b)
2326 {
2327 return uint4x2(
2328 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2329 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z);
2330 }
2331
2332 /// <summary>Returns the uint4x3 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x3 matrix.</summary>
2333 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2334 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2335 /// <returns>The computed matrix multiplication.</returns>
2336 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2337 public static uint4x3 mul(uint4x3 a, uint3x3 b)
2338 {
2339 return uint4x3(
2340 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2341 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
2342 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z);
2343 }
2344
2345 /// <summary>Returns the uint4x4 matrix result of a matrix multiplication between a uint4x3 matrix and a uint3x4 matrix.</summary>
2346 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2347 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2348 /// <returns>The computed matrix multiplication.</returns>
2349 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2350 public static uint4x4 mul(uint4x3 a, uint3x4 b)
2351 {
2352 return uint4x4(
2353 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z,
2354 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z,
2355 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z,
2356 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z);
2357 }
2358
2359 /// <summary>Returns the uint4 column vector result of a matrix multiplication between a uint4x4 matrix and a uint4 column vector.</summary>
2360 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2361 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2362 /// <returns>The computed matrix multiplication.</returns>
2363 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2364 public static uint4 mul(uint4x4 a, uint4 b)
2365 {
2366 return a.c0 * b.x + a.c1 * b.y + a.c2 * b.z + a.c3 * b.w;
2367 }
2368
2369 /// <summary>Returns the uint4x2 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x2 matrix.</summary>
2370 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2371 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2372 /// <returns>The computed matrix multiplication.</returns>
2373 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2374 public static uint4x2 mul(uint4x4 a, uint4x2 b)
2375 {
2376 return uint4x2(
2377 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2378 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w);
2379 }
2380
2381 /// <summary>Returns the uint4x3 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x3 matrix.</summary>
2382 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2383 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2384 /// <returns>The computed matrix multiplication.</returns>
2385 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2386 public static uint4x3 mul(uint4x4 a, uint4x3 b)
2387 {
2388 return uint4x3(
2389 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2390 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
2391 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w);
2392 }
2393
2394 /// <summary>Returns the uint4x4 matrix result of a matrix multiplication between a uint4x4 matrix and a uint4x4 matrix.</summary>
2395 /// <param name="a">Left hand side argument of the matrix multiply.</param>
2396 /// <param name="b">Right hand side argument of the matrix multiply.</param>
2397 /// <returns>The computed matrix multiplication.</returns>
2398 [MethodImpl(MethodImplOptions.AggressiveInlining)]
2399 public static uint4x4 mul(uint4x4 a, uint4x4 b)
2400 {
2401 return uint4x4(
2402 a.c0 * b.c0.x + a.c1 * b.c0.y + a.c2 * b.c0.z + a.c3 * b.c0.w,
2403 a.c0 * b.c1.x + a.c1 * b.c1.y + a.c2 * b.c1.z + a.c3 * b.c1.w,
2404 a.c0 * b.c2.x + a.c1 * b.c2.y + a.c2 * b.c2.z + a.c3 * b.c2.w,
2405 a.c0 * b.c3.x + a.c1 * b.c3.y + a.c2 * b.c3.z + a.c3 * b.c3.w);
2406 }
2407
2408 }
2409}