Files
marqdo/plugins/quantum/src/lib.rs
T
cflmy fb135ae2f8 refactor(plugins): 抽出 marqdo-plugin-sdk — ABI 前言从 5 份变 1 份
新增工作区成员 crates/marqdo-plugin-sdk:ABI 类型、HOST_* 静态回调、
host_strdup/set_out/set_err/parse_args/reply/host_query_json(_with)/
take_host_string/init_plugin,以及生成四个 #[no_mangle] 导出的
marqdo_plugin! 宏。ABI 常量、符号名、结构体布局一律未变。

5 个插件改为依赖 SDK + 一行宏调用:
  agent  1237 → 929  (-308)
  quantum 1045 → 835 (-210)
  linalg  688 → 524  (-164)
  llm     405 → 278  (-127)
  demo    170 → 73   (-97)
  SDK 新增 232 行 → 净减约 674 行

迁移中发现并修正三次"编译通过但语义已变":
1. 注册项抽取漏 11 项 —— 正则 [a-z_0-9]+ 匹配不到 mcp_server::agent_mcp_serve、
   sandbox::* 这类路径限定函数名;改为允许 :: 后重抽。
   已用脚本逐项比对 (名称, 参数串, 函数) 三元组:agent 63/63、quantum 41/41、
   linalg 31/31、llm 2/2、demo 2/2,全部 0 差异。
2. mcp_client 被误判死模块(删 327 行后才发现 agent_mcp_client 正注册它)→ 恢复。
3. 量子插件两个"未使用"函数删除时连带吃掉 density_from_amps/flat_to_nested
   → 恢复原文件并改为 #[allow(dead_code)]。

验证:cargo build --release(含 5 个插件)零警告;
cargo test --release 609 passed / 0 failed;
量子金样实跑 p00-ok / p11-ok / ping-ok。

文档:doc/design/change-plugin-sdk.md
2026-10-22 15:49:13 +08:00

836 lines
28 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! 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<Value, String> = (|| $body(&args))();
reply(
out_json,
err_msg,
r.map_err(|e| format!("{}: {e}", stringify!($name))),
)
}
};
}
fn arg_u(v: &Value, key: &str) -> Result<usize, String> {
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<f64, String> {
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<String> {
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<Value, String> {
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(&amps),
}))
});
q_ffi!(quantum_probabilities, |args: &Value| {
let c = circuit_of(args)?;
let (qubits, amps) = sim::simulate_circuit(c)?;
Ok(Value::Object(sim::probabilities(&amps, 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::<Result<Vec<_>, _>>()?,
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::<usize>()
.map_err(|_| format!("bad qubit `{t}`"))
})
.collect::<Result<Vec<_>, _>>()?
}
}
_ => 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(&amps),
}))
});
fn draw_theme_of(args: &Value) -> Result<draw::ThemeName, String> {
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(&amps, qubits);
("probs", draw::probs_svg(&probs, theme))
}
"bloch" | "布洛赫" => {
let (qubits, amps) = sim::simulate_circuit(c)?;
let (x, y, z) = sim::bloch_vector(&amps, qubits, qubit)?;
("bloch", draw::bloch_svg(x, y, z, theme))
}
"hinton" | "欣顿" => {
let (n, amps) = sim::simulate_circuit(c)?;
let (_, rho) = linalg::density_from_amps(&amps, 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(&amps, 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(&amps, 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(&amps, 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(&amps, n))
}
"multibloch" | "多布洛赫" => {
let (n, amps) = sim::simulate_circuit(c)?;
("multibloch", draw::multibloch_svg(&amps, 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(&amps, 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(&amps, 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(&amps, 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<Vec<usize>, 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),
]);