新增工作区成员 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
836 lines
28 KiB
Rust
836 lines
28 KiB
Rust
//! 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(&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::<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(&s),
|
||
}))
|
||
});
|
||
|
||
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(&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<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),
|
||
]);
|