QuarkDSL Online CompilerQuarkDSL

Hybrid Quantum-Classical Programming LanguageQuantum-Classical Compiler

Code Templates

Quantum Convolutional Neural Network

Production QCNN for medical image classification using amplitude encoding, parameterized quantum circuits, and GPU-accelerated preprocessing

VQE for H2 Molecule

Production VQE implementation for hydrogen molecule ground state using UCCSD ansatz, parameter-shift gradients, and adaptive convergence

BB84 Quantum Key Distribution

Production QKD implementation with basis reconciliation, error detection, privacy amplification for secure communication

Mean-Variance Portfolio Optimization

Production Markowitz portfolio optimization with covariance matrix, Sharpe ratio maximization, and constraint handling

Hybrid Data Pipeline

Complete GPU preprocessing, quantum encoding, and quantum processing pipeline for data transformation workflows

GPU Array Processing

Basic GPU-accelerated array operations for data preprocessing, feature scaling, and batch transformations

Quantum Entanglement Demo

Pure quantum computing example demonstrating Bell state creation and quantum superposition principles

Integer Array Operations

High-performance integer array addition for batch processing, data aggregation, and numerical computations

Minimal Hybrid Example

Simplest hybrid quantum-classical program showing GPU preprocessing and quantum feature encoding

Source Code

// Quantum Convolutional Neural Network (QCNN)
// Production implementation for medical image classification
// Based on Cong et al. (2019) Nature Physics

@gpu
fn normalize_and_pad(pixels: [float]) -> [float] {
    let normalized = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0];
    let sum_squares = 0.0;

for i in 0..8 {
        normalized[i] = pixels[i] / 255.0;
        sum_squares = sum_squares + (normalized[i] * normalized[i]);
    }

let norm = sum_squares;
    for i in 0..8 {
        normalized[i] = normalized[i] / norm;
    }

return normalized;
}

@gpu
fn extract_edge_features(data: [float]) -> [float] {
    let features = [0.0, 0.0, 0.0, 0.0];

features[0] = data[0] - data[1];
    features[1] = data[2] - data[3];
    features[2] = data[4] - data[5];
    features[3] = data[6] - data[7];

return features;
}

@quantum
fn amplitude_encoding(amplitudes: [float]) -> int {
    ry(0, amplitudes[0] * 3.14159);
    ry(1, amplitudes[1] * 3.14159);
    ry(2, amplitudes[2] * 3.14159);
    ry(3, amplitudes[3] * 3.14159);
    return 0;
}

@quantum
fn qcnn_layer(theta: [float]) -> int {
    cx(0, 1);
    cx(2, 3);

ry(0, theta[0]);
    ry(1, theta[1]);
    ry(2, theta[2]);
    ry(3, theta[3]);

cx(1, 2);

ry(1, theta[0]);
    ry(2, theta[1]);

return 0;
}

@quantum
fn measure_classification() -> int {
    let result = measure(0);
    return result;
}

fn main() -> int {
    let raw_image = [142.0, 89.0, 201.0, 67.0, 178.0, 123.0, 95.0, 210.0];

let normalized = normalize_and_pad(raw_image);
    let features = extract_edge_features(normalized);

amplitude_encoding(features);

let trained_params = [0.785, 1.571, 0.524, 2.094];
    qcnn_layer(trained_params);

let classification = measure_classification();
    print(classification);

return classification;
}

Target Backend

Full Output Mode

MINIMAL

Use Real IBM Quantum Hardware

SIM

Output

Click "Run Code" or "Queue Quantum Job" to execute