runmat_runtime/builtins/strings/core/
char.rs

1//! MATLAB-compatible `char` builtin with GPU-aware conversion semantics for RunMat.
2
3use 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::Symbolic(expr) => Ok(vec![expr.to_string().chars().collect()]),
226        Value::StringArray(sa) => string_array_rows(sa),
227        Value::Num(n) => Ok(vec![vec![number_to_char(*n)?]]),
228        Value::Int(i) => {
229            let as_double = i.to_f64();
230            Ok(vec![vec![number_to_char(as_double)?]])
231        }
232        Value::Bool(b) => {
233            let code = if *b { 1.0 } else { 0.0 };
234            Ok(vec![vec![number_to_char(code)?]])
235        }
236        Value::Tensor(t) => tensor_rows(t),
237        Value::SparseTensor(s) => {
238            ensure_sparse_dense_conversion(s)?;
239            let dense = s.to_dense().map_err(char_flow)?;
240            tensor_rows(&dense)
241        }
242        Value::LogicalArray(la) => logical_rows(la),
243        Value::Cell(ca) => cell_rows(ca),
244        Value::GpuTensor(_) => Err(char_error(&CHAR_ERROR_INVALID_INPUT)),
245        Value::Complex(_, _) | Value::ComplexTensor(_) => Err(char_error_with_message(
246            "char: complex inputs are not supported",
247            &CHAR_ERROR_INVALID_INPUT,
248        )),
249        Value::Struct(_)
250        | Value::Object(_)
251        | Value::HandleObject(_)
252        | Value::Listener(_)
253        | Value::FunctionHandle(_)
254        | Value::ExternalFunctionHandle(_)
255        | Value::MethodFunctionHandle(_)
256        | Value::BoundFunctionHandle { .. }
257        | Value::Closure(_)
258        | Value::ClassRef(_)
259        | Value::MException(_)
260        | Value::OutputList(_) => Err(char_error_with_message(
261            format!("char: unsupported input type {:?}", value),
262            &CHAR_ERROR_INVALID_INPUT,
263        )),
264    }
265}
266
267fn char_array_rows(ca: &CharArray) -> Vec<Vec<char>> {
268    let mut rows = Vec::with_capacity(ca.rows);
269    for r in 0..ca.rows {
270        let mut row = Vec::with_capacity(ca.cols);
271        for c in 0..ca.cols {
272            row.push(ca.data[r * ca.cols + c]);
273        }
274        rows.push(row);
275    }
276    rows
277}
278
279fn string_array_rows(sa: &StringArray) -> BuiltinResult<Vec<Vec<char>>> {
280    ensure_two_dimensional(&sa.shape, "char")?;
281    if sa.data.is_empty() {
282        return Ok(Vec::new());
283    }
284    let mut rows = Vec::with_capacity(sa.data.len());
285    let rows_count = sa.rows();
286    let cols_count = sa.cols();
287    if rows_count == 0 || cols_count == 0 {
288        return Ok(Vec::new());
289    }
290    for c in 0..cols_count {
291        for r in 0..rows_count {
292            let idx = r + c * rows_count;
293            rows.push(sa.data[idx].chars().collect());
294        }
295    }
296    Ok(rows)
297}
298
299fn tensor_rows(t: &Tensor) -> BuiltinResult<Vec<Vec<char>>> {
300    ensure_two_dimensional(&t.shape, "char")?;
301    let (rows, cols) = infer_rows_cols(&t.shape, t.data.len());
302    if rows == 0 {
303        return Ok(Vec::new());
304    }
305    let mut out = Vec::with_capacity(rows);
306    for r in 0..rows {
307        let mut row = Vec::with_capacity(cols);
308        for c in 0..cols {
309            if cols == 0 {
310                continue;
311            }
312            let idx = r + c * rows;
313            let value = t.data[idx];
314            row.push(number_to_char(value)?);
315        }
316        out.push(row);
317    }
318    Ok(out)
319}
320
321fn logical_rows(la: &LogicalArray) -> BuiltinResult<Vec<Vec<char>>> {
322    ensure_two_dimensional(&la.shape, "char")?;
323    let (rows, cols) = infer_rows_cols(&la.shape, la.data.len());
324    if rows == 0 {
325        return Ok(Vec::new());
326    }
327    let mut out = Vec::with_capacity(rows);
328    for r in 0..rows {
329        let mut row = Vec::with_capacity(cols);
330        for c in 0..cols {
331            if cols == 0 {
332                continue;
333            }
334            let idx = r + c * rows;
335            let code = if la.data[idx] != 0 { 1.0 } else { 0.0 };
336            row.push(number_to_char(code)?);
337        }
338        out.push(row);
339    }
340    Ok(out)
341}
342
343fn cell_rows(ca: &CellArray) -> BuiltinResult<Vec<Vec<char>>> {
344    let mut rows = Vec::with_capacity(ca.data.len());
345    for ptr in &ca.data {
346        let element = (ptr).clone();
347        let mut converted = value_to_char_rows(&element)?;
348        match converted.len() {
349            0 => rows.push(Vec::new()),
350            1 => rows.push(converted.remove(0)),
351            _ => {
352                return Err(char_error_with_message(
353                    "char: cell elements must be character vectors or string scalars",
354                    &CHAR_ERROR_INVALID_INPUT,
355                ))
356            }
357        }
358    }
359    Ok(rows)
360}
361
362fn ensure_sparse_dense_conversion(sparse: &SparseTensor) -> BuiltinResult<()> {
363    let total_elements = sparse.rows.checked_mul(sparse.cols).ok_or_else(|| {
364        char_error_with_message(
365            "char: sparse matrix dimensions overflow",
366            &CHAR_ERROR_INVALID_INPUT,
367        )
368    })?;
369    if total_elements > CHAR_SPARSE_DENSE_ELEMENT_LIMIT {
370        return Err(char_error_with_message(
371            format!(
372                "char: cannot convert sparse tensor {}x{} with {} stored entries to dense character array ({} elements exceeds safe threshold)",
373                sparse.rows,
374                sparse.cols,
375                sparse.nnz(),
376                total_elements
377            ),
378            &CHAR_ERROR_INVALID_INPUT,
379        ));
380    }
381    Ok(())
382}
383
384fn number_to_char(value: f64) -> BuiltinResult<char> {
385    if !value.is_finite() {
386        return Err(char_error_with_message(
387            "char: numeric inputs must be finite",
388            &CHAR_ERROR_INVALID_CODEPOINT,
389        ));
390    }
391    let rounded = value.round();
392    if (value - rounded).abs() > 1e-9 {
393        return Err(char_error_with_message(
394            format!("char: numeric inputs must be integers in the Unicode range (got {value})"),
395            &CHAR_ERROR_INVALID_CODEPOINT,
396        ));
397    }
398    if rounded < 0.0 {
399        return Err(char_error_with_message(
400            format!("char: negative code points are invalid (got {rounded})"),
401            &CHAR_ERROR_INVALID_CODEPOINT,
402        ));
403    }
404    if rounded > 0x10FFFF as f64 {
405        return Err(char_error_with_message(
406            format!("char: code point {} exceeds Unicode range", rounded as u64),
407            &CHAR_ERROR_INVALID_CODEPOINT,
408        ));
409    }
410    let code = rounded as u32;
411    char::from_u32(code).ok_or_else(|| {
412        char_error_with_message(
413            format!("char: invalid code point {code}"),
414            &CHAR_ERROR_INVALID_CODEPOINT,
415        )
416    })
417}
418
419fn ensure_two_dimensional(shape: &[usize], context: &str) -> BuiltinResult<()> {
420    if shape.len() <= 2 {
421        return Ok(());
422    }
423    if shape.iter().skip(2).all(|&d| d == 1) {
424        return Ok(());
425    }
426    Err(char_error_with_message(
427        format!("{context}: inputs must be 2-D"),
428        &CHAR_ERROR_DIMENSION,
429    ))
430}
431
432fn infer_rows_cols(shape: &[usize], len: usize) -> (usize, usize) {
433    match shape.len() {
434        0 => {
435            if len == 0 {
436                (0, 0)
437            } else {
438                (1, 1)
439            }
440        }
441        1 => (1, shape[0]),
442        2 => (shape[0], shape[1]),
443        _ => {
444            let rows = shape[0];
445            let cols = if shape.len() > 1 { shape[1] } else { 1 };
446            (rows, cols)
447        }
448    }
449}
450
451#[cfg(test)]
452pub(crate) mod tests {
453    use super::*;
454    use crate::builtins::common::test_support;
455    use runmat_builtins::{ResolveContext, Type};
456
457    fn char_builtin(rest: Vec<Value>) -> BuiltinResult<Value> {
458        futures::executor::block_on(super::char_builtin(rest))
459    }
460    use runmat_builtins::StringArray;
461
462    fn error_message(err: crate::RuntimeError) -> String {
463        err.message().to_string()
464    }
465
466    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
467    #[test]
468    fn char_no_arguments_returns_empty() {
469        let result = char_builtin(Vec::new()).expect("char");
470        match result {
471            Value::CharArray(ca) => {
472                assert_eq!(ca.rows, 0);
473                assert_eq!(ca.cols, 0);
474                assert!(ca.data.is_empty());
475            }
476            other => panic!("expected char array, got {other:?}"),
477        }
478    }
479
480    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
481    #[test]
482    fn char_from_string_scalar() {
483        let value = Value::String("RunMat".to_string());
484        let result = char_builtin(vec![value]).expect("char");
485        match result {
486            Value::CharArray(ca) => {
487                assert_eq!(ca.rows, 1);
488                assert_eq!(ca.cols, 6);
489                assert_eq!(ca.data, "RunMat".chars().collect::<Vec<_>>());
490            }
491            other => panic!("expected char array, got {other:?}"),
492        }
493    }
494
495    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
496    #[test]
497    fn char_from_numeric_tensor() {
498        let tensor =
499            Tensor::new(vec![82.0, 85.0, 78.0, 77.0, 65.0, 84.0], vec![1, 6]).expect("tensor");
500        let result = char_builtin(vec![Value::Tensor(tensor)]).expect("char");
501        match result {
502            Value::CharArray(ca) => {
503                assert_eq!(ca.rows, 1);
504                assert_eq!(ca.cols, 6);
505                assert_eq!(ca.data, "RUNMAT".chars().collect::<Vec<_>>());
506            }
507            other => panic!("expected char array, got {other:?}"),
508        }
509    }
510
511    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
512    #[test]
513    fn char_from_string_array_with_padding() {
514        let data = vec!["cat".to_string(), "giraffe".to_string()];
515        let sa = StringArray::new(data, vec![2, 1]).expect("string array");
516        let result = char_builtin(vec![Value::StringArray(sa)]).expect("char from string array");
517        match result {
518            Value::CharArray(ca) => {
519                assert_eq!(ca.rows, 2);
520                assert_eq!(ca.cols, 7);
521                assert_eq!(
522                    ca.data,
523                    vec!['c', 'a', 't', ' ', ' ', ' ', ' ', 'g', 'i', 'r', 'a', 'f', 'f', 'e']
524                );
525            }
526            other => panic!("expected char array, got {other:?}"),
527        }
528    }
529
530    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
531    #[test]
532    fn char_from_cell_array_of_strings() {
533        let cell = CellArray::new(
534            vec![
535                Value::from("north"),
536                Value::from("east"),
537                Value::from("west"),
538            ],
539            3,
540            1,
541        )
542        .expect("cell array");
543        let result = char_builtin(vec![Value::Cell(cell)]).expect("char");
544        match result {
545            Value::CharArray(ca) => {
546                assert_eq!(ca.rows, 3);
547                assert_eq!(ca.cols, 5);
548                assert_eq!(
549                    ca.data,
550                    vec!['n', 'o', 'r', 't', 'h', 'e', 'a', 's', 't', ' ', 'w', 'e', 's', 't', ' ']
551                );
552            }
553            other => panic!("expected char array, got {other:?}"),
554        }
555    }
556
557    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
558    #[test]
559    fn char_numeric_and_text_arguments_concatenate() {
560        let text = Value::String("hi".to_string());
561        let codes = Tensor::new(vec![65.0, 66.0], vec![1, 2]).expect("tensor");
562        let result = char_builtin(vec![text, Value::Tensor(codes)]).expect("char");
563        match result {
564            Value::CharArray(ca) => {
565                assert_eq!(ca.rows, 2);
566                assert_eq!(ca.cols, 2);
567                assert_eq!(ca.data, vec!['h', 'i', 'A', 'B']);
568            }
569            other => panic!("expected char array, got {other:?}"),
570        }
571    }
572
573    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
574    #[test]
575    fn char_gpu_tensor_round_trip() {
576        test_support::with_test_provider(|provider| {
577            let tensor = Tensor::new(vec![82.0, 85.0, 78.0], vec![1, 3]).expect("tensor");
578            let view = runmat_accelerate_api::HostTensorView {
579                data: &tensor.data,
580                shape: &tensor.shape,
581            };
582            let handle = provider.upload(&view).expect("upload");
583            let result = char_builtin(vec![Value::GpuTensor(handle)]).expect("char");
584            match result {
585                Value::CharArray(ca) => {
586                    assert_eq!(ca.rows, 1);
587                    assert_eq!(ca.cols, 3);
588                    assert_eq!(ca.data, vec!['R', 'U', 'N']);
589                }
590                other => panic!("expected char array, got {other:?}"),
591            }
592        });
593    }
594
595    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
596    #[test]
597    fn char_rejects_non_integer_numeric() {
598        let err =
599            error_message(char_builtin(vec![Value::Num(65.5)]).expect_err("non-integer numeric"));
600        assert!(err.contains("integers"), "unexpected error message: {err}");
601    }
602
603    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
604    #[test]
605    fn char_rejects_high_dimension_tensor() {
606        let tensor =
607            Tensor::new(vec![65.0, 66.0], vec![1, 1, 2]).expect("tensor construction failed");
608        let err = error_message(
609            char_builtin(vec![Value::Tensor(tensor)]).expect_err("should reject >2D tensor"),
610        );
611        assert!(err.contains("2-D"), "expected dimension error, got {err}");
612    }
613
614    #[test]
615    fn char_rejects_oversized_sparse_tensor_before_densifying() {
616        let sparse = SparseTensor::zeros(CHAR_SPARSE_DENSE_ELEMENT_LIMIT + 1, 1);
617        let err = char_builtin(vec![Value::SparseTensor(sparse)]).unwrap_err();
618
619        assert_eq!(err.identifier(), Some("RunMat:char:InvalidInput"));
620        assert!(err.message().contains("exceeds safe threshold"));
621    }
622
623    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
624    #[test]
625    fn char_string_array_column_major_order() {
626        let data = vec![
627            "c0r0".to_string(),
628            "c0r1".to_string(),
629            "c1r0".to_string(),
630            "c1r1".to_string(),
631        ];
632        let sa = StringArray::new(data, vec![2, 2]).expect("string array");
633        let result = char_builtin(vec![Value::StringArray(sa)]).expect("char");
634        match result {
635            Value::CharArray(ca) => {
636                assert_eq!(ca.rows, 4);
637                assert_eq!(ca.cols, 4);
638                assert_eq!(ca.data, "c0r0c0r1c1r0c1r1".chars().collect::<Vec<char>>());
639            }
640            other => panic!("expected char array, got {other:?}"),
641        }
642    }
643
644    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
645    #[test]
646    fn char_rejects_high_dimension_string_array() {
647        let sa = StringArray::new(vec!["a".to_string(), "b".to_string()], vec![1, 1, 2])
648            .expect("string array");
649        let err = error_message(
650            char_builtin(vec![Value::StringArray(sa)]).expect_err("should reject >2D string array"),
651        );
652        assert!(err.contains("2-D"), "expected dimension error, got {err}");
653    }
654
655    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
656    #[test]
657    fn char_rejects_complex_input() {
658        let err =
659            error_message(char_builtin(vec![Value::Complex(1.0, 2.0)]).expect_err("complex input"));
660        assert!(
661            err.contains("complex"),
662            "expected complex error message, got {err}"
663        );
664    }
665
666    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test::wasm_bindgen_test)]
667    #[test]
668    #[cfg(feature = "wgpu")]
669    fn char_wgpu_numeric_codes_matches_cpu() {
670        use runmat_accelerate::backend::wgpu::provider::{
671            register_wgpu_provider, WgpuProviderOptions,
672        };
673
674        let _ = register_wgpu_provider(WgpuProviderOptions::default());
675
676        let tensor = Tensor::new(vec![82.0, 85.0, 78.0], vec![1, 3]).unwrap();
677        let cpu = char_builtin(vec![Value::Tensor(tensor.clone())]).expect("char cpu");
678
679        let view = runmat_accelerate_api::HostTensorView {
680            data: &tensor.data,
681            shape: &tensor.shape,
682        };
683        let handle = runmat_accelerate_api::provider()
684            .expect("wgpu provider")
685            .upload(&view)
686            .expect("upload");
687        let gpu = char_builtin(vec![Value::GpuTensor(handle)]).expect("char gpu");
688
689        match (cpu, gpu) {
690            (Value::CharArray(expected), Value::CharArray(actual)) => {
691                assert_eq!(actual, expected);
692            }
693            other => panic!("unexpected results {other:?}"),
694        }
695    }
696
697    #[test]
698    fn char_type_is_string_array() {
699        assert_eq!(
700            string_array_type(&[Type::Num], &ResolveContext::new(Vec::new())),
701            Type::cell_of(Type::String)
702        );
703    }
704}
runmat_runtime/builtins/strings/core/char.rs

runmat_runtime/builtins/strings/core/
char.rs
