1use runmat_builtins::{
4 BuiltinCompletionPolicy, BuiltinDescriptor, BuiltinErrorDescriptor, BuiltinOutputMode,
5 BuiltinParamArity, BuiltinParamDescriptor, BuiltinParamType, BuiltinSignatureDescriptor,
6 CellArray, CharArray, LogicalArray, SparseTensor, StringArray, Tensor, Value,
7};
8use runmat_macros::runtime_builtin;
9
10use crate::builtins::common::map_control_flow_with_builtin;
11use crate::builtins::common::spec::{
12 BroadcastSemantics, BuiltinFusionSpec, BuiltinGpuSpec, ConstantStrategy, GpuOpKind,
13 ReductionNaN, ResidencyPolicy, ShapeRequirements,
14};
15use crate::builtins::strings::type_resolvers::string_array_type;
16use crate::{build_runtime_error, gather_if_needed_async, BuiltinResult, RuntimeError};
17
18#[runmat_macros::register_gpu_spec(builtin_path = "crate::builtins::strings::core::char")]
19pub const GPU_SPEC: BuiltinGpuSpec = BuiltinGpuSpec {
20 name: "char",
21 op_kind: GpuOpKind::Custom("conversion"),
22 supported_precisions: &[],
23 broadcast: BroadcastSemantics::None,
24 provider_hooks: &[],
25 constant_strategy: ConstantStrategy::InlineLiteral,
26 residency: ResidencyPolicy::GatherImmediately,
27 nan_mode: ReductionNaN::Include,
28 two_pass_threshold: None,
29 workgroup_size: None,
30 accepts_nan_mode: false,
31 notes:
32 "Conversion always runs on the CPU; GPU tensors are gathered before building the result.",
33};
34
35#[runmat_macros::register_fusion_spec(builtin_path = "crate::builtins::strings::core::char")]
36pub const FUSION_SPEC: BuiltinFusionSpec = BuiltinFusionSpec {
37 name: "char",
38 shape: ShapeRequirements::Any,
39 constant_strategy: ConstantStrategy::InlineLiteral,
40 elementwise: None,
41 reduction: None,
42 emits_nan: false,
43 notes: "Character materialisation runs outside of fusion; results always live on the host.",
44};
45
46const BUILTIN_NAME: &str = "char";
47const CHAR_SPARSE_DENSE_ELEMENT_LIMIT: usize = 10_000_000;
48
49const CHAR_OUTPUT: [BuiltinParamDescriptor; 1] = [BuiltinParamDescriptor {
50 name: "C",
51 ty: BuiltinParamType::Any,
52 arity: BuiltinParamArity::Required,
53 default: None,
54 description: "Character array result.",
55}];
56
57const CHAR_INPUT_SINGLE: [BuiltinParamDescriptor; 1] = [BuiltinParamDescriptor {
58 name: "X",
59 ty: BuiltinParamType::Any,
60 arity: BuiltinParamArity::Required,
61 default: None,
62 description: "Input value to convert into character data.",
63}];
64
65const CHAR_INPUT_VARIADIC: [BuiltinParamDescriptor; 1] = [BuiltinParamDescriptor {
66 name: "X...",
67 ty: BuiltinParamType::Any,
68 arity: BuiltinParamArity::Variadic,
69 default: None,
70 description: "Multiple inputs converted row-wise and padded.",
71}];
72
73const CHAR_SIGNATURES: [BuiltinSignatureDescriptor; 3] = [
74 BuiltinSignatureDescriptor {
75 label: "C = char()",
76 inputs: &[],
77 outputs: &CHAR_OUTPUT,
78 },
79 BuiltinSignatureDescriptor {
80 label: "C = char(X)",
81 inputs: &CHAR_INPUT_SINGLE,
82 outputs: &CHAR_OUTPUT,
83 },
84 BuiltinSignatureDescriptor {
85 label: "C = char(X...)",
86 inputs: &CHAR_INPUT_VARIADIC,
87 outputs: &CHAR_OUTPUT,
88 },
89];
90
91const CHAR_ERROR_INVALID_INPUT: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
92 code: "RM.CHAR.INVALID_INPUT",
93 identifier: Some("RunMat:char:InvalidInput"),
94 when: "Input type cannot be converted to character data.",
95 message: "char: invalid input",
96};
97
98const CHAR_ERROR_INVALID_CODEPOINT: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
99 code: "RM.CHAR.INVALID_CODEPOINT",
100 identifier: Some("RunMat:char:InvalidCodePoint"),
101 when: "Numeric input is not a finite integer Unicode code point.",
102 message: "char: numeric inputs must be finite Unicode code points",
103};
104
105const CHAR_ERROR_DIMENSION: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
106 code: "RM.CHAR.INVALID_DIMENSION",
107 identifier: Some("RunMat:char:InvalidDimension"),
108 when: "Array inputs are not 2-D (or trailing singleton dimensions).",
109 message: "char: inputs must be 2-D",
110};
111
112const CHAR_ERROR_INTERNAL: BuiltinErrorDescriptor = BuiltinErrorDescriptor {
113 code: "RM.CHAR.INTERNAL",
114 identifier: Some("RunMat:char:InternalError"),
115 when: "Internal character array construction failed.",
116 message: "char: internal error",
117};
118
119const CHAR_ERRORS: [BuiltinErrorDescriptor; 4] = [
120 CHAR_ERROR_INVALID_INPUT,
121 CHAR_ERROR_INVALID_CODEPOINT,
122 CHAR_ERROR_DIMENSION,
123 CHAR_ERROR_INTERNAL,
124];
125
126pub const CHAR_DESCRIPTOR: BuiltinDescriptor = BuiltinDescriptor {
127 signatures: &CHAR_SIGNATURES,
128 output_mode: BuiltinOutputMode::Fixed,
129 completion_policy: BuiltinCompletionPolicy::Public,
130 errors: &CHAR_ERRORS,
131};
132
133fn char_error(error: &'static BuiltinErrorDescriptor) -> RuntimeError {
134 char_error_with_message(error.message, error)
135}
136
137fn char_error_with_message(
138 message: impl Into<String>,
139 error: &'static BuiltinErrorDescriptor,
140) -> RuntimeError {
141 let mut builder = build_runtime_error(message).with_builtin(BUILTIN_NAME);
142 if let Some(identifier) = error.identifier {
143 builder = builder.with_identifier(identifier);
144 }
145 builder.build()
146}
147
148fn char_flow(message: impl Into<String>) -> RuntimeError {
149 char_error_with_message(message, &CHAR_ERROR_INTERNAL)
150}
151
152fn remap_char_flow(err: RuntimeError) -> RuntimeError {
153 map_control_flow_with_builtin(err, BUILTIN_NAME)
154}
155
156#[runtime_builtin(
157 name = "char",
158 category = "strings/core",
159 summary = "Convert numeric codes and text values into character arrays.",
160 keywords = "char,character,string,gpu",
161 accel = "conversion",
162 type_resolver(string_array_type),
163 descriptor(crate::builtins::strings::core::char::CHAR_DESCRIPTOR),
164 builtin_path = "crate::builtins::strings::core::char"
165)]
166async fn char_builtin(rest: Vec<Value>) -> crate::BuiltinResult<Value> {
167 if rest.is_empty() {
168 let empty =
169 CharArray::new(Vec::new(), 0, 0).map_err(|_| char_error(&CHAR_ERROR_INTERNAL))?;
170 return Ok(Value::CharArray(empty));
171 }
172
173 let mut rows: Vec<Vec<char>> = Vec::new();
174 let mut max_width = 0usize;
175
176 for arg in rest {
177 let gathered = gather_if_needed_async(&arg)
178 .await
179 .map_err(remap_char_flow)?;
180 let mut produced = value_to_char_rows(&gathered)?;
181 for row in &produced {
182 if row.len() > max_width {
183 max_width = row.len();
184 }
185 }
186 rows.append(&mut produced);
187 }
188
189 if rows.is_empty() {
190 let empty =
191 CharArray::new(Vec::new(), 0, 0).map_err(|_| char_error(&CHAR_ERROR_INTERNAL))?;
192 return Ok(Value::CharArray(empty));
193 }
194
195 let cols = max_width;
196 let total_rows = rows.len();
197 let mut data = vec![' '; total_rows * cols];
198 for (row_idx, row) in rows.into_iter().enumerate() {
199 for (col_idx, ch) in row.into_iter().enumerate() {
200 if col_idx < cols {
201 data[row_idx * cols + col_idx] = ch;
202 }
203 }
204 }
205
206 let array =
207 CharArray::new(data, total_rows, cols).map_err(|_| char_error(&CHAR_ERROR_INTERNAL))?;
208 Ok(Value::CharArray(array))
209}
210
211fn value_to_char_rows(value: &Value) -> BuiltinResult<Vec<Vec<char>>> {
212 if let Some(array) = crate::builtins::datetime::datetime_char_array(value)
213 .map_err(|err| char_flow(err.message().to_string()))?
214 {
215 return Ok(char_array_rows(&array));
216 }
217 if let Some(array) = crate::builtins::duration::duration_char_array(value)
218 .map_err(|err| char_flow(err.message().to_string()))?
219 {
220 return Ok(char_array_rows(&array));
221 }
222 match value {
223 Value::CharArray(ca) => Ok(char_array_rows(ca)),
224 Value::String(s) => Ok(vec![s.chars().collect()]),
225 Value::StringArray(sa) => string_array_rows(sa),
226 Value::Num(n) => Ok(vec![vec![number_to_char(*n)?]]),
227 Value::Int(i) => {
228 let as_double = i.to_f64();
229 Ok(vec![vec![number_to_char(as_double)?]])
230 }
231 Value::Bool(b) => {
232 let code = if *b { 1.0 } else { 0.0 };
233 Ok(vec![vec![number_to_char(code)?]])
234 }
235 Value::Tensor(t) => tensor_rows(t),
236 Value::SparseTensor(s) => {
237 ensure_sparse_dense_conversion(s)?;
238 let dense = s.to_dense().map_err(char_flow)?;
239 tensor_rows(&dense)
240 }
241 Value::LogicalArray(la) => logical_rows(la),
242 Value::Cell(ca) => cell_rows(ca),
243 Value::GpuTensor(_) => Err(char_error(&CHAR_ERROR_INVALID_INPUT)),
244 Value::Complex(_, _) | Value::ComplexTensor(_) => Err(char_error_with_message(
245 "char: complex inputs are not supported",
246 &CHAR_ERROR_INVALID_INPUT,
247 )),
248 Value::Struct(_)
249 | Value::Object(_)
250 | Value::HandleObject(_)
251 | Value::Listener(_)
252 | Value::FunctionHandle(_)
253 | Value::ExternalFunctionHandle(_)
254 | Value::MethodFunctionHandle(_)
255 | Value::BoundFunctionHandle { .. }
256 | Value::Closure(_)
257 | Value::ClassRef(_)
258 | Value::MException(_)
259 | Value::OutputList(_) => Err(char_error_with_message(
260 format!("char: unsupported input type {:?}", value),
261 &CHAR_ERROR_INVALID_INPUT,
262 )),
263 }
264}
265
266fn char_array_rows(ca: &CharArray) -> Vec<Vec<char>> {
267 let mut rows = Vec::with_capacity(ca.rows);
268 for r in 0..ca.rows {
269 let mut row = Vec::with_capacity(ca.cols);
270 for c in 0..ca.cols {
271 row.push(ca.data[r * ca.cols + c]);
272 }
273 rows.push(row);
274 }
275 rows
276}
277
278fn string_array_rows(sa: &StringArray) -> BuiltinResult<Vec<Vec<char>>> {
279 ensure_two_dimensional(&sa.shape, "char")?;
280 if sa.data.is_empty() {
281 return Ok(Vec::new());
282 }
283 let mut rows = Vec::with_capacity(sa.data.len());
284 let rows_count = sa.rows();
285 let cols_count = sa.cols();
286 if rows_count == 0 || cols_count == 0 {
287 return Ok(Vec::new());
288 }
289 for c in 0..cols_count {
290 for r in 0..rows_count {
291 let idx = r + c * rows_count;
292 rows.push(sa.data[idx].chars().collect());
293 }
294 }
295 Ok(rows)
296}
297
298fn tensor_rows(t: &Tensor) -> BuiltinResult<Vec<Vec<char>>> {
299 ensure_two_dimensional(&t.shape, "char")?;
300 let (rows, cols) = infer_rows_cols(&t.shape, t.data.len());
301 if rows == 0 {
302 return Ok(Vec::new());
303 }
304 let mut out = Vec::with_capacity(rows);
305 for r in 0..rows {
306 let mut row = Vec::with_capacity(cols);
307 for c in 0..cols {
308 if cols == 0 {
309 continue;
310 }
311 let idx = r + c * rows;
312 let value = t.data[idx];
313 row.push(number_to_char(value)?);
314 }
315 out.push(row);
316 }
317 Ok(out)
318}
319
320fn logical_rows(la: &LogicalArray) -> BuiltinResult<Vec<Vec<char>>> {
321 ensure_two_dimensional(&la.shape, "char")?;
322 let (rows, cols) = infer_rows_cols(&la.shape, la.data.len());
323 if rows == 0 {
324 return Ok(Vec::new());
325 }
326 let mut out = Vec::with_capacity(rows);
327 for r in 0..rows {
328 let mut row = Vec::with_capacity(cols);
329 for c in 0..cols {
330 if cols == 0 {
331 continue;
332 }
333 let idx = r + c * rows;
334 let code = if la.data[idx] != 0 { 1.0 } else { 0.0 };
335 row.push(number_to_char(code)?);
336 }
337 out.push(row);
338 }
339 Ok(out)
340}
341
342fn cell_rows(ca: &CellArray) -> BuiltinResult<Vec<Vec<char>>> {
343 let mut rows = Vec::with_capacity(ca.data.len());
344 for ptr in &ca.data {
345 let element = (**ptr).clone();
346 let mut converted = value_to_char_rows(&element)?;
347 match converted.len() {
348 0 => rows.push(Vec::new()),
349 1 => rows.push(converted.remove(0)),
350 _ => {
351 return Err(char_error_with_message(
352 "char: cell elements must be character vectors or string scalars",
353 &CHAR_ERROR_INVALID_INPUT,
354 ))
355 }
356 }
357 }
358 Ok(rows)
359}
360
361fn ensure_sparse_dense_conversion(sparse: &SparseTensor) -> BuiltinResult<()> {
362 let total_elements = sparse.rows.checked_mul(sparse.cols).ok_or_else(|| {
363 char_error_with_message(
364 "char: sparse matrix dimensions overflow",
365 &CHAR_ERROR_INVALID_INPUT,
366 )
367 })?;
368 if total_elements > CHAR_SPARSE_DENSE_ELEMENT_LIMIT {
369 return Err(char_error_with_message(
370 format!(
371 "char: cannot convert sparse tensor {}x{} with {} stored entries to dense character array ({} elements exceeds safe threshold)",
372 sparse.rows,
373 sparse.cols,
374 sparse.nnz(),
375 total_elements
376 ),
377 &CHAR_ERROR_INVALID_INPUT,
378 ));
379 }
380 Ok(())
381}
382
383fn number_to_char(value: f64) -> BuiltinResult<char> {
384 if !value.is_finite() {
385 return Err(char_error_with_message(
386 "char: numeric inputs must be finite",
387 &CHAR_ERROR_INVALID_CODEPOINT,
388 ));
389 }
390 let rounded = value.round();
391 if (value - rounded).abs() > 1e-9 {
392 return Err(char_error_with_message(
393 format!("char: numeric inputs must be integers in the Unicode range (got {value})"),
394 &CHAR_ERROR_INVALID_CODEPOINT,
395 ));
396 }
397 if rounded < 0.0 {
398 return Err(char_error_with_message(
399 format!("char: negative code points are invalid (got {rounded})"),
400 &CHAR_ERROR_INVALID_CODEPOINT,
401 ));
402 }
403 if rounded > 0x10FFFF as f64 {
404 return Err(char_error_with_message(
405 format!("char: code point {} exceeds Unicode range", rounded as u64),
406 &CHAR_ERROR_INVALID_CODEPOINT,
407 ));
408 }
409 let code = rounded as u32;
410 char::from_u32(code).ok_or_else(|| {
411 char_error_with_message(
412 format!("char: invalid code point {code}"),
413 &CHAR_ERROR_INVALID_CODEPOINT,
414 )
415 })
416}
417
418fn ensure_two_dimensional(shape: &[usize], context: &str) -> BuiltinResult<()> {
419 if shape.len() <= 2 {
420 return Ok(());
421 }
422 if shape.iter().skip(2).all(|&d| d == 1) {
423 return Ok(());
424 }
425 Err(char_error_with_message(
426 format!("{context}: inputs must be 2-D"),
427 &CHAR_ERROR_DIMENSION,
428 ))
429}
430
431fn infer_rows_cols(shape: &[usize], len: usize) -> (usize, usize) {
432 match shape.len() {
433 0 => {
434 if len == 0 {
435 (0, 0)
436 } else {
437 (1, 1)
438 }
439 }
440 1 => (1, shape[0]),
441 2 => (shape[0], shape[1]),
442 _ => {
443 let rows = shape[0];
444 let cols = if shape.len() > 1 { shape[1] } else { 1 };
445 (rows, cols)
446 }
447 }
448}
449
450#[cfg(test)]
451pub(crate) mod tests {
452 use super::*;
453 use crate::builtins::common::test_support;
454 use runmat_builtins::{ResolveContext, Type};
455
456 fn char_builtin(rest: Vec<Value>) -> BuiltinResult<Value> {
457 futures::executor::block_on(super::char_builtin(rest))
458 }
459 use runmat_builtins::StringArray;
460
461 fn error_message(err: crate::RuntimeError) -> String {
462 err.message().to_string()
463 }
464
465 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
466 #[test]
467 fn char_no_arguments_returns_empty() {
468 let result = char_builtin(Vec::new()).expect("char");
469 match result {
470 Value::CharArray(ca) => {
471 assert_eq!(ca.rows, 0);
472 assert_eq!(ca.cols, 0);
473 assert!(ca.data.is_empty());
474 }
475 other => panic!("expected char array, got {other:?}"),
476 }
477 }
478
479 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
480 #[test]
481 fn char_from_string_scalar() {
482 let value = Value::String("RunMat".to_string());
483 let result = char_builtin(vec![value]).expect("char");
484 match result {
485 Value::CharArray(ca) => {
486 assert_eq!(ca.rows, 1);
487 assert_eq!(ca.cols, 6);
488 assert_eq!(ca.data, "RunMat".chars().collect::<Vec<_>>());
489 }
490 other => panic!("expected char array, got {other:?}"),
491 }
492 }
493
494 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
495 #[test]
496 fn char_from_numeric_tensor() {
497 let tensor =
498 Tensor::new(vec![82.0, 85.0, 78.0, 77.0, 65.0, 84.0], vec![1, 6]).expect("tensor");
499 let result = char_builtin(vec![Value::Tensor(tensor)]).expect("char");
500 match result {
501 Value::CharArray(ca) => {
502 assert_eq!(ca.rows, 1);
503 assert_eq!(ca.cols, 6);
504 assert_eq!(ca.data, "RUNMAT".chars().collect::<Vec<_>>());
505 }
506 other => panic!("expected char array, got {other:?}"),
507 }
508 }
509
510 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
511 #[test]
512 fn char_from_string_array_with_padding() {
513 let data = vec!["cat".to_string(), "giraffe".to_string()];
514 let sa = StringArray::new(data, vec![2, 1]).expect("string array");
515 let result = char_builtin(vec![Value::StringArray(sa)]).expect("char from string array");
516 match result {
517 Value::CharArray(ca) => {
518 assert_eq!(ca.rows, 2);
519 assert_eq!(ca.cols, 7);
520 assert_eq!(
521 ca.data,
522 vec!['c', 'a', 't', ' ', ' ', ' ', ' ', 'g', 'i', 'r', 'a', 'f', 'f', 'e']
523 );
524 }
525 other => panic!("expected char array, got {other:?}"),
526 }
527 }
528
529 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
530 #[test]
531 fn char_from_cell_array_of_strings() {
532 let cell = CellArray::new(
533 vec![
534 Value::from("north"),
535 Value::from("east"),
536 Value::from("west"),
537 ],
538 3,
539 1,
540 )
541 .expect("cell array");
542 let result = char_builtin(vec![Value::Cell(cell)]).expect("char");
543 match result {
544 Value::CharArray(ca) => {
545 assert_eq!(ca.rows, 3);
546 assert_eq!(ca.cols, 5);
547 assert_eq!(
548 ca.data,
549 vec!['n', 'o', 'r', 't', 'h', 'e', 'a', 's', 't', ' ', 'w', 'e', 's', 't', ' ']
550 );
551 }
552 other => panic!("expected char array, got {other:?}"),
553 }
554 }
555
556 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
557 #[test]
558 fn char_numeric_and_text_arguments_concatenate() {
559 let text = Value::String("hi".to_string());
560 let codes = Tensor::new(vec![65.0, 66.0], vec![1, 2]).expect("tensor");
561 let result = char_builtin(vec![text, Value::Tensor(codes)]).expect("char");
562 match result {
563 Value::CharArray(ca) => {
564 assert_eq!(ca.rows, 2);
565 assert_eq!(ca.cols, 2);
566 assert_eq!(ca.data, vec!['h', 'i', 'A', 'B']);
567 }
568 other => panic!("expected char array, got {other:?}"),
569 }
570 }
571
572 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
573 #[test]
574 fn char_gpu_tensor_round_trip() {
575 test_support::with_test_provider(|provider| {
576 let tensor = Tensor::new(vec![82.0, 85.0, 78.0], vec![1, 3]).expect("tensor");
577 let view = runmat_accelerate_api::HostTensorView {
578 data: &tensor.data,
579 shape: &tensor.shape,
580 };
581 let handle = provider.upload(&view).expect("upload");
582 let result = char_builtin(vec![Value::GpuTensor(handle)]).expect("char");
583 match result {
584 Value::CharArray(ca) => {
585 assert_eq!(ca.rows, 1);
586 assert_eq!(ca.cols, 3);
587 assert_eq!(ca.data, vec!['R', 'U', 'N']);
588 }
589 other => panic!("expected char array, got {other:?}"),
590 }
591 });
592 }
593
594 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
595 #[test]
596 fn char_rejects_non_integer_numeric() {
597 let err =
598 error_message(char_builtin(vec![Value::Num(65.5)]).expect_err("non-integer numeric"));
599 assert!(err.contains("integers"), "unexpected error message: {err}");
600 }
601
602 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
603 #[test]
604 fn char_rejects_high_dimension_tensor() {
605 let tensor =
606 Tensor::new(vec![65.0, 66.0], vec![1, 1, 2]).expect("tensor construction failed");
607 let err = error_message(
608 char_builtin(vec![Value::Tensor(tensor)]).expect_err("should reject >2D tensor"),
609 );
610 assert!(err.contains("2-D"), "expected dimension error, got {err}");
611 }
612
613 #[test]
614 fn char_rejects_oversized_sparse_tensor_before_densifying() {
615 let sparse = SparseTensor::zeros(CHAR_SPARSE_DENSE_ELEMENT_LIMIT + 1, 1);
616 let err = char_builtin(vec![Value::SparseTensor(sparse)]).unwrap_err();
617
618 assert_eq!(err.identifier(), Some("RunMat:char:InvalidInput"));
619 assert!(err.message().contains("exceeds safe threshold"));
620 }
621
622 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
623 #[test]
624 fn char_string_array_column_major_order() {
625 let data = vec![
626 "c0r0".to_string(),
627 "c0r1".to_string(),
628 "c1r0".to_string(),
629 "c1r1".to_string(),
630 ];
631 let sa = StringArray::new(data, vec![2, 2]).expect("string array");
632 let result = char_builtin(vec![Value::StringArray(sa)]).expect("char");
633 match result {
634 Value::CharArray(ca) => {
635 assert_eq!(ca.rows, 4);
636 assert_eq!(ca.cols, 4);
637 assert_eq!(ca.data, "c0r0c0r1c1r0c1r1".chars().collect::<Vec<char>>());
638 }
639 other => panic!("expected char array, got {other:?}"),
640 }
641 }
642
643 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
644 #[test]
645 fn char_rejects_high_dimension_string_array() {
646 let sa = StringArray::new(vec!["a".to_string(), "b".to_string()], vec![1, 1, 2])
647 .expect("string array");
648 let err = error_message(
649 char_builtin(vec![Value::StringArray(sa)]).expect_err("should reject >2D string array"),
650 );
651 assert!(err.contains("2-D"), "expected dimension error, got {err}");
652 }
653
654 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
655 #[test]
656 fn char_rejects_complex_input() {
657 let err =
658 error_message(char_builtin(vec![Value::Complex(1.0, 2.0)]).expect_err("complex input"));
659 assert!(
660 err.contains("complex"),
661 "expected complex error message, got {err}"
662 );
663 }
664
665 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
666 #[test]
667 #[cfg(feature = "wgpu")]
668 fn char_wgpu_numeric_codes_matches_cpu() {
669 use runmat_accelerate::backend::wgpu::provider::{
670 register_wgpu_provider, WgpuProviderOptions,
671 };
672
673 let _ = register_wgpu_provider(WgpuProviderOptions::default());
674
675 let tensor = Tensor::new(vec![82.0, 85.0, 78.0], vec![1, 3]).unwrap();
676 let cpu = char_builtin(vec![Value::Tensor(tensor.clone())]).expect("char cpu");
677
678 let view = runmat_accelerate_api::HostTensorView {
679 data: &tensor.data,
680 shape: &tensor.shape,
681 };
682 let handle = runmat_accelerate_api::provider()
683 .expect("wgpu provider")
684 .upload(&view)
685 .expect("upload");
686 let gpu = char_builtin(vec![Value::GpuTensor(handle)]).expect("char gpu");
687
688 match (cpu, gpu) {
689 (Value::CharArray(expected), Value::CharArray(actual)) => {
690 assert_eq!(actual, expected);
691 }
692 other => panic!("unexpected results {other:?}"),
693 }
694 }
695
696 #[test]
697 fn char_type_is_string_array() {
698 assert_eq!(
699 string_array_type(&[Type::Num], &ResolveContext::new(Vec::new())),
700 Type::cell_of(Type::String)
701 );
702 }
703}