Struct Hitachi 

pub struct Hitachi {
    pub last_energies: Vec<f64>,
    pub last_execution_ns: u64,
    /* private fields */
}

The Hitachi annealer as a backend.

Nothing here contacts anyone until you set it up

Constructing a Hitachi, describing its fabric, laying a program out on the grid and embedding one all run entirely locally. The single network call in this crate lives in Device::run, and reaching it takes a token you supplied, a program you laid out, and a call you made. There is no ambient default: Hitachi::from_env returns Err when ACW_TOKEN is unset rather than falling back to anything, and the crate reads no other environment variable, no config file and no credential store.

Fields

last_energies: Vec<f64>

Last raw energies returned, in the machine’s own sign convention.

last_execution_ns: u64

Nanoseconds the machine reported for the last run.

Implementations

impl Hitachi

pub fn new(token: impl Into<String>, machine: Machine) -> Hitachi

token comes from Annealing Cloud Web. Read it from the environment; do not commit it.

pub fn from_env(machine: Machine) -> Result<Hitachi, String>

From ACW_TOKEN in the environment.

Examples found in repository

examples/hitachi_run.rs (line 10)

fn main() {
    let mut d = match Hitachi::from_env(Machine::Asic) {
        Ok(d) => d,
        Err(e) => { eprintln!("{e}"); return; }
    };
    let f = d.fabric();
    println!("fabric        {} | {:?} | {} sites | degree {} | coupling {:?}",
             f.name, f.topology, f.max_spins.unwrap(), f.max_degree.unwrap(), f.coupling_precision);

    // A 4x4 antiferromagnetic block, laid out row-major so every coupling is King-adjacent.
    let side = Machine::Asic.side();
    let mut src = format!("ftp 1\nname acw-4x4-antiferro\nspins {}\n", 3 * side + 4);
    let mut edges = 0;
    for y in 0..4usize {
        for x in 0..4usize {
            let i = y * side + x;
            if x + 1 < 4 { src.push_str(&format!("factor -1 {i} {}\n", i + 1)); edges += 1; }
            if y + 1 < 4 { src.push_str(&format!("factor -1 {i} {}\n", i + side)); edges += 1; }
        }
    }
    let p = Program::from_ftp(&src).expect("program");
    println!("program       {} spins declared, {edges} couplings, digest {:016x}", p.spins, p.digest());

    let bad = d.program(&p);
    if !bad.is_empty() {
        for u in &bad { println!("REFUSED: {u}"); }
        return;
    }

    match d.run(&Schedule::geometric(0.1, 10.0, 20, 50), 1) {
        Err(e) => println!("run failed: {e}"),
        Ok(state) => {
            let g = p.to_graph().unwrap();
            println!("machine energy (their sign) {:?}", d.last_energies);
            println!("execution     {:.3} ms on the ASIC", d.last_execution_ns as f64 / 1e6);
            println!("our energy    {}", g.energy(&state));
            let ok = (0..4).all(|y| (0..4).all(|x| {
                let i = y * side + x;
                state[i] == if (x + y) % 2 == 0 { state[0] } else { -state[0] }
            }));
            println!("checkerboard  {}", if ok { "yes - every bond satisfied" } else { "no" });
            println!("ledger        {} node updates", d.ledger().samples);
        }
    }
}

pub fn with_endpoint(self, url: impl Into<String>) -> Hitachi

Send somewhere other than ACW_ENDPOINT — a mock, a proxy, or a self-hosted instance.

The address a driver posts to is the caller’s decision, not the driver’s. Without this the only way to exercise Device::run at all was to send a real job to a third party, which is why nothing in this crate’s tests has ever covered it.

pub fn endpoint(&self) -> &str

Where this instance will post. See Hitachi::with_endpoint.

pub fn place(&mut self, p: &Program) -> Result<Embedding, String>

Place a program on the grid, embedding it if it does not already fit.

Hitachi::layout requires a program whose couplings are already King-adjacent under the row-major layout — which is a real constraint on the caller and, until ferrotherm::embed existed, one this driver could only refuse. This tries that first, and when it fails uses minor embedding to find a placement.

Returns the embedding, which is needed to read the answer back: a variable may now occupy several sites, and ferrotherm::embed::unembed turns those back into one value and says which chains broke.

The embedded model is not the model that was written. Chains add couplings at chain_strength, and a program that fitted the grid already is placed unchanged, so the returned embedding is the identity and the distinction costs nothing.

pub fn layout(&mut self, p: &Program) -> Result<(), LayoutError>

Lay a program out on the grid, negating every weight for their sign convention.

Requires every coupling to be King-adjacent already. Hitachi::place embeds when it is not, and is what a caller who has not laid their model out by hand wants.

Trait Implementations

impl Device for Hitachi

fn fabric(&self) -> Fabric

What this backend can do. Callers check against it before submitting.

fn program(&mut self, p: &Program) -> Vec<Unsupported>

Load a program. Returns every reason it cannot run, empty on success.

fn run(&mut self, schedule: &Schedule, _seed: u64) -> Result<Vec<i8>, String>

Run a schedule and return the final state.

fn ledger(&self) -> Ledger

Operations charged so far, for the ledger.