//! Marqdo quantum plugin (C ABI v2): state-vector circuit simulation. mod draw; mod linalg; mod sim; use std::ffi::{CStr, CString}; use std::os::raw::{c_char, c_int, c_void}; use std::ptr; use serde_json::{json, Value}; use marqdo_plugin_sdk::*; macro_rules! q_ffi { ($name:ident, $body:expr) => { unsafe extern "C" fn $name( args_json: *const c_char, out_json: *mut *mut c_char, err_msg: *mut *mut c_char, ) -> c_int { let args = match parse_args(args_json) { Ok(v) => v, Err(e) => { set_err(err_msg, &format!("{}: {e}", stringify!($name))); return 1; } }; let r: Result = (|| $body(&args))(); reply( out_json, err_msg, r.map_err(|e| format!("{}: {e}", stringify!($name))), ) } }; } fn arg_u(v: &Value, key: &str) -> Result { match v.get(key) { Some(Value::Number(n)) => n .as_u64() .or_else(|| n.as_i64().map(|i| i as u64)) .map(|u| u as usize) .ok_or_else(|| format!("bad `{key}`")), Some(Value::String(s)) => s .trim() .parse() .map_err(|_| format!("bad `{key}`")), _ => Err(format!("missing `{key}`")), } } fn arg_f(v: &Value, key: &str) -> Result { match v.get(key) { Some(Value::Number(n)) => n .as_f64() .ok_or_else(|| format!("bad `{key}`")), Some(Value::String(s)) => s .trim() .parse() .map_err(|_| format!("bad `{key}`")), _ => Err(format!("missing `{key}`")), } } fn circuit_of(args: &Value) -> Result<&Value, String> { args.get("circuit") .or_else(|| args.get("电路")) .ok_or_else(|| "missing `circuit`".to_string()) } fn take_host_string(p: *mut c_char) -> Option { if p.is_null() { return None; } let s = unsafe { CStr::from_ptr(p) } .to_str() .ok() .map(|s| s.to_string()); unsafe { if let Some(free) = HOST_FREE { free(p as *mut c_void); } } s } fn host_query_json(name: &str, args: &Value) -> Result { let query = unsafe { HOST_QUERY }.ok_or_else(|| "host_query not available".to_string())?; let userdata = unsafe { HOST_USERDATA }; let c_name = CString::new(name).map_err(|e| e.to_string())?; let c_args = CString::new(args.to_string()).map_err(|e| e.to_string())?; let mut out_ptr: *mut c_char = ptr::null_mut(); let mut err_ptr: *mut c_char = ptr::null_mut(); let rc = unsafe { query( userdata, c_name.as_ptr(), c_args.as_ptr(), &mut out_ptr, &mut err_ptr, ) }; let err = take_host_string(err_ptr); let out = take_host_string(out_ptr); if rc != 0 { return Err(err.unwrap_or_else(|| format!("host_query `{name}` failed"))); } let out = out.unwrap_or_else(|| "null".into()); serde_json::from_str(&out).map_err(|e| format!("host_query `{name}` bad JSON: {e}")) } fn record_plot(svg: &str, path: Option<&str>) -> Result<(), String> { let mut args = json!({ "svg": svg }); if let Some(p) = path { if !p.is_empty() { args.as_object_mut() .unwrap() .insert("path".into(), json!(p)); } } host_query_json("record_plot", &args)?; Ok(()) } q_ffi!(quantum_ping, |_args: &Value| { Ok(json!({ "ok": true, "name": "quantum", "abi": ABI_VERSION, "max_qubits": sim::max_qubits(), })) }); q_ffi!(quantum_circuit_new, |args: &Value| { let qubits = arg_u(args, "qubits").or_else(|_| arg_u(args, "比特数"))?; let steps = args .get("steps") .or_else(|| args.get("步骤")) .filter(|v| !v.is_null()); sim::circuit_new(qubits, steps) }); q_ffi!(quantum_h, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "H", vec![q], None) }); q_ffi!(quantum_x, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "X", vec![q], None) }); q_ffi!(quantum_y, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "Y", vec![q], None) }); q_ffi!(quantum_z, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "Z", vec![q], None) }); q_ffi!(quantum_s, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "S", vec![q], None) }); q_ffi!(quantum_t, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "T", vec![q], None) }); q_ffi!(quantum_i, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; sim::push_op(c, "I", vec![q], None) }); q_ffi!(quantum_rx, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; let th = arg_f(args, "theta").or_else(|_| arg_f(args, "参数"))?; sim::push_op(c, "RX", vec![q], Some(th)) }); q_ffi!(quantum_ry, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; let th = arg_f(args, "theta").or_else(|_| arg_f(args, "参数"))?; sim::push_op(c, "RY", vec![q], Some(th)) }); q_ffi!(quantum_rz, |args: &Value| { let c = circuit_of(args)?; let q = arg_u(args, "qubit").or_else(|_| arg_u(args, "比特"))?; let th = arg_f(args, "theta").or_else(|_| arg_f(args, "参数"))?; sim::push_op(c, "RZ", vec![q], Some(th)) }); q_ffi!(quantum_cx, |args: &Value| { let c = circuit_of(args)?; let control = arg_u(args, "control").or_else(|_| arg_u(args, "控制"))?; let target = arg_u(args, "target").or_else(|_| arg_u(args, "目标"))?; sim::push_op(c, "CX", vec![control, target], None) }); q_ffi!(quantum_cz, |args: &Value| { let c = circuit_of(args)?; let control = arg_u(args, "control").or_else(|_| arg_u(args, "控制"))?; let target = arg_u(args, "target").or_else(|_| arg_u(args, "目标"))?; sim::push_op(c, "CZ", vec![control, target], None) }); q_ffi!(quantum_swap, |args: &Value| { let c = circuit_of(args)?; let a = arg_u(args, "a").or_else(|_| arg_u(args, "比特甲"))?; let b = arg_u(args, "b").or_else(|_| arg_u(args, "比特乙"))?; sim::push_op(c, "SWAP", vec![a, b], None) }); q_ffi!(quantum_simulate, |args: &Value| { let c = circuit_of(args)?; let (qubits, amps) = sim::simulate_circuit(c)?; Ok(json!({ "qubits": qubits, "dim": amps.len(), "amplitudes": sim::amps_to_json(&s), })) }); q_ffi!(quantum_probabilities, |args: &Value| { let c = circuit_of(args)?; let (qubits, amps) = sim::simulate_circuit(c)?; Ok(Value::Object(sim::probabilities(&s, qubits))) }); q_ffi!(quantum_run, |args: &Value| { let c = circuit_of(args)?; let shots = arg_u(args, "shots") .or_else(|_| arg_u(args, "次数")) .unwrap_or(1024); let seed = arg_u(args, "seed") .or_else(|_| arg_u(args, "种子")) .unwrap_or(1) as u64; sim::run_circuit(c, shots, seed) }); q_ffi!(quantum_barrier, |args: &Value| { let c = circuit_of(args)?; sim::push_op(c, "BARRIER", vec![], None) }); q_ffi!(quantum_measure, |args: &Value| { let c = circuit_of(args)?; let qs = match args.get("qubits").or_else(|| args.get("比特")) { None | Some(Value::Null) => vec![], Some(Value::Array(a)) => a .iter() .map(|v| { v.as_u64() .or_else(|| v.as_i64().map(|i| i as u64)) .ok_or_else(|| "bad qubit".to_string()) .map(|u| u as usize) }) .collect::, _>>()?, Some(Value::Number(n)) => { vec![n.as_u64().or_else(|| n.as_i64().map(|i| i as u64)).unwrap() as usize] } Some(Value::String(s)) => { if s.trim().is_empty() { vec![] } else { s.split(|c| c == ',' || c == ' ' || c == ',') .filter(|t| !t.is_empty()) .map(|t| { t.trim() .parse::() .map_err(|_| format!("bad qubit `{t}`")) }) .collect::, _>>()? } } _ => return Err("bad qubits for measure".into()), }; sim::push_op(c, "MEASURE", qs, None) }); q_ffi!(quantum_append, |args: &Value| { let c = circuit_of(args)?; let op = args .get("op") .or_else(|| args.get("操作")) .ok_or_else(|| "append needs `op`".to_string())?; sim::append(c, op) }); q_ffi!(quantum_noise, |args: &Value| { let c = circuit_of(args)?; let kind = args .get("kind") .or_else(|| args.get("种类")) .and_then(|v| v.as_str()) .ok_or_else(|| "noise needs `kind`".to_string())?; let p = arg_f(args, "p").or_else(|_| arg_f(args, "概率"))?; sim::set_noise(c, kind, p) }); q_ffi!(quantum_state, |args: &Value| { let c = circuit_of(args)?; let (qubits, amps) = sim::simulate_circuit(c)?; Ok(json!({ "_type": "quantum_state", "qubits": qubits, "dim": amps.len(), "amplitudes": sim::amps_to_json(&s), })) }); fn draw_theme_of(args: &Value) -> Result { match args .get("theme") .or_else(|| args.get("主题")) .and_then(|v| v.as_str()) { None => Ok(draw::ThemeName::Dark), Some(s) => draw::ThemeName::parse(s), } } q_ffi!(quantum_draw_circuit, |args: &Value| { let c = circuit_of(args)?; let kind = args .get("kind") .or_else(|| args.get("种类")) .and_then(|v| v.as_str()) .unwrap_or("circuit") .to_ascii_lowercase(); let theme = draw_theme_of(args)?; let qubit = arg_u(args, "qubit") .or_else(|_| arg_u(args, "比特")) .unwrap_or(0); let path = args .get("path") .or_else(|| args.get("路径")) .and_then(|v| v.as_str()) .filter(|s| !s.is_empty()); let (kind_out, svg) = match kind.as_str() { "circuit" | "" => ("circuit", draw::circuit_svg(c, theme)?), "probs" | "probabilities" | "概率" => { let (qubits, amps) = sim::simulate_circuit(c)?; let probs = sim::probabilities(&s, qubits); ("probs", draw::probs_svg(&probs, theme)) } "bloch" | "布洛赫" => { let (qubits, amps) = sim::simulate_circuit(c)?; let (x, y, z) = sim::bloch_vector(&s, qubits, qubit)?; ("bloch", draw::bloch_svg(x, y, z, theme)) } "hinton" | "欣顿" => { let (n, amps) = sim::simulate_circuit(c)?; let (_, rho) = linalg::density_from_amps(&s, n)?; let nested = linalg::flat_to_nested(&rho, 1 << n); ("hinton", draw::hinton_svg(&nested, "ρ hinton")) } "city" | "城市" => { let (n, amps) = sim::simulate_circuit(c)?; let (_, rho) = linalg::density_from_amps(&s, n)?; let nested = linalg::flat_to_nested(&rho, 1 << n); ("city", draw::city_svg(&nested, "ρ")) } "density" | "密度图" => { let (n, amps) = sim::simulate_circuit(c)?; let (_, rho) = linalg::density_from_amps(&s, n)?; let nested = linalg::flat_to_nested(&rho, 1 << n); ("density", draw::density_cells_svg(&nested, "ρ")) } "paulivec" | "泡利向量" => { let (n, amps) = sim::simulate_circuit(c)?; let (_, rho) = linalg::density_from_amps(&s, n)?; let dim = 1 << n; let labels = linalg::all_pauli_labels(n)?; let mut vals = Vec::with_capacity(labels.len()); for lab in &labels { vals.push(linalg::expect_pauli(&rho, dim, n, lab)?); } ("paulivec", draw::paulivec_svg(&labels, &vals, "Pauli")) } "qsphere" | "球" => { let (n, amps) = sim::simulate_circuit(c)?; ("qsphere", draw::qsphere_svg(&s, n)) } "multibloch" | "多布洛赫" => { let (n, amps) = sim::simulate_circuit(c)?; ("multibloch", draw::multibloch_svg(&s, n)?) } other => { return Err(format!( "unknown draw kind `{other}` (circuit|probs|bloch|hinton|city|density|paulivec|qsphere|multibloch)" )); } }; record_plot(&svg, path)?; let ops_n = c .get("ops") .and_then(|v| v.as_array()) .map(|a| a.len()) .unwrap_or(0); let qubits = c .get("qubits") .and_then(|v| v.as_u64()) .unwrap_or(0); Ok(json!({ "_type": "quantum_svg", "kind": kind_out, "qubits": qubits, "ops": ops_n, "svg": svg, })) }); q_ffi!(quantum_gate_new, |args: &Value| { let matrix = args.get("matrix").or_else(|| args.get("矩阵")); if let Some(m) = matrix { if !m.is_null() { let name = args .get("name") .or_else(|| args.get("名")) .and_then(|v| v.as_str()); return sim::gate_from_matrix(m, name); } } let name = args .get("name") .or_else(|| args.get("名")) .and_then(|v| v.as_str()) .ok_or_else(|| "gate needs `name` or `matrix`".to_string())?; let theta = match args.get("theta").or_else(|| args.get("参数")) { None | Some(Value::Null) => None, Some(v) => Some( v.as_f64() .or_else(|| v.as_str().and_then(|s| s.trim().parse().ok())) .ok_or_else(|| "bad theta".to_string())?, ), }; sim::gate_new(name, theta) }); q_ffi!(quantum_gate_from_matrix, |args: &Value| { let matrix = args .get("matrix") .or_else(|| args.get("矩阵")) .ok_or_else(|| "missing `matrix`".to_string())?; let name = args .get("name") .or_else(|| args.get("名")) .and_then(|v| v.as_str()); sim::gate_from_matrix(matrix, name) }); q_ffi!(quantum_gate_matrix, |args: &Value| { let gate = args .get("gate") .or_else(|| args.get("门")) .ok_or_else(|| "missing `gate`".to_string())?; let m = sim::gate_matrix_of(gate)?; Ok(sim::matrix_to_json(&m)) }); q_ffi!(quantum_gate_matches_matrix, |args: &Value| { let gate = args .get("gate") .or_else(|| args.get("门")) .ok_or_else(|| "missing `gate`".to_string())?; let matrix = args .get("matrix") .or_else(|| args.get("矩阵")) .ok_or_else(|| "missing `matrix`".to_string())?; let tol = args .get("tol") .or_else(|| args.get("容差")) .and_then(|v| v.as_f64()) .unwrap_or(1e-9); let expect = sim::gate_matrix_of(gate)?; let got = sim::parse_matrix(matrix)?; Ok(json!(sim::matrices_close(&expect, &got, tol))) }); q_ffi!(quantum_gate_draw, |args: &Value| { let gate = args .get("gate") .or_else(|| args.get("门")) .ok_or_else(|| "missing `gate`".to_string())?; let name = gate .get("name") .or_else(|| gate.get("名")) .and_then(|v| v.as_str()) .unwrap_or("?"); let kind = args .get("kind") .or_else(|| args.get("种类")) .or_else(|| args.get("类型")) .and_then(|v| v.as_str()) .unwrap_or("gate") .to_ascii_lowercase(); let path = args .get("path") .or_else(|| args.get("路径")) .and_then(|v| v.as_str()) .filter(|s| !s.is_empty()); let (kind_out, svg) = if matches!(kind.as_str(), "matrix" | "heatmap" | "矩阵") { let m = sim::gate_matrix_of(gate)?; ( "matrix", draw::matrix_heatmap_svg(&m, &format!("{name} matrix")), ) } else if matches!(kind.as_str(), "gate" | "glyph" | "门") { ("gate", draw::gate_svg(name)) } else { return Err(format!("unknown gate draw kind `{kind}` (gate|matrix)")); }; record_plot(&svg, path)?; Ok(json!({ "_type": "quantum_svg", "kind": kind_out, "svg": svg, })) }); q_ffi!(quantum_apply, |args: &Value| { let c = circuit_of(args)?; let gate = args .get("gate") .or_else(|| args.get("门")) .ok_or_else(|| "missing `gate`".to_string())?; let qubits = args.get("qubits").or_else(|| args.get("比特")); sim::apply_gate(c, gate, qubits) }); q_ffi!(quantum_density_from_state, |args: &Value| { let src = args .get("state") .or_else(|| args.get("态")) .or_else(|| args.get("circuit")) .or_else(|| args.get("电路")) .ok_or_else(|| "density needs `state` or `circuit`".to_string())?; let (n, amps) = linalg::amps_from_state_or_circuit(src)?; let (_, rho) = linalg::density_from_amps(&s, n)?; Ok(linalg::density_handle(n, &rho)) }); q_ffi!(quantum_density_from_matrix, |args: &Value| { let matrix = args .get("matrix") .or_else(|| args.get("矩阵")) .ok_or_else(|| "missing `matrix`".to_string())?; let bag = json!({ "matrix": matrix }); let (n, rho) = linalg::parse_density(&bag)?; Ok(linalg::density_handle(n, &rho)) }); q_ffi!(quantum_density_matrix, |args: &Value| { let d = args .get("density") .or_else(|| args.get("密度")) .ok_or_else(|| "missing `density`".to_string())?; let (n, rho) = linalg::parse_density(d)?; let dim = 1 << n; Ok(sim::matrix_to_json(&linalg::flat_to_nested(&rho, dim))) }); q_ffi!(quantum_density_purity, |args: &Value| { let d = args .get("density") .or_else(|| args.get("密度")) .ok_or_else(|| "missing `density`".to_string())?; let (n, rho) = linalg::parse_density(d)?; let dim = 1 << n; Ok(json!(linalg::purity(&rho, dim))) }); q_ffi!(quantum_density_partial_trace, |args: &Value| { let d = args .get("density") .or_else(|| args.get("密度")) .ok_or_else(|| "missing `density`".to_string())?; let keep_v = args .get("keep") .or_else(|| args.get("保留")) .ok_or_else(|| "missing `keep`".to_string())?; let keep = parse_usize_list(keep_v)?; let (n, rho) = linalg::parse_density(d)?; let (k, out) = linalg::partial_trace(&rho, n, &keep)?; Ok(linalg::density_handle(k, &out)) }); q_ffi!(quantum_density_eig, |args: &Value| { let d = args .get("density") .or_else(|| args.get("密度")) .ok_or_else(|| "missing `density`".to_string())?; let (n, rho) = linalg::parse_density(d)?; let dim = 1 << n; let (evals, evecs) = linalg::hermite_eig(&rho, dim)?; Ok(linalg::spectrum_handle(&evals, &evecs)) }); q_ffi!(quantum_density_expect, |args: &Value| { let d = args .get("density") .or_else(|| args.get("密度")) .or_else(|| args.get("state")) .or_else(|| args.get("态")) .or_else(|| args.get("circuit")) .or_else(|| args.get("电路")) .ok_or_else(|| "expect needs density/state/circuit".to_string())?; let (n, rho) = if d.get("amplitudes").is_some() || d.get("_type").and_then(|t| t.as_str()) == Some("quantum_state") || d.get("ops").is_some() { let (qn, amps) = linalg::amps_from_state_or_circuit(d)?; let (_, r) = linalg::density_from_amps(&s, qn)?; (qn, r) } else { linalg::parse_density(d)? }; let dim = 1 << n; let obs = args .get("obs") .or_else(|| args.get("可观测量")) .ok_or_else(|| "missing `obs`".to_string())?; let val = if let Some(s) = obs.as_str() { linalg::expect_pauli(&rho, dim, n, s)? } else { let (_od, om) = linalg::value_as_matrix(obs)?; linalg::expect_matrix(&rho, dim, &om, dim)? }; Ok(json!(val)) }); q_ffi!(quantum_density_draw, |args: &Value| { let d = args .get("density") .or_else(|| args.get("密度")) .ok_or_else(|| "missing `density`".to_string())?; let kind = args .get("kind") .or_else(|| args.get("种类")) .and_then(|v| v.as_str()) .unwrap_or("hinton") .to_ascii_lowercase(); let path = args .get("path") .or_else(|| args.get("路径")) .and_then(|v| v.as_str()) .filter(|s| !s.is_empty()); let (n, rho) = linalg::parse_density(d)?; let dim = 1 << n; let nested = linalg::flat_to_nested(&rho, dim); let (kind_out, svg) = match kind.as_str() { "hinton" | "欣顿" => ("hinton", draw::hinton_svg(&nested, "ρ hinton")), "city" | "城市" => ("city", draw::city_svg(&nested, "ρ")), "density" | "密度图" => ("density", draw::density_cells_svg(&nested, "ρ")), "paulivec" | "泡利向量" => { let labels = linalg::all_pauli_labels(n)?; let mut vals = Vec::with_capacity(labels.len()); for lab in &labels { vals.push(linalg::expect_pauli(&rho, dim, n, lab)?); } ("paulivec", draw::paulivec_svg(&labels, &vals, "Pauli")) } other => { return Err(format!( "unknown density draw kind `{other}` (hinton|city|density|paulivec)" )); } }; record_plot(&svg, path)?; Ok(json!({ "_type": "quantum_svg", "kind": kind_out, "qubits": n, "svg": svg, })) }); q_ffi!(quantum_kron, |args: &Value| { let a = args .get("a") .or_else(|| args.get("左")) .ok_or_else(|| "kron needs `a`".to_string())?; let b = args .get("b") .or_else(|| args.get("右")) .ok_or_else(|| "kron needs `b`".to_string())?; if (a.get("amplitudes").is_some() || a.get("_type").and_then(|t| t.as_str()) == Some("quantum_state")) && (b.get("amplitudes").is_some() || b.get("_type").and_then(|t| t.as_str()) == Some("quantum_state")) { let (na, aa) = linalg::amps_from_state_or_circuit(a)?; let (nb, bb) = linalg::amps_from_state_or_circuit(b)?; let out = linalg::kronecker_amps(&aa, &bb); return Ok(json!({ "_type": "quantum_state", "qubits": na + nb, "dim": out.len(), "amplitudes": sim::amps_to_json(&out), })); } let (_na, ma) = linalg::value_as_matrix(a)?; let (_nb, mb) = linalg::value_as_matrix(b)?; let da = (ma.len() as f64).sqrt() as usize; let db = (mb.len() as f64).sqrt() as usize; if da * da != ma.len() || db * db != mb.len() { return Err("kron: matrices must be square".into()); } let out = linalg::kronecker(&ma, da, &mb, db); let dim = da * db; let qubits_f = (dim as f64).log2(); if (qubits_f - qubits_f.round()).abs() < 1e-9 { let qubits = qubits_f.round() as usize; Ok(linalg::density_handle(qubits, &out)) } else { Ok(json!({ "_type": "quantum_density", "dim": dim, "matrix": sim::matrix_to_json(&linalg::flat_to_nested(&out, dim)), })) } }); q_ffi!(quantum_schmidt, |args: &Value| { let src = args .get("state") .or_else(|| args.get("态")) .or_else(|| args.get("circuit")) .or_else(|| args.get("电路")) .ok_or_else(|| "schmidt needs `state` or `circuit`".to_string())?; let cut = arg_u(args, "cut") .or_else(|_| arg_u(args, "分割")) .unwrap_or(1); let (n, amps) = linalg::amps_from_state_or_circuit(src)?; linalg::schmidt_decompose(&s, n, cut) }); q_ffi!(quantum_fidelity, |args: &Value| { let a = args .get("a") .or_else(|| args.get("左")) .ok_or_else(|| "fidelity needs `a`".to_string())?; let b = args .get("b") .or_else(|| args.get("右")) .ok_or_else(|| "fidelity needs `b`".to_string())?; let (_, aa) = linalg::amps_from_state_or_circuit(a)?; let (_, bb) = linalg::amps_from_state_or_circuit(b)?; Ok(json!(linalg::fidelity_pure(&aa, &bb)?)) }); fn parse_usize_list(v: &Value) -> Result, String> { match v { Value::Array(a) => a .iter() .map(|x| { x.as_u64() .or_else(|| x.as_i64().map(|i| i as u64)) .or_else(|| x.as_str().and_then(|s| s.trim().parse().ok())) .map(|u| u as usize) .ok_or_else(|| "bad keep list entry".to_string()) }) .collect(), Value::Number(n) => Ok(vec![n.as_u64().unwrap_or(0) as usize]), Value::String(s) => s .split(|c| c == ',' || c == ' ') .filter(|t| !t.is_empty()) .map(|t| t.parse().map_err(|_| format!("bad keep `{t}`"))) .collect(), _ => Err("keep must be list, number, or comma string".into()), } } marqdo_plugin!(marqdo_plugin_sdk::ABI_VERSION, [ ("quantum_ping", "", quantum_ping), ("quantum_circuit_new", "qubits,steps", quantum_circuit_new), ("quantum_h", "circuit,qubit", quantum_h), ("quantum_x", "circuit,qubit", quantum_x), ("quantum_y", "circuit,qubit", quantum_y), ("quantum_z", "circuit,qubit", quantum_z), ("quantum_s", "circuit,qubit", quantum_s), ("quantum_t", "circuit,qubit", quantum_t), ("quantum_i", "circuit,qubit", quantum_i), ("quantum_rx", "circuit,qubit,theta", quantum_rx), ("quantum_ry", "circuit,qubit,theta", quantum_ry), ("quantum_rz", "circuit,qubit,theta", quantum_rz), ("quantum_cx", "circuit,control,target", quantum_cx), ("quantum_cz", "circuit,control,target", quantum_cz), ("quantum_swap", "circuit,a,b", quantum_swap), ("quantum_simulate", "circuit", quantum_simulate), ("quantum_probabilities", "circuit", quantum_probabilities), ("quantum_run", "circuit,shots,seed", quantum_run), ("quantum_barrier", "circuit", quantum_barrier), ("quantum_measure", "circuit,qubits", quantum_measure), ("quantum_append", "circuit,op", quantum_append), ("quantum_noise", "circuit,kind,p", quantum_noise), ("quantum_state", "circuit", quantum_state), ("quantum_draw_circuit", "circuit,path,kind,qubit", quantum_draw_circuit), ("quantum_gate_new", "name,theta", quantum_gate_new), ("quantum_gate_from_matrix", "matrix", quantum_gate_from_matrix), ("quantum_gate_matrix", "gate", quantum_gate_matrix), ("quantum_gate_matches_matrix", "gate,matrix,tol", quantum_gate_matches_matrix), ("quantum_gate_draw", "gate,path,kind", quantum_gate_draw), ("quantum_apply", "circuit,gate,qubits", quantum_apply), ("quantum_density_from_state", "state", quantum_density_from_state), ("quantum_density_from_matrix", "matrix", quantum_density_from_matrix), ("quantum_density_matrix", "density", quantum_density_matrix), ("quantum_density_purity", "density", quantum_density_purity), ("quantum_density_partial_trace", "density,keep", quantum_density_partial_trace), ("quantum_density_eig", "density", quantum_density_eig), ("quantum_density_expect", "density,obs", quantum_density_expect), ("quantum_density_draw", "density,path,kind", quantum_density_draw), ("quantum_kron", "a,b", quantum_kron), ("quantum_schmidt", "state,cut", quantum_schmidt), ("quantum_fidelity", "a,b", quantum_fidelity), ]);