1#[macro_use]
2use crate::stdlib::*;
3
4macro_rules! register_horizontal_concatenate_fxn {
5 ($name:ident) => {
6 register_fxn_descriptor!(
7 $name,
8 bool, "bool",
9 String, "string",
10 u8, "u8",
11 u16, "u16",
12 u32, "u32",
13 u64, "u64",
14 u128, "u128",
15 i8, "i8",
16 i16, "i16",
17 i32, "i32",
18 i64, "i64",
19 i128, "i128",
20 f32, "f32",
21 f64, "f64",
22 C64, "c64",
23 R64, "r64"
24 );
25 };
26}
27
28macro_rules! register_fxns {
29 ($op:ident) => {
30 $op!(bool, "bool");
31 $op!(String, "string");
32 $op!(u8, "u8");
33 $op!(u16, "u16");
34 $op!(u32, "u32");
35 $op!(u64, "u64");
36 $op!(u128, "u128");
37 $op!(i8, "i8");
38 $op!(i16, "i16");
39 $op!(i32, "i32");
40 $op!(i64, "i64");
41 $op!(i128, "i128");
42 $op!(f64, "f64");
43 $op!(f32, "f32");
44 $op!(R64, "r64");
45 $op!(C64, "c64");
46 }
47}
48
49macro_rules! horizontal_concatenate {
52 ($name:ident, $vec_size:expr) => {
53 paste!{
54 #[derive(Debug)]
55 struct $name<T> {
56 out: Ref<[<RowVector $vec_size>]<T>>,
57 }
58 impl<T> MechFunctionFactory for $name<T>
59 where
60 T: Debug + Clone + Sync + Send + PartialEq + 'static +
61 ConstElem + CompileConst + AsValueKind,
62 Ref<[<RowVector $vec_size>]<T>>: ToValue
63 {
64 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
65 match args {
66 FunctionArgs::Unary(out, _arg0) => {
67 let out: Ref<[<RowVector $vec_size>]<T>> = unsafe { out.as_unchecked() }.clone();
68 Ok(Box::new(Self { out }))
69 },
70 _ => Err(MechError2::new(
71 IncorrectNumberOfArguments { expected: 1, found: args.len() },
72 None
73 ).with_compiler_loc()
74 ),
75 }
76 }
77 }
78 impl<T> MechFunctionImpl for $name<T>
79 where
80 T: Debug + Clone + Sync + Send + PartialEq + 'static,
81 Ref<[<RowVector $vec_size>]<T>>: ToValue
82 {
83 fn solve(&self) {}
84 fn out(&self) -> Value { self.out.to_value() }
85 fn to_string(&self) -> String { format!("{:#?}", self) }
86 }
87
88 #[cfg(feature = "compiler")]
89 impl<T> MechFunctionCompiler for $name<T>
90 where
91 T: ConstElem + CompileConst + AsValueKind
92 {
93 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
94 let name = format!("{}<{}{}>", stringify!($name), T::as_value_kind(), stringify!([<RowVector $vec_size>]));
95 compile_nullop!(name, self.out, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
96 }
97 }
98 register_horizontal_concatenate_fxn!($name);
99 }
100 };
101}
102
103macro_rules! horzcat_two_args {
104 ($fxn:ident, $e0:ident, $e1:ident, $out:ident, $opt:ident) => {
105 #[derive(Debug)]
106 struct $fxn<T> {
107 e0: Ref<$e0<T>>,
108 e1: Ref<$e1<T>>,
109 out: Ref<$out<T>>,
110 }
111 impl<T> MechFunctionFactory for $fxn<T>
112 where
113 T: Debug + Clone + Sync + Send + PartialEq + 'static +
114 ConstElem + CompileConst + AsValueKind,
115 Ref<$out<T>>: ToValue
116 {
117 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
118 match args {
119 FunctionArgs::Binary(out, arg0, arg1) => {
120 let e0: Ref<$e0<T>> = unsafe { arg0.as_unchecked() }.clone();
121 let e1: Ref<$e1<T>> = unsafe { arg1.as_unchecked() }.clone();
122 let out: Ref<$out<T>> = unsafe { out.as_unchecked() }.clone();
123 Ok(Box::new(Self { e0, e1, out }))
124 },
125 _ => Err(MechError2::new(
126 IncorrectNumberOfArguments { expected: 2, found: args.len() },
127 None
128 ).with_compiler_loc()
129 ),
130 }
131 }
132 }
133 impl<T> MechFunctionImpl for $fxn<T>
134 where
135 T: Debug + Clone + Sync + Send + PartialEq + 'static,
136 Ref<$out<T>>: ToValue
137 {
138 fn solve(&self) {
139 unsafe {
140 let e0_ptr = (*(self.e0.as_ptr())).clone();
141 let e1_ptr = (*(self.e1.as_ptr())).clone();
142 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
143 $opt!(out_ptr, e0_ptr, e1_ptr);
144 }
145 }
146 fn out(&self) -> Value { self.out.to_value() }
147 fn to_string(&self) -> String { format!("{:#?}", self) }
148 }
149 #[cfg(feature = "compiler")]
150 impl<T> MechFunctionCompiler for $fxn<T>
151 where
152 T: ConstElem + CompileConst + AsValueKind,
153 {
154 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
155 let name = format!("{}<{}{}{}{}>", stringify!($fxn), T::as_value_kind(), stringify!($out), stringify!($e0), stringify!($e1));
156 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
157 }
158 }
159 register_horizontal_concatenate_fxn!($fxn);
160 };
161}
162
163macro_rules! horzcat_three_args {
164 ($fxn:ident, $e0:ident, $e1:ident, $e2:ident, $out:ident, $opt:ident) => {
165 #[derive(Debug)]
166 struct $fxn<T> {
167 e0: Ref<$e0<T>>,
168 e1: Ref<$e1<T>>,
169 e2: Ref<$e2<T>>,
170 out: Ref<$out<T>>,
171 }
172 impl<T> MechFunctionFactory for $fxn<T>
173 where
174 T: Debug + Clone + Sync + Send + PartialEq + 'static +
175 ConstElem + CompileConst + AsValueKind,
176 Ref<$out<T>>: ToValue
177 {
178 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
179 match args {
180 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
181 let e0: Ref<$e0<T>> = unsafe { arg0.as_unchecked() }.clone();
182 let e1: Ref<$e1<T>> = unsafe { arg1.as_unchecked() }.clone();
183 let e2: Ref<$e2<T>> = unsafe { arg2.as_unchecked() }.clone();
184 let out: Ref<$out<T>> = unsafe { out.as_unchecked() }.clone();
185 Ok(Box::new(Self { e0, e1, e2, out }))
186 },
187 _ => Err(MechError2::new(
188 IncorrectNumberOfArguments { expected: 3, found: args.len() },
189 None
190 ).with_compiler_loc()
191 )
192 }
193 }
194 }
195 impl<T> MechFunctionImpl for $fxn<T>
196 where
197 T: Debug + Clone + Sync + Send + PartialEq + 'static,
198 Ref<$out<T>>: ToValue
199 {
200 fn solve(&self) {
201 unsafe {
202 let e0_ptr = (*(self.e0.as_ptr())).clone();
203 let e1_ptr = (*(self.e1.as_ptr())).clone();
204 let e2_ptr = (*(self.e2.as_ptr())).clone();
205 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
206 $opt!(out_ptr,e0_ptr,e1_ptr,e2_ptr);
207 }
208 }
209 fn out(&self) -> Value { self.out.to_value() }
210 fn to_string(&self) -> String { format!("{:#?}", self) }
211 }
212 #[cfg(feature = "compiler")]
213 impl<T> MechFunctionCompiler for $fxn<T>
214 where
215 T: ConstElem + CompileConst + AsValueKind,
216 {
217 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
218 let name = format!("{}<{}{}{}{}{}>", stringify!($fxn), T::as_value_kind(), stringify!($out), stringify!($e0), stringify!($e1), stringify!($e2));
219 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
220 }
221 }
222 register_horizontal_concatenate_fxn!($fxn);
223 };}
224
225macro_rules! horzcat_four_args {
226 ($fxn:ident, $e0:ident, $e1:ident, $e2:ident, $e3:ident, $out:ident, $opt:ident) => {
227 #[derive(Debug)]
228 struct $fxn<T> {
229 e0: Ref<$e0<T>>,
230 e1: Ref<$e1<T>>,
231 e2: Ref<$e2<T>>,
232 e3: Ref<$e3<T>>,
233 out: Ref<$out<T>>,
234 }
235 impl<T> MechFunctionFactory for $fxn<T>
236 where
237 T: Debug + Clone + Sync + Send + PartialEq + 'static +
238 ConstElem + CompileConst + AsValueKind,
239 Ref<$out<T>>: ToValue
240 {
241 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
242 match args {
243 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
244 let e0: Ref<$e0<T>> = unsafe { arg0.as_unchecked() }.clone();
245 let e1: Ref<$e1<T>> = unsafe { arg1.as_unchecked() }.clone();
246 let e2: Ref<$e2<T>> = unsafe { arg2.as_unchecked() }.clone();
247 let e3: Ref<$e3<T>> = unsafe { arg3.as_unchecked() }.clone();
248 let out: Ref<$out<T>> = unsafe { out.as_unchecked() }.clone();
249 Ok(Box::new(Self { e0, e1, e2, e3, out }))
250 },
251 _ => Err(MechError2::new(
252 IncorrectNumberOfArguments { expected: 4, found: args.len() },
253 None
254 ).with_compiler_loc()
255 ),
256 }
257 }
258 }
259 impl<T> MechFunctionImpl for $fxn<T>
260 where
261 T: Debug + Clone + Sync + Send + PartialEq + 'static,
262 Ref<$out<T>>: ToValue
263 {
264 fn solve(&self) {
265 unsafe {
266 let e0_ptr = (*(self.e0.as_ptr())).clone();
267 let e1_ptr = (*(self.e1.as_ptr())).clone();
268 let e2_ptr = (*(self.e2.as_ptr())).clone();
269 let e3_ptr = (*(self.e3.as_ptr())).clone();
270 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
271 $opt!(out_ptr,e0_ptr,e1_ptr,e2_ptr,e3_ptr);
272 }
273 }
274 fn out(&self) -> Value { self.out.to_value() }
275 fn to_string(&self) -> String { format!("{:#?}", self) }
276 }
277 #[cfg(feature = "compiler")]
278 impl<T> MechFunctionCompiler for $fxn<T>
279 where
280 T: ConstElem + CompileConst + AsValueKind,
281 {
282 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
283 let name = format!("{}<{}{}{}{}{}{}>", stringify!($fxn), T::as_value_kind(), stringify!($out), stringify!($e0), stringify!($e1), stringify!($e2), stringify!($e3));
284 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
285 }
286 }
287 register_horizontal_concatenate_fxn!($fxn);
288 };}
289
290#[cfg(feature = "matrixd")]
293struct HorizontalConcatenateTwoArgs<T> {
294 e0: Box<dyn CopyMat<T>>,
295 e1: Box<dyn CopyMat<T>>,
296 out: Ref<DMatrix<T>>,
297}
298#[cfg(feature = "matrixd")]
299impl<T> MechFunctionFactory for HorizontalConcatenateTwoArgs<T>
300where
301 T: Debug + Clone + Sync + Send + PartialEq + 'static +
302 ConstElem + CompileConst + AsValueKind,
303 Ref<DMatrix<T>>: ToValue
304{
305 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
306 match args {
307 FunctionArgs::Binary(out, arg0, arg1) => {
308 let e0: Box<dyn CopyMat<T>> = unsafe { arg0.get_copyable_matrix_unchecked::<T>() };
309 let e1: Box<dyn CopyMat<T>> = unsafe { arg1.get_copyable_matrix_unchecked::<T>() };
310 let out: Ref<DMatrix<T>> = unsafe { out.as_unchecked() }.clone();
311 Ok(Box::new(Self { e0, e1, out }))
312 },
313 _ => Err(MechError2::new(
314 IncorrectNumberOfArguments { expected: 2, found: args.len() },
315 None
316 ).with_compiler_loc()
317 ),
318 }
319 }
320}
321#[cfg(feature = "matrixd")]
322impl<T> MechFunctionImpl for HorizontalConcatenateTwoArgs<T>
323where
324 T: Debug + Clone + Sync + Send + PartialEq + 'static,
325 Ref<DMatrix<T>>: ToValue
326{
327 fn solve(&self) {
328 let offset = self.e0.copy_into(&self.out, 0);
329 self.e1.copy_into(&self.out, offset);
330 }
331 fn out(&self) -> Value { self.out.to_value() }
332 fn to_string(&self) -> String { format!("HorizontalConcatenateTwoArgs\n{:#?}", self.out) }
333}
334#[cfg(feature = "matrixd")]
335#[cfg(feature = "compiler")]
336impl<T> MechFunctionCompiler for HorizontalConcatenateTwoArgs<T>
337where
338 T: ConstElem + CompileConst + AsValueKind,
339{
340 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
341 let mut registers = [0, 0, 0];
342
343 registers[0] = compile_register!(self.out, ctx);
344 registers[1] = compile_register_mat!(self.e0, ctx);
345 registers[2] = compile_register_mat!(self.e1, ctx);
346
347 ctx.features.insert(FeatureFlag::Builtin(FeatureKind::HorzCat));
348
349 ctx.emit_binop(
350 hash_str(&format!("HorizontalConcatenateTwoArgs<{}>", T::as_value_kind())),
351 registers[0],
352 registers[1],
353 registers[2],
354 );
355
356 Ok(registers[0])
357 }
358}
359#[cfg(feature = "matrixd")]
360register_horizontal_concatenate_fxn!(HorizontalConcatenateTwoArgs);
361
362#[cfg(feature = "matrixd")]
365struct HorizontalConcatenateThreeArgs<T> {
366 e0: Box<dyn CopyMat<T>>,
367 e1: Box<dyn CopyMat<T>>,
368 e2: Box<dyn CopyMat<T>>,
369 out: Ref<DMatrix<T>>,
370}
371#[cfg(feature = "matrixd")]
372impl<T> MechFunctionFactory for HorizontalConcatenateThreeArgs<T>
373where
374 T: Debug + Clone + Sync + Send + PartialEq + 'static +
375 ConstElem + CompileConst + AsValueKind,
376 Ref<DMatrix<T>>: ToValue
377{
378 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
379 match args {
380 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
381 let e0: Box<dyn CopyMat<T>> = unsafe { arg0.get_copyable_matrix_unchecked::<T>() };
382 let e1: Box<dyn CopyMat<T>> = unsafe { arg1.get_copyable_matrix_unchecked::<T>() };
383 let e2: Box<dyn CopyMat<T>> = unsafe { arg2.get_copyable_matrix_unchecked::<T>() };
384 let out: Ref<DMatrix<T>> = unsafe { out.as_unchecked() }.clone();
385 Ok(Box::new(Self { e0, e1, e2, out }))
386 },
387 _ => Err(MechError2::new(
388 IncorrectNumberOfArguments { expected: 3, found: args.len() },
389 None
390 ).with_compiler_loc()
391 ),
392 }
393 }
394}
395#[cfg(feature = "matrixd")]
396impl<T> MechFunctionImpl for HorizontalConcatenateThreeArgs<T>
397where
398 T: Debug + Clone + Sync + Send + PartialEq + 'static,
399 Ref<DMatrix<T>>: ToValue
400{
401 fn solve(&self) {
402 let mut offset = self.e0.copy_into(&self.out,0);
403 offset += self.e1.copy_into(&self.out,offset);
404 self.e2.copy_into(&self.out,offset);
405 }
406 fn out(&self) -> Value { self.out.to_value() }
407 fn to_string(&self) -> String { format!("HorizontalConcatenateThreeArgs\n{:#?}", self.out) }
408}
409#[cfg(feature = "matrixd")]
410#[cfg(feature = "compiler")]
411impl<T> MechFunctionCompiler for HorizontalConcatenateThreeArgs<T>
412where
413 T: ConstElem + CompileConst + AsValueKind,
414{
415 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
416 let mut registers = [0, 0, 0, 0];
417
418 registers[0] = compile_register!(self.out, ctx);
419 registers[1] = compile_register_mat!(self.e0, ctx);
420 registers[2] = compile_register_mat!(self.e1, ctx);
421 registers[3] = compile_register_mat!(self.e2, ctx);
422
423 ctx.features.insert(FeatureFlag::Builtin(FeatureKind::HorzCat));
424
425 ctx.emit_ternop(
426 hash_str(&format!("HorizontalConcatenateThreeArgs<{}>", T::as_value_kind())),
427 registers[0],
428 registers[1],
429 registers[2],
430 registers[3],
431 );
432 Ok(registers[0])
433 }
434}
435#[cfg(feature = "matrixd")]
436register_horizontal_concatenate_fxn!(HorizontalConcatenateThreeArgs);
437
438#[cfg(feature = "matrixd")]
441struct HorizontalConcatenateFourArgs<T> {
442 e0: Box<dyn CopyMat<T>>,
443 e1: Box<dyn CopyMat<T>>,
444 e2: Box<dyn CopyMat<T>>,
445 e3: Box<dyn CopyMat<T>>,
446 out: Ref<DMatrix<T>>,
447}
448#[cfg(feature = "matrixd")]
449impl<T> MechFunctionFactory for HorizontalConcatenateFourArgs<T>
450where
451 T: Debug + Clone + Sync + Send + PartialEq + 'static +
452 ConstElem + CompileConst + AsValueKind,
453 Ref<DMatrix<T>>: ToValue
454{
455 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
456 match args {
457 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
458 let e0: Box<dyn CopyMat<T>> = unsafe { arg0.get_copyable_matrix_unchecked::<T>() };
459 let e1: Box<dyn CopyMat<T>> = unsafe { arg1.get_copyable_matrix_unchecked::<T>() };
460 let e2: Box<dyn CopyMat<T>> = unsafe { arg2.get_copyable_matrix_unchecked::<T>() };
461 let e3: Box<dyn CopyMat<T>> = unsafe { arg3.get_copyable_matrix_unchecked::<T>() };
462 let out: Ref<DMatrix<T>> = unsafe { out.as_unchecked() }.clone();
463 Ok(Box::new(Self { e0, e1, e2, e3, out }))
464 },
465 _ => Err(MechError2::new(
466 IncorrectNumberOfArguments { expected: 4, found: args.len() },
467 None
468 ).with_compiler_loc()
469 ),
470 }
471 }
472}
473#[cfg(feature = "matrixd")]
474impl<T> MechFunctionImpl for HorizontalConcatenateFourArgs<T>
475where
476 T: Debug + Clone + Sync + Send + PartialEq + 'static,
477 Ref<DMatrix<T>>: ToValue,
478{
479 fn solve(&self) {
480 let mut offset = self.e0.copy_into(&self.out, 0);
481 offset += self.e1.copy_into(&self.out, offset);
482 offset += self.e2.copy_into(&self.out, offset);
483 self.e3.copy_into(&self.out, offset);
484 }
485 fn out(&self) -> Value { self.out.to_value() }
486 fn to_string(&self) -> String { format!("HorizontalConcatenateFourArgs\n{:#?}", self.out) }
487}
488#[cfg(feature = "matrixd")]
489#[cfg(feature = "compiler")]
490impl<T> MechFunctionCompiler for HorizontalConcatenateFourArgs<T>
491where
492 T: ConstElem + CompileConst + AsValueKind,
493{
494 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
495 let mut registers = [0, 0, 0];
496
497 registers[0] = compile_register!(self.out, ctx);
498
499 let e0_addr = self.e0.addr();
500 let e0_reg = ctx.alloc_register_for_ptr(e0_addr);
501 let e0_const_id = self.e0.compile_const_mat(ctx).unwrap();
502 ctx.emit_const_load(e0_reg, e0_const_id);
503 registers[1] = e0_reg;
504
505 let e1_addr = self.e1.addr();
506 let e1_reg = ctx.alloc_register_for_ptr(e1_addr);
507 let e1_const_id = self.e1.compile_const_mat(ctx).unwrap();
508 ctx.emit_const_load(e1_reg, e1_const_id);
509 registers[2] = e1_reg;
510
511 let e2_addr = self.e2.addr();
512 let e2_reg = ctx.alloc_register_for_ptr(e2_addr);
513 let e2_const_id = self.e2.compile_const_mat(ctx).unwrap();
514 ctx.emit_const_load(e2_reg, e2_const_id);
515 let mut registers = [registers[0], registers[1], registers[2], e2_reg];
516
517 let e3_addr = self.e3.addr();
518 let e3_reg = ctx.alloc_register_for_ptr(e3_addr);
519 let e3_const_id = self.e3.compile_const_mat(ctx).unwrap();
520 ctx.emit_const_load(e3_reg, e3_const_id);
521 let mut registers = [registers[0], registers[1], registers[2], registers[3], e3_reg];
522
523 ctx.features.insert(FeatureFlag::Builtin(FeatureKind::HorzCat));
524
525 ctx.emit_quadop(
526 hash_str(&format!("HorizontalConcatenateFourArgs<{}>", T::as_value_kind())),
527 registers[0],
528 registers[1],
529 registers[2],
530 registers[3],
531 registers[4],
532 );
533 Ok(registers[0])
534 }
535}
536
537#[cfg(feature = "matrixd")]
540struct HorizontalConcatenateNArgs<T> {
541 e0: Vec<Box<dyn CopyMat<T>>>,
542 out: Ref<DMatrix<T>>,
543}
544#[cfg(feature = "matrixd")]
545impl<T> MechFunctionFactory for HorizontalConcatenateNArgs<T>
546where
547 T: Debug + Clone + Sync + Send + PartialEq + 'static +
548 ConstElem + CompileConst + AsValueKind,
549 Ref<DMatrix<T>>: ToValue
550{
551 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
552 match args {
553 FunctionArgs::Variadic(out, vargs) => {
554 let mut e0: Vec<Box<dyn CopyMat<T>>> = Vec::new();
555 for arg in vargs {
556 let mat: Box<dyn CopyMat<T>> = unsafe { arg.get_copyable_matrix_unchecked::<T>() };
557 e0.push(mat);
558 }
559 let out: Ref<DMatrix<T>> = unsafe { out.as_unchecked() }.clone();
560 Ok(Box::new(Self { e0, out }))
561 },
562 _ => Err(MechError2::new(
563 IncorrectNumberOfArguments { expected: 0, found: args.len() },
564 None
565 ).with_compiler_loc()
566 ),
567 }
568 }
569}
570#[cfg(feature = "matrixd")]
571impl<T> MechFunctionImpl for HorizontalConcatenateNArgs<T>
572where
573 T: Debug + Clone + Sync + Send + PartialEq + 'static,
574 Ref<DMatrix<T>>: ToValue,
575{
576 fn solve(&self) {
577 let mut offset = 0;
578 for e in &self.e0 {
579 offset += e.copy_into(&self.out, offset);
580 }
581 }
582 fn out(&self) -> Value { self.out.to_value() }
583 fn to_string(&self) -> String { format!("HorizontalConcatenateNArgs\n{:#?}", self.out) }
584}
585#[cfg(feature = "matrixd")]
586#[cfg(feature = "compiler")]
587impl<T> MechFunctionCompiler for HorizontalConcatenateNArgs<T>
588where
589 T: ConstElem + CompileConst + AsValueKind,
590{
591 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
592 let mut registers = [0, 0];
593 registers[0] = compile_register!(self.out, ctx);
594
595 let mut mat_regs = Vec::new();
596 for e in &self.e0 {
597 let e_addr = e.addr();
598 let e_reg = ctx.alloc_register_for_ptr(e_addr);
599 let e_const_id = e.compile_const_mat(ctx).unwrap();
600 ctx.emit_const_load(e_reg, e_const_id);
601 mat_regs.push(e_reg);
602 }
603 ctx.features.insert(FeatureFlag::Builtin(FeatureKind::HorzCat));
604 ctx.emit_varop(
605 hash_str("HorizontalConcatenateNArgs"),
606 registers[0],
607 mat_regs,
608 );
609 Ok(registers[0])
610 }
611}
612
613#[cfg(feature = "row_vectord")]
616#[derive(Debug)]
617struct HorizontalConcatenateRD<T> {
618 out: Ref<RowDVector<T>>,
619}
620#[cfg(feature = "row_vectord")]
621impl<T> MechFunctionFactory for HorizontalConcatenateRD<T>
622where
623 T: Debug + Clone + Sync + Send + PartialEq + 'static +
624 ConstElem + CompileConst + AsValueKind,
625 Ref<RowDVector<T>>: ToValue
626{
627 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
628 match args {
629 FunctionArgs::Unary(out, _arg0) => {
630 let out: Ref<RowDVector<T>> = unsafe { out.as_unchecked() }.clone();
631 Ok(Box::new(Self { out }))
632 },
633 _ => Err(MechError2::new(
634 IncorrectNumberOfArguments { expected: 1, found: args.len() },
635 None
636 ).with_compiler_loc()
637 ),
638 }
639 }
640}
641#[cfg(feature = "row_vectord")]
642impl<T> MechFunctionImpl for HorizontalConcatenateRD<T>
643where
644 T: Debug + Clone + Sync + Send + PartialEq + 'static,
645 Ref<RowDVector<T>>: ToValue
646{
647 fn solve(&self) {}
648 fn out(&self) -> Value { self.out.to_value() }
649 fn to_string(&self) -> String { format!("{:#?}", self) }
650}
651#[cfg(feature = "row_vectord")]
652#[cfg(feature = "compiler")]
653impl<T> MechFunctionCompiler for HorizontalConcatenateRD<T>
654where
655 T: ConstElem + CompileConst + AsValueKind
656{
657 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
658 let name = format!("HorizontalConcatenateRD<{}>", T::as_value_kind());
659 compile_nullop!(name, self.out, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
660 }
661}
662#[cfg(feature = "row_vectord")]
663register_horizontal_concatenate_fxn!(HorizontalConcatenateRD);
664
665#[cfg(feature = "row_vectord")]
668struct HorizontalConcatenateRDN<T> {
669 scalar: Vec<(Ref<T>,usize)>,
670 matrix: Vec<(Box<dyn CopyMat<T>>,usize)>,
671 out: Ref<RowDVector<T>>,
672}
673#[cfg(feature = "row_vectord")]
674impl<T> MechFunctionFactory for HorizontalConcatenateRDN<T>
675where
676 T: Debug + Clone + Sync + Send + PartialEq + 'static +
677 ConstElem + CompileConst + AsValueKind,
678 Ref<RowDVector<T>>: ToValue
679{
680 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
681 match args {
682 FunctionArgs::Variadic(out, vargs) => {
683 let mut scalar: Vec<(Ref<T>,usize)> = Vec::new();
684 let mut matrix: Vec<(Box<dyn CopyMat<T>>,usize)> = Vec::new();
685 for (i, arg) in vargs.into_iter().enumerate() {
686 let kind = arg.kind();
687 if arg.is_scalar() {
688 let scalar_ref = unsafe { arg.as_unchecked::<T>() };
689 scalar.push((scalar_ref.clone(), i));
690 } else {
691 let mat_ref: Box<dyn CopyMat<T>> = unsafe { arg.get_copyable_matrix_unchecked::<T>() };
692 matrix.push((mat_ref, i));
693 }
694 }
695 let out: Ref<RowDVector<T>> = unsafe { out.as_unchecked() }.clone();
696 Ok(Box::new(Self { scalar, matrix, out }))
697 },
698 _ => Err(MechError2::new(
699 IncorrectNumberOfArguments { expected: 1, found: args.len() },
700 None
701 ).with_compiler_loc()
702 ),
703 }
704 }
705}
706#[cfg(feature = "row_vectord")]
707impl<T> MechFunctionImpl for HorizontalConcatenateRDN<T>
708where
709 T: Debug + Clone + Sync + Send + PartialEq + 'static,
710 Ref<RowDVector<T>>: ToValue
711{
712 fn solve(&self) {
713 unsafe {
714 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
715 for (e, i) in &self.matrix {
716 let _ = e.copy_into_r(&self.out, *i);
717 }
718 for (e, i) in &self.scalar {
719 out_ptr[*i] = e.borrow().clone();
720 }
721 }
722 }
723 fn out(&self) -> Value { self.out.to_value() }
724 fn to_string(&self) -> String { format!("HorizontalConcatenateRDN\n{:#?}", self.out) }
725}
726#[cfg(feature = "row_vectord")]
727#[cfg(feature = "compiler")]
728impl<T> MechFunctionCompiler for HorizontalConcatenateRDN<T>
729where
730 T: CompileConst + ConstElem + AsValueKind
731{
732 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
733 let mut registers = [0, 0];
734
735 registers[0] = compile_register!(self.out, ctx);
736
737 let mut mat_regs = Vec::new();
738 for (e, _) in &self.matrix {
739 let e_addr = e.addr();
740 let e_reg = ctx.alloc_register_for_ptr(e_addr);
741 let e_const_id = e.compile_const_mat(ctx).unwrap();
742 ctx.emit_const_load(e_reg, e_const_id);
743 mat_regs.push(e_reg);
744 }
745 let mut scalar_regs = Vec::new();
746 for (e, _) in &self.scalar {
747 let e_reg = compile_register_brrw!(e, ctx);
748 scalar_regs.push(e_reg);
749 }
750 let mut all_regs = vec![];
751 all_regs.push(registers[0]);
752 all_regs.extend(mat_regs);
753 all_regs.extend(scalar_regs);
754
755 ctx.features.insert(FeatureFlag::Builtin(FeatureKind::HorzCat));
756
757 ctx.emit_varop(
758 hash_str(&format!("HorizontalConcatenateRDN<{}>", T::as_value_kind())),
759 registers[0],
760 all_regs[1..].to_vec(),
761 );
762
763 Ok(registers[0])
764 }
765}
766#[cfg(feature = "row_vectord")]
767register_horizontal_concatenate_fxn!(HorizontalConcatenateRDN);
768
769#[cfg(feature = "matrixd")]
772#[derive(Debug)]
773struct HorizontalConcatenateS1D<T> {
774 arg: Ref<T>,
775 out: Ref<DMatrix<T>>,
776}
777#[cfg(feature = "matrixd")]
778impl<T> MechFunctionFactory for HorizontalConcatenateS1D<T>
779where
780 T: Debug + Clone + Sync + Send + PartialEq + 'static +
781 ConstElem + CompileConst + AsValueKind,
782 Ref<DMatrix<T>>: ToValue
783{
784 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
785 match args {
786 FunctionArgs::Unary(out, arg0) => {
787 let arg: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
788 let out: Ref<DMatrix<T>> = unsafe { out.as_unchecked() }.clone();
789 Ok(Box::new(Self { arg, out }))
790 },
791 _ => Err(MechError2::new(
792 IncorrectNumberOfArguments { expected: 1, found: args.len() },
793 None
794 ).with_compiler_loc()
795 ),
796 }
797 }
798}
799#[cfg(feature = "matrixd")]
800impl<T> MechFunctionImpl for HorizontalConcatenateS1D<T>
801where
802 T: Debug + Clone + Sync + Send + PartialEq + 'static,
803 Ref<DMatrix<T>>: ToValue
804{
805 fn solve(&self) {
806 unsafe {
807 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
808 out_ptr[0] = self.arg.borrow().clone();
809 }
810 }
811 fn out(&self) -> Value { self.out.to_value() }
812 fn to_string(&self) -> String { format!("{:#?}", self) }
813}
814#[cfg(feature = "matrixd")]
815#[cfg(feature = "compiler")]
816impl<T> MechFunctionCompiler for HorizontalConcatenateS1D<T>
817where
818 T: ConstElem + CompileConst + AsValueKind
819{
820 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
821 let name = format!("HorizontalConcatenateS1D<{}>", T::as_value_kind());
822 compile_unop!(name, self.out, self.arg, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
823 }
824}
825#[cfg(feature = "matrixd")]
826register_horizontal_concatenate_fxn!(HorizontalConcatenateS1D);
827
828#[cfg(feature = "matrix1")]
831#[derive(Debug)]
832struct HorizontalConcatenateS1<T> {
833 arg: Ref<T>,
834 out: Ref<Matrix1<T>>,
835}
836#[cfg(feature = "matrix1")]
837impl<T> MechFunctionFactory for HorizontalConcatenateS1<T>
838where
839 T: Debug + Clone + Sync + Send + PartialEq + 'static +
840 ConstElem + CompileConst + AsValueKind,
841 Ref<Matrix1<T>>: ToValue
842{
843 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
844 match args {
845 FunctionArgs::Unary(out, arg0) => {
846 let arg: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
847 let out: Ref<Matrix1<T>> = unsafe { out.as_unchecked() }.clone();
848 Ok(Box::new(Self { arg, out }))
849 },
850 _ => Err(MechError2::new(
851 IncorrectNumberOfArguments { expected: 1, found: args.len() },
852 None
853 ).with_compiler_loc()
854 ),
855 }
856 }
857}
858#[cfg(feature = "matrix1")]
859impl<T> MechFunctionImpl for HorizontalConcatenateS1<T>
860where
861 T: Debug + Clone + Sync + Send + PartialEq + 'static,
862 Ref<Matrix1<T>>: ToValue
863{
864 fn solve(&self) {
865 unsafe {
866 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
867 out_ptr[0] = self.arg.borrow().clone();
868 }
869 }
870 fn out(&self) -> Value { self.out.to_value() }
871 fn to_string(&self) -> String { format!("{:#?}", self) }
872}
873#[cfg(feature = "matrix1")]
874#[cfg(feature = "compiler")]
875impl<T> MechFunctionCompiler for HorizontalConcatenateS1<T>
876where
877 T: ConstElem + CompileConst + AsValueKind
878{
879 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
880 let name = format!("HorizontalConcatenateS1<{}>", T::as_value_kind());
881 compile_unop!(name, self.out, self.arg, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
882 }
883}
884#[cfg(feature = "matrix1")]
885register_horizontal_concatenate_fxn!(HorizontalConcatenateS1);
886
887#[cfg(feature = "row_vector2")]
890#[derive(Debug)]
891struct HorizontalConcatenateS2<T> {
892 e0: Ref<T>,
893 e1: Ref<T>,
894 out: Ref<RowVector2<T>>,
895}
896#[cfg(feature = "row_vector2")]
897impl<T> MechFunctionFactory for HorizontalConcatenateS2<T>
898where
899 T: Debug + Clone + Sync + Send + PartialEq + 'static +
900 ConstElem + CompileConst + AsValueKind,
901 Ref<RowVector2<T>>: ToValue
902{
903 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
904 match args {
905 FunctionArgs::Binary(out, arg0, arg1) => {
906 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
907 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
908 let out: Ref<RowVector2<T>> = unsafe { out.as_unchecked() }.clone();
909 Ok(Box::new(Self { e0, e1, out }))
910 },
911 _ => Err(MechError2::new(
912 IncorrectNumberOfArguments { expected: 2, found: args.len() },
913 None
914 ).with_compiler_loc()
915 ),
916 }
917 }
918}
919#[cfg(feature = "row_vector2")]
920impl<T> MechFunctionImpl for HorizontalConcatenateS2<T>
921where
922 T: Debug + Clone + Sync + Send + PartialEq + 'static,
923 Ref<RowVector2<T>>: ToValue
924{
925 fn solve(&self) {
926 unsafe {
927 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
928 out_ptr[0] = self.e0.borrow().clone();
929 out_ptr[1] = self.e1.borrow().clone();
930 }
931 }
932 fn out(&self) -> Value { self.out.to_value() }
933 fn to_string(&self) -> String { format!("{:#?}", self) }
934}
935#[cfg(feature = "row_vector2")]
936#[cfg(feature = "compiler")]
937impl<T> MechFunctionCompiler for HorizontalConcatenateS2<T>
938where
939 T: ConstElem + CompileConst + AsValueKind
940{
941 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
942 let name = format!("HorizontalConcatenateS2<{}>", T::as_value_kind());
943 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
944 }
945}
946#[cfg(feature = "row_vector2")]
947register_horizontal_concatenate_fxn!(HorizontalConcatenateS2);
948
949#[cfg(feature = "row_vector3")]
952#[derive(Debug)]
953struct HorizontalConcatenateS3<T> {
954 e0: Ref<T>,
955 e1: Ref<T>,
956 e2: Ref<T>,
957 out: Ref<RowVector3<T>>,
958}
959#[cfg(feature = "row_vector3")]
960impl<T> MechFunctionFactory for HorizontalConcatenateS3<T>
961where
962 T: Debug + Clone + Sync + Send + PartialEq + 'static +
963 ConstElem + CompileConst + AsValueKind,
964 Ref<RowVector3<T>>: ToValue
965{
966 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
967 match args {
968 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
969 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
970 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
971 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
972 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
973 Ok(Box::new(Self { e0, e1, e2, out }))
974 },
975 _ => Err(MechError2::new(
976 IncorrectNumberOfArguments { expected: 3, found: args.len() },
977 None
978 ).with_compiler_loc()
979 ),
980 }
981 }
982}
983#[cfg(feature = "row_vector3")]
984impl<T> MechFunctionImpl for HorizontalConcatenateS3<T>
985where
986 T: Debug + Clone + Sync + Send + PartialEq + 'static,
987 Ref<RowVector3<T>>: ToValue
988{
989 fn solve(&self) {
990 unsafe {
991 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
992 out_ptr[0] = self.e0.borrow().clone();
993 out_ptr[1] = self.e1.borrow().clone();
994 out_ptr[2] = self.e2.borrow().clone();
995 }
996 }
997 fn out(&self) -> Value { self.out.to_value() }
998 fn to_string(&self) -> String { format!("{:#?}", self) }
999}
1000#[cfg(feature = "row_vector3")]
1001#[cfg(feature = "compiler")]
1002impl<T> MechFunctionCompiler for HorizontalConcatenateS3<T>
1003where
1004 T: ConstElem + CompileConst + AsValueKind
1005{
1006 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1007 let name = format!("HorizontalConcatenateS3<{}>", T::as_value_kind());
1008 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1009 }
1010}
1011#[cfg(feature = "row_vector3")]
1012register_horizontal_concatenate_fxn!(HorizontalConcatenateS3);
1013
1014#[cfg(feature = "row_vector4")]
1017#[derive(Debug)]
1018struct HorizontalConcatenateS4<T> {
1019 e0: Ref<T>,
1020 e1: Ref<T>,
1021 e2: Ref<T>,
1022 e3: Ref<T>,
1023 out: Ref<RowVector4<T>>,
1024}
1025#[cfg(feature = "row_vector4")]
1026impl<T> MechFunctionFactory for HorizontalConcatenateS4<T>
1027where
1028 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1029 ConstElem + CompileConst + AsValueKind,
1030 Ref<RowVector4<T>>: ToValue
1031{
1032 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1033 match args {
1034 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
1035 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1036 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1037 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
1038 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
1039 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1040 Ok(Box::new(Self { e0, e1, e2, e3, out }))
1041 },
1042 _ => Err(MechError2::new(
1043 IncorrectNumberOfArguments { expected: 4, found: args.len() },
1044 None
1045 ).with_compiler_loc()
1046 ),
1047 }
1048 }
1049}
1050#[cfg(feature = "row_vector4")]
1051impl<T> MechFunctionImpl for HorizontalConcatenateS4<T>
1052where
1053 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1054 Ref<RowVector4<T>>: ToValue
1055{
1056 fn solve(&self) {
1057 unsafe {
1058 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1059 out_ptr[0] = self.e0.borrow().clone();
1060 out_ptr[1] = self.e1.borrow().clone();
1061 out_ptr[2] = self.e2.borrow().clone();
1062 out_ptr[3] = self.e3.borrow().clone();
1063 }
1064 }
1065 fn out(&self) -> Value { self.out.to_value() }
1066 fn to_string(&self) -> String { format!("{:#?}", self) }
1067}
1068#[cfg(feature = "row_vector4")]
1069#[cfg(feature = "compiler")]
1070impl<T> MechFunctionCompiler for HorizontalConcatenateS4<T>
1071where
1072 T: ConstElem + CompileConst + AsValueKind
1073{
1074 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1075 let name = format!("HorizontalConcatenateS4<{}>", T::as_value_kind());
1076 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1077 }
1078}
1079#[cfg(feature = "row_vector4")]
1080register_horizontal_concatenate_fxn!(HorizontalConcatenateS4);
1081
1082#[cfg(feature = "row_vector2")]
1085horizontal_concatenate!(HorizontalConcatenateR2,2);
1086
1087#[cfg(feature = "row_vector3")]
1090horizontal_concatenate!(HorizontalConcatenateR3,3);
1091
1092#[cfg(feature = "row_vector4")]
1095horizontal_concatenate!(HorizontalConcatenateR4,4);
1096
1097#[cfg(feature = "row_vectord")]
1100#[derive(Debug)]
1101struct HorizontalConcatenateSD<T> {
1102 out: Ref<RowDVector<T>>,
1103}
1104#[cfg(feature = "row_vectord")]
1105impl<T> MechFunctionFactory for HorizontalConcatenateSD<T>
1106where
1107 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1108 ConstElem + CompileConst + AsValueKind,
1109 Ref<RowDVector<T>>: ToValue
1110{
1111 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1112 match args {
1113 FunctionArgs::Unary(out, _arg0) => {
1114 let out: Ref<RowDVector<T>> = unsafe { out.as_unchecked() }.clone();
1115 Ok(Box::new(Self { out }))
1116 },
1117 _ => Err(MechError2::new(
1118 IncorrectNumberOfArguments { expected: 1, found: args.len() },
1119 None
1120 ).with_compiler_loc()
1121 ),
1122 }
1123 }
1124}
1125#[cfg(feature = "row_vectord")]
1126impl<T> MechFunctionImpl for HorizontalConcatenateSD<T>
1127where
1128 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1129 Ref<RowDVector<T>>: ToValue
1130{
1131 fn solve(&self) { }
1132 fn out(&self) -> Value { self.out.to_value() }
1133 fn to_string(&self) -> String { format!("{:#?}", self) }
1134}
1135#[cfg(feature = "row_vectord")]
1136#[cfg(feature = "compiler")]
1137impl<T> MechFunctionCompiler for HorizontalConcatenateSD<T>
1138where
1139 T: ConstElem + CompileConst + AsValueKind
1140{
1141 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1142 let name = format!("HorizontalConcatenateSD<{}>", T::as_value_kind());
1143 compile_nullop!(name, self.out, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1144 }
1145}
1146#[cfg(feature = "row_vectord")]
1147register_horizontal_concatenate_fxn!(HorizontalConcatenateSD);
1148
1149macro_rules! horzcat_single {
1152 ($name:ident,$shape:ident) => {
1153 #[derive(Debug)]
1154 struct $name<T> {
1155 out: Ref<$shape<T>>,
1156 }
1157 impl<T> MechFunctionFactory for $name<T>
1158 where
1159 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1160 ConstElem + CompileConst + AsValueKind,
1161 Ref<$shape<T>>: ToValue
1162 {
1163 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1164 match args {
1165 FunctionArgs::Unary(out, _arg0) => {
1166 let out: Ref<$shape<T>> = unsafe { out.as_unchecked() }.clone();
1167 Ok(Box::new(Self { out }))
1168 },
1169 _ => Err(MechError2::new(
1170 IncorrectNumberOfArguments { expected: 1, found: args.len() },
1171 None
1172 ).with_compiler_loc()
1173 ),
1174 }
1175 }
1176 }
1177 impl<T> MechFunctionImpl for $name<T>
1178 where
1179 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1180 Ref<$shape<T>>: ToValue
1181 {
1182 fn solve(&self) { }
1183 fn out(&self) -> Value { self.out.to_value() }
1184 fn to_string(&self) -> String { format!("{:#?}", self) }
1185 }
1186 #[cfg(feature = "compiler")]
1187 impl<T> MechFunctionCompiler for $name<T>
1188 where
1189 T: ConstElem + CompileConst + AsValueKind
1190 {
1191 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1192 let name = format!("{}<{}>", stringify!($name), T::as_value_kind());
1193 compile_nullop!(name, self.out, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1194 }
1195 }
1196 register_horizontal_concatenate_fxn!($name);
1197 }
1198}
1199
1200#[cfg(feature = "matrix1")]
1201horzcat_single!(HorizontalConcatenateM1,Matrix1);
1202#[cfg(feature = "matrix2")]
1203horzcat_single!(HorizontalConcatenateM2,Matrix2);
1204#[cfg(feature = "matrix3")]
1205horzcat_single!(HorizontalConcatenateM3,Matrix3);
1206#[cfg(feature = "matrix4")]
1207horzcat_single!(HorizontalConcatenateM4,Matrix4);
1208#[cfg(feature = "matrix2x3")]
1209horzcat_single!(HorizontalConcatenateM2x3,Matrix2x3);
1210#[cfg(feature = "matrix3x2")]
1211horzcat_single!(HorizontalConcatenateM3x2,Matrix3x2);
1212#[cfg(feature = "matrixd")]
1213horzcat_single!(HorizontalConcatenateMD,DMatrix);
1214#[cfg(feature = "vector2")]
1215horzcat_single!(HorizontalConcatenateV2,Vector2);
1216#[cfg(feature = "vector3")]
1217horzcat_single!(HorizontalConcatenateV3,Vector3);
1218#[cfg(feature = "vector4")]
1219horzcat_single!(HorizontalConcatenateV4,Vector4);
1220#[cfg(feature = "vectord")]
1221horzcat_single!(HorizontalConcatenateVD,DVector);
1222
1223#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1226#[derive(Debug)]
1227struct HorizontalConcatenateSR2<T> {
1228 e0: Ref<T>,
1229 e1: Ref<RowVector2<T>>,
1230 out: Ref<RowVector3<T>>,
1231}
1232#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1233impl<T> MechFunctionFactory for HorizontalConcatenateSR2<T>
1234where
1235 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1236 ConstElem + CompileConst + AsValueKind,
1237 Ref<RowVector3<T>>: ToValue
1238{
1239 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1240 match args {
1241 FunctionArgs::Binary(out, arg0, arg1) => {
1242 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1243 let e1: Ref<RowVector2<T>> = unsafe { arg1.as_unchecked() }.clone();
1244 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
1245 Ok(Box::new(Self { e0, e1, out }))
1246 },
1247 _ => Err(MechError2::new(
1248 IncorrectNumberOfArguments { expected: 2, found: args.len() },
1249 None
1250 ).with_compiler_loc()
1251 ),
1252 }
1253 }
1254}
1255#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1256impl<T> MechFunctionImpl for HorizontalConcatenateSR2<T>
1257where
1258 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1259 Ref<RowVector3<T>>: ToValue
1260{
1261 fn solve(&self) {
1262 unsafe {
1263 let e0_ptr = (*(self.e0.as_ptr())).clone();
1264 let e1_ptr = (*(self.e1.as_ptr())).clone();
1265 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1266 out_ptr[0] = e0_ptr.clone();
1267 out_ptr[1] = e1_ptr[0].clone();
1268 out_ptr[2] = e1_ptr[1].clone();
1269 }
1270 }
1271 fn out(&self) -> Value { self.out.to_value() }
1272 fn to_string(&self) -> String { format!("{:#?}", self) }
1273}
1274#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1275#[cfg(feature = "compiler")]
1276impl<T> MechFunctionCompiler for HorizontalConcatenateSR2<T>
1277where
1278 T: ConstElem + CompileConst + AsValueKind
1279{
1280 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1281 let name = format!("HorizontalConcatenateSR2<{}>", T::as_value_kind());
1282 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1283 }
1284}
1285#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1286register_horizontal_concatenate_fxn!(HorizontalConcatenateSR2);
1287
1288#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1291#[derive(Debug)]
1292struct HorizontalConcatenateR2S<T> {
1293 e0: Ref<RowVector2<T>>,
1294 e1: Ref<T>,
1295 out: Ref<RowVector3<T>>,
1296}
1297#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1298impl<T> MechFunctionFactory for HorizontalConcatenateR2S<T>
1299where
1300 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1301 ConstElem + CompileConst + AsValueKind,
1302 Ref<RowVector3<T>>: ToValue
1303{
1304 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1305 match args {
1306 FunctionArgs::Binary(out, arg0, arg1) => {
1307 let e0: Ref<RowVector2<T>> = unsafe { arg0.as_unchecked() }.clone();
1308 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1309 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
1310 Ok(Box::new(Self { e0, e1, out }))
1311 },
1312 _ => Err(MechError2::new(
1313 IncorrectNumberOfArguments { expected: 2, found: args.len() },
1314 None
1315 ).with_compiler_loc()
1316 ),
1317 }
1318 }
1319}
1320#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1321impl<T> MechFunctionImpl for HorizontalConcatenateR2S<T>
1322where
1323 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1324 Ref<RowVector3<T>>: ToValue
1325{
1326 fn solve(&self) {
1327 unsafe {
1328 let e0_ptr = (*(self.e0.as_ptr())).clone();
1329 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1330 out_ptr[0] = e0_ptr[0].clone();
1331 out_ptr[1] = e0_ptr[1].clone();
1332 out_ptr[2] = self.e1.borrow().clone();
1333 }
1334 }
1335 fn out(&self) -> Value { self.out.to_value() }
1336 fn to_string(&self) -> String { format!("{:#?}", self) }
1337}
1338#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1339#[cfg(feature = "compiler")]
1340impl<T> MechFunctionCompiler for HorizontalConcatenateR2S<T>
1341where
1342 T: ConstElem + CompileConst + AsValueKind
1343{
1344 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1345 let name = format!("HorizontalConcatenateR2S<{}>", T::as_value_kind());
1346 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1347 }
1348}
1349#[cfg(all(feature = "row_vector2", feature = "row_vector3"))]
1350register_horizontal_concatenate_fxn!(HorizontalConcatenateR2S);
1351#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1354#[derive(Debug)]
1355struct HorizontalConcatenateSM1<T> {
1356 e0: Ref<T>,
1357 e1: Ref<Matrix1<T>>,
1358 out: Ref<RowVector2<T>>,
1359}
1360#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1361impl<T> MechFunctionFactory for HorizontalConcatenateSM1<T>
1362where
1363 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1364 ConstElem + CompileConst + AsValueKind,
1365 Ref<RowVector2<T>>: ToValue
1366{
1367 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1368 match args {
1369 FunctionArgs::Binary(out, arg0, arg1) => {
1370 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1371 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
1372 let out: Ref<RowVector2<T>> = unsafe { out.as_unchecked() }.clone();
1373 Ok(Box::new(Self { e0, e1, out }))
1374 },
1375 _ => Err(MechError2::new(
1376 IncorrectNumberOfArguments { expected: 2, found: args.len() },
1377 None
1378 ).with_compiler_loc()
1379 ),
1380 }
1381 }
1382}
1383#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1384impl<T> MechFunctionImpl for HorizontalConcatenateSM1<T>
1385where
1386 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1387 Ref<RowVector2<T>>: ToValue
1388{
1389 fn solve(&self) {
1390 unsafe {
1391 let e0_val = self.e0.borrow().clone();
1392 let e1_ptr = (*(self.e1.as_ptr())).clone();
1393 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1394 out_ptr[0] = e0_val;
1395 out_ptr[1] = e1_ptr[0].clone();
1396 }
1397 }
1398 fn out(&self) -> Value { self.out.to_value() }
1399 fn to_string(&self) -> String { format!("{:#?}", self) }
1400}
1401#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1402#[cfg(feature = "compiler")]
1403impl<T> MechFunctionCompiler for HorizontalConcatenateSM1<T>
1404where
1405 T: ConstElem + CompileConst + AsValueKind
1406{
1407 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1408 let name = format!("HorizontalConcatenateSM1<{}>", T::as_value_kind());
1409 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1410 }
1411}
1412#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1413register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1);
1414
1415#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1418#[derive(Debug)]
1419struct HorizontalConcatenateM1S<T> {
1420 e0: Ref<Matrix1<T>>, e1: Ref<T>, out: Ref<RowVector2<T>>,
1423}
1424#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1425impl<T> MechFunctionFactory for HorizontalConcatenateM1S<T>
1426where
1427 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1428 ConstElem + CompileConst + AsValueKind,
1429 Ref<RowVector2<T>>: ToValue
1430{
1431 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1432 match args {
1433 FunctionArgs::Binary(out, arg0, arg1) => {
1434 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
1435 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1436 let out: Ref<RowVector2<T>> = unsafe { out.as_unchecked() }.clone();
1437 Ok(Box::new(Self { e0, e1, out }))
1438 },
1439 _ => Err(MechError2::new(
1440 IncorrectNumberOfArguments { expected: 2, found: args.len() },
1441 None
1442 ).with_compiler_loc()
1443 )
1444 }
1445 }
1446}
1447#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1448impl<T> MechFunctionImpl for HorizontalConcatenateM1S<T>
1449where
1450 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1451 Ref<RowVector2<T>>: ToValue
1452{
1453 fn solve(&self) {
1454 unsafe {
1455 let e0_ptr = (*(self.e0.as_ptr())).clone();
1456 let e1_val = self.e1.borrow().clone();
1457 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1458 out_ptr[0] = e0_ptr[0].clone();
1459 out_ptr[1] = e1_val;
1460 }
1461 }
1462 fn out(&self) -> Value { self.out.to_value() }
1463 fn to_string(&self) -> String { format!("{:#?}", self) }
1464}
1465#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1466#[cfg(feature = "compiler")]
1467impl<T> MechFunctionCompiler for HorizontalConcatenateM1S<T>
1468where
1469 T: ConstElem + CompileConst + AsValueKind
1470{
1471 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1472 let name = format!("HorizontalConcatenateM1S<{}>", T::as_value_kind());
1473 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1474 }
1475}
1476#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
1477register_horizontal_concatenate_fxn!(HorizontalConcatenateM1S);
1478
1479#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1482#[derive(Debug)]
1483struct HorizontalConcatenateSSSM1<T> {
1484 e0: Ref<T>,
1485 e1: Ref<T>,
1486 e2: Ref<T>,
1487 e3: Ref<Matrix1<T>>,
1488 out: Ref<RowVector4<T>>,
1489}
1490#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1491impl<T> MechFunctionFactory for HorizontalConcatenateSSSM1<T>
1492where
1493 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1494 ConstElem + CompileConst + AsValueKind,
1495 Ref<RowVector4<T>>: ToValue
1496{
1497 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1498 match args {
1499 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
1500 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1501 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1502 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
1503 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
1504 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1505 Ok(Box::new(Self { e0, e1, e2, e3, out }))
1506 },
1507 _ => Err(MechError2::new(
1508 IncorrectNumberOfArguments { expected: 4, found: args.len() },
1509 None
1510 ).with_compiler_loc()
1511 ),
1512 }
1513 }
1514}
1515#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1516impl<T> MechFunctionImpl for HorizontalConcatenateSSSM1<T>
1517where
1518 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1519 Ref<RowVector4<T>>: ToValue
1520{
1521 fn solve(&self) {
1522 unsafe {
1523 let e0_val = self.e0.borrow().clone();
1524 let e1_val = self.e1.borrow().clone();
1525 let e2_val = self.e2.borrow().clone();
1526 let e3_ptr = (*(self.e3.as_ptr())).clone();
1527 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1528 out_ptr[0] = e0_val;
1529 out_ptr[1] = e1_val;
1530 out_ptr[2] = e2_val;
1531 out_ptr[3] = e3_ptr[0].clone();
1532 }
1533 }
1534 fn out(&self) -> Value { self.out.to_value() }
1535 fn to_string(&self) -> String { format!("{:#?}", self) }
1536}
1537#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1538#[cfg(feature = "compiler")]
1539impl<T> MechFunctionCompiler for HorizontalConcatenateSSSM1<T>
1540where
1541 T: ConstElem + CompileConst + AsValueKind
1542{
1543 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1544 let name = format!("HorizontalConcatenateSSSM1<{}>", T::as_value_kind());
1545 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1546 }
1547}
1548#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1549register_horizontal_concatenate_fxn!(HorizontalConcatenateSSSM1);
1550
1551#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1554#[derive(Debug)]
1555struct HorizontalConcatenateSSM1S<T> {
1556 e0: Ref<T>,
1557 e1: Ref<T>,
1558 e2: Ref<Matrix1<T>>,
1559 e3: Ref<T>,
1560 out: Ref<RowVector4<T>>,
1561}
1562#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1563impl<T> MechFunctionFactory for HorizontalConcatenateSSM1S<T>
1564where
1565 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1566 ConstElem + CompileConst + AsValueKind,
1567 Ref<RowVector4<T>>: ToValue
1568{
1569 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1570 match args {
1571 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
1572 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1573 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1574 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
1575 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
1576 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1577 Ok(Box::new(Self { e0, e1, e2, e3, out }))
1578 },
1579 _ => Err(MechError2::new(
1580 IncorrectNumberOfArguments { expected: 4, found: args.len() },
1581 None
1582 ).with_compiler_loc()
1583 ),
1584 }
1585 }
1586}
1587#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1588impl<T> MechFunctionImpl for HorizontalConcatenateSSM1S<T>
1589where
1590 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1591 Ref<RowVector4<T>>: ToValue
1592{
1593 fn solve(&self) {
1594 unsafe {
1595 let e0_val = self.e0.borrow().clone();
1596 let e1_val = self.e1.borrow().clone();
1597 let e2_ptr = (*(self.e2.as_ptr())).clone();
1598 let e3_val = self.e3.borrow().clone();
1599 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1600 out_ptr[0] = e0_val;
1601 out_ptr[1] = e1_val;
1602 out_ptr[2] = e2_ptr[0].clone();
1603 out_ptr[3] = e3_val;
1604 }
1605 }
1606 fn out(&self) -> Value { self.out.to_value() }
1607 fn to_string(&self) -> String { format!("{:#?}", self) }
1608}
1609#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1610#[cfg(feature = "compiler")]
1611impl<T> MechFunctionCompiler for HorizontalConcatenateSSM1S<T>
1612where
1613 T: ConstElem + CompileConst + AsValueKind
1614{
1615 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1616 let name = format!("HorizontalConcatenateSSM1S<{}>", T::as_value_kind());
1617 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1618 }
1619}
1620#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1621register_horizontal_concatenate_fxn!(HorizontalConcatenateSSM1S);
1622
1623#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1626#[derive(Debug)]
1627struct HorizontalConcatenateSM1SS<T> {
1628 e0: Ref<T>,
1629 e1: Ref<Matrix1<T>>,
1630 e2: Ref<T>,
1631 e3: Ref<T>,
1632 out: Ref<RowVector4<T>>,
1633}
1634#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1635impl<T> MechFunctionFactory for HorizontalConcatenateSM1SS<T>
1636where
1637 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1638 ConstElem + CompileConst + AsValueKind,
1639 Ref<RowVector4<T>>: ToValue
1640{
1641 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1642 match args {
1643 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
1644 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1645 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
1646 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
1647 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
1648 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1649 Ok(Box::new(Self { e0, e1, e2, e3, out }))
1650 },
1651 _ => Err(MechError2::new(
1652 IncorrectNumberOfArguments { expected: 4, found: args.len() },
1653 None
1654 ).with_compiler_loc()
1655 ),
1656 }
1657 }
1658}
1659#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1660impl<T> MechFunctionImpl for HorizontalConcatenateSM1SS<T>
1661where
1662 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1663 Ref<RowVector4<T>>: ToValue
1664{
1665 fn solve(&self) {
1666 unsafe {
1667 let e0_val = self.e0.borrow().clone();
1668 let e1_ptr = (*(self.e1.as_ptr())).clone();
1669 let e2_val = self.e2.borrow().clone();
1670 let e3_val = self.e3.borrow().clone();
1671 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1672 out_ptr[0] = e0_val;
1673 out_ptr[1] = e1_ptr[0].clone();
1674 out_ptr[2] = e2_val;
1675 out_ptr[3] = e3_val;
1676 }
1677 }
1678 fn out(&self) -> Value { self.out.to_value() }
1679 fn to_string(&self) -> String { format!("{:#?}", self) }
1680}
1681#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1682#[cfg(feature = "compiler")]
1683impl<T> MechFunctionCompiler for HorizontalConcatenateSM1SS<T>
1684where
1685 T: ConstElem + CompileConst + AsValueKind
1686{
1687 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1688 let name = format!("HorizontalConcatenateSM1SS<{}>", T::as_value_kind());
1689 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1690 }
1691}
1692#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1693register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1SS);
1694
1695#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1698#[derive(Debug)]
1699struct HorizontalConcatenateM1SSS<T> {
1700 e0: Ref<Matrix1<T>>,
1701 e1: Ref<T>,
1702 e2: Ref<T>,
1703 e3: Ref<T>,
1704 out: Ref<RowVector4<T>>,
1705}
1706#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1707impl<T> MechFunctionFactory for HorizontalConcatenateM1SSS<T>
1708where
1709 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1710 ConstElem + CompileConst + AsValueKind,
1711 Ref<RowVector4<T>>: ToValue
1712{
1713 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1714 match args {
1715 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
1716 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
1717 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1718 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
1719 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
1720 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1721 Ok(Box::new(Self { e0, e1, e2, e3, out }))
1722 },
1723 _ => Err(MechError2::new(
1724 IncorrectNumberOfArguments { expected: 4, found: args.len() },
1725 None
1726 ).with_compiler_loc()
1727 ),
1728 }
1729 }
1730}
1731#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1732impl<T> MechFunctionImpl for HorizontalConcatenateM1SSS<T>
1733where
1734 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1735 Ref<RowVector4<T>>: ToValue
1736{
1737 fn solve(&self) {
1738 unsafe {
1739 let e0_ptr = (*(self.e0.as_ptr())).clone();
1740 let e1_val = self.e1.borrow().clone();
1741 let e2_val = self.e2.borrow().clone();
1742 let e3_val = self.e3.borrow().clone();
1743 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1744 out_ptr[0] = e0_ptr[0].clone();
1745 out_ptr[1] = e1_val;
1746 out_ptr[2] = e2_val;
1747 out_ptr[3] = e3_val;
1748 }
1749 }
1750 fn out(&self) -> Value { self.out.to_value() }
1751 fn to_string(&self) -> String { format!("{:#?}", self) }
1752}
1753#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1754#[cfg(feature = "compiler")]
1755impl<T> MechFunctionCompiler for HorizontalConcatenateM1SSS<T>
1756where
1757 T: ConstElem + CompileConst + AsValueKind
1758{
1759 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1760 let name = format!("HorizontalConcatenateM1SSS<{}>", T::as_value_kind());
1761 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1762 }
1763}
1764#[cfg(all(feature = "matrix1", feature = "row_vector4"))]
1765register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SSS);
1766
1767#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1770#[derive(Debug)]
1771struct HorizontalConcatenateSR3<T> {
1772 e0: Ref<T>,
1773 e1: Ref<RowVector3<T>>,
1774 out: Ref<RowVector4<T>>,
1775}
1776#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1777impl<T> MechFunctionFactory for HorizontalConcatenateSR3<T>
1778where
1779 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1780 ConstElem + CompileConst + AsValueKind,
1781 Ref<RowVector4<T>>: ToValue
1782{
1783 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1784 match args {
1785 FunctionArgs::Binary(out, arg0, arg1) => {
1786 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1787 let e1: Ref<RowVector3<T>> = unsafe { arg1.as_unchecked() }.clone();
1788 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1789 Ok(Box::new(Self { e0, e1, out }))
1790 },
1791 _ => Err(MechError2::new(
1792 IncorrectNumberOfArguments { expected: 2, found: args.len() },
1793 None
1794 ).with_compiler_loc()
1795 )
1796 }
1797 }
1798}
1799#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1800impl<T> MechFunctionImpl for HorizontalConcatenateSR3<T>
1801where
1802 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1803 Ref<RowVector4<T>>: ToValue
1804{
1805 fn solve(&self) {
1806 unsafe {
1807 let e0_ptr = (*(self.e0.as_ptr())).clone();
1808 let e1_ptr = (*(self.e1.as_ptr())).clone();
1809 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1810 out_ptr[0] = e0_ptr.clone();
1811 out_ptr[1] = e1_ptr[0].clone();
1812 out_ptr[2] = e1_ptr[1].clone();
1813 out_ptr[3] = e1_ptr[2].clone();
1814 }
1815 }
1816 fn out(&self) -> Value { self.out.to_value() }
1817 fn to_string(&self) -> String { format!("{:#?}", self) }
1818}
1819#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1820#[cfg(feature = "compiler")]
1821impl<T> MechFunctionCompiler for HorizontalConcatenateSR3<T>
1822where
1823 T: ConstElem + CompileConst + AsValueKind
1824{
1825 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1826 let name = format!("HorizontalConcatenateSR3<{}>", T::as_value_kind());
1827 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1828 }
1829}
1830#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1831register_horizontal_concatenate_fxn!(HorizontalConcatenateSR3);
1832
1833#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1836#[derive(Debug)]
1837struct HorizontalConcatenateR3S<T> {
1838 e0: Ref<RowVector3<T>>,
1839 e1: Ref<T>,
1840 out: Ref<RowVector4<T>>,
1841}
1842#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1843impl<T> MechFunctionFactory for HorizontalConcatenateR3S<T>
1844where
1845 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1846 ConstElem + CompileConst + AsValueKind,
1847 Ref<RowVector4<T>>: ToValue
1848{
1849 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1850 match args {
1851 FunctionArgs::Binary(out, arg0, arg1) => {
1852 let e0: Ref<RowVector3<T>> = unsafe { arg0.as_unchecked() }.clone();
1853 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1854 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
1855 Ok(Box::new(Self { e0, e1, out }))
1856 },
1857 _ => Err(MechError2::new(
1858 IncorrectNumberOfArguments { expected: 2, found: args.len() },
1859 None
1860 ).with_compiler_loc()
1861 )
1862 }
1863 }
1864}
1865#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1866impl<T> MechFunctionImpl for HorizontalConcatenateR3S<T>
1867where
1868 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1869 Ref<RowVector4<T>>: ToValue,
1870{
1871 fn solve(&self) {
1872 unsafe {
1873 let e0_ptr = (*(self.e0.as_ptr())).clone();
1874 let e1_ptr = self.e1.borrow().clone();
1875 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1876 out_ptr[0] = e0_ptr[0].clone();
1877 out_ptr[1] = e0_ptr[1].clone();
1878 out_ptr[2] = e0_ptr[2].clone();
1879 out_ptr[3] = e1_ptr.clone();
1880 }
1881 }
1882 fn out(&self) -> Value { self.out.to_value() }
1883 fn to_string(&self) -> String { format!("{:#?}", self) }
1884}
1885#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1886#[cfg(feature = "compiler")]
1887impl<T> MechFunctionCompiler for HorizontalConcatenateR3S<T>
1888where
1889 T: ConstElem + CompileConst + AsValueKind
1890{
1891 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1892 let name = format!("HorizontalConcatenateR3S<{}>", T::as_value_kind());
1893 compile_binop!(name, self.out, self.e0, self.e1, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1894 }
1895}
1896#[cfg(all(feature = "row_vector3", feature = "row_vector4"))]
1897register_horizontal_concatenate_fxn!(HorizontalConcatenateR3S);
1898
1899#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1902#[derive(Debug)]
1903struct HorizontalConcatenateSSM1<T> {
1904 e0: Ref<T>, e1: Ref<T>, e2: Ref<Matrix1<T>>, out: Ref<RowVector3<T>>,
1908}
1909#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1910impl<T> MechFunctionFactory for HorizontalConcatenateSSM1<T>
1911where
1912 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1913 ConstElem + CompileConst + AsValueKind,
1914 Ref<RowVector3<T>>: ToValue
1915{
1916 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1917 match args {
1918 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
1919 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1920 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
1921 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
1922 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
1923 Ok(Box::new(Self { e0, e1, e2, out }))
1924 },
1925 _ => Err(MechError2::new(
1926 IncorrectNumberOfArguments { expected: 3, found: args.len() },
1927 None
1928 ).with_compiler_loc()
1929 ),
1930 }
1931 }
1932}
1933#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1934impl<T> MechFunctionImpl for HorizontalConcatenateSSM1<T>
1935where
1936 T: Debug + Clone + Sync + Send + PartialEq + 'static,
1937 Ref<RowVector3<T>>: ToValue
1938{
1939 fn solve(&self) {
1940 unsafe {
1941 let e0_val = self.e0.borrow().clone();
1942 let e1_val = self.e1.borrow().clone();
1943 let e2_ptr = (*(self.e2.as_ptr())).clone();
1944 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
1945 out_ptr[0] = e0_val;
1946 out_ptr[1] = e1_val;
1947 out_ptr[2] = e2_ptr[0].clone();
1948 }
1949 }
1950 fn out(&self) -> Value { self.out.to_value() }
1951 fn to_string(&self) -> String { format!("{:#?}", self) }
1952}
1953#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1954#[cfg(feature = "compiler")]
1955impl<T> MechFunctionCompiler for HorizontalConcatenateSSM1<T>
1956where
1957 T: ConstElem + CompileConst + AsValueKind
1958{
1959 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
1960 let name = format!("HorizontalConcatenateSSM1<{}>", T::as_value_kind());
1961 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
1962 }
1963}
1964#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1965register_horizontal_concatenate_fxn!(HorizontalConcatenateSSM1);
1966
1967#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1970#[derive(Debug)]
1971struct HorizontalConcatenateSM1S<T> {
1972 e0: Ref<T>, e1: Ref<Matrix1<T>>, e2: Ref<T>, out: Ref<RowVector3<T>>,
1976}
1977#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
1978impl<T> MechFunctionFactory for HorizontalConcatenateSM1S<T>
1979where
1980 T: Debug + Clone + Sync + Send + PartialEq + 'static +
1981 ConstElem + CompileConst + AsValueKind,
1982 Ref<RowVector3<T>>: ToValue
1983{
1984 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
1985 match args {
1986 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
1987 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
1988 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
1989 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
1990 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
1991 Ok(Box::new(Self { e0, e1, e2, out }))
1992 },
1993 _ => Err(MechError2::new(
1994 IncorrectNumberOfArguments { expected: 3, found: args.len() },
1995 None
1996 ).with_compiler_loc()
1997 ),
1998 }
1999 }
2000}
2001#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2002impl<T> MechFunctionImpl for HorizontalConcatenateSM1S<T>
2003where
2004 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2005 Ref<RowVector3<T>>: ToValue
2006{
2007 fn solve(&self) {
2008 unsafe {
2009 let e0_val = self.e0.borrow().clone();
2010 let e1_ptr = (*(self.e1.as_ptr())).clone();
2011 let e2_val = self.e2.borrow().clone();
2012 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2013 out_ptr[0] = e0_val;
2014 out_ptr[1] = e1_ptr[0].clone();
2015 out_ptr[2] = e2_val;
2016 }
2017 }
2018 fn out(&self) -> Value { self.out.to_value() }
2019 fn to_string(&self) -> String { format!("{:#?}", self) }
2020}
2021#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2022#[cfg(feature = "compiler")]
2023impl<T> MechFunctionCompiler for HorizontalConcatenateSM1S<T>
2024where
2025 T: ConstElem + CompileConst + AsValueKind
2026{
2027 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2028 let name = format!("HorizontalConcatenateSM1S<{}>", T::as_value_kind());
2029 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2030 }
2031}
2032#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2033register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1S);
2034
2035#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2038#[derive(Debug)]
2039struct HorizontalConcatenateM1SS<T> {
2040 e0: Ref<Matrix1<T>>, e1: Ref<T>, e2: Ref<T>, out: Ref<RowVector3<T>>,
2044}
2045#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2046impl<T> MechFunctionFactory for HorizontalConcatenateM1SS<T>
2047where
2048 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2049 ConstElem + CompileConst + AsValueKind,
2050 Ref<RowVector3<T>>: ToValue
2051{
2052 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2053 match args {
2054 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2055 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
2056 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
2057 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2058 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
2059 Ok(Box::new(Self { e0, e1, e2, out }))
2060 },
2061 _ => Err(MechError2::new(
2062 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2063 None
2064 ).with_compiler_loc()
2065 ),
2066 }
2067 }
2068}
2069#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2070impl<T> MechFunctionImpl for HorizontalConcatenateM1SS<T>
2071where
2072 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2073 Ref<RowVector3<T>>: ToValue
2074{
2075 fn solve(&self) {
2076 unsafe {
2077 let e0_ptr = (*(self.e0.as_ptr())).clone();
2078 let e1_val = self.e1.borrow().clone();
2079 let e2_val = self.e2.borrow().clone();
2080 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2081 out_ptr[0] = e0_ptr[0].clone();
2082 out_ptr[1] = e1_val;
2083 out_ptr[2] = e2_val;
2084 }
2085 }
2086 fn out(&self) -> Value { self.out.to_value() }
2087 fn to_string(&self) -> String { format!("{:#?}", self) }
2088}
2089#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2090#[cfg(feature = "compiler")]
2091impl<T> MechFunctionCompiler for HorizontalConcatenateM1SS<T>
2092where
2093 T: ConstElem + CompileConst + AsValueKind
2094{
2095 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2096 let name = format!("HorizontalConcatenateM1SS<{}>", T::as_value_kind());
2097 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2098 }
2099}
2100#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2101register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SS);
2102
2103#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2106#[derive(Debug)]
2107struct HorizontalConcatenateSSR2<T> {
2108 e0: Ref<T>,
2109 e1: Ref<T>,
2110 e2: Ref<RowVector2<T>>,
2111 out: Ref<RowVector4<T>>,
2112}
2113#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2114impl<T> MechFunctionFactory for HorizontalConcatenateSSR2<T>
2115where
2116 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2117 ConstElem + CompileConst + AsValueKind,
2118 Ref<RowVector4<T>>: ToValue
2119{
2120 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2121 match args {
2122 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2123 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
2124 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
2125 let e2: Ref<RowVector2<T>> = unsafe { arg2.as_unchecked() }.clone();
2126 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2127 Ok(Box::new(Self { e0, e1, e2, out }))
2128 },
2129 _ => Err(MechError2::new(
2130 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2131 None
2132 ).with_compiler_loc()
2133 ),
2134 }
2135 }
2136}
2137#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2138impl<T> MechFunctionImpl for HorizontalConcatenateSSR2<T>
2139where
2140 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2141 Ref<RowVector4<T>>: ToValue,
2142{
2143 fn solve(&self) {
2144 unsafe {
2145 let e0_val = self.e0.borrow().clone();
2146 let e1_val = self.e1.borrow().clone();
2147 let e2_ptr = (*(self.e2.as_ptr())).clone();
2148 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2149 out_ptr[0] = e0_val;
2150 out_ptr[1] = e1_val;
2151 out_ptr[2] = e2_ptr[0].clone();
2152 out_ptr[3] = e2_ptr[1].clone();
2153 }
2154 }
2155 fn out(&self) -> Value { self.out.to_value() }
2156 fn to_string(&self) -> String { format!("{:#?}", self) }
2157}
2158#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2159#[cfg(feature = "compiler")]
2160impl<T> MechFunctionCompiler for HorizontalConcatenateSSR2<T>
2161where
2162 T: ConstElem + CompileConst + AsValueKind
2163{
2164 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2165 let name = format!("HorizontalConcatenateSSR2<{}>", T::as_value_kind());
2166 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2167 }
2168}
2169#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2170register_horizontal_concatenate_fxn!(HorizontalConcatenateSSR2);
2171
2172#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2175#[derive(Debug)]
2176struct HorizontalConcatenateSR2S<T> {
2177 e0: Ref<T>,
2178 e1: Ref<RowVector2<T>>,
2179 e2: Ref<T>,
2180 out: Ref<RowVector4<T>>,
2181}
2182#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2183impl<T> MechFunctionFactory for HorizontalConcatenateSR2S<T>
2184where
2185 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2186 ConstElem + CompileConst + AsValueKind,
2187 Ref<RowVector4<T>>: ToValue
2188{
2189 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2190 match args {
2191 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2192 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
2193 let e1: Ref<RowVector2<T>> = unsafe { arg1.as_unchecked() }.clone();
2194 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2195 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2196 Ok(Box::new(Self { e0, e1, e2, out }))
2197 },
2198 _ => Err(MechError2::new(
2199 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2200 None
2201 ).with_compiler_loc()
2202 ),
2203 }
2204 }
2205}
2206#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2207impl<T> MechFunctionImpl for HorizontalConcatenateSR2S<T>
2208where
2209 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2210 Ref<RowVector4<T>>: ToValue,
2211{
2212 fn solve(&self) {
2213 unsafe {
2214 let e0_val = self.e0.borrow().clone();
2215 let e1_ptr = (*(self.e1.as_ptr())).clone();
2216 let e2_val = self.e2.borrow().clone();
2217 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2218 out_ptr[0] = e0_val;
2219 out_ptr[1] = e1_ptr[0].clone();
2220 out_ptr[2] = e1_ptr[1].clone();
2221 out_ptr[3] = e2_val;
2222 }
2223 }
2224 fn out(&self) -> Value { self.out.to_value() }
2225 fn to_string(&self) -> String { format!("{:#?}", self) }
2226}
2227#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2228#[cfg(feature = "compiler")]
2229impl<T> MechFunctionCompiler for HorizontalConcatenateSR2S<T>
2230where
2231 T: ConstElem + CompileConst + AsValueKind
2232{
2233 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2234 let name = format!("HorizontalConcatenateSR2S<{}>", T::as_value_kind());
2235 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2236 }
2237}
2238#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2239register_horizontal_concatenate_fxn!(HorizontalConcatenateSR2S);
2240
2241#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2244#[derive(Debug)]
2245struct HorizontalConcatenateR2SS<T> {
2246 e0: Ref<RowVector2<T>>,
2247 e1: Ref<T>,
2248 e2: Ref<T>,
2249 out: Ref<RowVector4<T>>,
2250}
2251#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2252impl<T> MechFunctionFactory for HorizontalConcatenateR2SS<T>
2253where
2254 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2255 ConstElem + CompileConst + AsValueKind,
2256 Ref<RowVector4<T>>: ToValue
2257{
2258 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2259 match args {
2260 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2261 let e0: Ref<RowVector2<T>> = unsafe { arg0.as_unchecked() }.clone();
2262 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
2263 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2264 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2265 Ok(Box::new(Self { e0, e1, e2, out }))
2266 },
2267 _ => Err(MechError2::new(
2268 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2269 None
2270 ).with_compiler_loc()
2271 ),
2272 }
2273 }
2274}
2275#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2276impl<T> MechFunctionImpl for HorizontalConcatenateR2SS<T>
2277where
2278 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2279 Ref<RowVector4<T>>: ToValue,
2280{
2281 fn solve(&self) {
2282 unsafe {
2283 let e0_ptr = (*(self.e0.as_ptr())).clone();
2284 let e1_val = self.e1.borrow().clone();
2285 let e2_val = self.e2.borrow().clone();
2286 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2287 out_ptr[0] = e0_ptr[0].clone();
2288 out_ptr[1] = e0_ptr[1].clone();
2289 out_ptr[2] = e1_val;
2290 out_ptr[3] = e2_val;
2291 }
2292 }
2293 fn out(&self) -> Value { self.out.to_value() }
2294 fn to_string(&self) -> String { format!("{:#?}", self) }
2295}
2296#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2297#[cfg(feature = "compiler")]
2298impl<T> MechFunctionCompiler for HorizontalConcatenateR2SS<T>
2299where
2300 T: ConstElem + CompileConst + AsValueKind
2301{
2302 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2303 let name = format!("HorizontalConcatenateR2SS<{}>", T::as_value_kind());
2304 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2305 }
2306}
2307#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2308register_horizontal_concatenate_fxn!(HorizontalConcatenateR2SS);
2309
2310#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2313#[derive(Debug)]
2314struct HorizontalConcatenateM1M1S<T> {
2315 e0: Ref<Matrix1<T>>,
2316 e1: Ref<Matrix1<T>>,
2317 e2: Ref<T>,
2318 out: Ref<RowVector3<T>>,
2319}
2320#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2321impl<T> MechFunctionFactory for HorizontalConcatenateM1M1S<T>
2322where
2323 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2324 ConstElem + CompileConst + AsValueKind,
2325 Ref<RowVector3<T>>: ToValue
2326{
2327 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2328 match args {
2329 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2330 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
2331 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
2332 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2333 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
2334 Ok(Box::new(Self { e0, e1, e2, out }))
2335 },
2336 _ => Err(MechError2::new(
2337 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2338 None
2339 ).with_compiler_loc()
2340 ),
2341 }
2342 }
2343}
2344#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2345impl<T> MechFunctionImpl for HorizontalConcatenateM1M1S<T>
2346where
2347 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2348 Ref<RowVector3<T>>: ToValue
2349{
2350 fn solve(&self) {
2351 unsafe {
2352 let e0_ptr = (*(self.e0.as_ptr())).clone();
2353 let e1_ptr = (*(self.e1.as_ptr())).clone();
2354 let e2_val = self.e2.borrow().clone();
2355 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2356 out_ptr[0] = e0_ptr[0].clone();
2357 out_ptr[1] = e1_ptr[0].clone();
2358 out_ptr[2] = e2_val;
2359 }
2360 }
2361 fn out(&self) -> Value { self.out.to_value() }
2362 fn to_string(&self) -> String { format!("{:#?}", self) }
2363}
2364#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2365#[cfg(feature = "compiler")]
2366impl<T> MechFunctionCompiler for HorizontalConcatenateM1M1S<T>
2367where
2368 T: ConstElem + CompileConst + AsValueKind
2369{
2370 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2371 let name = format!("HorizontalConcatenateM1M1S<{}>", T::as_value_kind());
2372 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2373 }
2374}
2375#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2376register_horizontal_concatenate_fxn!(HorizontalConcatenateM1M1S);
2377
2378macro_rules! horzcat_m1m1 {
2381 ($out:expr, $e0:expr, $e1:expr) => {
2382 $out[0] = $e0[0].clone();
2383 $out[1] = $e1[0].clone();
2384 };}
2385#[cfg(all(feature = "matrix1", feature = "row_vector2"))]
2386horzcat_two_args!(HorizontalConcatenateM1M1,Matrix1,Matrix1,RowVector2,horzcat_m1m1);
2387
2388#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2391#[derive(Debug)]
2392struct HorizontalConcatenateM1SM1<T> {
2393 e0: Ref<Matrix1<T>>,
2394 e1: Ref<T>,
2395 e2: Ref<Matrix1<T>>,
2396 out: Ref<RowVector3<T>>,
2397}
2398#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2399impl<T> MechFunctionFactory for HorizontalConcatenateM1SM1<T>
2400where
2401 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2402 ConstElem + CompileConst + AsValueKind,
2403 Ref<RowVector3<T>>: ToValue
2404{
2405 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2406 match args {
2407 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2408 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
2409 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
2410 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
2411 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
2412 Ok(Box::new(Self { e0, e1, e2, out }))
2413 },
2414 _ => Err(MechError2::new(
2415 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2416 None
2417 ).with_compiler_loc()
2418 ),
2419 }
2420 }
2421}
2422#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2423impl<T> MechFunctionImpl for HorizontalConcatenateM1SM1<T>
2424where
2425 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2426 Ref<RowVector3<T>>: ToValue
2427{
2428 fn solve(&self) {
2429 unsafe {
2430 let e0_ptr = (*(self.e0.as_ptr())).clone();
2431 let e1_val = self.e1.borrow().clone();
2432 let e2_ptr = (*(self.e2.as_ptr())).clone();
2433 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2434 out_ptr[0] = e0_ptr[0].clone();
2435 out_ptr[1] = e1_val;
2436 out_ptr[2] = e2_ptr[0].clone();
2437 }
2438 }
2439 fn out(&self) -> Value { self.out.to_value() }
2440 fn to_string(&self) -> String { format!("{:#?}", self) }
2441}
2442#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2443#[cfg(feature = "compiler")]
2444impl<T> MechFunctionCompiler for HorizontalConcatenateM1SM1<T>
2445where
2446 T: ConstElem + CompileConst + AsValueKind
2447{
2448 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2449 let name = format!("HorizontalConcatenateM1SM1<{}>", T::as_value_kind());
2450 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2451 }
2452}
2453#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2454register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SM1);
2455
2456#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2459#[derive(Debug)]
2460struct HorizontalConcatenateSM1M1<T> {
2461 e0: Ref<T>,
2462 e1: Ref<Matrix1<T>>,
2463 e2: Ref<Matrix1<T>>,
2464 out: Ref<RowVector3<T>>,
2465}
2466#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2467impl<T> MechFunctionFactory for HorizontalConcatenateSM1M1<T>
2468where
2469 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2470 ConstElem + CompileConst + AsValueKind,
2471 Ref<RowVector3<T>>: ToValue
2472{
2473 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2474 match args {
2475 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2476 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
2477 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
2478 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
2479 let out: Ref<RowVector3<T>> = unsafe { out.as_unchecked() }.clone();
2480 Ok(Box::new(Self { e0, e1, e2, out }))
2481 },
2482 _ => Err(MechError2::new(
2483 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2484 None
2485 ).with_compiler_loc()
2486 ),
2487 }
2488 }
2489}
2490#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2491impl<T> MechFunctionImpl for HorizontalConcatenateSM1M1<T>
2492where
2493 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2494 Ref<RowVector3<T>>: ToValue
2495{
2496 fn solve(&self) {
2497 unsafe {
2498 let e0_val = self.e0.borrow().clone();
2499 let e1_ptr = (*(self.e1.as_ptr())).clone();
2500 let e2_ptr = (*(self.e2.as_ptr())).clone();
2501 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2502 out_ptr[0] = e0_val;
2503 out_ptr[1] = e1_ptr[0].clone();
2504 out_ptr[2] = e2_ptr[0].clone();
2505 }
2506 }
2507 fn out(&self) -> Value { self.out.to_value() }
2508 fn to_string(&self) -> String { format!("{:#?}", self) }
2509}
2510#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2511#[cfg(feature = "compiler")]
2512impl<T> MechFunctionCompiler for HorizontalConcatenateSM1M1<T>
2513where
2514 T: ConstElem + CompileConst + AsValueKind
2515{
2516 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2517 let name = format!("HorizontalConcatenateSM1M1<{}>", T::as_value_kind());
2518 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2519 }
2520}
2521#[cfg(all(feature = "matrix1", feature = "row_vector3"))]
2522register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1M1);
2523
2524macro_rules! horzcat_r2r2 {
2527 ($out:expr, $e0:expr, $e1:expr) => {
2528 $out[0] = $e0[0].clone();
2529 $out[1] = $e0[1].clone();
2530 $out[2] = $e1[0].clone();
2531 $out[3] = $e1[1].clone();
2532 };}
2533#[cfg(all(feature = "row_vector2", feature = "row_vector4"))]
2534horzcat_two_args!(HorizontalConcatenateR2R2,RowVector2,RowVector2,RowVector4,horzcat_r2r2);
2535
2536macro_rules! horzcat_m1r3 {
2539 ($out:expr, $e0:expr, $e1:expr) => {
2540 $out[0] = $e0[0].clone();
2541 $out[1] = $e1[0].clone();
2542 $out[2] = $e1[1].clone();
2543 $out[3] = $e1[2].clone();
2544 };}
2545#[cfg(all(feature = "matrix1", feature = "row_vector3", feature = "row_vector4"))]
2546horzcat_two_args!(HorizontalConcatenateM1R3,Matrix1,RowVector3,RowVector4,horzcat_m1r3);
2547
2548macro_rules! horzcat_r3m1 {
2551 ($out:expr, $e0:expr, $e1:expr) => {
2552 $out[0] = $e0[0].clone();
2553 $out[1] = $e0[1].clone();
2554 $out[2] = $e0[2].clone();
2555 $out[3] = $e1[0].clone();
2556 };}
2557#[cfg(all(feature = "matrix1", feature = "row_vector3", feature = "row_vector4"))]
2558horzcat_two_args!(HorizontalConcatenateR3M1,RowVector3,Matrix1,RowVector4,horzcat_r3m1);
2559
2560#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2563#[derive(Debug)]
2564struct HorizontalConcatenateSM1R2<T> {
2565 e0: Ref<T>,
2566 e1: Ref<Matrix1<T>>,
2567 e2: Ref<RowVector2<T>>,
2568 out: Ref<RowVector4<T>>,
2569}
2570#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2571impl<T> MechFunctionFactory for HorizontalConcatenateSM1R2<T>
2572where
2573 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2574 ConstElem + CompileConst + AsValueKind,
2575 Ref<RowVector4<T>>: ToValue
2576{
2577 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2578 match args {
2579 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2580 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
2581 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
2582 let e2: Ref<RowVector2<T>> = unsafe { arg2.as_unchecked() }.clone();
2583 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2584 Ok(Box::new(Self { e0, e1, e2, out }))
2585 },
2586 _ => Err(MechError2::new(
2587 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2588 None
2589 ).with_compiler_loc()
2590 ),
2591 }
2592 }
2593}
2594#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2595impl<T> MechFunctionImpl for HorizontalConcatenateSM1R2<T>
2596where
2597 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2598 Ref<RowVector4<T>>: ToValue
2599{
2600 fn solve(&self) {
2601 unsafe {
2602 let e0_val = self.e0.borrow().clone();
2603 let e1_ptr = (*(self.e1.as_ptr())).clone();
2604 let e2_ptr = (*(self.e2.as_ptr())).clone();
2605 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2606 out_ptr[0] = e0_val;
2607 out_ptr[1] = e1_ptr[0].clone();
2608 out_ptr[2] = e2_ptr[0].clone();
2609 out_ptr[3] = e2_ptr[1].clone();
2610 }
2611 }
2612 fn out(&self) -> Value { self.out.to_value() }
2613 fn to_string(&self) -> String { format!("{:#?}", self) }
2614}
2615#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2616#[cfg(feature = "compiler")]
2617impl<T> MechFunctionCompiler for HorizontalConcatenateSM1R2<T>
2618where
2619 T: ConstElem + CompileConst + AsValueKind
2620{
2621 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2622 let name = format!("HorizontalConcatenateSM1R2<{}>", T::as_value_kind());
2623 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2624 }
2625}
2626#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2627register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1R2);
2628
2629#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2632#[derive(Debug)]
2633struct HorizontalConcatenateM1SR2<T> {
2634 e0: Ref<Matrix1<T>>,
2635 e1: Ref<T>,
2636 e2: Ref<RowVector2<T>>,
2637 out: Ref<RowVector4<T>>,
2638}
2639#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2640impl<T> MechFunctionFactory for HorizontalConcatenateM1SR2<T>
2641where
2642 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2643 ConstElem + CompileConst + AsValueKind,
2644 Ref<RowVector4<T>>: ToValue
2645{
2646 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2647 match args {
2648 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2649 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
2650 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
2651 let e2: Ref<RowVector2<T>> = unsafe { arg2.as_unchecked() }.clone();
2652 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2653 Ok(Box::new(Self { e0, e1, e2, out }))
2654 },
2655 _ => Err(MechError2::new(
2656 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2657 None
2658 ).with_compiler_loc()
2659 ),
2660 }
2661 }
2662}
2663#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2664impl<T> MechFunctionImpl for HorizontalConcatenateM1SR2<T>
2665where
2666 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2667 Ref<RowVector4<T>>: ToValue
2668{
2669 fn solve(&self) {
2670 unsafe {
2671 let e0_ptr = (*(self.e0.as_ptr())).clone();
2672 let e1_val = self.e1.borrow().clone();
2673 let e2_ptr = (*(self.e2.as_ptr())).clone();
2674 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2675 out_ptr[0] = e0_ptr[0].clone();
2676 out_ptr[1] = e1_val;
2677 out_ptr[2] = e2_ptr[0].clone();
2678 out_ptr[3] = e2_ptr[1].clone();
2679 }
2680 }
2681 fn out(&self) -> Value { self.out.to_value() }
2682 fn to_string(&self) -> String { format!("{:#?}", self) }
2683}
2684#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2685#[cfg(feature = "compiler")]
2686impl<T> MechFunctionCompiler for HorizontalConcatenateM1SR2<T>
2687where
2688 T: ConstElem + CompileConst + AsValueKind
2689{
2690 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2691 let name = format!("HorizontalConcatenateM1SR2<{}>", T::as_value_kind());
2692 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2693 }
2694}
2695#[cfg(all(feature = "matrix1", feature = "row_vector2", feature = "row_vector4"))]
2696register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SR2);
2697
2698#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
2701#[derive(Debug)]
2702struct HorizontalConcatenateSM1SM1<T> {
2703 e0: Ref<T>,
2704 e1: Ref<Matrix1<T>>,
2705 e2: Ref<T>,
2706 e3: Ref<Matrix1<T>>,
2707 out: Ref<RowVector4<T>>,
2708}
2709#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
2710impl<T> MechFunctionFactory for HorizontalConcatenateSM1SM1<T>
2711where
2712 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2713 ConstElem + CompileConst + AsValueKind,
2714 Ref<RowVector4<T>>: ToValue
2715{
2716 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2717 match args {
2718 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
2719 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
2720 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
2721 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2722 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
2723 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2724 Ok(Box::new(Self { e0, e1, e2, e3, out }))
2725 },
2726 _ => Err(MechError2::new(
2727 IncorrectNumberOfArguments { expected: 4, found: args.len() },
2728 None
2729 ).with_compiler_loc()
2730 ),
2731 }
2732 }
2733}
2734#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
2735impl<T> MechFunctionImpl for HorizontalConcatenateSM1SM1<T>
2736where
2737 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2738 Ref<RowVector4<T>>: ToValue
2739{
2740 fn solve(&self) {
2741 unsafe {
2742 let e0_val = self.e0.borrow().clone();
2743 let e1_ptr = (*(self.e1.as_ptr())).clone();
2744 let e2_val = self.e2.borrow().clone();
2745 let e3_ptr = (*(self.e3.as_ptr())).clone();
2746 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2747 out_ptr[0] = e0_val;
2748 out_ptr[1] = e1_ptr[0].clone();
2749 out_ptr[2] = e2_val;
2750 out_ptr[3] = e3_ptr[0].clone();
2751 }
2752 }
2753 fn out(&self) -> Value { self.out.to_value() }
2754 fn to_string(&self) -> String { format!("{:#?}", self) }
2755}
2756#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
2757#[cfg(feature = "compiler")]
2758impl<T> MechFunctionCompiler for HorizontalConcatenateSM1SM1<T>
2759where
2760 T: ConstElem + CompileConst + AsValueKind
2761{
2762 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2763 let name = format!("HorizontalConcatenateSM1SM1<{}>", T::as_value_kind());
2764 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2765 }
2766}
2767#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
2768register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1SM1);
2769
2770#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2773#[derive(Debug)]
2774struct HorizontalConcatenateM1R2S<T> {
2775 e0: Ref<Matrix1<T>>,
2776 e1: Ref<RowVector2<T>>,
2777 e2: Ref<T>,
2778 out: Ref<RowVector4<T>>,
2779}
2780#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2781impl<T> MechFunctionFactory for HorizontalConcatenateM1R2S<T>
2782where
2783 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2784 ConstElem + CompileConst + AsValueKind,
2785 Ref<RowVector4<T>>: ToValue
2786{
2787 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2788 match args {
2789 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2790 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
2791 let e1: Ref<RowVector2<T>> = unsafe { arg1.as_unchecked() }.clone();
2792 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2793 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2794 Ok(Box::new(Self { e0, e1, e2, out }))
2795 },
2796 _ => Err(MechError2::new(
2797 IncorrectNumberOfArguments { expected: 3, found: args.len() },
2798 None
2799 ).with_compiler_loc()
2800 ),
2801 }
2802 }
2803}
2804#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2805impl<T> MechFunctionImpl for HorizontalConcatenateM1R2S<T>
2806where
2807 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2808 Ref<RowVector4<T>>: ToValue,
2809{
2810 fn solve(&self) {
2811 unsafe {
2812 let e0_ptr = (*(self.e0.as_ptr())).clone();
2813 let e1_ptr = (*(self.e1.as_ptr())).clone();
2814 let e2_val = self.e2.borrow().clone();
2815 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2816 out_ptr[0] = e0_ptr[0].clone();
2817 out_ptr[1] = e1_ptr[0].clone();
2818 out_ptr[2] = e1_ptr[1].clone();
2819 out_ptr[3] = e2_val;
2820 }
2821 }
2822 fn out(&self) -> Value { self.out.to_value() }
2823 fn to_string(&self) -> String { format!("{:#?}", self) }
2824}
2825#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2826#[cfg(feature = "compiler")]
2827impl<T> MechFunctionCompiler for HorizontalConcatenateM1R2S<T>
2828where
2829 T: ConstElem + CompileConst + AsValueKind
2830{
2831 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2832 let name = format!("HorizontalConcatenateM1R2S<{}>", T::as_value_kind());
2833 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2834 }
2835}
2836#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2837register_horizontal_concatenate_fxn!(HorizontalConcatenateM1R2S);
2838
2839#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2842#[derive(Debug)]
2843struct HorizontalConcatenateR2M1S<T> {
2844 e0: Ref<RowVector2<T>>,
2845 e1: Ref<Matrix1<T>>,
2846 e2: Ref<T>,
2847 out: Ref<RowVector4<T>>,
2848}
2849#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2850impl<T> MechFunctionFactory for HorizontalConcatenateR2M1S<T>
2851where
2852 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2853 ConstElem + CompileConst + AsValueKind,
2854 Ref<RowVector4<T>>: ToValue
2855{
2856 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2857 match args {
2858 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2859 let e0: Ref<RowVector2<T>> = unsafe { arg0.as_unchecked() }.clone();
2860 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
2861 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
2862 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2863 Ok(Box::new(Self { e0, e1, e2, out }))
2864 },
2865 _ => Err(MechError2::new(
2866 IncorrectNumberOfArguments { expected: 2, found: args.len() },
2867 None
2868 ).with_compiler_loc()
2869 ),
2870 }
2871 }
2872}
2873#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2874impl<T> MechFunctionImpl for HorizontalConcatenateR2M1S<T>
2875where
2876 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2877 Ref<RowVector4<T>>: ToValue
2878{
2879 fn solve(&self) {
2880 unsafe {
2881 let e0_ptr = (*(self.e0.as_ptr())).clone();
2882 let e1_ptr = (*(self.e1.as_ptr())).clone();
2883 let e2_val = self.e2.borrow().clone();
2884 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2885 out_ptr[0] = e0_ptr[0].clone();
2886 out_ptr[1] = e0_ptr[1].clone();
2887 out_ptr[2] = e1_ptr[0].clone();
2888 out_ptr[3] = e2_val;
2889 }
2890 }
2891 fn out(&self) -> Value { self.out.to_value() }
2892 fn to_string(&self) -> String { format!("{:#?}", self) }
2893}
2894#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2895#[cfg(feature = "compiler")]
2896impl<T> MechFunctionCompiler for HorizontalConcatenateR2M1S<T>
2897where
2898 T: ConstElem + CompileConst + AsValueKind
2899{
2900 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2901 let name = format!("HorizontalConcatenateR2M1S<{}>", T::as_value_kind());
2902 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2903 }
2904}
2905#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2906register_horizontal_concatenate_fxn!(HorizontalConcatenateR2M1S);
2907
2908#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2911#[derive(Debug)]
2912struct HorizontalConcatenateR2SM1<T> {
2913 e0: Ref<RowVector2<T>>,
2914 e1: Ref<T>,
2915 e2: Ref<Matrix1<T>>,
2916 out: Ref<RowVector4<T>>,
2917}
2918#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2919impl<T> MechFunctionFactory for HorizontalConcatenateR2SM1<T>
2920where
2921 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2922 ConstElem + CompileConst + AsValueKind,
2923 Ref<RowVector4<T>>: ToValue
2924{
2925 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2926 match args {
2927 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2928 let e0: Ref<RowVector2<T>> = unsafe { arg0.as_unchecked() }.clone();
2929 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
2930 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
2931 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
2932 Ok(Box::new(Self { e0, e1, e2, out }))
2933 },
2934 _ => Err(MechError2::new(
2935 IncorrectNumberOfArguments { expected: 2, found: args.len() },
2936 None
2937 ).with_compiler_loc()
2938 ),
2939 }
2940 }
2941}
2942#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2943impl<T> MechFunctionImpl for HorizontalConcatenateR2SM1<T>
2944where
2945 T: Debug + Clone + Sync + Send + PartialEq + 'static,
2946 Ref<RowVector4<T>>: ToValue,
2947{
2948 fn solve(&self) {
2949 unsafe {
2950 let e0_ptr = (*(self.e0.as_ptr())).clone();
2951 let e1_val = self.e1.borrow().clone();
2952 let e2_ptr = (*(self.e2.as_ptr())).clone();
2953 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
2954 out_ptr[0] = e0_ptr[0].clone();
2955 out_ptr[1] = e0_ptr[1].clone();
2956 out_ptr[2] = e1_val;
2957 out_ptr[3] = e2_ptr[0].clone();
2958 }
2959 }
2960 fn out(&self) -> Value { self.out.to_value() }
2961 fn to_string(&self) -> String { format!("{:#?}", self) }
2962}
2963#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2964#[cfg(feature = "compiler")]
2965impl<T> MechFunctionCompiler for HorizontalConcatenateR2SM1<T>
2966where
2967 T: ConstElem + CompileConst + AsValueKind
2968{
2969 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
2970 let name = format!("HorizontalConcatenateR2SM1<{}>", T::as_value_kind());
2971 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
2972 }
2973}
2974#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2975register_horizontal_concatenate_fxn!(HorizontalConcatenateR2SM1);
2976
2977#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2980#[derive(Debug)]
2981struct HorizontalConcatenateSR2M1<T> {
2982 e0: Ref<T>,
2983 e1: Ref<RowVector2<T>>,
2984 e2: Ref<Matrix1<T>>,
2985 out: Ref<RowVector4<T>>,
2986}
2987#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
2988impl<T> MechFunctionFactory for HorizontalConcatenateSR2M1<T>
2989where
2990 T: Debug + Clone + Sync + Send + PartialEq + 'static +
2991 ConstElem + CompileConst + AsValueKind,
2992 Ref<RowVector4<T>>: ToValue
2993{
2994 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
2995 match args {
2996 FunctionArgs::Ternary(out, arg0, arg1, arg2) => {
2997 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
2998 let e1: Ref<RowVector2<T>> = unsafe { arg1.as_unchecked() }.clone();
2999 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3000 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3001 Ok(Box::new(Self { e0, e1, e2, out }))
3002 },
3003 _ => Err(MechError2::new(
3004 IncorrectNumberOfArguments { expected: 3, found: args.len() },
3005 None
3006 ).with_compiler_loc()
3007 ),
3008 }
3009 }
3010}
3011#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
3012impl<T> MechFunctionImpl for HorizontalConcatenateSR2M1<T>
3013where
3014 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3015 Ref<RowVector4<T>>: ToValue
3016{
3017 fn solve(&self) {
3018 unsafe {
3019 let e0_val = self.e0.borrow().clone();
3020 let e1_ptr = (*(self.e1.as_ptr())).clone();
3021 let e2_ptr = (*(self.e2.as_ptr())).clone();
3022 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3023 out_ptr[0] = e0_val;
3024 out_ptr[1] = e1_ptr[0].clone();
3025 out_ptr[2] = e1_ptr[1].clone();
3026 out_ptr[3] = e2_ptr[0].clone();
3027 }
3028 }
3029 fn out(&self) -> Value { self.out.to_value() }
3030 fn to_string(&self) -> String { format!("{:#?}", self) }
3031}
3032#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
3033#[cfg(feature = "compiler")]
3034impl<T> MechFunctionCompiler for HorizontalConcatenateSR2M1<T>
3035where
3036 T: ConstElem + CompileConst + AsValueKind
3037{
3038 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3039 let name = format!("HorizontalConcatenateSR2M1<{}>", T::as_value_kind());
3040 compile_ternop!(name, self.out, self.e0, self.e1, self.e2, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3041 }
3042}
3043#[cfg(all(feature = "row_vector4", feature = "row_vector2", feature = "matrix1"))]
3044register_horizontal_concatenate_fxn!(HorizontalConcatenateSR2M1);
3045
3046#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3049#[derive(Debug)]
3050struct HorizontalConcatenateSSM1M1<T> {
3051 e0: Ref<T>,
3052 e1: Ref<T>,
3053 e2: Ref<Matrix1<T>>,
3054 e3: Ref<Matrix1<T>>,
3055 out: Ref<RowVector4<T>>,
3056}
3057#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3058impl<T> MechFunctionFactory for HorizontalConcatenateSSM1M1<T>
3059where
3060 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3061 ConstElem + CompileConst + AsValueKind,
3062 Ref<RowVector4<T>>: ToValue
3063{
3064 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3065 match args {
3066 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3067 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
3068 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
3069 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3070 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
3071 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3072 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3073 },
3074 _ => Err(MechError2::new(
3075 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3076 None
3077 ).with_compiler_loc()
3078 ),
3079 }
3080 }
3081}
3082#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3083impl<T> MechFunctionImpl for HorizontalConcatenateSSM1M1<T>
3084where
3085 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3086 Ref<RowVector4<T>>: ToValue
3087{
3088 fn solve(&self) {
3089 unsafe {
3090 let e0_val = self.e0.borrow().clone();
3091 let e1_val = self.e1.borrow().clone();
3092 let e2_ptr = (*(self.e2.as_ptr())).clone();
3093 let e3_ptr = (*(self.e3.as_ptr())).clone();
3094 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3095 out_ptr[0] = e0_val;
3096 out_ptr[1] = e1_val;
3097 out_ptr[2] = e2_ptr[0].clone();
3098 out_ptr[3] = e3_ptr[0].clone();
3099 }
3100 }
3101 fn out(&self) -> Value { self.out.to_value() }
3102 fn to_string(&self) -> String { format!("{:#?}", self) }
3103}
3104#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3105#[cfg(feature = "compiler")]
3106impl<T> MechFunctionCompiler for HorizontalConcatenateSSM1M1<T>
3107where
3108 T: ConstElem + CompileConst + AsValueKind
3109{
3110 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3111 let name = format!("HorizontalConcatenateSSM1M1<{}>", T::as_value_kind());
3112 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3113 }
3114}
3115#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3116register_horizontal_concatenate_fxn!(HorizontalConcatenateSSM1M1);
3117
3118#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3121#[derive(Debug)]
3122struct HorizontalConcatenateM1M1SS<T> {
3123 e0: Ref<Matrix1<T>>,
3124 e1: Ref<Matrix1<T>>,
3125 e2: Ref<T>,
3126 e3: Ref<T>,
3127 out: Ref<RowVector4<T>>,
3128}
3129#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3130impl<T> MechFunctionFactory for HorizontalConcatenateM1M1SS<T>
3131where
3132 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3133 ConstElem + CompileConst + AsValueKind,
3134 Ref<RowVector4<T>>: ToValue
3135{
3136 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3137 match args {
3138 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3139 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3140 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
3141 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
3142 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
3143 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3144 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3145 },
3146 _ => Err(MechError2::new(
3147 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3148 None
3149 ).with_compiler_loc()
3150 ),
3151 }
3152 }
3153}
3154#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3155impl<T> MechFunctionImpl for HorizontalConcatenateM1M1SS<T>
3156where
3157 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3158 Ref<RowVector4<T>>: ToValue
3159{
3160 fn solve(&self) {
3161 unsafe {
3162 let e0_ptr = (*(self.e0.as_ptr())).clone();
3163 let e1_ptr = (*(self.e1.as_ptr())).clone();
3164 let e2_val = self.e2.borrow().clone();
3165 let e3_val = self.e3.borrow().clone();
3166 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3167 out_ptr[0] = e0_ptr[0].clone();
3168 out_ptr[1] = e1_ptr[0].clone();
3169 out_ptr[2] = e2_val;
3170 out_ptr[3] = e3_val;
3171 }
3172 }
3173 fn out(&self) -> Value { self.out.to_value() }
3174 fn to_string(&self) -> String { format!("{:#?}", self) }
3175}
3176#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3177#[cfg(feature = "compiler")]
3178impl<T> MechFunctionCompiler for HorizontalConcatenateM1M1SS<T>
3179where
3180 T: ConstElem + CompileConst + AsValueKind
3181{
3182 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3183 let name = format!("HorizontalConcatenateM1M1SS<{}>", T::as_value_kind());
3184 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3185 }
3186}
3187#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3188register_horizontal_concatenate_fxn!(HorizontalConcatenateM1M1SS);
3189
3190#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3193#[derive(Debug)]
3194struct HorizontalConcatenateSM1M1S<T> {
3195 e0: Ref<T>,
3196 e1: Ref<Matrix1<T>>,
3197 e2: Ref<Matrix1<T>>,
3198 e3: Ref<T>,
3199 out: Ref<RowVector4<T>>,
3200}
3201#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3202impl<T> MechFunctionFactory for HorizontalConcatenateSM1M1S<T>
3203where
3204 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3205 ConstElem + CompileConst + AsValueKind,
3206 Ref<RowVector4<T>>: ToValue
3207{
3208 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3209 match args {
3210 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3211 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
3212 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
3213 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3214 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
3215 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3216 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3217 },
3218 _ => Err(MechError2::new(
3219 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3220 None
3221 ).with_compiler_loc()
3222 ),
3223 }
3224 }
3225}
3226#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3227impl<T> MechFunctionImpl for HorizontalConcatenateSM1M1S<T>
3228where
3229 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3230 Ref<RowVector4<T>>: ToValue
3231{
3232 fn solve(&self) {
3233 unsafe {
3234 let e0_val = self.e0.borrow().clone();
3235 let e1_ptr = (*(self.e1.as_ptr())).clone();
3236 let e2_ptr = (*(self.e2.as_ptr())).clone();
3237 let e3_val = self.e3.borrow().clone();
3238 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3239 out_ptr[0] = e0_val;
3240 out_ptr[1] = e1_ptr[0].clone();
3241 out_ptr[2] = e2_ptr[0].clone();
3242 out_ptr[3] = e3_val;
3243 }
3244 }
3245 fn out(&self) -> Value { self.out.to_value() }
3246 fn to_string(&self) -> String { format!("{:#?}", self) }
3247}
3248#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3249#[cfg(feature = "compiler")]
3250impl<T> MechFunctionCompiler for HorizontalConcatenateSM1M1S<T>
3251where
3252 T: ConstElem + CompileConst + AsValueKind
3253{
3254 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3255 let name = format!("HorizontalConcatenateSM1M1S<{}>", T::as_value_kind());
3256 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3257 }
3258}
3259#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3260register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1M1S);
3261
3262#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3265#[derive(Debug)]
3266struct HorizontalConcatenateM1SSM1<T> {
3267 e0: Ref<Matrix1<T>>,
3268 e1: Ref<T>,
3269 e2: Ref<T>,
3270 e3: Ref<Matrix1<T>>,
3271 out: Ref<RowVector4<T>>,
3272}
3273#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3274impl<T> MechFunctionFactory for HorizontalConcatenateM1SSM1<T>
3275where
3276 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3277 ConstElem + CompileConst + AsValueKind,
3278 Ref<RowVector4<T>>: ToValue
3279{
3280 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3281 match args {
3282 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3283 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3284 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
3285 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
3286 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
3287 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3288 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3289 },
3290 _ => Err(MechError2::new(
3291 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3292 None
3293 ).with_compiler_loc()
3294 ),
3295 }
3296 }
3297}
3298#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3299impl<T> MechFunctionImpl for HorizontalConcatenateM1SSM1<T>
3300where
3301 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3302 Ref<RowVector4<T>>: ToValue
3303{
3304 fn solve(&self) {
3305 unsafe {
3306 let e0_ptr = (*(self.e0.as_ptr())).clone();
3307 let e1_val = self.e1.borrow().clone();
3308 let e2_val = self.e2.borrow().clone();
3309 let e3_ptr = (*(self.e3.as_ptr())).clone();
3310 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3311 out_ptr[0] = e0_ptr[0].clone();
3312 out_ptr[1] = e1_val;
3313 out_ptr[2] = e2_val;
3314 out_ptr[3] = e3_ptr[0].clone();
3315 }
3316 }
3317 fn out(&self) -> Value { self.out.to_value() }
3318 fn to_string(&self) -> String { format!("{:#?}", self) }
3319}
3320#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3321#[cfg(feature = "compiler")]
3322impl<T> MechFunctionCompiler for HorizontalConcatenateM1SSM1<T>
3323where
3324 T: ConstElem + CompileConst + AsValueKind
3325{
3326 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3327 let name = format!("HorizontalConcatenateM1SSM1<{}>", T::as_value_kind());
3328 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3329 }
3330}
3331#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3332register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SSM1);
3333
3334#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3337#[derive(Debug)]
3338struct HorizontalConcatenateM1SM1S<T> {
3339 e0: Ref<Matrix1<T>>,
3340 e1: Ref<T>,
3341 e2: Ref<Matrix1<T>>,
3342 e3: Ref<T>,
3343 out: Ref<RowVector4<T>>,
3344}
3345#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3346impl<T> MechFunctionFactory for HorizontalConcatenateM1SM1S<T>
3347where
3348 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3349 ConstElem + CompileConst + AsValueKind,
3350 Ref<RowVector4<T>>: ToValue
3351{
3352 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3353 match args {
3354 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3355 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3356 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
3357 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3358 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
3359 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3360 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3361 },
3362 _ => Err(MechError2::new(
3363 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3364 None
3365 ).with_compiler_loc()
3366 ),
3367 }
3368 }
3369}
3370#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3371impl<T> MechFunctionImpl for HorizontalConcatenateM1SM1S<T>
3372where
3373 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3374 Ref<RowVector4<T>>: ToValue
3375{
3376 fn solve(&self) {
3377 unsafe {
3378 let e0_ptr = (*(self.e0.as_ptr())).clone();
3379 let e1_val = self.e1.borrow().clone();
3380 let e2_ptr = (*(self.e2.as_ptr())).clone();
3381 let e3_val = self.e3.borrow().clone();
3382 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3383 out_ptr[0] = e0_ptr[0].clone();
3384 out_ptr[1] = e1_val;
3385 out_ptr[2] = e2_ptr[0].clone();
3386 out_ptr[3] = e3_val;
3387 }
3388 }
3389 fn out(&self) -> Value { self.out.to_value() }
3390 fn to_string(&self) -> String { format!("{:#?}", self) }
3391}
3392#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3393#[cfg(feature = "compiler")]
3394impl<T> MechFunctionCompiler for HorizontalConcatenateM1SM1S<T>
3395where
3396 T: ConstElem + CompileConst + AsValueKind
3397{
3398 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3399 let name = format!("HorizontalConcatenateM1SM1S<{}>", T::as_value_kind());
3400 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3401 }
3402}
3403#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3404register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SM1S);
3405
3406macro_rules! horzcat_m1r2 {
3409 ($out:expr, $e0:expr, $e1:expr) => {
3410 $out[0] = $e0[0].clone();
3411 $out[1] = $e1[0].clone();
3412 $out[2] = $e1[1].clone();
3413 };
3414}
3415#[cfg(all(feature = "row_vector3", feature = "matrix1", feature = "row_vector2"))]
3416horzcat_two_args!(HorizontalConcatenateM1R2, Matrix1, RowVector2, RowVector3, horzcat_m1r2);
3417
3418macro_rules! horzcat_r2m1 {
3421 ($out:expr, $e0:expr, $e1:expr) => {
3422 $out[0] = $e0[0].clone();
3423 $out[1] = $e0[1].clone();
3424 $out[2] = $e1[0].clone();
3425 };
3426}
3427#[cfg(all(feature = "row_vector3", feature = "matrix1", feature = "row_vector2"))]
3428horzcat_two_args!(HorizontalConcatenateR2M1, RowVector2, Matrix1, RowVector3, horzcat_r2m1);
3429
3430macro_rules! horzcat_m1m1m1 {
3433 ($out:expr, $e0:expr,$e1:expr,$e2:expr) => {
3434 $out[0] = $e0[0].clone();
3435 $out[1] = $e1[0].clone();
3436 $out[2] = $e2[0].clone();
3437 };
3438}
3439#[cfg(all(feature = "row_vector3", feature = "matrix1"))]
3440horzcat_three_args!(HorizontalConcatenateM1M1M1,Matrix1,Matrix1,Matrix1,RowVector3, horzcat_m1m1m1);
3441
3442macro_rules! horzcat_m1m1r2 {
3445 ($out:expr, $e0:expr, $e1:expr, $e2:expr) => {
3446 $out[0] = $e0[0].clone();
3447 $out[1] = $e1[0].clone();
3448 $out[2] = $e2[0].clone();
3449 $out[3] = $e2[1].clone();
3450 };
3451}
3452#[cfg(all(feature = "row_vector4", feature = "matrix1", feature = "row_vector2"))]
3453horzcat_three_args!(HorizontalConcatenateM1M1R2, Matrix1, Matrix1, RowVector2, RowVector4, horzcat_m1m1r2);
3454
3455macro_rules! horzcat_m1r2m1 {
3458 ($out:expr, $e0:expr, $e1:expr, $e2:expr) => {
3459 $out[0] = $e0[0].clone();
3460 $out[1] = $e1[0].clone();
3461 $out[2] = $e1[1].clone();
3462 $out[3] = $e2[0].clone();
3463 };
3464}
3465#[cfg(all(feature = "row_vector4", feature = "matrix1", feature = "row_vector2"))]
3466horzcat_three_args!(HorizontalConcatenateM1R2M1, Matrix1, RowVector2, Matrix1, RowVector4, horzcat_m1r2m1);
3467
3468macro_rules! horzcat_r2m1m1 {
3469 ($out:expr, $e0:expr, $e1:expr, $e2:expr) => {
3470 $out[0] = $e0[0].clone();
3471 $out[1] = $e0[1].clone();
3472 $out[2] = $e1[0].clone();
3473 $out[3] = $e2[0].clone();
3474 };
3475}
3476#[cfg(all(feature = "row_vector4", feature = "matrix1", feature = "row_vector2"))]
3477horzcat_three_args!(HorizontalConcatenateR2M1M1, RowVector2, Matrix1, Matrix1, RowVector4, horzcat_r2m1m1);
3478
3479#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3482#[derive(Debug)]
3483struct HorizontalConcatenateSM1M1M1<T> {
3484 e0: Ref<T>,
3485 e1: Ref<Matrix1<T>>,
3486 e2: Ref<Matrix1<T>>,
3487 e3: Ref<Matrix1<T>>,
3488 out: Ref<RowVector4<T>>,
3489}
3490#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3491impl<T> MechFunctionFactory for HorizontalConcatenateSM1M1M1<T>
3492where
3493 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3494 ConstElem + CompileConst + AsValueKind,
3495 Ref<RowVector4<T>>: ToValue
3496{
3497 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3498 match args {
3499 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3500 let e0: Ref<T> = unsafe { arg0.as_unchecked() }.clone();
3501 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
3502 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3503 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
3504 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3505 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3506 },
3507 _ => Err(MechError2::new(
3508 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3509 None
3510 ).with_compiler_loc()
3511 ),
3512 }
3513 }
3514}
3515#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3516impl<T> MechFunctionImpl for HorizontalConcatenateSM1M1M1<T>
3517where
3518 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3519 Ref<RowVector4<T>>: ToValue,
3520{
3521 fn solve(&self) {
3522 unsafe {
3523 let e0_val = self.e0.borrow().clone();
3524 let e1_ptr = (*(self.e1.as_ptr())).clone();
3525 let e2_ptr = (*(self.e2.as_ptr())).clone();
3526 let e3_ptr = (*(self.e3.as_ptr())).clone();
3527 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3528 out_ptr[0] = e0_val;
3529 out_ptr[1] = e1_ptr[0].clone();
3530 out_ptr[2] = e2_ptr[0].clone();
3531 out_ptr[3] = e3_ptr[0].clone();
3532 }
3533 }
3534 fn out(&self) -> Value { self.out.to_value() }
3535 fn to_string(&self) -> String { format!("{:#?}", self) }
3536}
3537#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3538#[cfg(feature = "compiler")]
3539impl<T> MechFunctionCompiler for HorizontalConcatenateSM1M1M1<T>
3540where
3541 T: ConstElem + CompileConst + AsValueKind
3542{
3543 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3544 let name = format!("HorizontalConcatenateSM1M1M1<{}>", T::as_value_kind());
3545 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3546 }
3547}
3548#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3549register_horizontal_concatenate_fxn!(HorizontalConcatenateSM1M1M1);
3550
3551#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3554#[derive(Debug)]
3555struct HorizontalConcatenateM1SM1M1<T> {
3556 e0: Ref<Matrix1<T>>,
3557 e1: Ref<T>,
3558 e2: Ref<Matrix1<T>>,
3559 e3: Ref<Matrix1<T>>,
3560 out: Ref<RowVector4<T>>,
3561}
3562#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3563impl<T> MechFunctionFactory for HorizontalConcatenateM1SM1M1<T>
3564where
3565 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3566 ConstElem + CompileConst + AsValueKind,
3567 Ref<RowVector4<T>>: ToValue
3568{
3569 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3570 match args {
3571 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3572 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3573 let e1: Ref<T> = unsafe { arg1.as_unchecked() }.clone();
3574 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3575 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
3576 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3577 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3578 },
3579 _ => Err(MechError2::new(
3580 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3581 None
3582 ).with_compiler_loc()
3583 ),
3584 }
3585 }
3586}
3587#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3588impl<T> MechFunctionImpl for HorizontalConcatenateM1SM1M1<T>
3589where
3590 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3591 Ref<RowVector4<T>>: ToValue
3592{
3593 fn solve(&self) {
3594 unsafe {
3595 let e0_ptr = (*(self.e0.as_ptr())).clone();
3596 let e1_val = self.e1.borrow().clone();
3597 let e2_ptr = (*(self.e2.as_ptr())).clone();
3598 let e3_ptr = (*(self.e3.as_ptr())).clone();
3599 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3600 out_ptr[0] = e0_ptr[0].clone();
3601 out_ptr[1] = e1_val;
3602 out_ptr[2] = e2_ptr[0].clone();
3603 out_ptr[3] = e3_ptr[0].clone();
3604 }
3605 }
3606 fn out(&self) -> Value { self.out.to_value() }
3607 fn to_string(&self) -> String { format!("{:#?}", self) }
3608}
3609#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3610#[cfg(feature = "compiler")]
3611impl<T> MechFunctionCompiler for HorizontalConcatenateM1SM1M1<T>
3612where
3613 T: ConstElem + CompileConst + AsValueKind
3614{
3615 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3616 let name = format!("HorizontalConcatenateM1SM1M1<{}>", T::as_value_kind());
3617 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3618 }
3619}
3620#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3621register_horizontal_concatenate_fxn!(HorizontalConcatenateM1SM1M1);
3622
3623#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3626#[derive(Debug)]
3627struct HorizontalConcatenateM1M1SM1<T> {
3628 e0: Ref<Matrix1<T>>,
3629 e1: Ref<Matrix1<T>>,
3630 e2: Ref<T>,
3631 e3: Ref<Matrix1<T>>,
3632 out: Ref<RowVector4<T>>,
3633}
3634#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3635impl<T> MechFunctionFactory for HorizontalConcatenateM1M1SM1<T>
3636where
3637 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3638 ConstElem + CompileConst + AsValueKind,
3639 Ref<RowVector4<T>>: ToValue
3640{
3641 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3642 match args {
3643 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3644 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3645 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
3646 let e2: Ref<T> = unsafe { arg2.as_unchecked() }.clone();
3647 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
3648 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3649 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3650 },
3651 _ => Err(MechError2::new(
3652 IncorrectNumberOfArguments { expected: 4, found: args.len() },
3653 None
3654 ).with_compiler_loc()
3655 ),
3656 }
3657 }
3658}
3659#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3660impl<T> MechFunctionImpl for HorizontalConcatenateM1M1SM1<T>
3661where
3662 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3663 Ref<RowVector4<T>>: ToValue
3664{
3665 fn solve(&self) {
3666 unsafe {
3667 let e0_ptr = (*(self.e0.as_ptr())).clone();
3668 let e1_ptr = (*(self.e1.as_ptr())).clone();
3669 let e2_val = self.e2.borrow().clone();
3670 let e3_ptr = (*(self.e3.as_ptr())).clone();
3671 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3672 out_ptr[0] = e0_ptr[0].clone();
3673 out_ptr[1] = e1_ptr[0].clone();
3674 out_ptr[2] = e2_val;
3675 out_ptr[3] = e3_ptr[0].clone();
3676 }
3677 }
3678 fn out(&self) -> Value { self.out.to_value() }
3679 fn to_string(&self) -> String { format!("{:#?}", self) }
3680}
3681#[cfg(all(feature = "row_vector4", feature = "matrix1", feature = "compiler"))]
3682impl<T> MechFunctionCompiler for HorizontalConcatenateM1M1SM1<T>
3683where
3684 T: ConstElem + CompileConst + AsValueKind
3685{
3686 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3687 let name = format!("HorizontalConcatenateM1M1SM1<{}>", T::as_value_kind());
3688 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3689 }
3690}
3691#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3692register_horizontal_concatenate_fxn!(HorizontalConcatenateM1M1SM1);
3693
3694#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3697#[derive(Debug)]
3698struct HorizontalConcatenateM1M1M1S<T> {
3699 e0: Ref<Matrix1<T>>,
3700 e1: Ref<Matrix1<T>>,
3701 e2: Ref<Matrix1<T>>,
3702 e3: Ref<T>,
3703 out: Ref<RowVector4<T>>,
3704}
3705#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3706impl<T> MechFunctionFactory for HorizontalConcatenateM1M1M1S<T>
3707where
3708 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3709 ConstElem + CompileConst + AsValueKind,
3710 Ref<RowVector4<T>>: ToValue
3711{
3712 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3713 match args {
3714 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3715 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3716 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
3717 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3718 let e3: Ref<T> = unsafe { arg3.as_unchecked() }.clone();
3719 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3720 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3721 },
3722 _ => Err(MechError2::new(
3723 IncorrectNumberOfArguments { expected: 2, found: args.len() },
3724 None
3725 ).with_compiler_loc()
3726 ),
3727 }
3728 }
3729}
3730#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3731impl<T> MechFunctionImpl for HorizontalConcatenateM1M1M1S<T>
3732where
3733 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3734 Ref<RowVector4<T>>: ToValue
3735{
3736 fn solve(&self) {
3737 unsafe {
3738 let e0_ptr = (*(self.e0.as_ptr())).clone();
3739 let e1_ptr = (*(self.e1.as_ptr())).clone();
3740 let e2_ptr = (*(self.e2.as_ptr())).clone();
3741 let e3_val = self.e3.borrow().clone();
3742 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3743 out_ptr[0] = e0_ptr[0].clone();
3744 out_ptr[1] = e1_ptr[0].clone();
3745 out_ptr[2] = e2_ptr[0].clone();
3746 out_ptr[3] = e3_val;
3747 }
3748 }
3749 fn out(&self) -> Value { self.out.to_value() }
3750 fn to_string(&self) -> String { format!("{:#?}", self) }
3751}
3752#[cfg(all(feature = "row_vector4", feature = "matrix1", feature = "compiler"))]
3753impl<T> MechFunctionCompiler for HorizontalConcatenateM1M1M1S<T>
3754where
3755 T: ConstElem + CompileConst + AsValueKind
3756{
3757 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3758 let name = format!("HorizontalConcatenateM1M1M1S<{}>", T::as_value_kind());
3759 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3760 }
3761}
3762#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3763register_horizontal_concatenate_fxn!(HorizontalConcatenateM1M1M1S);
3764
3765#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3768#[derive(Debug)]
3769struct HorizontalConcatenateM1M1M1M1<T> {
3770 e0: Ref<Matrix1<T>>,
3771 e1: Ref<Matrix1<T>>,
3772 e2: Ref<Matrix1<T>>,
3773 e3: Ref<Matrix1<T>>,
3774 out: Ref<RowVector4<T>>,
3775}
3776#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3777impl<T> MechFunctionFactory for HorizontalConcatenateM1M1M1M1<T>
3778where
3779 T: Debug + Clone + Sync + Send + PartialEq + 'static +
3780 ConstElem + CompileConst + AsValueKind,
3781 Ref<RowVector4<T>>: ToValue
3782{
3783 fn new(args: FunctionArgs) -> MResult<Box<dyn MechFunction>> {
3784 match args {
3785 FunctionArgs::Quaternary(out, arg0, arg1, arg2, arg3) => {
3786 let e0: Ref<Matrix1<T>> = unsafe { arg0.as_unchecked() }.clone();
3787 let e1: Ref<Matrix1<T>> = unsafe { arg1.as_unchecked() }.clone();
3788 let e2: Ref<Matrix1<T>> = unsafe { arg2.as_unchecked() }.clone();
3789 let e3: Ref<Matrix1<T>> = unsafe { arg3.as_unchecked() }.clone();
3790 let out: Ref<RowVector4<T>> = unsafe { out.as_unchecked() }.clone();
3791 Ok(Box::new(Self { e0, e1, e2, e3, out }))
3792 },
3793 _ => Err(MechError2::new(
3794 IncorrectNumberOfArguments { expected: 2, found: args.len() },
3795 None
3796 ).with_compiler_loc()
3797 ),
3798 }
3799 }
3800}
3801#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3802impl<T> MechFunctionImpl for HorizontalConcatenateM1M1M1M1<T>
3803where
3804 T: Debug + Clone + Sync + Send + PartialEq + 'static,
3805 Ref<RowVector4<T>>: ToValue,
3806{
3807 fn solve(&self) {
3808 unsafe {
3809 let e0_ptr = (*(self.e0.as_ptr())).clone();
3810 let e1_ptr = (*(self.e1.as_ptr())).clone();
3811 let e2_ptr = (*(self.e2.as_ptr())).clone();
3812 let e3_ptr = (*(self.e3.as_ptr())).clone();
3813 let mut out_ptr = (&mut *(self.out.as_mut_ptr()));
3814 out_ptr[0] = e0_ptr[0].clone();
3815 out_ptr[1] = e1_ptr[0].clone();
3816 out_ptr[2] = e2_ptr[0].clone();
3817 out_ptr[3] = e3_ptr[0].clone();
3818 }
3819 }
3820 fn out(&self) -> Value { self.out.to_value() }
3821 fn to_string(&self) -> String { format!("{:#?}", self) }
3822}
3823#[cfg(all(feature = "row_vector4", feature = "matrix1", feature = "compiler"))]
3824impl<T> MechFunctionCompiler for HorizontalConcatenateM1M1M1M1<T>
3825where
3826 T: ConstElem + CompileConst + AsValueKind
3827{
3828 fn compile(&self, ctx: &mut CompileCtx) -> MResult<Register> {
3829 let name = format!("HorizontalConcatenateM1M1M1M1<{}>", T::as_value_kind());
3830 compile_quadop!(name, self.out, self.e0, self.e1, self.e2, self.e3, ctx, FeatureFlag::Builtin(FeatureKind::HorzCat));
3831 }
3832}
3833#[cfg(all(feature = "row_vector4", feature = "matrix1"))]
3834register_horizontal_concatenate_fxn!(HorizontalConcatenateM1M1M1M1);
3835
3836macro_rules! horzcat_v2v2 {
3839 ($out:expr, $e0:expr, $e1:expr) => {
3840 $out[0] = $e0[0].clone();
3841 $out[1] = $e0[1].clone();
3842 $out[2] = $e1[0].clone();
3843 $out[3] = $e1[1].clone();
3844 };
3845}
3846#[cfg(all(feature = "vector2", feature = "matrix2"))]
3847horzcat_two_args!(HorizontalConcatenateV2V2, Vector2, Vector2, Matrix2, horzcat_v2v2);
3848
3849macro_rules! horzcat_v3v3 {
3850 ($out:expr, $e0:expr, $e1:expr) => {
3851 $out[0] = $e0[0].clone();
3852 $out[1] = $e0[1].clone();
3853 $out[2] = $e0[2].clone();
3854 $out[3] = $e1[0].clone();
3855 $out[4] = $e1[1].clone();
3856 $out[5] = $e1[2].clone();
3857 };
3858}
3859#[cfg(all(feature = "vector3", feature = "matrix3x2"))]
3860horzcat_two_args!(HorizontalConcatenateV3V3, Vector3, Vector3, Matrix3x2, horzcat_v3v3);
3861
3862macro_rules! horzcat_v2m2 {
3865 ($out:expr, $e0:expr, $e1:expr) => {
3866 $out[0] = $e0[0].clone();
3867 $out[1] = $e0[1].clone();
3868 $out[2] = $e1[0].clone();
3869 $out[3] = $e1[1].clone();
3870 $out[4] = $e1[2].clone();
3871 $out[5] = $e1[3].clone();
3872 };
3873}
3874#[cfg(all(feature = "vector2", feature = "matrix2", feature = "matrix2x3"))]
3875horzcat_two_args!(HorizontalConcatenateV2M2, Vector2, Matrix2, Matrix2x3, horzcat_v2m2);
3876
3877macro_rules! horzcat_m2v2 {
3880 ($out:expr, $e0:expr, $e1:expr) => {
3881 $out[0] = $e0[0].clone();
3882 $out[1] = $e0[1].clone();
3883 $out[2] = $e0[2].clone();
3884 $out[3] = $e0[3].clone();
3885 $out[4] = $e1[0].clone();
3886 $out[5] = $e1[1].clone();
3887 };
3888}
3889#[cfg(all(feature = "vector2", feature = "matrix2", feature = "matrix2x3"))]
3890horzcat_two_args!(HorizontalConcatenateM2V2, Matrix2, Vector2, Matrix2x3, horzcat_m2v2);
3891
3892macro_rules! horzcat_m3x2v3 {
3895 ($out:expr, $e0:expr, $e1:expr) => {
3896 $out[0] = $e0[0].clone();
3897 $out[1] = $e0[1].clone();
3898 $out[2] = $e0[2].clone();
3899 $out[3] = $e0[3].clone();
3900 $out[4] = $e0[4].clone();
3901 $out[5] = $e0[5].clone();
3902 $out[6] = $e1[0].clone();
3903 $out[7] = $e1[1].clone();
3904 $out[8] = $e1[2].clone();
3905 };
3906}
3907#[cfg(all(feature = "vector3", feature = "matrix3x2", feature = "matrix3"))]
3908horzcat_two_args!(HorizontalConcatenateM3x2V3, Matrix3x2, Vector3, Matrix3, horzcat_m3x2v3);
3909
3910macro_rules! horzcat_v3m3x2 {
3913 ($out:expr, $e0:expr, $e1:expr) => {
3914 $out[0] = $e0[0].clone();
3915 $out[1] = $e0[1].clone();
3916 $out[2] = $e0[2].clone();
3917 $out[3] = $e1[0].clone();
3918 $out[4] = $e1[1].clone();
3919 $out[5] = $e1[2].clone();
3920 $out[6] = $e1[3].clone();
3921 $out[7] = $e1[4].clone();
3922 $out[8] = $e1[5].clone();
3923 };
3924}
3925#[cfg(all(feature = "vector3", feature = "matrix3x2", feature = "matrix3"))]
3926horzcat_two_args!(HorizontalConcatenateV3M3x2, Vector3, Matrix3x2, Matrix3, horzcat_v3m3x2);
3927
3928macro_rules! horzcat_v4md {
3931 ($out:expr, $e0:expr, $e1:expr) => {
3932 $out[0] = $e0[0].clone();
3933 $out[1] = $e0[1].clone();
3934 $out[2] = $e0[2].clone();
3935 $out[3] = $e0[3].clone();
3936 let offset = 4;
3937 for i in 0..$e1.len() {
3938 $out[i + offset] = $e1[i].clone();
3939 }
3940 };
3941}
3942#[cfg(all(feature = "matrixd", feature = "matrix4", feature = "vector4"))]
3943horzcat_two_args!(HorizontalConcatenateV4MD, Vector4, DMatrix, Matrix4, horzcat_v4md);
3944
3945macro_rules! horzcat_mdv4 {
3948 ($out:expr, $e0:expr, $e1:expr) => {
3949 let e0_len = $e0.len();
3950 for i in 0..e0_len {
3951 $out[i] = $e0[i].clone();
3952 }
3953 let offset = e0_len;
3954 $out[offset] = $e1[0].clone();
3955 $out[offset + 1] = $e1[1].clone();
3956 $out[offset + 2] = $e1[2].clone();
3957 $out[offset + 3] = $e1[3].clone();
3958 };
3959}
3960#[cfg(all(feature = "matrixd", feature = "matrix4", feature = "vector4"))]
3961horzcat_two_args!(HorizontalConcatenateMDV4, DMatrix, Vector4, Matrix4, horzcat_mdv4);
3962
3963macro_rules! horzcat_mdmd {
3966 ($out:expr, $e0:expr, $e1:expr) => {
3967 let e0_len = $e0.len();
3968 for i in 0..e0_len {
3969 $out[i] = $e0[i].clone();
3970 }
3971 let offset = e0_len;
3972 for i in 0..$e1.len() {
3973 $out[i + offset] = $e1[i].clone();
3974 }
3975 };
3976}
3977#[cfg(all(feature = "matrixd", feature = "matrix4"))]
3978horzcat_two_args!(HorizontalConcatenateMDMD, DMatrix, DMatrix, Matrix4, horzcat_mdmd);
3979
3980macro_rules! horzcat_mdmdmd {
3983 ($out:expr, $e0:expr, $e1:expr, $e2:expr) => {
3984 let e0_len = $e0.len();
3985 for i in 0..e0_len {
3986 $out[i] = $e0[i].clone();
3987 }
3988 let offset = e0_len;
3989 for i in 0..$e1.len() {
3990 $out[i + offset] = $e1[i].clone();
3991 }
3992 let offset = offset + $e1.len();
3993 for i in 0..$e2.len() {
3994 $out[i + offset] = $e2[i].clone();
3995 }
3996 };
3997}
3998
3999#[cfg(all(feature = "vector2", feature = "matrix2x3"))]
4002horzcat_three_args!(HorizontalConcatenateV2V2V2, Vector2, Vector2, Vector2, Matrix2x3, horzcat_mdmdmd);
4003
4004#[cfg(all(feature = "vector3", feature = "matrix3"))]
4007horzcat_three_args!(HorizontalConcatenateV3V3V3, Vector3, Vector3, Vector3, Matrix3, horzcat_mdmdmd);
4008
4009#[cfg(all(feature = "matrixd", feature = "vector4", feature = "matrix4"))]
4012horzcat_three_args!(HorizontalConcatenateV4V4MD, Vector4, Vector4, DMatrix, Matrix4, horzcat_mdmdmd);
4013
4014#[cfg(all(feature = "matrixd", feature = "vector4", feature = "matrix4"))]
4017horzcat_three_args!(HorizontalConcatenateV4MDV4, Vector4, DMatrix, Vector4, Matrix4, horzcat_mdmdmd);
4018
4019#[cfg(all(feature = "matrixd", feature = "vector4", feature = "matrix4"))]
4022horzcat_three_args!(HorizontalConcatenateMDV4V4, DMatrix, Vector4, Vector4, Matrix4, horzcat_mdmdmd);
4023
4024
4025macro_rules! horzcat_mdmdmdmd {
4028 ($out:expr, $e0:expr, $e1:expr, $e2:expr, $e3:expr) => {
4029 let e0_len = $e0.len();
4030 for i in 0..e0_len {
4031 $out[i] = $e0[i].clone();
4032 }
4033 let offset = e0_len;
4034 for i in 0..$e1.len() {
4035 $out[i + offset] = $e1[i].clone();
4036 }
4037 let offset = offset + $e1.len();
4038 for i in 0..$e2.len() {
4039 $out[i + offset] = $e2[i].clone();
4040 }
4041 let offset = offset + $e2.len();
4042 for i in 0..$e3.len() {
4043 $out[i + offset] = $e3[i].clone();
4044 }
4045 };
4046}
4047
4048#[cfg(all(feature = "matrix4", feature = "vector4"))]
4049horzcat_four_args!(HorizontalConcatenateV4V4V4V4, Vector4, Vector4, Vector4, Vector4, Matrix4, horzcat_mdmdmdmd);
4050
4051macro_rules! impl_horzcat_arms {
4052 ($kind:ident, $args:expr, $default:expr) => {
4053 paste!{
4054 {
4055
4056 #[cfg(feature = "matrix")]
4057 fn extract_matrix(arg: &Value) -> MResult<Box<dyn CopyMat<$kind>>> {
4058 match arg {
4059 Value::[<Matrix $kind:camel>](m) => Ok(m.get_copyable_matrix()),
4060 Value::MutableReference(inner) => match &*inner.borrow() {
4061 Value::[<Matrix $kind:camel>](m) => Ok(m.get_copyable_matrix()),
4062 _ => Err(MechError2::new(UnhandledFunctionArgumentKind1{arg: arg.kind(), fxn_name: "matrix/horzcat".to_string()},None).with_compiler_loc())
4063 },
4064 _ => Err(MechError2::new(UnhandledFunctionArgumentKind1{arg: arg.kind(), fxn_name: "matrix/horzcat".to_string()},None).with_compiler_loc())
4065 }
4066 }
4067 #[cfg(feature = "row_vector2")] fn get_r2(value: &Value) -> Option<Ref<RowVector2<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::RowVector2(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::RowVector2(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4069 #[cfg(not(feature = "row_vector2"))]
4070 fn get_r2(_value: &Value) -> Option<()> { None }
4071
4072 #[cfg(feature = "row_vector3")] fn get_r3(value: &Value) -> Option<Ref<RowVector3<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::RowVector3(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::RowVector3(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4074 #[cfg(not(feature = "row_vector3"))]
4075 fn get_r3(_value: &Value) -> Option<()> { None }
4076
4077 #[cfg(feature = "row_vector4")] fn get_r4(value: &Value) -> Option<Ref<RowVector4<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::RowVector4(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::RowVector4(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4079 #[cfg(not(feature = "row_vector4"))]
4080 fn get_r4(_value: &Value) -> Option<()> { None }
4081
4082 #[cfg(feature = "vector2")] fn get_v2(value: &Value) -> Option<Ref<Vector2<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Vector2(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Vector2(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4084 #[cfg(not(feature = "vector2"))]
4085 fn get_v2(_value: &Value) -> Option<()> { None }
4086
4087 #[cfg(feature = "vector3")] fn get_v3(value: &Value) -> Option<Ref<Vector3<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Vector3(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Vector3(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4089 #[cfg(not(feature = "vector3"))]
4090 fn get_v3(_value: &Value) -> Option<()> { None }
4091
4092 #[cfg(feature = "vector4")] fn get_v4(value: &Value) -> Option<Ref<Vector4<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Vector4(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Vector4(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4094 #[cfg(not(feature = "vector4"))]
4095 fn get_v4(_value: &Value) -> Option<()> { None }
4096
4097 #[cfg(feature = "matrixd")] fn get_md(value: &Value) -> Option<Ref<DMatrix<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::DMatrix(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::DMatrix(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4099 #[cfg(not(feature = "matrixd"))]
4100 fn get_md(_value: &Value) -> Option<()> { None }
4101
4102 #[cfg(feature = "vectord")] fn get_vd(value: &Value) -> Option<Ref<DVector<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::DVector(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::DVector(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4104 #[cfg(not(feature = "vectord"))]
4105 fn get_vd(_value: &Value) -> Option<()> { None }
4106
4107 #[cfg(feature = "row_vectord")] fn get_rd(value: &Value) -> Option<Ref<RowDVector<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::RowDVector(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::RowDVector(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4109 #[cfg(not(feature = "row_vectord"))]
4110 fn get_rd(_value: &Value) -> Option<()> { None }
4111
4112 #[cfg(feature = "matrix3x2")] fn get_m3x2(value: &Value) -> Option<Ref<Matrix3x2<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Matrix3x2(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Matrix3x2(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4114 #[cfg(not(feature = "matrix3x2"))]
4115 fn get_m3x2(_value: &Value) -> Option<()> { None }
4116
4117 #[cfg(feature = "matrix2x3")] fn get_m2x3(value: &Value) -> Option<Ref<Matrix2x3<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Matrix2x3(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Matrix2x3(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4119 #[cfg(not(feature = "matrix2x3"))]
4120 fn get_m2x3(_value: &Value) -> Option<()> { None }
4121
4122 #[cfg(feature = "matrix1")] fn get_m1(value: &Value) -> Option<Ref<Matrix1<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Matrix1(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Matrix1(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4124 #[cfg(not(feature = "matrix1"))]
4125 fn get_m1(_value: &Value) -> Option<()> { None }
4126
4127 #[cfg(feature = "matrix2")] fn get_m2(value: &Value) -> Option<Ref<Matrix2<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Matrix2(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Matrix2(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4129 #[cfg(not(feature = "matrix2"))]
4130 fn get_m2(_value: &Value) -> Option<()> { None }
4131
4132 #[cfg(feature = "matrix3")] fn get_m3(value: &Value) -> Option<Ref<Matrix3<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Matrix3(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Matrix3(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4134 #[cfg(not(feature = "matrix3"))]
4135 fn get_m3(_value: &Value) -> Option<()> { None }
4136
4137 #[cfg(feature = "matrix4")] fn get_m4(value: &Value) -> Option<Ref<Matrix4<$kind>>> { match value { Value::[<Matrix $kind:camel>](Matrix::Matrix4(v)) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<Matrix $kind:camel>](Matrix::Matrix4(v)) => Some(v.clone()), _ => None, }, _ => None, } }
4139 #[cfg(not(feature = "matrix4"))]
4140 fn get_m4(_value: &Value) -> Option<()> { None }
4141
4142 fn get_s(value: &Value) -> Option<Ref<$kind>> { match value { Value::[<$kind:camel>](v) => Some(v.clone()), Value::MutableReference(inner) => match &*inner.borrow() { Value::[<$kind:camel>](v) => Some(v.clone()), _ => None, }, _ => None, } }
4143
4144 let arguments = $args;
4145 let rows = arguments[0].shape()[0];
4146 let columns:usize = arguments.iter().fold(0, |acc, x| acc + x.shape()[1]);
4147 let rows:usize = arguments[0].shape()[0];
4148 let nargs = arguments.len();
4149 let kinds: Vec<ValueKind> = arguments.iter().map(|x| x.kind()).collect::<Vec<ValueKind>>();
4150 let no_refs = !kinds.iter().any(|x| {
4151 match x {
4152 ValueKind::Reference(_) => true,
4153 _ => false,
4154 }});
4155 match (nargs,rows,columns) {
4156 #[cfg(feature = "matrix1")]
4157 (1,1,1) => {
4158 let a_m1 = get_m1(&arguments[0]);
4159 let a_sc = get_s(&arguments[0]);
4160 match (a_m1, a_sc) {
4161 (Some(ref e0), None) => return Ok(Box::new(HorizontalConcatenateM1{out: e0.clone()})),
4162 (None, Some(ref e0)) => return Ok(Box::new(HorizontalConcatenateS1{arg: e0.clone(), out: Ref::new(Matrix1::from_element($default))})),
4163 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix1".to_string())).with_compiler_loc()),
4164 }
4165 }
4166 #[cfg(all(feature = "matrixd", not(feature = "matrix1")))]
4167 (1,1,1) => {
4168 let a_m1 = get_md(&arguments[0]);
4169 let a_sc = get_s(&arguments[0]);
4170 match (a_m1, a_sc) {
4171 (Some(ref e0), None) => return Ok(Box::new(HorizontalConcatenateMD{out: e0.clone()})),
4172 (None, Some(ref e0)) => return Ok(Box::new(HorizontalConcatenateS1D{arg: e0.clone(), out: Ref::new(DMatrix::from_element(1,1,$default))})),
4173 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrixd".to_string())).with_compiler_loc()),
4174 }
4175 }
4176 #[cfg(feature = "row_vector2")]
4177 (1, 1, 2) => {
4178 let er2 = get_r2(&arguments[0]);
4179 match &er2 {
4180 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateR2 {out: e0.clone() })),
4181 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("row_vector2".to_string())).with_compiler_loc()),
4182 }
4183 }
4184 #[cfg(feature = "row_vector3")]
4185 (1, 1, 3) => {
4186 let er3 = get_r3(&arguments[0]);
4187 match &er3 {
4188 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateR3 { out: e0.clone() })),
4189 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("row_vector3".to_string())).with_compiler_loc()),
4190 }
4191 }
4192 #[cfg(feature = "row_vector4")]
4193 (1, 1, 4) => {
4194 let er4 = get_r4(&arguments[0]);
4195 match &er4 {
4196 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateR4{out: e0.clone()})),
4197 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrixd".to_string())).with_compiler_loc()),
4198 }
4199 }
4200 #[cfg(feature = "row_vectord")]
4201 (1, 1, n) => {
4202 let erd = get_rd(&arguments[0]);
4203 let emd = get_md(&arguments[0]);
4204 let es = get_s(&arguments[0]);
4205 match (emd, erd, es) {
4206 #[cfg(feature = "matrixd")]
4207 (Some(ref e0), None, None) => return Ok(Box::new(HorizontalConcatenateMD { out: e0.clone() })),
4208 (None, Some(ref e0), None) => return Ok(Box::new(HorizontalConcatenateRD { out: e0.clone() })),
4209 #[cfg(feature = "matrixd")]
4210 (None, None, Some(ref e0)) => return Ok(Box::new(HorizontalConcatenateS1D {arg: e0.clone(), out: Ref::new(DMatrix::from_element(1,1,$default))})),
4211 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrixd".to_string())).with_compiler_loc()),
4212 }
4213 }
4214 #[cfg(feature = "row_vector2")]
4215 (2,1,2) => {
4216 let mut out = RowVector2::from_element($default);
4217 let am1 = get_m1(&arguments[0]);
4218 let bm1 = get_m1(&arguments[1]);
4219 let asc = get_s(&arguments[0]);
4220 let bsc = get_s(&arguments[1]);
4221 match (am1, bm1, asc, bsc) {
4222 #[cfg(feature = "matrix1")]
4223 (Some(ref e0), Some(ref e1), None, None) => return Ok(Box::new(HorizontalConcatenateM1M1 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4224 #[cfg(feature = "matrix1")]
4225 (Some(ref e0), None, None, Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateM1S { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4226 #[cfg(feature = "matrix1")]
4227 (None, Some(ref e1), Some(ref e0), None) => return Ok(Box::new(HorizontalConcatenateSM1 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4228 (None, None, Some(ref e0), Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateS2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4229 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix1".to_string())).with_compiler_loc()),
4230 }
4231 }
4232 #[cfg(feature = "row_vector3")]
4233 (2,1,3) => {
4234 let mut out = RowVector3::from_element($default);
4235 let a_r2 = get_r2(&arguments[0]);
4236 let b_r2 = get_r2(&arguments[1]);
4237 let a_sc = get_s(&arguments[0]);
4238 let b_sc = get_s(&arguments[1]);
4239 let a_m1 = get_m1(&arguments[0]);
4240 let b_m1 = get_m1(&arguments[1]);
4241 match (a_r2, b_r2, a_sc, b_sc, a_m1, b_m1) {
4242 #[cfg(feature = "matrix1")]
4243 (Some(ref e0), _, _, _, _, Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateR2M1 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4244 #[cfg(feature = "row_vector2")]
4245 (Some(ref e0), _, _, Some(ref e1), _, _) => return Ok(Box::new(HorizontalConcatenateR2S { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4246 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4247 (_, Some(ref e1), _, _, Some(ref e0), _) => return Ok(Box::new(HorizontalConcatenateM1R2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4248 #[cfg(feature = "row_vector2")]
4249 (_, Some(ref e1), Some(ref e0), _, _, _) => return Ok(Box::new(HorizontalConcatenateSR2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4250 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("row_vector2 or matrix1".to_string())).with_compiler_loc()),
4251 }
4252 }
4253 #[cfg(feature = "row_vector4")]
4254 (2,1,4) => {
4255 let mut out = RowVector4::from_element($default);
4256 let a_r3 = get_r3(&arguments[0]);
4257 let b_r3 = get_r3(&arguments[1]);
4258 let a_sc = get_s(&arguments[0]);
4259 let b_sc = get_s(&arguments[1]);
4260 let a_m1 = get_m1(&arguments[0]);
4261 let b_m1 = get_m1(&arguments[1]);
4262 let a_r2 = get_r2(&arguments[0]);
4263 let b_r2 = get_r2(&arguments[1]);
4264 match (a_r3, b_r3, a_sc, b_sc, a_m1, b_m1, a_r2, b_r2) {
4265 #[cfg(all(feature = "matrix1", feature = "row_vector3"))]
4266 (Some(ref e0), _, _, _, _, Some(ref e1), _, _) => return Ok(Box::new(HorizontalConcatenateR3M1 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4267 #[cfg(feature = "row_vector3")]
4268 (Some(ref e0), _, _, Some(ref e1), _, _, _, _) => return Ok(Box::new(HorizontalConcatenateR3S { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4269 #[cfg(all(feature = "matrix1", feature = "row_vector3"))]
4270 (_, Some(ref e1), _, _, Some(ref e0), _, _, _) => return Ok(Box::new(HorizontalConcatenateM1R3 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4271 #[cfg(feature = "row_vector3")]
4272 (_, Some(ref e1), Some(ref e0), _, _, _, _, _) => return Ok(Box::new(HorizontalConcatenateSR3 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4273 #[cfg(feature = "row_vector2")]
4274 (_, _, _, _, _, _, Some(ref e0), Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateR2R2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4275 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix1, row_vector2, row_vector3".to_string())).with_compiler_loc()),
4276 }
4277 }
4278 #[cfg(feature = "row_vector3")]
4279 (3,1,3) => {
4280 let mut out = RowVector3::from_element($default);
4281 let a_m1 = get_m1(&arguments[0]);
4282 let b_m1 = get_m1(&arguments[1]);
4283 let c_m1 = get_m1(&arguments[2]);
4284 let a_sc = get_s(&arguments[0]);
4285 let b_sc = get_s(&arguments[1]);
4286 let c_sc = get_s(&arguments[2]);
4287 match (a_m1, b_m1, c_m1, a_sc, b_sc, c_sc) {
4288 #[cfg(feature = "matrix1")]
4289 (_, _, _, Some(ref e0), Some(ref e1), Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateS3 {e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4290 #[cfg(feature = "matrix1")]
4291 (Some(ref e0), Some(ref e1), _, _, _, Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateM1M1S { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4292 #[cfg(feature = "matrix1")]
4293 (Some(ref e0), _, Some(ref e2), _, Some(ref e1), _) => return Ok(Box::new(HorizontalConcatenateM1SM1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4294 #[cfg(feature = "matrix1")]
4295 (_, Some(ref e1), Some(ref e2), Some(ref e0), _, _) => return Ok(Box::new(HorizontalConcatenateSM1M1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4296 #[cfg(feature = "matrix1")]
4297 (_, Some(ref e1), _, Some(ref e0), _, Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateSM1S {e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4298 #[cfg(feature = "matrix1")]
4299 (_, _, Some(ref e2), Some(ref e0), Some(ref e1), _) => return Ok(Box::new(HorizontalConcatenateSSM1 {e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4300 #[cfg(feature = "matrix1")]
4301 (Some(ref e0), _, _, _, Some(ref e1), Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateM1SS {e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4302 #[cfg(feature = "matrix1")]
4303 (Some(ref e0), Some(ref e1), Some(ref e2), _, _, _) => return Ok(Box::new(HorizontalConcatenateM1M1M1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4304 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix1".to_string())).with_compiler_loc()),
4305 }
4306 }
4307 #[cfg(feature = "row_vector4")]
4308 (3,1,4) => {
4309 let mut out = RowVector4::from_element($default);
4310 let a_sc = get_s(&arguments[0]);
4311 let b_sc = get_s(&arguments[1]);
4312 let c_sc = get_s(&arguments[2]);
4313 let a_r2 = get_r2(&arguments[0]);
4314 let b_r2 = get_r2(&arguments[1]);
4315 let c_r2 = get_r2(&arguments[2]);
4316 let a_m1 = get_m1(&arguments[0]);
4317 let b_m1 = get_m1(&arguments[1]);
4318 let c_m1 = get_m1(&arguments[2]);
4319 match (a_sc, b_sc, c_sc, a_r2, b_r2, c_r2, a_m1, b_m1, c_m1) {
4320 #[cfg(feature = "row_vector2")]
4321 (Some(ref e0), Some(ref e1), _, _, _, Some(ref e2), _, _, _) => return Ok(Box::new(HorizontalConcatenateSSR2{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4322 #[cfg(feature = "row_vector2")]
4323 (Some(ref e0), _, Some(ref e2), _, Some(ref e1), _, _, _, _) => return Ok(Box::new(HorizontalConcatenateSR2S{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4324 #[cfg(feature = "row_vector2")]
4325 (_, Some(ref e1), Some(ref e2), Some(ref e0), _, _, _, _, _) => return Ok(Box::new(HorizontalConcatenateR2SS{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4326 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4327 (_, _, _, _, _, Some(ref e2), Some(ref e0), Some(ref e1), _) => return Ok(Box::new(HorizontalConcatenateM1M1R2{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4328 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4329 (_, _, _, _, Some(ref e1), _, Some(ref e0), _, Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateM1R2M1{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4330 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4331 (_, _, _, Some(ref e0), _, _, _, Some(ref e1), Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateR2M1M1{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4332 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4333 (Some(ref e0), _, _, _, _, Some(ref e2), _, Some(ref e1), _) => return Ok(Box::new(HorizontalConcatenateSM1R2{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4334 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4335 (Some(ref e0), _, _, _, Some(ref e1), _, _, _, Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateSR2M1{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4336 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4337 (_, Some(ref e1), _, _, _, Some(ref e2), Some(ref e0), _, _) => return Ok(Box::new(HorizontalConcatenateM1SR2{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4338 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4339 (_, Some(ref e1), _, Some(ref e0), _, _, _, _, Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateR2SM1{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4340 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4341 (_, _, Some(ref e2), _, Some(ref e1), _, Some(ref e0), _, _) => return Ok(Box::new(HorizontalConcatenateM1R2S{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4342 #[cfg(all(feature = "matrix1", feature = "row_vector2"))]
4343 (_, _, Some(ref e2), Some(ref e0), _, _, _, Some(ref e1), _) => return Ok(Box::new(HorizontalConcatenateR2M1S{e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out)})),
4344 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("row_vector2 or matrix1".to_string())).with_compiler_loc()),
4345 }
4346 }
4347 #[cfg(feature = "row_vector4")]
4348 (4,1,4) => {
4349 let mut out = RowVector4::from_element($default);
4350 let a_s = get_s(&arguments[0]);
4351 let b_s = get_s(&arguments[1]);
4352 let c_s = get_s(&arguments[2]);
4353 let d_s = get_s(&arguments[3]);
4354 let a_m1 = get_m1(&arguments[0]);
4355 let b_m1 = get_m1(&arguments[1]);
4356 let c_m1 = get_m1(&arguments[2]);
4357 let d_m1 = get_m1(&arguments[3]);
4358 match (a_s, b_s, c_s, d_s, a_m1, b_m1, c_m1, d_m1) {
4359 (Some(ref e0), Some(ref e1), Some(ref e2), Some(ref e3), _, _, _, _) => return Ok(Box::new(HorizontalConcatenateS4 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4360 #[cfg(feature = "matrix1")]
4361 (Some(ref e0), Some(ref e1), Some(ref e2), _, _, _, _, Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateSSSM1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4362 #[cfg(feature = "matrix1")]
4363 (Some(ref e0), Some(ref e1), _, Some(ref e3), _, _, Some(ref e2), _) => return Ok(Box::new(HorizontalConcatenateSSM1S { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4364 #[cfg(feature = "matrix1")]
4365 (Some(ref e0), _, Some(ref e2), Some(ref e3), _, Some(ref e1), _, _) => return Ok(Box::new(HorizontalConcatenateSM1SS { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4366 #[cfg(feature = "matrix1")]
4367 (_, Some(ref e1), Some(ref e2), Some(ref e3), Some(ref e0), _, _, _) => return Ok(Box::new(HorizontalConcatenateM1SSS { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4368 #[cfg(feature = "matrix1")]
4369 (Some(ref e0), Some(ref e1), _, _, _, Some(ref e2), _, Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateSSM1M1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4370 #[cfg(feature = "matrix1")]
4371 (Some(ref e0), _, Some(ref e2), _, _, Some(ref e1), _, Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateSM1SM1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4372 #[cfg(feature = "matrix1")]
4373 (_, _, Some(ref e2), Some(ref e3), Some(ref e0), Some(ref e1), _, _) => return Ok(Box::new(HorizontalConcatenateM1M1SS { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4374 #[cfg(feature = "matrix1")]
4375 (Some(ref e0), _, _, Some(ref e3), _, Some(ref e1), Some(ref e2), _) => return Ok(Box::new(HorizontalConcatenateSM1M1S { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4376 #[cfg(feature = "matrix1")]
4377 (_, Some(ref e1), Some(ref e2), _, Some(ref e0), _, _, Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateM1SSM1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4378 #[cfg(feature = "matrix1")]
4379 (_, Some(ref e1), _, Some(ref e3), Some(ref e0), _, Some(ref e2), _) => return Ok(Box::new(HorizontalConcatenateM1SM1S { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4380 #[cfg(feature = "matrix1")]
4381 (Some(ref e0), _, _, _, _, Some(ref e1), Some(ref e2), Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateSM1M1M1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4382 #[cfg(feature = "matrix1")]
4383 (_, Some(ref e1), _, _, Some(ref e0), _, Some(ref e2), Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateM1SM1M1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4384 #[cfg(feature = "matrix1")]
4385 (_, _, Some(ref e2), _, Some(ref e0), Some(ref e1), _, Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateM1M1SM1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4386 #[cfg(feature = "matrix1")]
4387 (_, _, _, Some(ref e3), Some(ref e0), Some(ref e1), Some(ref e2), _) => return Ok(Box::new(HorizontalConcatenateM1M1M1S { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4388 #[cfg(feature = "matrix1")]
4389 (_, _, _, _, Some(ref e0), Some(ref e1), Some(ref e2), Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateM1M1M1M1 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4390 _ => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix1".to_string())).with_compiler_loc()),
4391 }
4392 }
4393 #[cfg(feature = "row_vectord")]
4394 (m,1,n) => {
4395 let mut out = RowDVector::from_element(n,$default);
4396 let mut matrix_args: Vec<(Box<dyn CopyMat<$kind>>,usize)> = vec![];
4397 let mut scalar_args: Vec<(Ref<$kind>,usize)> = vec![];
4398 let mut i = 0;
4399 for arg in arguments.iter() {
4400 match &arg {
4401 Value::[<$kind:camel>](e0) => {
4402 scalar_args.push((e0.clone(),i));
4403 i += 1;
4404 }
4405 Value::[<Matrix $kind:camel>](e0) => {
4406 matrix_args.push((e0.get_copyable_matrix(),i));
4407 i += e0.shape()[1];
4408 }
4409 Value::MutableReference(e0) => {
4410 match e0.borrow().clone() {
4411 Value::[<Matrix $kind:camel>](e0) => {
4412 matrix_args.push((e0.get_copyable_matrix(),i));
4413 i += e0.shape()[1];
4414 }
4415 Value::[<$kind:camel>](e0) => {
4416 scalar_args.push((e0.clone(),i));
4417 i += 1;
4418 }
4419 x => return Err(MechError2::new(UnhandledFunctionArgumentKind1{arg: x.kind(), fxn_name: "matrix/horzcat".to_string()}, None).with_compiler_loc()),
4420 }
4421 }
4422 x => return Err(MechError2::new(UnhandledFunctionArgumentKind1{arg: x.kind(), fxn_name: "matrix/horzcat".to_string()}, None).with_compiler_loc()),
4423 }
4424 }
4425 return Ok(Box::new(HorizontalConcatenateRDN{scalar: scalar_args, matrix: matrix_args, out: Ref::new(out)}));
4426 }
4427 #[cfg(feature = "vector2")]
4428 (1, 2, 1) => {
4429 let ev2 = get_v2(&arguments[0]);
4430 match &ev2 {
4431 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateV2 { out: e0.clone() })),
4432 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector2".to_string())).with_compiler_loc()),
4433 }
4434 }
4435 #[cfg(feature = "matrix2")]
4436 (1, 2, 2) => {
4437 let em2 = get_m2(&arguments[0]);
4438 match &em2 {
4439 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateM2 { out: e0.clone() })),
4440 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix2".to_string())).with_compiler_loc()),
4441 }
4442 }
4443 #[cfg(feature = "matrix2x3")]
4444 (1, 2, 3) => {
4445 let em2x3 = get_m2x3(&arguments[0]);
4446 match &em2x3 {
4447 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateM2x3 { out: e0.clone() })),
4448 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix2x3".to_string())).with_compiler_loc()),
4449 }
4450 }
4451 #[cfg(feature = "vector3")]
4452 (1, 3, 1) => {
4453 let ev3 = get_v3(&arguments[0]);
4454 match &ev3 {
4455 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateV3 { out: e0.clone() })),
4456 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector3".to_string())).with_compiler_loc()),
4457 }
4458 }
4459 #[cfg(feature = "matrix3x2")]
4460 (1, 3, 2) => {
4461 let am3x2 = get_m3x2(&arguments[0]);
4462 match &am3x2 {
4463 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateM3x2{out: e0.clone()})),
4464 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix3x2".to_string())).with_compiler_loc()),
4465 }
4466 }
4467 #[cfg(feature = "matrix3")]
4468 (1, 3, 3) => {
4469 let em3 = get_m3(&arguments[0]);
4470 match &em3 {
4471 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateM3 { out: e0.clone() })),
4472 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix3".to_string())).with_compiler_loc()),
4473 }
4474 }
4475 #[cfg(feature = "vector4")]
4476 (1, 4, 1) => {
4477 let ev4 = get_v4(&arguments[0]);
4478 match &ev4 {
4479 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateV4 { out: e0.clone() })),
4480 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector4".to_string())).with_compiler_loc()),
4481 }
4482 }
4483 #[cfg(feature = "matrix4")]
4484 (1, 4, 4) => {
4485 let em4 = get_m4(&arguments[0]);
4486 match &em4 {
4487 Some(ref e0) => return Ok(Box::new(HorizontalConcatenateM4 { out: e0.clone() })),
4488 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrix4".to_string())).with_compiler_loc()),
4489 }
4490 }
4491 #[cfg(feature = "matrixd")]
4492 (1, m, n) => {
4493 println!("Horzcat MatrixD branch {:?}", arguments);
4494 let emd = get_md(&arguments[0]);
4495 let evd = get_vd(&arguments[0]);
4496 match (emd, evd) {
4497 (Some(ref e0), None) => return Ok(Box::new(HorizontalConcatenateMD{out: e0.clone()})),
4498 #[cfg(feature = "vectord")]
4499 (NOne, Some(ref e0)) => return Ok(Box::new(HorizontalConcatenateVD{out: e0.clone()})),
4500 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("matrixd or vectord".to_string())).with_compiler_loc()),
4501 }
4502 }
4503 #[cfg(all(feature = "matrix2", feature ="vector2"))]
4504 (2, 2, 2) => {
4505 let mut out = Matrix2::from_element($default);
4506 let av2 = get_v2(&arguments[0]);
4507 let bv2 = get_v2(&arguments[1]);
4508 match (av2, bv2) {
4509 #[cfg(feature = "vector2")]
4510 (Some(e0), Some(e1)) => return Ok(Box::new(HorizontalConcatenateV2V2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4511 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector2".to_string())).with_compiler_loc()),
4512 }
4513 }
4514 #[cfg(feature = "matrix3x2")]
4515 (2, 3, 2) => {
4516 let mut out = Matrix3x2::from_element($default);
4517 let av3 = get_v3(&arguments[0]);
4518 let bv3 = get_v3(&arguments[1]);
4519 match (av3, bv3) {
4520 #[cfg(feature = "vector3")]
4521 (Some(e0), Some(e1)) => return Ok(Box::new(HorizontalConcatenateV3V3 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4522 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector3".to_string())).with_compiler_loc()),
4523 }
4524 }
4525 #[cfg(feature = "matrix2x3")]
4526 (2,2,3) => {
4527 let mut out = Matrix2x3::from_element($default);
4528 let av2 = get_v2(&arguments[0]);
4529 let am2 = get_m2(&arguments[0]);
4530 let bv2 = get_v2(&arguments[1]);
4531 let bm2 = get_m2(&arguments[1]);
4532 match (av2, bv2, am2, bm2) {
4533 #[cfg(all(feature = "vector2", feature = "matrix2"))]
4534 (Some(ref e0), _, _, Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateV2M2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4535 #[cfg(all(feature = "vector2", feature = "matrix2"))]
4536 (_, Some(ref e1), Some(ref e0), _) => return Ok(Box::new(HorizontalConcatenateM2V2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4537 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector2 or matrix2".to_string())).with_compiler_loc()),
4538 }
4539 }
4540 #[cfg(feature = "matrix3")]
4541 (2, 3, 3) => {
4542 let mut out = Matrix3::from_element($default);
4543 let av3 = get_v3(&arguments[0]);
4544 let am3x2 = get_m3x2(&arguments[0]);
4545 let bv3 = get_v3(&arguments[1]);
4546 let bm3x2 = get_m3x2(&arguments[1]);
4547 match (av3, bv3, am3x2, bm3x2) {
4548 #[cfg(all(feature = "vector3", feature = "matrix3x2"))]
4549 (Some(ref e0), _, _, Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateV3M3x2 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4550 #[cfg(all(feature = "vector3", feature = "matrix3x2"))]
4551 (_, Some(ref e1), Some(ref e0), _) => return Ok(Box::new(HorizontalConcatenateM3x2V3 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4552 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector3 or matrix3x2".to_string())).with_compiler_loc()),
4553 }
4554 }
4555 #[cfg(feature = "matrix4")]
4556 (2, 4, 4) => {
4557 let mut out = Matrix4::from_element($default);
4558 let av4 = get_v4(&arguments[0]);
4559 let bv4 = get_v4(&arguments[1]);
4560 let amd = get_md(&arguments[0]);
4561 let bmd = get_md(&arguments[1]);
4562 match (av4, bv4, amd, bmd) {
4563 #[cfg(all(feature = "vector4", feature = "matrixd"))]
4564 (Some(ref e0), _, _, Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateV4MD { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4565 #[cfg(all(feature = "vector4", feature = "matrixd"))]
4566 (_, Some(ref e1), Some(ref e0), _) => return Ok(Box::new(HorizontalConcatenateMDV4 { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4567 #[cfg(feature = "matrixd")]
4568 (_, _, Some(ref e0), Some(ref e1)) => return Ok(Box::new(HorizontalConcatenateMDMD { e0: e0.clone(), e1: e1.clone(), out: Ref::new(out) })),
4569 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector4 or matrixd".to_string())).with_compiler_loc()),
4570 }
4571 }
4572 #[cfg(feature = "matrixd")]
4573 (2,m,n) => {
4574 let mut out = DMatrix::from_element(m,n,$default);
4575 let e0 = extract_matrix(&arguments[0])?;
4576 let e1 = extract_matrix(&arguments[1])?;
4577 Ok(Box::new(HorizontalConcatenateTwoArgs{e0,e1,out:Ref::new(out)}))
4578 }
4579 #[cfg(feature = "matrix2x3")]
4580 (3, 2, 3) => {
4581 let mut out = Matrix2x3::from_element($default);
4582 let av2 = get_v2(&arguments[0]);
4583 let bv2 = get_v2(&arguments[1]);
4584 let cv2 = get_v2(&arguments[2]);
4585 match (av2, bv2, cv2) {
4586 #[cfg(feature = "vector2")]
4587 (Some(ref e0), Some(ref e1), Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateV2V2V2 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4588 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector2".to_string())).with_compiler_loc()),
4589 }
4590 }
4591 #[cfg(feature = "matrix3")]
4592 (3, 3, 3) => {
4593 let mut out = Matrix3::from_element($default);
4594 let av3 = get_v3(&arguments[0]);
4595 let bv3 = get_v3(&arguments[1]);
4596 let cv3 = get_v3(&arguments[2]);
4597 match (&av3, &bv3, &cv3) {
4598 #[cfg(feature = "vector3")]
4599 (Some(ref e0), Some(ref e1), Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateV3V3V3 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4600 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector3".to_string())).with_compiler_loc()),
4601 }
4602 }
4603 #[cfg(feature = "matrix4")]
4604 (3, 4, 4) => {
4605 let mut out = Matrix4::from_element($default);
4606 let av4 = get_v4(&arguments[0]);
4607 let bv4 = get_v4(&arguments[1]);
4608 let cv4 = get_v4(&arguments[2]);
4609 let amd = get_md(&arguments[0]);
4610 let bmd = get_md(&arguments[1]);
4611 let cmd = get_md(&arguments[2]);
4612 match (av4, bv4, cv4, amd, bmd, cmd) {
4613 #[cfg(all(feature = "vector4", feature = "matrixd"))]
4614 (Some(ref e0), Some(ref e1), _, _, _, Some(ref e2)) => return Ok(Box::new(HorizontalConcatenateV4V4MD { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4615 #[cfg(all(feature = "vector4", feature = "matrixd"))]
4616 (Some(ref e0), _, Some(ref e2), _, Some(ref e1), _) => return Ok(Box::new(HorizontalConcatenateV4MDV4 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4617 #[cfg(all(feature = "matrixd", feature = "vector4"))]
4618 (_, Some(ref e1), Some(ref e2), Some(ref e0), _, _) => return Ok(Box::new(HorizontalConcatenateMDV4V4 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), out: Ref::new(out) })),
4619 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector4 or matrixd".to_string())).with_compiler_loc()),
4620 }
4621 }
4622 #[cfg(feature = "matrixd")]
4623 (3,m,n) => {
4624 let mut out = DMatrix::from_element(m, n, $default);
4625 let e0 = extract_matrix(&arguments[0])?;
4626 let e1 = extract_matrix(&arguments[1])?;
4627 let e2 = extract_matrix(&arguments[2])?;
4628 return Ok(Box::new(HorizontalConcatenateThreeArgs {e0,e1,e2,out: Ref::new(out)}));
4629 }
4630 #[cfg(feature = "matrix4")]
4631 (4, 4, 4) => {
4632 let mut out = Matrix4::from_element($default);
4633 let av4 = get_v4(&arguments[0]);
4634 let bv4 = get_v4(&arguments[1]);
4635 let cv4 = get_v4(&arguments[2]);
4636 let dv4 = get_v4(&arguments[3]);
4637 match (&av4, &bv4, &cv4, &dv4) {
4638 #[cfg(feature = "vector4")]
4639 (Some(ref e0), Some(ref e1), Some(ref e2), Some(ref e3)) => return Ok(Box::new(HorizontalConcatenateV4V4V4V4 { e0: e0.clone(), e1: e1.clone(), e2: e2.clone(), e3: e3.clone(), out: Ref::new(out) })),
4640 x => return Err(MechError2::new(HorizontalConcatenateDimensionMismatchError{}, Some("vector4".to_string())).with_compiler_loc()),
4641 }
4642 }
4643 #[cfg(feature = "matrixd")]
4644 (4,m,n) => {
4645 let mut out = DMatrix::from_element(m,n,$default);
4646 let e0 = extract_matrix(&arguments[0])?;
4647 let e1 = extract_matrix(&arguments[1])?;
4648 let e2 = extract_matrix(&arguments[2])?;
4649 let e3 = extract_matrix(&arguments[3])?;
4650 return Ok(Box::new(HorizontalConcatenateFourArgs {e0,e1,e2,e3,out: Ref::new(out)}));
4651 }
4652 #[cfg(feature = "matrixd")]
4653 (l,m,n) => {
4654 let mut out = DMatrix::from_element(m,n,$default);
4655 let mut args = vec![];
4656 for arg in arguments {
4657 let e0 = extract_matrix(&arg)?;
4658 args.push(e0);
4659 }
4660 Ok(Box::new(HorizontalConcatenateNArgs{e0: args, out:Ref::new(out.clone())}))
4661 }
4662 x => return Err(MechError2::new(
4663 UnhandledFunctionArgumentKindVarg { arg: arguments.iter().map(|x| x.kind()).collect(), fxn_name: "matrix/horzcat".to_string() },
4664 None
4665 ).with_compiler_loc()),
4666 }
4667 }}}}
4668
4669fn impl_horzcat_fxn(arguments: &Vec<Value>) -> MResult<Box<dyn MechFunction>> {
4670 let kinds: Vec<ValueKind> = arguments.iter().map(|x| x.kind()).collect::<Vec<ValueKind>>();
4673 let target_kind = kinds[0].clone();
4674
4675 #[cfg(feature = "f64")]
4676 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::F64) { return impl_horzcat_arms!(f64, arguments, f64::default()) } }
4677
4678 #[cfg(feature = "f32")]
4679 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::F32) { return impl_horzcat_arms!(f32, arguments, f32::default()) } }
4680
4681 #[cfg(feature = "u8")]
4682 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::U8) { return impl_horzcat_arms!(u8, arguments, u8::default()) } }
4683
4684 #[cfg(feature = "u16")]
4685 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::U16) { return impl_horzcat_arms!(u16, arguments, u16::default()) } }
4686
4687 #[cfg(feature = "u32")]
4688 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::U32) { return impl_horzcat_arms!(u32, arguments, u32::default()) } }
4689
4690 #[cfg(feature = "u64")]
4691 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::U64) { return impl_horzcat_arms!(u64, arguments, u64::default()) } }
4692
4693 #[cfg(feature = "u128")]
4694 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::U128){ return impl_horzcat_arms!(u128,arguments, u128::default()) } }
4695
4696 #[cfg(feature = "i8")]
4697 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::I8) { return impl_horzcat_arms!(i8, arguments, i8::default()) } }
4698
4699 #[cfg(feature = "i16")]
4700 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::I16) { return impl_horzcat_arms!(i16, arguments, i16::default()) } }
4701
4702 #[cfg(feature = "i32")]
4703 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::I32) { return impl_horzcat_arms!(i32, arguments, i32::default()) } }
4704
4705 #[cfg(feature = "i64")]
4706 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::I64) { return impl_horzcat_arms!(i64, arguments, i64::default()) } }
4707
4708 #[cfg(feature = "i128")]
4709 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::I128){ return impl_horzcat_arms!(i128,arguments, i128::default()) } }
4710
4711 #[cfg(feature = "bool")]
4712 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::Bool) { return impl_horzcat_arms!(bool, arguments, bool::default()) } }
4713
4714 #[cfg(feature = "string")]
4715 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::String) { return impl_horzcat_arms!(String, arguments, String::default()) } }
4716
4717 #[cfg(feature = "rational")]
4718 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::R64) { return impl_horzcat_arms!(R64, arguments, R64::default()) } }
4719
4720 #[cfg(feature = "complex")]
4721 { if ValueKind::is_compatible(target_kind.clone(), ValueKind::C64) { return impl_horzcat_arms!(C64, arguments, C64::default()) } }
4722
4723 Err(MechError2::new(
4724 UnhandledFunctionArgumentKindVarg { arg: arguments.iter().map(|x| x.kind()).collect(), fxn_name: "matrix/horzcat".to_string() },
4725 None
4726 ).with_compiler_loc()
4727 )
4728}
4729
4730
4731pub struct MatrixHorzCat {}
4732impl NativeFunctionCompiler for MatrixHorzCat {
4733 fn compile(&self, arguments: &Vec<Value>) -> MResult<Box<dyn MechFunction>> {
4734 impl_horzcat_fxn(arguments)
4735 }
4736}
4737
4738register_descriptor! {
4739 FunctionCompilerDescriptor {
4740 name: "matrix/horzcat",
4741 ptr: &MatrixHorzCat{},
4742 }
4743}
4744
4745#[derive(Debug, Clone)]
4746pub struct HorizontalConcatenateDimensionMismatchError {
4747}
4748impl MechErrorKind2 for HorizontalConcatenateDimensionMismatchError {
4749 fn name(&self) -> &str { "HorizontalConcatenateDimensionMismatch" }
4750 fn message(&self) -> String {
4751 format!("Cannot horizontally concatenate matrices/vectors with dimensions that do not align.")
4752 }
4753}