• autd3
• autd3-gain-holo
• autd3-modulation-audio-file
• autd3-link-twincat
• autd3-link-simulator
• autd3-link-soem
• autd3-emulator

CMakeのFetchContentを使用してインストールできる.

• autd3
  • Windows: https://github.com/shinolab/autd3-cpp/releases/download/v32.0.1/autd3-v32.0.1-win-x64.zip
  • macOS: https://github.com/shinolab/autd3-cpp/releases/download/v32.0.1/autd3-v32.0.1-macos-aarch64.tar.gz
  • Linux: https://github.com/shinolab/autd3-cpp/releases/download/v32.0.1/autd3-v32.0.1-linux-x64.tar.gz
• autd3-link-soem
  • Windows: https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-win-x64.zip
  • macOS: https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-macos-aarch64.tar.gz
  • Linux: https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-linux-x64.tar.gz

NuGetで公開している.

• AUTD3Sharp
• AUTD3Sharp.Link.SOEM

Unity Package Manager経由でインストール可能. 以下のリポジトリを追加する.

• AUTD3Sharp: https://github.com/shinolab/AUTD3Sharp.git#upm/latest
• AUTD3Sharp.Link.SOEM: https://github.com/shinolab/AUTD3Sharp.Link.SOEM.git#upm/latest

PyPIで公開している.

• pyautd3
• pyautd3_link_soem
• pyautd3_emulator

まずは適当なプロジェクトを作成し, autd3ライブラリを依存関係に追加する. また, デバイスとの通信を行うautd3-link-soemライブラリも依存関係に追加する.

cargo new --bin autd3-sample
cd autd3-sample
cargo add autd3
cargo add autd3-link-soem

次に, src/main.rsファイルを編集し, 以下のようにする. これは単一焦点に$150\mathrm{Hz}$のAM変調をかける場合のソースコードである.

use autd3::prelude::*;
use autd3_link_soem::{SOEMOption, Status, SOEM};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Open controller with SOEM link
    // Here, the AUTD3 device is placed at the origin
    let mut autd = Controller::open(
        [AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        }],
        SOEM::new(
            // The first argument is a callback that is called when error occurs
            |slave, status| {
                eprintln!("slave[{}]: {}", slave, status);
                if status == Status::Lost {
                    // You can also wait for the link to recover, without exitting the process
                    std::process::exit(-1);
                }
            },
            // The second argument is a option of SOEM link.
            SOEMOption::default(),
        ),
    )?;

    // Check firmware version
    // This code assumes that the version is v11.0.0 or v10.0.1
    autd.firmware_version()?.iter().for_each(|firm_info| {
        println!("{}", firm_info);
    });

    // Enable silencer
    // Note that this is enabled by default, so it is not actually necessary
    // To disable, send Silencer::disable()
    autd.send(Silencer::default())?;

    // A focus at 150mm directly above the center of the device
    let g = Focus {
        pos: autd.center() + Vector3::new(0., 0., 150.0 * mm),
        option: FocusOption::default(),
    };

    // 150 Hz sine wave modulation
    let m = Sine {
        freq: 150 * Hz,
        option: SineOption::default(),
    };

    // Send data
    autd.send((m, g))?;

    println!("press enter to quit...");
    let mut _s = String::new();
    std::io::stdin().read_line(&mut _s)?;

    // Close controller
    autd.close()?;

    Ok(())
}

そして, これを実行する.

cargo run --release

Linux,macOS使用時の注意

Linux, macOSでは, SOEMを使用するのに管理者権限が必要になる. その場合は,

cargo build --release && sudo ./target/release/autd3_sample

とすること.

依存プログラムのインストール

本チュートリアルではCMakeを使用するので, インストールしておくこと.

AUTD3クライアントプログラムの作成

まず, ターミナルを開き, 適当なディレクトリを用意する.

mkdir autd3-sample
cd autd3-sample

次に, autd3-sample以下にCMakeLists.txt, main.cppファイルを作成する.

└─autd3-sample
        CMakeLists.txt
        main.cpp

次に, CMakeLists.txtを以下のようにする.

cmake_minimum_required(VERSION 3.21)

project(autd3-sample)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.24.0") 
  cmake_policy(SET CMP0135 NEW)
endif()

include(FetchContent)
if(WIN32)
  FetchContent_Declare(
    autd3
    URL https://github.com/shinolab/autd3-cpp/releases/download/v30.0.1/autd3-v30.0.1-win-x64.zip
  )
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v30.0.1/autd3-link-soem-v30.0.1-win-x64.zip
  )
elseif(APPLE)
  FetchContent_Declare(
    autd3
    URL https://github.com/shinolab/autd3-cpp/releases/download/v30.0.1/autd3-v30.0.1-macos-aarch64.tar.gz
  )
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v30.0.1/autd3-link-soem-v30.0.1-macos-aarch64.tar.gz
  )
else()
  FetchContent_Declare(
    autd3
    URL https://github.com/shinolab/autd3-cpp/releases/download/v30.0.1/autd3-v30.0.1-linux-x64.tar.gz
  )
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v30.0.1/autd3-link-soem-v30.0.1-linux-x64.tar.gz
  )
endif()
set(USE_SYSTEM_EIGEN OFF)
FetchContent_MakeAvailable(autd3 autd3-link-soem)

add_executable(main main.cpp)

target_link_libraries(main PRIVATE autd3::autd3 autd3::link::soem)

NOTE: 上記の例では, 依存ライブラリ (Eigen3) を自動的にダウンロードするようになっている. すでにEigen3がインストールされている場合, USE_SYSTEM_EIGENをONにすると, 自動ダウンロードを無効化し, インストール済みのものを使用できる.

また, main.cppを以下のようにする. これは単一焦点に$150\mathrm{Hz}$のAM変調をかける場合のソースコードである.

#include <autd3_link_soem.hpp>
#include <iostream>

#include "autd3.hpp"

using namespace autd3;

int main() try {
  auto autd = Controller::open(
      {AUTD3{
          .pos = Point3::origin(),
          .rot = Quaternion::Identity(),
      }},
      link::SOEM(
          [](const uint16_t slave, const link::Status status) {
            std::cout << "slave [" << slave << "]: " << status << std::endl;
            if (status == link::Status::Lost()) exit(-1);
          },
          link::SOEMOption{}));

  const auto firm_version = autd.firmware_version();
  std::copy(firm_version.begin(), firm_version.end(),
            std::ostream_iterator<FirmwareVersion>(std::cout, "\n"));

  autd.send(Silencer{});

  Focus g(autd.center() + Vector3(0, 0, 150), FocusOption{});
  Sine m(150 * Hz, SineOption{});

  autd.send((m, g));

  std::cout << "press enter to finish..." << std::endl;
  std::cin.ignore();

  autd.close();

  return 0;
} catch (std::exception& ex) {
  std::cerr << ex.what() << std::endl;
}

次に, CMakeでビルドする.

mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release

これで, 実行ファイルが生成されるので, これを実行する.

.\Release\main.exe

sudo ./main

トラブルシューティング

• anaconda (miniconda) がactivateされている場合に, ビルドエラーになる可能性がある.
  • この場合, buildディレクトリを削除し, conda deactivateを実行したのち再びcmakeを実行する.

まず, ターミナルを開き, 適当なプロジェクトを作成し, AUTD3Sharpライブラリを追加する.

dotnet new console --name autd3-sample
cd autd3-sample
dotnet add package AUTD3Sharp
dotnet add package AUTD3Sharp.Link.SOEM

次に, Program.csを以下のようにする. これは単一焦点に$150\mathrm{Hz}$のAM変調をかける場合のソースコードである.

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;

using var autd = Controller.Open(
    [new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity)],
    new SOEM(
        (slave, status) =>
            {
                Console.Error.WriteLine($"slave [{slave}]: {status}");
                if (status == Status.Lost)
                    Environment.Exit(-1);
            },
        new SOEMOption()
    )
);

var firmList = autd.FirmwareVersion();
foreach (var firm in firmList)
    Console.WriteLine(firm);

autd.Send(new Silencer());

var g = new Focus(
    pos: autd.Center() + new Vector3(0, 0, 150),
    option: new FocusOption()
);
var m = new Sine(
    freq: 150u * Hz,
    option: new SineOption()
);
autd.Send((m, g));

Console.ReadKey(true);

autd.Close();

そして, これを実行する.

dotnet run -c:Release

Linux,macOS使用時の注意

Linux, macOSでは, SOEMを使用するのに管理者権限が必要な場合がある. その場合は,

sudo dotnet run -c:Release

とすること.

pyautd3ライブラリのインストール

pip install pyautd3
pip install pyautd3_link_soem

次に, main.pyを作成し, 以下のようにする. これは単一焦点に$150\mathrm{Hz}$のAM変調をかける場合のソースコードである.

import os

import numpy as np
from pyautd3 import (
    AUTD3,
    Controller,
    Focus,
    FocusOption,
    Hz,
    Silencer,
    Sine,
    SineOption,
)
from pyautd3_link_soem import SOEM, SOEMOption, Status


def err_handler(slave: int, status: Status) -> None:
    print(f"slave [{slave}]: {status}")
    if status == Status.Lost():
        os._exit(-1)


if __name__ == "__main__":
    with Controller.open(
        [AUTD3(pos=[0.0, 0.0, 0.0], rot=[1, 0, 0, 0])],
        SOEM(err_handler=err_handler, option=SOEMOption()),
    ) as autd:
        firmware_version = autd.firmware_version()
        print(
            "\n".join(
                [f"[{i}]: {firm}" for i, firm in enumerate(firmware_version)],
            ),
        )

        autd.send(Silencer())

        g = Focus(
            pos=autd.center() + np.array([0.0, 0.0, 150.0]),
            option=FocusOption(),
        )
        m = Sine(
            freq=150 * Hz,
            option=SineOption(),
        )
        autd.send((m, g))

        _ = input()

        autd.close()

そして, これを実行する.

python main.py

Linux使用時の注意

Linuxでは, SOEMを使用するのに管理者権限が必要になる. その場合は,

sudo setcap cap_net_raw,cap_net_admin=eip <your python path>

とした後, main.pyを実行する.

python main.py

macOS使用時の注意

macOSでは, SOEMを使用するのに管理者権限が必要になる. その場合は,

sudo chmod +r /dev/bpf*

とした後, main.pyを実行する.

python main.py

use autd3::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let link = autd3::link::Nop::new();
let _ =
Controller::open(
    [
        AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        },
        AUTD3 {
            pos: Point3::new(AUTD3::DEVICE_WIDTH, 0., 0.),
            rot: UnitQuaternion::identity(),
        },
    ],
    link,
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
link::Nop link;
Controller::open({AUTD3{
                      .pos = Point3::origin(),
                      .rot = Quaternion::Identity(),
                  },
                  AUTD3{
                      .pos = Point3(AUTD3::DEVICE_WIDTH, 0, 0),
                      .rot = Quaternion::Identity(),
                  }},
                 std::move(link));
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
var link = new Nop();
Controller.Open([
   new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity),
   new AUTD3(pos: new Point3(AUTD3.DeviceWidth, 0, 0), rot: Quaternion.Identity)
], link)
;

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
link = Nop()
Controller.open(
    [
        AUTD3(pos=[0.0, 0.0, 0.0], rot=[1, 0, 0, 0]),
        AUTD3(pos=[AUTD3.DEVICE_WIDTH, 0.0, 0.0], rot=[1, 0, 0, 0]),
    ],
    link,
)

use autd3::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let link = autd3::link::Nop::new();
let _ =
Controller::open(
    [
        AUTD3 {
            pos: Point3::new(-AUTD3::DEVICE_WIDTH, 0., 0.),
            rot: UnitQuaternion::identity(),
        },
        AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        },
    ],
    link,
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
link::Nop link;
Controller::open(
    {
        AUTD3{
            .pos = Point3(-AUTD3::DEVICE_WIDTH, 0, 0),
            .rot = Quaternion::Identity(),
        },
        AUTD3{
            .pos = Point3::origin(),
            .rot = Quaternion::Identity(),
        },
    },
    std::move(link));
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
var link = new Nop();
Controller.Open([
   new AUTD3(pos: new Point3(-AUTD3.DeviceWidth, 0, 0), rot: Quaternion.Identity),
   new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity)
], link)
;

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
link = Nop()
Controller.open(
    [
        AUTD3(pos=[-AUTD3.DEVICE_WIDTH, 0.0, 0.0], rot=[1, 0, 0, 0]),
        AUTD3(pos=[0.0, 0.0, 0.0], rot=[1, 0, 0, 0]),
    ],
    link,
)

use autd3::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let link = autd3::link::Nop::new();
let _ =
Controller::open(
    [
        AUTD3 {
            pos: Point3::origin(),
            rot: UnitQuaternion::identity(),
        },
        AUTD3 {
            pos: Point3::new(0., 0., AUTD3::DEVICE_WIDTH),
            rot: EulerAngle::ZYZ(0. * rad, PI/2.0 * rad, 0. * rad).into(),
        },
    ],
    link,
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
link::Nop link;
Controller::open({AUTD3{
                      .pos = Point3::origin(),
                      .rot = Quaternion::Identity(),
                  },
                  AUTD3{
                      .pos = Point3(0, 0, AUTD3::DEVICE_WIDTH),
                      .rot = EulerAngles::ZYZ(0. * rad, pi / 2.0 * rad,
                                              0. * rad),
                  }},
                 std::move(link));
return 0; }

using System;
using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var link = new Nop();
Controller.Open([
   new AUTD3(pos: Point3.Origin, rot: Quaternion.Identity),
   new AUTD3(
      pos: new Point3(0, 0, AUTD3.DeviceWidth),
      rot: EulerAngles.Zyz(0 * rad, MathF.PI / 2 * rad, 0 * rad))
], link)
;

import numpy as np
from pyautd3 import AUTD3, Controller, EulerAngles, Nop, rad
link = Nop()
Controller.open(
    [
        AUTD3(pos=[0.0, 0.0, 0.0], rot=[1.0, 0.0, 0.0, 0.0]),
        AUTD3(
            pos=[0.0, 0.0, AUTD3.DEVICE_WIDTH],
            rot=EulerAngles.ZYZ(0 * rad, np.pi / 2 * rad, 0 * rad),
        ),
    ],
    link,
)

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let num_dev = autd.num_devices();
let num_tr = autd.num_transducers();
let center = autd.center();
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
const auto num_dev = autd.num_devices();
const auto num_tr = autd.num_transducers();
const auto center = autd.center();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var numDevices = autd.NumDevices();
var numTransducers = autd.NumTransducers();
var center = autd.Center();

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
num_devices = autd.num_devices()
num_transducers = autd.num_transducers()
center = autd.center()

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let dev = &autd[0];
for dev in &autd {
    // do something
}
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
{
auto dev = autd[0];
}
{
for (auto& dev : autd) {
  // do something
}
}
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
{
var dev = autd[0];
}
foreach (var dev in autd)
{
  // do something
}

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
dev = autd[0]
for _dev in autd:
    pass

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let dev = &mut autd[0];
let idx = dev.idx();
dev.enable = false;
dev.sound_speed = 340e3;
dev.set_sound_speed_from_temp(15.);
let wavelength = dev.wavelength();
let wavenumber = dev.wavenumber();
let rotation = dev.rotation();
let x_dir = dev.x_direction();
let y_dir = dev.y_direction();
let axial_dir = dev.axial_direction();
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
auto dev = autd[0];
const auto idx = dev.idx();
const auto enable = dev.enable();
dev.set_enable(false);
const auto sound_speed = dev.sound_speed();
dev.set_sound_speed(340e3);
dev.set_sound_speed_from_temp(15.);
const auto wavelength = dev.wavelength();
const auto wavenumber = dev.wavenumber();
const auto rotation = dev.rotation();
const auto x_dir = dev.x_direction();
const auto y_dir = dev.y_direction();
const auto axial_dir = dev.axial_direction();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var dev = autd[0];
var idx = dev.Idx();
dev.Enable = false;
dev.SoundSpeed = 340e3f;
dev.SetSoundSpeedFromTemp(15);
var wavelength = dev.Wavelength();
var wavenumber = dev.Wavenumber();
var rotation = dev.Rotation();
var xDir = dev.XDirection();
var yDir = dev.YDirection();
var axialDir = dev.AxialDirection();

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
dev = autd[0]
idx = dev.idx()
dev.enable = False
dev.sound_speed = 340e3
dev.set_sound_speed_from_temp(15.0)
wavelength = dev.wavelength()
wavenumber = dev.wavenumber()
rotation = dev.rotation()
x_dir = dev.x_direction()
y_dir = dev.y_direction()
axial_dir = dev.axial_direction()

use autd3::prelude::*;
#[allow(unused_variables)] 
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let tr = &autd[0][0];
for tr in &autd[0] {
    // do something
}
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
{
auto tr = autd[0][0];
}
{
for (auto& tr : autd[0]) {
  // do something
}
}
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
{
var tr = autd[0][0];
}
foreach (var tr in autd[0])
{
  // do something
}

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
tr = autd[0][0]
for _tr in autd[0]:
    pass

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let tr = &autd[0][0];
let idx = tr.idx();
let dev_idx = tr.dev_idx();
let position = tr.position();
Ok(())
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
const auto tr = autd[0][0];
const auto idx = tr.idx();
const auto dev_idx = tr.dev_idx();
const auto position = tr.position();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var tr = autd[0][0];
var trIdx = tr.Idx();
var devIdx = tr.DevIdx();
var position = tr.Position();

from pyautd3 import AUTD3, Controller
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
tr = autd[0][0]
idx = tr.idx()
dev_idx = tr.dev_idx()
position = tr.position()

cargo add autd3-link-twincat

target_link_libraries(<TARGET> PRIVATE autd3::link::twincat)

メインライブラリに含まれている.

メインライブラリに含まれている.

メインライブラリに含まれている.

use autd3_link_twincat::TwinCAT;

fn main() {
let _ = 
TwinCAT::new();
}

#include "autd3/link/twincat.hpp"

int main() {
using namespace autd3;
link::TwinCAT();
return 0; }

using AUTD3Sharp.Link;

new TwinCAT();

from pyautd3.link.twincat import TwinCAT

TwinCAT()

cargo add autd3-link-soem

if(WIN32)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-win-x64.zip
  )
elseif(APPLE)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-macos-aarch64.tar.gz
  )
else()
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-linux-x64.tar.gz
  )
endif()
FetchContent_MakeAvailable(autd3-link-soem)
target_link_libraries(<TARGET> PRIVATE autd3::link::soem)

dotnet add package AUTD3Sharp.Link.SOEM

https://github.com/shinolab/AUTD3Sharp.Link.SOEM.git#upm/latestをUnity Package Managerで追加する.

pip install pyautd3_link_soem

#[cfg(target_os = "windows")]
use autd3_link_soem::ProcessPriority;
use autd3_link_soem::{Status, SyncMode, ThreadPriority, TimerStrategy, SOEM, SOEMOption};
use std::num::NonZeroUsize;
use std::time::Duration;

fn main() {
let _ = 
SOEM::new(
    |slave, status| {
        eprintln!("slave [{}]: {}", slave, status);
        if status == Status::Lost {
            std::process::exit(-1);
        }
    },
    SOEMOption {
        buf_size: NonZeroUsize::new(32).unwrap(),
        timer_strategy: TimerStrategy::SpinSleep,
        sync_mode: SyncMode::DC,
        ifname: String::new(),
        state_check_interval: Duration::from_millis(100),
        sync0_cycle: Duration::from_millis(1),
        send_cycle: Duration::from_millis(1),
        thread_priority: ThreadPriority::Max,
        #[cfg(target_os = "windows")]
        process_priority: ProcessPriority::High,
        sync_tolerance: Duration::from_micros(1),
        sync_timeout: Duration::from_secs(10),
    },
);
}

#include <iostream>
#include <autd3_link_soem.hpp>

int main() {
using namespace autd3;
link::SOEM(
    [](const uint16_t slave, const link::Status status) {
      std::cout << "slave [" << slave << "]: " << status << std::endl;
      if (status == link::Status::Lost()) {
        exit(-1);
      }
    },
    link::SOEMOption{
        .buf_size = 32,
        .timer_strategy = link::TimerStrategy::SpinSleep,
        .sync_mode = link::SyncMode::DC,
        .ifname = "",
        .state_check_interval = std::chrono::milliseconds(100),
        .sync0_cycle = std::chrono::milliseconds(1),
        .send_cycle = std::chrono::milliseconds(1),
        .thread_priority = link::ThreadPriority::Max(),
        .process_priority = link::ProcessPriority::High,
        .sync_tolerance = std::chrono::microseconds(1),
        .sync_timeout = std::chrono::seconds(10),

    });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;

using AUTD3Sharp.Utils;
new SOEM(
    errHandler: (slave, status) =>
    {
        Console.Error.WriteLine($"slave [{slave}]: {status}");
        if (status == Status.Lost)
            Environment.Exit(-1);
    },
    option: new SOEMOption
    {
        BufSize = 32,
        TimerStrategy = TimerStrategy.SpinSleep,
        SyncMode = SyncMode.DC,
        Ifname = "",
        StateCheckInterval = Duration.FromMillis(100),
        Sync0Cycle = Duration.FromMillis(1),
        SendCycle = Duration.FromMillis(1),
        ThreadPriority = AUTD3Sharp.Link.ThreadPriority.Max,
        ProcessPriority = ProcessPriority.High,
        SyncTolerance = Duration.FromMicros(1),
        SyncTimeout = Duration.FromSecs(10),
    }
);

import os
from pyautd3 import Duration
from pyautd3_link_soem import (
    SOEM,
    ProcessPriority,
    SOEMOption,
    Status,
    SyncMode,
    ThreadPriority,
    TimerStrategy,
)


def err_handler(slave: int, status: Status) -> None:
    print(f"slave [{slave}]: {status}")
    if status == Status.Lost():
        os._exit(-1)


SOEM(
    err_handler=err_handler,
    option=SOEMOption(
        buf_size=32,
        timer_strategy=TimerStrategy.SpinSleep,
        sync_mode=SyncMode.DC,
        ifname="",
        state_check_interval=Duration.from_millis(100),
        sync0_cycle=Duration.from_millis(1),
        send_cycle=Duration.from_millis(1),
        thread_priority=ThreadPriority.Max,
        process_priority=ProcessPriority.High,  # only available on Windows
        sync_tolerance=Duration.from_micros(1),
        sync_timeout=Duration.from_secs(10),
    ),
)

cargo add autd3-link-simulator --features blocking

target_link_libraries(<TARGET> PRIVATE autd3::link::simulator)

メインライブラリに含まれている.

メインライブラリに含まれている.

メインライブラリに含まれている.

use autd3_link_simulator::Simulator;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
Simulator::new("127.0.0.1:8080".parse()?);
Ok(())
}

#include "autd3/link/simulator.hpp"

int main() {
using namespace autd3;
link::Simulator("127.0.0.1:8080");
return 0; }

using System.Net;
using AUTD3Sharp.Link;

new Simulator(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 8080));

from pyautd3.link.simulator import Simulator

Simulator("127.0.0.1:8080")

cargo add autd3-link-twincat --features remote

target_link_libraries(<TARGET> PRIVATE autd3::link::twincat)

メインライブラリに含まれている.

メインライブラリに含まれている.

メインライブラリに含まれている.

use autd3_link_twincat::remote::{RemoteTwinCAT, RemoteTwinCATOption};

fn main() {
let _ = 
RemoteTwinCAT::new("172.16.99.111.1.1", RemoteTwinCATOption {
    server_ip: "172.16.99.104".to_string(),
    client_ams_net_id: "172.16.99.62.1.1".to_string(),
});
}

#include "autd3/link/twincat.hpp"

int main() {
using namespace autd3;
link::RemoteTwinCAT("172.16.99.111.1.1",
                    link::RemoteTwinCATOption{
                        .server_ip = "172.16.99.104",
                        .client_ams_net_id = "172.16.99.62.1.1"});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;

new RemoteTwinCAT(
        serverAmsNetId: "172.16.99.111.1.1",
        option: new RemoteTwinCATOption
        {
                ServerIp = "172.16.99.104",
                ClientAmsNetId = "172.16.99.62.1.1"
        }
);

from pyautd3.link.twincat import RemoteTwinCAT, RemoteTwinCATOption

RemoteTwinCAT(
    server_ams_net_id="172.16.99.111.1.1",
    option=RemoteTwinCATOption(
        server_ip="172.16.99.104",
        client_ams_net_id="172.16.99.62.1.1",
    ),
)

cargo add autd3-link-soem --features "remote blocking"

if(WIN32)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-win-x64.zip
  )
elseif(APPLE)
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-macos-aarch64.tar.gz
  )
else()
  FetchContent_Declare(
    autd3-link-soem
    URL https://github.com/shinolab/autd3-cpp-link-soem/releases/download/v32.0.1/autd3-link-soem-v32.0.1-linux-x64.tar.gz
  )
endif()
FetchContent_MakeAvailable(autd3-link-soem)
target_link_libraries(<TARGET> PRIVATE autd3::link::soem)

dotnet add package AUTD3Sharp.Link.SOEM

https://github.com/shinolab/AUTD3Sharp.Link.SOEM.git#upm/latestをUnity Package Managerで追加する.

pip install pyautd3_link_soem

use autd3_link_soem::RemoteSOEM;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
RemoteSOEM::new("172.16.99.104:8080".parse()?);
Ok(())
}

#include <autd3_link_soem.hpp>

int main() {
using namespace autd3;
link::RemoteSOEM("172.16.99.104:8080");
return 0; }

using System.Net;
using AUTD3Sharp.Link;

new RemoteSOEM(new IPEndPoint(IPAddress.Parse("172.16.99.104"), 8080))
;

from pyautd3_link_soem import RemoteSOEM

RemoteSOEM("172.16.99.104:8080")

use autd3::prelude::*;
#[allow(unused_variables)]
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
autd.send(ReadsFPGAState::new(|_dev| true))?;

let info = autd.fpga_state()?;
Ok(())
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
autd.send(ReadsFPGAState([](const auto&) { return true; }));

const auto info = autd.fpga_state();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
autd.Send(new ReadsFPGAState(_ => true));

var info = autd.FPGAState();

from pyautd3 import Controller, AUTD3, ReadsFPGAState
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
autd.send(ReadsFPGAState(lambda _: True))

info = autd.fpga_state()

use autd3::prelude::*;
use autd3::gain::IntoBoxedGain;

use std::collections::HashMap;
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut autd = Controller::open(
        [AUTD3::default(), AUTD3::default()],
        autd3::link::Nop::new(),
    )?;
    let x = 0.;
    let y = 0.;
    let z = 0.;
autd.group_send(
    |dev| match dev.idx() {
        0 => Some("focus"),
        1 => Some("null"),
        _ => None,
    },
    HashMap::from([
        (
            "focus",
            Focus {
                pos: Point3::new(x, y, z),
                option: Default::default(),
            }
            .into_boxed(),
        ),
        ("null", Null {}.into_boxed()),
    ]),
)?;
    Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
autd.group_send(
    [](const Device& dev) -> std::optional<const char*> {
      if (dev.idx() == 0) {
        return "null";
      } else if (dev.idx() == 1) {
        return "focus";
      } else {
        return std::nullopt;
      }
    },
    std::unordered_map<const char*, std::shared_ptr<driver::Datagram>>{
        {"focus",
         std::make_shared<Focus>(Focus(Point3(x, y, z), FocusOption{}))},
        {"null", std::make_shared<Null>()}});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Modulation;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
autd.GroupSend(dev =>
    {
        return dev.Idx() switch
        {
            0 => "null",
            1 => "focus",
            _ => null
        };
    },
    new GroupDictionary {
        { "null", new Null() },
        { "focus", new Focus(pos: new Point3(x, y, z), option: new FocusOption()) }
    }
);

from pyautd3 import AUTD3, Controller, Device
from pyautd3.gain import Focus, FocusOption, Null
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
x = 0.0
y = 0.0
z = 0.0
def key_map(dev: Device) -> str | None:
    if dev.idx == 0:
        return "null"
    if dev.idx == 1:
        return "focus"
    return None


autd.group_send(
    key_map=key_map,
    data_map={"null": Null(), "focus": Focus(pos=[x, y, z], option=FocusOption())},
)

use std::time::Duration;
use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut autd = Controller::open([AUTD3::default()], autd3::link::Nop::new())?;
let mut sender = autd.sender(SenderOption {
    send_interval: Duration::from_millis(1),
    receive_interval: Duration::from_millis(1),
    timeout: None,
    parallel: ParallelMode::Auto,
    sleeper: SpinSleeper::default(),
});
let d = Null {};
sender.send(d)?;
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
auto autd = Controller::open({AUTD3{}}, link::Nop{});
auto sender = autd.sender(SenderOption{
    .send_interval = std::chrono::milliseconds(1),
    .receive_interval = std::chrono::milliseconds(1),
    .timeout = std::nullopt,
    .parallel = ParallelMode::Auto,
    .sleeper = SpinSleeper(),
});
const Null d;
sender.send(d);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Link;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Utils;
using var autd = Controller.Open([new AUTD3()], new Nop());
var sender = autd.Sender(
    new SenderOption
    {
        SendInterval = Duration.FromMillis(1),
        ReceiveInterval = Duration.FromMillis(1),
        Timeout = null,
        Parallel = ParallelMode.Auto,
        Sleeper = new SpinSleeper()
    }
);
var d = new Null();
sender.Send(d);

from pyautd3 import AUTD3, Controller, Duration, Null, SenderOption, SpinSleeper, ParallelMode
from pyautd3.link.nop import Nop
autd = Controller.open([AUTD3()], Nop())
sender = autd.sender(
    SenderOption(
        send_interval=Duration.from_millis(1),
        receive_interval=Duration.from_millis(1),
        timeout=None,
        parallel=ParallelMode.Auto,
        sleeper=SpinSleeper(),
    )
)
d = Null()
sender.send(d)

use autd3::prelude::*;
fn main() {
let _ = 
Null {};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Null{};
return 0; }

using AUTD3Sharp.Gain;
new Null();

from pyautd3 import Null
Null()

use autd3::prelude::*;
fn main() {
let x = 0.;
let y = 0.;
let z = 0.;
let _ = 
Focus {
    pos: Point3::new(x, y, z),
    option: FocusOption {
        intensity: EmitIntensity::MAX,
        phase_offset: Phase::ZERO,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
Focus(Point3(x, y, z),
      FocusOption{
          .intensity = std::numeric_limits<EmitIntensity>::max(),
          .phase_offset = Phase::zero(),
      });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
new Focus(
    pos: new Point3(x, y, z),
    option: new FocusOption
    {
        Intensity = EmitIntensity.Max,
        PhaseOffset = Phase.Zero
    }
);

from pyautd3 import EmitIntensity, Focus, FocusOption, Phase

x = 1.0
y = 0.0
z = 0.0
Focus(
    pos=[x, y, z],
    option=FocusOption(
        intensity=EmitIntensity.MAX,
        phase_offset=Phase.ZERO,
    ),
)

use autd3::prelude::*;
fn main() {
let x = 0.;
let y = 0.;
let z = 0.;
let nx = 0.;
let ny = 0.;
let nz = 0.;
let theta = 0. * rad;
let _ = 
Bessel {
    pos: Point3::new(x, y, z),
    dir: UnitVector3::new_normalize(Vector3::new(nx, ny, nz)),
    theta,
    option: BesselOption {
        intensity: EmitIntensity::MAX,
        phase_offset: Phase::ZERO,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
const auto nx = 0.0;
const auto ny = 0.0;
const auto nz = 1.0;
const auto theta = 0.0;
Bessel(Point3(x, y, z), Vector3(nx, ny, nz), theta* rad,
       BesselOption{
           .intensity = std::numeric_limits<EmitIntensity>::max(),
           .phase_offset = Phase::zero(),
       });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
using static AUTD3Sharp.Units;
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
var nx = 0.0f;
var ny = 0.0f;
var nz = 1.0f;
var theta = 0.0f;
new Bessel(
    pos: new Point3(x, y, z),
    dir: new Vector3(nx, ny, nz),
    theta: theta * rad,
    option: new BesselOption
    {
        Intensity = EmitIntensity.Max,
        PhaseOffset = Phase.Zero
    }
);

from pyautd3 import Bessel, BesselOption, EmitIntensity, Phase, rad

x = 0.0
y = 0.0
z = 0.0
nx = 1.0
ny = 0.0
nz = 0.0
theta = 0.0
Bessel(
    pos=[x, y, z],
    direction=[nx, ny, nz],
    theta=theta * rad,
    option=BesselOption(
        intensity=EmitIntensity.MAX,
        phase_offset=Phase.ZERO,
    ),
)

use autd3::prelude::*;
fn main() {
let nx = 0.;
let ny = 0.;
let nz = 0.;
let _ = 
Plane {
    dir: UnitVector3::new_normalize(Vector3::new(nx, ny, nz)),
    option: PlaneOption {
        intensity: EmitIntensity::MAX,
        phase_offset: Phase::ZERO,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
const auto nx = 0.0;
const auto ny = 0.0;
const auto nz = 1.0;
Plane(Vector3(nx, ny, nz),
      PlaneOption{
          .intensity = std::numeric_limits<EmitIntensity>::max(),
          .phase_offset = Phase::zero(),
      });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
var nx = 0.0f;
var ny = 0.0f;
var nz = 1.0f;
new Plane(
    dir: new Vector3(nx, ny, nz),
    option: new PlaneOption
    {
        Intensity = EmitIntensity.Max,
        PhaseOffset = Phase.Zero
    }
);

from pyautd3 import EmitIntensity, Phase, Plane, PlaneOption
nx = 1.0
ny = 0.0
nz = 0.0
Plane(
    direction=[nx, ny, nz],
    option=PlaneOption(
        intensity=EmitIntensity.MAX,
        phase_offset=Phase.ZERO,
    ),
)

use autd3::prelude::*;
fn main() {
let _ = 
Uniform {
    intensity: EmitIntensity::MAX, 
    phase: Phase::ZERO,
};
}

#include<autd3.hpp>
#include <limits>
int main() {
using namespace autd3;
Uniform(std::numeric_limits<EmitIntensity>::max(), Phase::zero());
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Gain;
new Uniform(
    intensity: EmitIntensity.Max,
    phase: Phase.Zero
);

from pyautd3 import EmitIntensity, Phase, Uniform
Uniform(intensity=EmitIntensity.MAX, phase=Phase.ZERO)

use autd3::gain::Custom;
use autd3::prelude::*;

fn main() {
let _ =
Custom::new(|_dev| {
    |_tr| Drive {
        phase: Phase::ZERO,
        intensity: EmitIntensity::MIN,
    }
});
}

#include<autd3.hpp>
#include <autd3/gain/custom.hpp>

int main() {
using namespace autd3;
gain::Custom([](const auto& dev) {
  return [](const auto& tr) {
    return Drive(Phase::zero(), std::numeric_limits<EmitIntensity>::min());
  };
});
return 0; }

using System;
using AUTD3Sharp;
using AUTD3Sharp.Gain;
using static AUTD3Sharp.Units;

new Custom(dev => tr => new Drive(Phase.Zero, EmitIntensity.Min));

from pyautd3 import Drive, EmitIntensity, Phase
from pyautd3.gain import Custom

Custom(lambda _dev: lambda _tr: Drive(phase=Phase.ZERO, intensity=EmitIntensity.MIN))

use autd3::gain::IntoBoxedGain;
use autd3::prelude::*;
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let x = 0.;
let y = 0.;
let z = 0.;
let _ =
Group {
    key_map: |_dev| {
        |tr| match tr.idx() {
            0..=100 => Some("null"),
            _ => Some("focus"),
        }
    },
    gain_map: HashMap::from([
        ("null", Null {}.into_boxed()),
        (
            "focus",
            Focus {
                pos: Point3::new(x, y, z),
                option: Default::default(),
            }
            .into_boxed(),
        ),
    ]),
};
Ok(())
}

#include<optional>
#include<autd3.hpp>
int main() {
using namespace autd3;
const auto x = 0.0;
const auto y = 0.0;
const auto z = 0.0;
Group(
    [](const auto& dev) {
      return [](const auto& tr) -> std::optional<const char*> {
        if (tr.idx() <= 100) return "null";
        return "focus";
      };
    },
    std::unordered_map<const char*, std::shared_ptr<Gain>>{
        {"focus", std::make_shared<Focus>(Point3(x, y, z), FocusOption{})},
        {"null", std::make_shared<Null>()}});
return 0; }

using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Driver.Datagram;
var x = 0.0f;
var y = 0.0f;
var z = 0.0f;
new Group(
    keyMap: dev => tr => tr.Idx() <= 100 ? "null" : "focus",
    gainMap: new Dictionary<object, IGain> {
        { "null", new Null() },
        { "focus", new Focus(pos: new Point3(x, y, z), option: new FocusOption()) }
    }
);

from pyautd3 import Focus, FocusOption, Group, Null
x = 1.0
y = 0.0
z = 0.0
Group(
    key_map=lambda _: lambda tr: "null" if tr.idx() <= 100 else "focus",
    gain_map={"null": Null(), "focus": Focus(pos=[x, y, z], option=FocusOption())},
)

cargo add autd3-gain-holo

target_link_libraries(<TARGET> PRIVATE autd3::gain::holo)

メインライブラリに含まれている.

メインライブラリに含まれている.

メインライブラリに含まれている.

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, Naive, NaiveOption};
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
Naive {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: NaiveOption {
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::Naive(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::NaiveOption{
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new Naive(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new NaiveOption
    {
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import Naive, EmissionConstraint, NaiveOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
Naive(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=NaiveOption(
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, GS, GSOption};
use std::num::NonZeroUsize;
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
GS {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: GSOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::GS(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::GSOption{
        .repeat = 100,
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new GS(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new GSOption
    {
        Repeat = 100,
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import GS, EmissionConstraint, GSOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
GS(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=GSOption(
        repeat=100,
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, GSPAT, GSPATOption};
use std::num::NonZeroUsize;
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
GSPAT {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: GSPATOption {
        repeat: NonZeroUsize::new(100).unwrap(),
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::GSPAT(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::GSPATOption{
        .repeat = 100,
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new GSPAT(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new GSPATOption
    {
        Repeat = 100,
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import GSPAT, EmissionConstraint, GSPATOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
GSPAT(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=GSPATOption(
        repeat=100,
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, NalgebraBackend, Pa, LM, LMOption};
use std::num::NonZeroUsize;
use std::sync::Arc;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let backend = Arc::new(NalgebraBackend::default());
let _ = 
LM {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: LMOption {
        eps_1: 1e-8,
        eps_2: 1e-8,
        tau: 1e-3,
        k_max: NonZeroUsize::new(5).unwrap(),
        initial: vec![],
        constraint: EmissionConstraint::Clamp(EmitIntensity::MIN, EmitIntensity::MAX),
        ..Default::default()
    },
    backend,
};
}

#include<autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
const auto backend = std::make_shared<gain::holo::NalgebraBackend>();
auto g = gain::holo::LM(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::LMOption{
        .eps_1 = 1e-8,
        .eps_2 = 1e-8,
        .tau = 1e-3,
        .k_max = 5,
        .initial = {},
        .constraint = gain::holo::EmissionConstraint::Clamp(
            std::numeric_limits<EmitIntensity>::min(),
            std::numeric_limits<EmitIntensity>::max()),
    },
    backend);
return 0; }

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
var backend = new NalgebraBackend();
new LM(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new LMOption
    {
        Eps1 = 1e-8f,
        Eps2 = 1e-8f,
        Tau = 1e-3f,
        KMax = 5,
        Initial = [],
        EmissionConstraint = EmissionConstraint.Clamp(EmitIntensity.Min, EmitIntensity.Max),
    },
    backend: backend
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import LM, EmissionConstraint, LMOption, NalgebraBackend, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
backend = NalgebraBackend()
LM(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=LMOption(
        eps_1=1e-8,
        eps_2=1e-8,
        tau=1e-3,
        k_max=5,
        initial = None,
        constraint=EmissionConstraint.Clamp(EmitIntensity.MIN, EmitIntensity.MAX),
    ),
    backend=backend,
)

use autd3::prelude::*;
use autd3_gain_holo::{EmissionConstraint, Pa, Greedy, GreedyOption, Sphere};
use std::num::NonZeroU8;

fn main() {
let x1 = 0.;
let y1 = 0.;
let z1 = 0.;
let x2 = 0.;
let y2 = 0.;
let z2 = 0.;
let _ = 
Greedy::<Sphere> {
    foci: vec![
        (Point3::new(x1, y1, z1), 5e3 * Pa),
        (Point3::new(x2, y2, z2), 5e3 * Pa),
    ],
    option: GreedyOption {
        phase_div: NonZeroU8::new(16).unwrap(),
        constraint: EmissionConstraint::Uniform(EmitIntensity::MAX),
        ..Default::default()
    },
};
}

#include <autd3.hpp>
#include "autd3/gain/holo.hpp"

using namespace autd3;
using gain::holo::Pa;

int main() {
const auto x1 = 0.0;
const auto y1 = 0.0;
const auto z1 = 0.0;
const auto x2 = 0.0;
const auto y2 = 0.0;
const auto z2 = 0.0;
auto g = gain::holo::Greedy(
    std::vector<std::pair<Point3, gain::holo::Amplitude>>{
        {Point3(x1, y1, z1), 5e3 * Pa},
        {Point3(x2, y2, z2), 5e3 * Pa},
    },
    gain::holo::GreedyOption{
        .phase_div = 16,
        .constraint = gain::holo::EmissionConstraint::Uniform(
            std::numeric_limits<EmitIntensity>::max())});
  return 0;
}

using AUTD3Sharp.Gain.Holo;

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var x1 = 0.0f;
var y1 = 0.0f;
var z1 = 0.0f;
var x2 = 0.0f;
var y2 = 0.0f;
var z2 = 0.0f;
new Greedy(
    foci: [
             (new Point3(x1, y1, z1), 5e3f * Pa),
             (new Point3(x2, y2, z2), 5e3f * Pa)
    ],
    option: new GreedyOption
    {
        PhaseDiv = 16,
        EmissionConstraint = EmissionConstraint.Uniform(EmitIntensity.Max),
    }
);

import numpy as np
from pyautd3 import EmitIntensity
from pyautd3.gain.holo import Greedy, EmissionConstraint, GreedyOption, Pa

x1 = 0.0
y1 = 0.0
z1 = 0.0
x2 = 0.0
y2 = 0.0
z2 = 0.0
Greedy(
    foci=[(np.array([x1, y1, z1]), 5e3 * Pa), (np.array([x2, y2, z2]), 5e3 * Pa)],
    option=GreedyOption(
        phase_div=16,
        constraint=EmissionConstraint.Uniform(EmitIntensity.MAX),
    ),
)

use autd3::prelude::*;
use autd3::gain::Cache;

fn main() {
let _ = 
Cache::new(Null::new());
}

#include<autd3.hpp>
#include <autd3/gain/cache.hpp>

int main() {
using namespace autd3;
gain::Cache(Null{});
return 0; }

using AUTD3Sharp.Gain;

new Cache(new Null());

from pyautd3 import Null
from pyautd3.gain import Cache

Cache(Null())

use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let stm = FociSTM {
    foci: vec![Point3::origin(), Point3::origin()],
    config: 1.0 * Hz,
};
dbg!(stm.sampling_config()?.freq()?); // -> 2Hz
Ok(())
}

#include<iostream>
#include<autd3.hpp>
int main() {
using namespace autd3;
FociSTM stm(
    std::vector{
        Point3::origin(),
        Point3::origin(),
    },
    1.0f * Hz);
std::cout << stm.sampling_config().freq() << std::endl;  // -> 2Hz
                                                         return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using static AUTD3Sharp.Units;
var stm = new FociSTM(foci: [Point3.Origin, Point3.Origin], config: 1.0f * Hz);
Console.WriteLine(stm.SamplingConfig().Freq()); // -> 2 Hz

import numpy as np
from pyautd3 import FociSTM, Hz
stm = FociSTM(
    foci=[np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, 0.0])],
    config=1.0 * Hz,
)
print(stm.sampling_config().freq())  # -> 2Hz

use autd3::prelude::*;
fn main() {
let start = Point3::origin();
let end = Point3::origin();
let center = Point3::origin();
let radius = 30.0 * mm;
let num_points = 50;
let n = Vector3::z_axis();
let intensity = EmitIntensity::MAX;
let _ = 
FociSTM {
    foci: Line {
        start,
        end,
        num_points,
        intensity,
    },
    config: 1.0 * Hz,
};

let _ = 
FociSTM {
    foci: Circle {
        center,
        radius,
        num_points,
        n, // normal vector to the plane where the circle is drawn
        intensity,
    },
    config: 1.0 * Hz,
};
}

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
FociSTM {
    foci: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            center + p
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<Point3> foci;
std::ranges::copy(iota(0) | take(points_num) | transform([&](auto i) {
                    const auto theta = 2.0f * pi * static_cast<float>(i) /
                                       static_cast<float>(points_num);
                    Point3 p = center + radius * Vector3(std::cos(theta),
                                                         std::sin(theta), 0);
                    return p;
                  }),
                  std::back_inserter(foci));
FociSTM(foci, 1.0f * Hz);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new FociSTM(
    foci: Enumerable.Range(0, pointNum).Select(i =>
    {
        var theta = 2.0f * MathF.PI * i / pointNum;
        return center + radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0);
    }),
    config: 1.0f * Hz
);

import numpy as np
from pyautd3 import FociSTM, Hz
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
FociSTM(
    foci=(
        center + radius * np.array([np.cos(theta), np.sin(theta), 0])
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
)

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
FociSTM {
    foci: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            ControlPoints {
                points: [
                    ControlPoint {
                        point: center + p,
                        phase_offset: Phase::ZERO,
                    },
                    ControlPoint {
                        point: center - p,
                        phase_offset: Phase::ZERO,
                    },
                ],
                intensity: EmitIntensity::MAX,
            }
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<ControlPoints<2>> foci;
std::ranges::copy(
    iota(0) | take(points_num) | transform([&](auto i) {
      const auto theta =
          2.0f * pi * static_cast<float>(i) / static_cast<float>(points_num);
      Vector3 p = radius * Vector3(std::cos(theta), std::sin(theta), 0);
      return ControlPoints<2>{
          .points = std::array{ControlPoint{.point = center + p,
                                            .phase_offset = Phase::zero()},
                               ControlPoint{.point = center - p,
                                            .phase_offset = Phase::zero()}},
          .intensity = std::numeric_limits<EmitIntensity>::max()};
    }),
    std::back_inserter(foci));
FociSTM stm(foci, 1.0f * Hz);
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new FociSTM(
    foci: Enumerable.Range(0, pointNum).Select(i =>
        {
            var theta = 2.0f * MathF.PI * i / pointNum;
            var p = radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0);
            return new ControlPoints(
                points: [
                    new ControlPoint { Point = center + p, PhaseOffset = Phase.Zero},
                    new ControlPoint { Point = center - p, PhaseOffset = Phase.Zero}
                ],
                intensity: EmitIntensity.Max
            );
        }),
    config: 1.0f * Hz
);

import numpy as np
from pyautd3 import ControlPoint, ControlPoints, EmitIntensity, FociSTM, Hz, Phase
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
FociSTM(
    foci=(
        ControlPoints(
            points=[
                ControlPoint(
                    point=center + radius * np.array([np.cos(theta), np.sin(theta), 0]),
                    phase_offset=Phase.ZERO,
                ),
                ControlPoint(
                    point=center - radius * np.array([np.cos(theta), np.sin(theta), 0]),
                    phase_offset=Phase.ZERO,
                ),
            ],
            intensity=EmitIntensity.MAX,
        )
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
)

use autd3::prelude::*;
fn main() {
let center = Point3::new(0., 0., 150.0 * mm);
let point_num = 200;
let radius = 30.0 * mm;
let _ = 
GainSTM {
    gains: (0..point_num)
        .map(|i| {
            let theta = 2.0 * PI * i as f32 / point_num as f32;
            let p = radius * Vector3::new(theta.cos(), theta.sin(), 0.0);
            Focus {
                pos: center + p,
                option: FocusOption::default(),
            }
        })
        .collect::<Vec<_>>(),
    config: 1.0 * Hz,
    option: GainSTMOption {
        mode: GainSTMMode::PhaseIntensityFull,
    },
};
}

#include <ranges>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
using namespace std::ranges::views;
int main() {
using namespace autd3;
const Point3 center(0, 0, 150);
const auto points_num = 200;
const auto radius = 30.0f;
std::vector<Focus> gains;
std::ranges::copy(iota(0) | take(points_num) | transform([&](auto i) {
                    const auto theta = 2.0f * pi * static_cast<float>(i) /
                                       static_cast<float>(points_num);
                    return Focus(center + radius * Vector3(std::cos(theta),
                                                           std::sin(theta), 0),
                                 FocusOption{});
                  }),
                  std::back_inserter(gains));
GainSTM(gains, 1.0f * Hz,
        GainSTMOption{.mode = GainSTMMode::PhaseIntensityFull});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
using AUTD3Sharp.Gain;
using AUTD3Sharp.Link;
using static AUTD3Sharp.Units;
var center = new Point3(0, 0, 150);
const int pointNum = 200;
const float radius = 30.0f;
new GainSTM(
    gains: Enumerable.Range(0, pointNum).Select(i =>
    {
        var theta = 2.0f * MathF.PI * i / pointNum;
        return new Focus(
            pos: center + radius * new Vector3(MathF.Cos(theta), MathF.Sin(theta), 0),
            option: new FocusOption()
        );
    }),
    config: 1.0f * Hz,
    option: new GainSTMOption
    {
        Mode = GainSTMMode.PhaseIntensityFull
    }
);

import numpy as np
from pyautd3 import Focus, FocusOption, GainSTM, GainSTMMode, GainSTMOption, Hz
center = np.array([0.0, 0.0, 150.0])
point_num = 200
radius = 30.0
GainSTM(
    gains=(
        Focus(
            pos=center + radius * np.array([np.cos(theta), np.sin(theta), 0]),
            option=FocusOption(),
        )
        for theta in (2.0 * np.pi * i / point_num for i in range(point_num))
    ),
    config=1.0 * Hz,
    option=GainSTMOption(
        mode=GainSTMMode.PhaseIntensityFull,
    ),
)

use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let m = Sine {
    freq: 150 * Hz,
    option: SineOption::default(),
};
dbg!(m.sampling_config().freq()?); // -> 4kHz
    Ok(())
}

#include<iostream>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
const auto m = Sine(150 * Hz, SineOption{});
std::cout << m.sampling_config().freq() << std::endl;  // -> 4kHz
                                                       return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
var m = new Sine(freq: 150u * Hz, option: new SineOption());
Console.WriteLine(m.SamplingConfig().Freq()); // -> 4kHz

from pyautd3 import Hz
from pyautd3.modulation import Sine, SineOption
m = Sine(freq=150 * Hz, option=SineOption())
print(m.sampling_config().freq())  # -> 4kHz

use autd3::prelude::*;
fn main() {
let _ = 
Static { intensity: 0xFF };
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Static(0xFF);
return 0; }

using AUTD3Sharp.Modulation;
new Static(intensity: 0xFF);

from pyautd3 import Static
Static(intensity=0xFF)

use autd3::prelude::*;
fn main() {
let _ = 
Sine {
    freq: 150 * Hz,
    option: SineOption {
        intensity: u8::MAX,
        offset: 0x80,
        phase: 0. * rad,
        clamp: false,
        sampling_config: SamplingConfig::FREQ_4K,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Sine(150 * Hz, SineOption{
                   .intensity = 0xFF,
                   .offset = 0x80,
                   .phase = 0.0f * rad,
                   .clamp = false,
                   .sampling_config = SamplingConfig::freq_4k(),
               });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Sine(
    freq: 150u * Hz,
    option: new SineOption
    {
        Intensity = 0xFF,
        Offset = 0x80,
        Phase = 0f * rad,
        Clamp = false,
        SamplingConfig = SamplingConfig.Freq4K
    }
);

from pyautd3 import Hz, SamplingConfig, Sine, SineOption, rad
Sine(
    freq=150 * Hz,
    option=SineOption(
        intensity=0xFF,
        offset=0x80,
        phase=0.0 * rad,
        clamp=False,
        sampling_config=SamplingConfig.FREQ_4K,
    ),
)

use autd3::prelude::*;
fn main() {
    let _ = 
Sine {
    freq: 150. * Hz,
    option: SineOption::default(),
}
.into_nearest();
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Sine(150.0f * Hz, SineOption{}).into_nearest();
return 0; }

using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Sine(freq: 150.0f * Hz, option: new SineOption()).IntoNearest();

from pyautd3 import Hz, Sine, SineOption
Sine(freq=150.0 * Hz, option=SineOption()).into_nearest()

use autd3::modulation::{Fourier, FourierOption};
use autd3::prelude::*;

fn main() {
let _ = 
Fourier {
    components: vec![
        Sine {
            freq: 100 * Hz,
            option: Default::default(),
        },
        Sine {
            freq: 150 * Hz,
            option: Default::default(),
        },
    ],
    option: FourierOption {
        scale_factor: None,
        clamp: false,
        offset: 0x00,
    },
};
}

#include<autd3.hpp>
#include <autd3/modulation/fourier.hpp>

int main() {
using namespace autd3;
modulation::Fourier({Sine(100 * Hz, SineOption{}),
                     Sine(150 * Hz, SineOption{})},
                    modulation::FourierOption{
                        .scale_factor = std::nullopt,
                        .clamp = false,
                        .offset = 0x00,
                    });

return 0; }

using AUTD3Sharp.Modulation;

using static AUTD3Sharp.Units;
new Fourier(
    components: [
        new Sine(freq: 100u * Hz, option: new SineOption()),
        new Sine(freq: 150u * Hz, option: new SineOption())
    ],
    option: new FourierOption
    {
        ScaleFactor = null,
        Clamp = false,
        Offset = 0x00
    }
);

from pyautd3 import Hz, Sine, SineOption
from pyautd3.modulation import Fourier, FourierOption

Fourier(
    components=[
        Sine(freq=100 * Hz, option=SineOption()),
        Sine(freq=150 * Hz, option=SineOption()),
    ],
    option=FourierOption(
        scale_factor=None,
        clamp=False,
        offset=0x00,
    ),
)

use autd3::prelude::*;
fn main() {
let _ = 
Square {
    freq: 150 * Hz,
    option: SquareOption {
        low: u8::MIN,
        high: u8::MAX,
        duty: 0.5,
        sampling_config: SamplingConfig::FREQ_4K,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Square(150 * Hz, SquareOption{
                     .low = 0x00,
                     .high = 0xFF,
                     .duty = 0.5f,
                     .sampling_config = SamplingConfig::freq_4k(),
                 });
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Square(
    freq: 150u * Hz,
    option: new SquareOption
    {
        Low = 0x00,
        High = 0xFF,
        Duty = 0.5f,
        SamplingConfig = SamplingConfig.Freq4K
    }
);

from pyautd3 import Hz, SamplingConfig, Square, SquareOption
Square(
    freq=150 * Hz,
    option=SquareOption(
        low=0x00,
        high=0xFF,
        duty=0.5,
        sampling_config=SamplingConfig.FREQ_4K,
    ),
)

use autd3::prelude::*;
fn main() {
let _ = 
Square {
    freq: 150.0 * Hz,
    option: Default::default(),
}
.into_nearest();
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Square(150.0f * Hz, SquareOption{}).into_nearest();
return 0; }

using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new Square(freq: 150.0f * Hz, option: new SquareOption()).IntoNearest();

from pyautd3 import Hz, Square, SquareOption
Square(freq=150.0 * Hz, option=SquareOption()).into_nearest()

cargo add autd3-modulation-audio-file

target_link_libraries(<TARGET> PRIVATE autd3::modulation::audio_file)

メインライブラリに含まれている.

メインライブラリに含まれている.

メインライブラリに含まれている.

use autd3_modulation_audio_file::Wav;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
Wav::new("path/to/foo.wav")?;
Ok(())
}

#include<autd3.hpp>
#include "autd3/modulation/audio_file.hpp"

int main() {
using namespace autd3;
modulation::audio_file::Wav("path/to/foo.wav");
return 0; }

using AUTD3Sharp.Modulation.AudioFile;

new Wav(path: "path/to/foo.wav");

import pathlib
from pyautd3.modulation.audio_file import Wav

Wav(path=pathlib.Path("path/to/foo.wav"))

cargo add autd3-modulation-audio-file

target_link_libraries(<TARGET> PRIVATE autd3::modulation::audio_file)

メインライブラリに含まれている.

メインライブラリに含まれている.

メインライブラリに含まれている.

use autd3::prelude::*;
use autd3_modulation_audio_file::{Csv, CsvOption};

fn main() {
let _ = 
Csv {
    path: "path/to/foo.csv",
    sampling_config: 4000.0 * Hz,
    option: CsvOption { delimiter: b',' },
};
}

#include<autd3.hpp>
#include "autd3/modulation/audio_file.hpp"

int main() {
using namespace autd3;
const auto path = "path/to/foo.csv";
modulation::audio_file::Csv(path, 4000.0f * Hz,
                            modulation::audio_file::CsvOption{
                                .delimiter = ',',
                            });
return 0; }

using AUTD3Sharp.Modulation.AudioFile;

using static AUTD3Sharp.Units;
new Csv(
    path: "path/to/foo.csv",
    samplingConfig: 4000f * Hz,
    option: new CsvOption
    {
        Delimiter = ',',
    }
);

import pathlib
from pyautd3 import Hz
from pyautd3.modulation.audio_file import Csv, CsvOption

Csv(
    path=pathlib.Path("path/to/foo.csv"),
    sampling_config=4000.0 * Hz,
    option=CsvOption(
        delimiter=",",
    ),
)

use autd3::modulation::Custom;

use autd3::prelude::*;
fn main() {
let _ = 
Custom {
    buffer: vec![0xFF, 0x00],
    sampling_config: 4.0 * kHz,
};
}

#include<vector>
#include<autd3.hpp>
#include <autd3/modulation/custom.hpp>

int main() {
using namespace autd3;
modulation::Custom(std::vector<uint8_t>{0xFF, 0x00}, 4000.0f * Hz);
return 0; }

using AUTD3Sharp;
using static AUTD3Sharp.Units;
using AUTD3Sharp.Modulation;

new Custom(
    buffer: [0xFF, 0x00],
    samplingConfig: 4000f * Hz
);

from pyautd3 import Hz
import numpy as np
from pyautd3.modulation import Custom

Custom(
    buffer=np.array([0xFF, 0x00]),
    sampling_config=4000.0 * Hz,
)

use autd3::prelude::*;
use autd3::modulation::Cache;

fn main() {
let _ = 
Cache::new(Static::default());
}

#include<autd3.hpp>
#include <autd3/modulation/cache.hpp>

int main() {
using namespace autd3;
modulation::Cache(Static{});
return 0; }

using AUTD3Sharp.Modulation;

new Cache(new Static());

from pyautd3 import Static
from pyautd3.modulation import Cache

Cache(Static())

use autd3::prelude::*;
use autd3::modulation::RadiationPressure;
 
fn main() {
let _ = 
RadiationPressure {
    target: Sine {
        freq: 150 * Hz,
        option: Default::default(),
    },
};
}

#include<autd3.hpp>
#include <autd3/modulation/radiation_pressure.hpp>

int main() {
using namespace autd3;
modulation::RadiationPressure(Sine(150 * Hz, SineOption{}));
return 0; }

using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;

new RadiationPressure(target: new Sine(freq: 150u * Hz, option: new SineOption()));

from pyautd3 import Hz, Sine, SineOption
from pyautd3.modulation import RadiationPressure

RadiationPressure(target=Sine(freq=150 * Hz, option=SineOption()))

use autd3::prelude::*;
use autd3::modulation::Fir;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
Fir {
    target: Sine {
        freq: 150. * Hz,
        option: SineOption {
            sampling_config: SamplingConfig::new(20.0 * kHz),
            ..Default::default()
        },
    },
    coef: vec![
        -0.000009, -0.000013, -0.000016, -0.000021, -0.000025, -0.000030, -0.000036,
        -0.000042, -0.000049, -0.000056, -0.000064, -0.000072, -0.000080, -0.000088,
        -0.000096, -0.000105, -0.000113, -0.000120, -0.000128, -0.000134, -0.000139,
        -0.000143, -0.000146, -0.000146, -0.000145, -0.000141, -0.000135, -0.000124,
        -0.000111, -0.000093, -0.000071, -0.000044, -0.000012, 0.000026, 0.000071,
        0.000122, 0.000180, 0.000247, 0.000321, 0.000405, 0.000497, 0.000599, 0.000712,
        0.000835, 0.000968, 0.001113, 0.001270, 0.001439, 0.001619, 0.001812, 0.002018,
        0.002236, 0.002467, 0.002711, 0.002968, 0.003237, 0.003518, 0.003812, 0.004118,
        0.004435, 0.004764, 0.005103, 0.005452, 0.005811, 0.006178, 0.006554, 0.006937,
        0.007326, 0.007720, 0.008119, 0.008521, 0.008925, 0.009331, 0.009737, 0.010141,
        0.010543, 0.010941, 0.011335, 0.011722, 0.012101, 0.012472, 0.012833, 0.013183,
        0.013520, 0.013843, 0.014152, 0.014445, 0.014720, 0.014978, 0.015217, 0.015435,
        0.015633, 0.015810, 0.015964, 0.016096, 0.016204, 0.016289, 0.016350, 0.016386,
        0.016399, 0.016386, 0.016350, 0.016289, 0.016204, 0.016096, 0.015964, 0.015810,
        0.015633, 0.015435, 0.015217, 0.014978, 0.014720, 0.014445, 0.014152, 0.013843,
        0.013520, 0.013183, 0.012833, 0.012472, 0.012101, 0.011722, 0.011335, 0.010941,
        0.010543, 0.010141, 0.009737, 0.009331, 0.008925, 0.008521, 0.008119, 0.007720,
        0.007326, 0.006937, 0.006554, 0.006178, 0.005811, 0.005452, 0.005103, 0.004764,
        0.004435, 0.004118, 0.003812, 0.003518, 0.003237, 0.002968, 0.002711, 0.002467,
        0.002236, 0.002018, 0.001812, 0.001619, 0.001439, 0.001270, 0.001113, 0.000968,
        0.000835, 0.000712, 0.000599, 0.000497, 0.000405, 0.000321, 0.000247, 0.000180,
        0.000122, 0.000071, 0.000026, -0.000012, -0.000044, -0.000071, -0.000093,
        -0.000111, -0.000124, -0.000135, -0.000141, -0.000145, -0.000146, -0.000146,
        -0.000143, -0.000139, -0.000134, -0.000128, -0.000120, -0.000113, -0.000105,
        -0.000096, -0.000088, -0.000080, -0.000072, -0.000064, -0.000056, -0.000049,
        -0.000042, -0.000036, -0.000030, -0.000025, -0.000021, -0.000016, -0.000013,
        -0.000009,
    ],
};
Ok(())
}

#include<autd3.hpp>
#include <autd3/modulation/fir.hpp>

int main() {
using namespace autd3;
modulation::Fir(
    Sine(150 * Hz,
         SineOption{
             .sampling_config = SamplingConfig(20.0f * kHz),
         }),
    std::vector{
        -0.000009f, -0.000013f, -0.000016f, -0.000021f, -0.000025f, -0.000030f,
        -0.000036f, -0.000042f, -0.000049f, -0.000056f, -0.000064f, -0.000072f,
        -0.000080f, -0.000088f, -0.000096f, -0.000105f, -0.000113f, -0.000120f,
        -0.000128f, -0.000134f, -0.000139f, -0.000143f, -0.000146f, -0.000146f,
        -0.000145f, -0.000141f, -0.000135f, -0.000124f, -0.000111f, -0.000093f,
        -0.000071f, -0.000044f, -0.000012f, 0.000026f,  0.000071f,  0.000122f,
        0.000180f,  0.000247f,  0.000321f,  0.000405f,  0.000497f,  0.000599f,
        0.000712f,  0.000835f,  0.000968f,  0.001113f,  0.001270f,  0.001439f,
        0.001619f,  0.001812f,  0.002018f,  0.002236f,  0.002467f,  0.002711f,
        0.002968f,  0.003237f,  0.003518f,  0.003812f,  0.004118f,  0.004435f,
        0.004764f,  0.005103f,  0.005452f,  0.005811f,  0.006178f,  0.006554f,
        0.006937f,  0.007326f,  0.007720f,  0.008119f,  0.008521f,  0.008925f,
        0.009331f,  0.009737f,  0.010141f,  0.010543f,  0.010941f,  0.011335f,
        0.011722f,  0.012101f,  0.012472f,  0.012833f,  0.013183f,  0.013520f,
        0.013843f,  0.014152f,  0.014445f,  0.014720f,  0.014978f,  0.015217f,
        0.015435f,  0.015633f,  0.015810f,  0.015964f,  0.016096f,  0.016204f,
        0.016289f,  0.016350f,  0.016386f,  0.016399f,  0.016386f,  0.016350f,
        0.016289f,  0.016204f,  0.016096f,  0.015964f,  0.015810f,  0.015633f,
        0.015435f,  0.015217f,  0.014978f,  0.014720f,  0.014445f,  0.014152f,
        0.013843f,  0.013520f,  0.013183f,  0.012833f,  0.012472f,  0.012101f,
        0.011722f,  0.011335f,  0.010941f,  0.010543f,  0.010141f,  0.009737f,
        0.009331f,  0.008925f,  0.008521f,  0.008119f,  0.007720f,  0.007326f,
        0.006937f,  0.006554f,  0.006178f,  0.005811f,  0.005452f,  0.005103f,
        0.004764f,  0.004435f,  0.004118f,  0.003812f,  0.003518f,  0.003237f,
        0.002968f,  0.002711f,  0.002467f,  0.002236f,  0.002018f,  0.001812f,
        0.001619f,  0.001439f,  0.001270f,  0.001113f,  0.000968f,  0.000835f,
        0.000712f,  0.000599f,  0.000497f,  0.000405f,  0.000321f,  0.000247f,
        0.000180f,  0.000122f,  0.000071f,  0.000026f,  -0.000012f, -0.000044f,
        -0.000071f, -0.000093f, -0.000111f, -0.000124f, -0.000135f, -0.000141f,
        -0.000145f, -0.000146f, -0.000146f, -0.000143f, -0.000139f, -0.000134f,
        -0.000128f, -0.000120f, -0.000113f, -0.000105f, -0.000096f, -0.000088f,
        -0.000080f, -0.000072f, -0.000064f, -0.000056f, -0.000049f, -0.000042f,
        -0.000036f, -0.000030f, -0.000025f, -0.000021f, -0.000016f, -0.000013f,
        -0.000009f});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;

new Fir(
    target: new Sine(freq: 150u * Hz, option: new SineOption
    {
        SamplingConfig = new SamplingConfig(20f * kHz)
    }),
    coef: [-0.000009f, -0.000013f, -0.000016f, -0.000021f, -0.000025f,
            -0.000030f, -0.000036f, -0.000042f, -0.000049f, -0.000056f,
            -0.000064f, -0.000072f, -0.000080f, -0.000088f, -0.000096f,
            -0.000105f, -0.000113f, -0.000120f, -0.000128f, -0.000134f,
            -0.000139f, -0.000143f, -0.000146f, -0.000146f, -0.000145f,
            -0.000141f, -0.000135f, -0.000124f, -0.000111f, -0.000093f,
            -0.000071f, -0.000044f, -0.000012f, 0.000026f,  0.000071f,
            0.000122f,  0.000180f,  0.000247f,  0.000321f,  0.000405f,
            0.000497f,  0.000599f,  0.000712f,  0.000835f,  0.000968f,
            0.001113f,  0.001270f,  0.001439f,  0.001619f,  0.001812f,
            0.002018f,  0.002236f,  0.002467f,  0.002711f,  0.002968f,
            0.003237f,  0.003518f,  0.003812f,  0.004118f,  0.004435f,
            0.004764f,  0.005103f,  0.005452f,  0.005811f,  0.006178f,
            0.006554f,  0.006937f,  0.007326f,  0.007720f,  0.008119f,
            0.008521f,  0.008925f,  0.009331f,  0.009737f,  0.010141f,
            0.010543f,  0.010941f,  0.011335f,  0.011722f,  0.012101f,
            0.012472f,  0.012833f,  0.013183f,  0.013520f,  0.013843f,
            0.014152f,  0.014445f,  0.014720f,  0.014978f,  0.015217f,
            0.015435f,  0.015633f,  0.015810f,  0.015964f,  0.016096f,
            0.016204f,  0.016289f,  0.016350f,  0.016386f,  0.016399f,
            0.016386f,  0.016350f,  0.016289f,  0.016204f,  0.016096f,
            0.015964f,  0.015810f,  0.015633f,  0.015435f,  0.015217f,
            0.014978f,  0.014720f,  0.014445f,  0.014152f,  0.013843f,
            0.013520f,  0.013183f,  0.012833f,  0.012472f,  0.012101f,
            0.011722f,  0.011335f,  0.010941f,  0.010543f,  0.010141f,
            0.009737f,  0.009331f,  0.008925f,  0.008521f,  0.008119f,
            0.007720f,  0.007326f,  0.006937f,  0.006554f,  0.006178f,
            0.005811f,  0.005452f,  0.005103f,  0.004764f,  0.004435f,
            0.004118f,  0.003812f,  0.003518f,  0.003237f,  0.002968f,
            0.002711f,  0.002467f,  0.002236f,  0.002018f,  0.001812f,
            0.001619f,  0.001439f,  0.001270f,  0.001113f,  0.000968f,
            0.000835f,  0.000712f,  0.000599f,  0.000497f,  0.000405f,
            0.000321f,  0.000247f,  0.000180f,  0.000122f,  0.000071f,
            0.000026f,  -0.000012f, -0.000044f, -0.000071f, -0.000093f,
            -0.000111f, -0.000124f, -0.000135f, -0.000141f, -0.000145f,
            -0.000146f, -0.000146f, -0.000143f, -0.000139f, -0.000134f,
            -0.000128f, -0.000120f, -0.000113f, -0.000105f, -0.000096f,
            -0.000088f, -0.000080f, -0.000072f, -0.000064f, -0.000056f,
            -0.000049f, -0.000042f, -0.000036f, -0.000030f, -0.000025f,
            -0.000021f, -0.000016f, -0.000013f, -0.000009f]
);

from pyautd3 import Hz, Sine, SineOption, kHz, SamplingConfig
from pyautd3.modulation import Fir

Fir(
    target=Sine(
        freq=150 * Hz,
        option=SineOption(
            sampling_config=SamplingConfig(20.0 * kHz),
        ),
    ),
    coef=[
        -0.000009, -0.000013, -0.000016, -0.000021, -0.000025, -0.000030, -0.000036,
        -0.000042, -0.000049, -0.000056, -0.000064, -0.000072, -0.000080, -0.000088,
        -0.000096, -0.000105, -0.000113, -0.000120, -0.000128, -0.000134, -0.000139,
        -0.000143, -0.000146, -0.000146, -0.000145, -0.000141, -0.000135, -0.000124,
        -0.000111, -0.000093, -0.000071, -0.000044, -0.000012, 0.000026, 0.000071,
        0.000122, 0.000180, 0.000247, 0.000321, 0.000405, 0.000497, 0.000599, 0.000712,
        0.000835, 0.000968, 0.001113, 0.001270, 0.001439, 0.001619, 0.001812, 0.002018,
        0.002236, 0.002467, 0.002711, 0.002968, 0.003237, 0.003518, 0.003812, 0.004118,
        0.004435, 0.004764, 0.005103, 0.005452, 0.005811, 0.006178, 0.006554, 0.006937,
        0.007326, 0.007720, 0.008119, 0.008521, 0.008925, 0.009331, 0.009737, 0.010141,
        0.010543, 0.010941, 0.011335, 0.011722, 0.012101, 0.012472, 0.012833, 0.013183,
        0.013520, 0.013843, 0.014152, 0.014445, 0.014720, 0.014978, 0.015217, 0.015435,
        0.015633, 0.015810, 0.015964, 0.016096, 0.016204, 0.016289, 0.016350, 0.016386,
        0.016399, 0.016386, 0.016350, 0.016289, 0.016204, 0.016096, 0.015964, 0.015810,
        0.015633, 0.015435, 0.015217, 0.014978, 0.014720, 0.014445, 0.014152, 0.013843,
        0.013520, 0.013183, 0.012833, 0.012472, 0.012101, 0.011722, 0.011335, 0.010941,
        0.010543, 0.010141, 0.009737, 0.009331, 0.008925, 0.008521, 0.008119, 0.007720,
        0.007326, 0.006937, 0.006554, 0.006178, 0.005811, 0.005452, 0.005103, 0.004764,
        0.004435, 0.004118, 0.003812, 0.003518, 0.003237, 0.002968, 0.002711, 0.002467,
        0.002236, 0.002018, 0.001812, 0.001619, 0.001439, 0.001270, 0.001113, 0.000968,
        0.000835, 0.000712, 0.000599, 0.000497, 0.000405, 0.000321, 0.000247, 0.000180,
        0.000122, 0.000071, 0.000026, -0.000012, -0.000044, -0.000071, -0.000093,
        -0.000111, -0.000124, -0.000135, -0.000141, -0.000145, -0.000146, -0.000146,
        -0.000143, -0.000139, -0.000134, -0.000128, -0.000120, -0.000113, -0.000105,
        -0.000096, -0.000088, -0.000080, -0.000072, -0.000064, -0.000056, -0.000049,
        -0.000042, -0.000036, -0.000030, -0.000025, -0.000021, -0.000016, -0.000013,
        -0.000009,
    ],
)

use std::num::NonZeroU16;
use std::time::Duration;
use autd3::prelude::*;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let _ = 
SamplingConfig::new(NonZeroU16::new(10).unwrap());
// or
let _ = 
SamplingConfig::new(4000.0 * Hz);
// or
let _ = 
SamplingConfig::new(Duration::from_micros(250));
Ok(())
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
SamplingConfig(10);
// or
SamplingConfig(4000.0f * Hz);
// or
SamplingConfig(std::chrono::microseconds(250));
return 0; }

using AUTD3Sharp;
using static AUTD3Sharp.Units;
new SamplingConfig(10);
// or
new SamplingConfig(4000f * Hz);
// or
new SamplingConfig(Duration.FromMicros(250));

from pyautd3 import Duration, Hz, SamplingConfig
SamplingConfig(10)
# or
SamplingConfig(4000.0 * Hz)
# or
SamplingConfig(Duration.from_micros(250))

use std::time::Duration;
use autd3::prelude::*;
fn main() {
let _ = 
SamplingConfig::new(4000.0 * Hz).into_nearest();
// or
let _ = 
SamplingConfig::new(Duration::from_micros(250)).into_nearest();
}

#include<autd3.hpp>
#include<chrono>
int main() {
using namespace autd3;
const auto s =
SamplingConfig(4000.0f * Hz).into_nearest();
// or
const auto sp =
SamplingConfig(std::chrono::microseconds(250)).into_nearest();
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
using static AUTD3Sharp.Units;
new SamplingConfig(4000.0f * Hz).IntoNearest();
// or
new SamplingConfig(Duration.FromMicros(250)).IntoNearest();

from pyautd3 import Duration, Hz, SamplingConfig
SamplingConfig(4000.0 * Hz).into_nearest()
# or
SamplingConfig(Duration.from_micros(250)).into_nearest()

use autd3::prelude::*;
fn main() {
let _ = 
WithSegment {
    inner: Static::default(),
    segment: Segment::S1,
    transition_mode: Some(TransitionMode::Immediate),
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
WithSegment(Static{}, Segment::S1, TransitionMode::Immediate());
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
new WithSegment(
    inner: new Static(),
    segment: Segment.S1,
    transitionMode: TransitionMode.Immediate
);

from pyautd3 import Segment, Static, TransitionMode, WithSegment
WithSegment(
    inner=Static(),
    segment=Segment.S1,
    transition_mode=TransitionMode.Immediate,
)

use autd3::prelude::*;
fn main() {
SwapSegment::Modulation(Segment::S1, TransitionMode::Immediate);
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
SwapSegment::Modulation(Segment::S1, TransitionMode::Immediate());
return 0; }

using AUTD3Sharp;
SwapSegment.Modulation(Segment.S1, TransitionMode.Immediate);

from pyautd3 import Segment, SwapSegment, TransitionMode
SwapSegment.Modulation(Segment.S1, TransitionMode.Immediate)

use std::num::NonZeroU16;
use autd3::prelude::*;
fn main() {
let _ = 
WithLoopBehavior {
    inner: Static::default(),
    loop_behavior: LoopBehavior::Infinite,
    segment: Segment::S1,
    transition_mode: Some(TransitionMode::Immediate),
};

let _ = 
WithLoopBehavior {
    inner: Static::default(),
    loop_behavior: LoopBehavior::Finite(NonZeroU16::new(1).unwrap()),
    segment: Segment::S1,
    transition_mode: Some(TransitionMode::SyncIdx),
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;

WithLoopBehavior(Static{}, LoopBehavior::Infinite(), Segment::S1,
                 TransitionMode::Immediate());

WithLoopBehavior(Static{}, LoopBehavior::Finite(1), Segment::S1,
                 TransitionMode::SyncIdx());
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Modulation;
new WithLoopBehavior(
    inner: new Static(),
    loopBehavior: LoopBehavior.Infinite,
    segment: Segment.S1,
    transitionMode: TransitionMode.Immediate
);

new WithLoopBehavior(
    inner: new Static(),
    loopBehavior: LoopBehavior.Finite(1),
    segment: Segment.S1,
    transitionMode: TransitionMode.SyncIdx
);

from pyautd3 import Segment, Static, TransitionMode, LoopBehavior, WithLoopBehavior
WithLoopBehavior(
    inner=Static(),
    loop_behavior=LoopBehavior.Infinite,
    segment=Segment.S1,
    transition_mode=TransitionMode.Immediate,
)

WithLoopBehavior(
    inner=Static(),
    loop_behavior=LoopBehavior.Finite(1),
    segment=Segment.S1,
    transition_mode=TransitionMode.SyncIdx,
)

use autd3::prelude::*;
fn main() {
let _ = 
Silencer::default();
let _ = 
Silencer::disable();
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Silencer();
Silencer::disable();
return 0; }

using AUTD3Sharp;
new Silencer();
Silencer.Disable();

from pyautd3 import Silencer
Silencer()
Silencer.disable()

use autd3::prelude::*;
use std::num::NonZeroU16;
fn main() {
let _ = 
Silencer {
    config: FixedUpdateRate {
        intensity: NonZeroU16::MIN,
        phase: NonZeroU16::MIN,
    },
};
}

#include<autd3.hpp>
int main() {
using namespace autd3;
Silencer{FixedUpdateRate{.intensity = 1, .phase = 1}};
return 0; }

using AUTD3Sharp;
new Silencer(
    config: new FixedUpdateRate
    {
        Intensity = 1,
        Phase = 1
    }
);

from pyautd3 import Silencer, FixedUpdateRate
Silencer(
    config=FixedUpdateRate(
        intensity=1,
        phase=1,
    ),
)

use autd3::prelude::*;
use std::time::Duration;
fn main() {
let _ = 
Silencer {
    config: FixedCompletionTime {
        intensity: Duration::from_micros(250),
        phase: Duration::from_micros(250),
        strict_mode: true,
    },
};
}

#include<chrono>
#include<autd3.hpp>
int main() {
using namespace autd3;
Silencer{FixedCompletionTime{.intensity = std::chrono::microseconds(250),
                             .phase = std::chrono::microseconds(250),
                             .strict_mode = true}};
return 0; }

using AUTD3Sharp;
new Silencer(
    config: new FixedCompletionTime
    {
        Intensity = Duration.FromMicros(250),
        Phase = Duration.FromMicros(250),
        StrictMode = true
    }
);

from pyautd3 import Duration, FixedCompletionTime, Silencer
Silencer(
    config=FixedCompletionTime(
        intensity=Duration.from_micros(250),
        phase=Duration.from_micros(250),
        strict_mode=True,
    ),
)

use autd3::prelude::*;
fn main() {
let _ =
PhaseCorrection::new(|_dev| |_tr| Phase::ZERO);
}

#include<chrono>
#include<autd3.hpp>
#include<autd3/link/nop.hpp>
int main() {
using namespace autd3;
PhaseCorrection([](const auto&) {
  return [](const auto&) { return Phase::zero(); };
});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
new PhaseCorrection(_dev => _tr => Phase.Zero);

from pyautd3 import Phase, PhaseCorrection
PhaseCorrection(lambda _dev: lambda _tr: Phase.ZERO)

use autd3::prelude::*;
fn main() {
let _ =
PulseWidthEncoder::new(|_dev| |i| PulseWidth::from_duty(i.0 as f32 / 510.0).unwrap());
}

#include<autd3.hpp>
#include<autd3/link/nop.hpp>
#include<vector>
int main() {
using namespace autd3;
auto autd =
Controller::open({AUTD3{}}, link::Nop{});
PulseWidthEncoder([](const auto& dev) {
  return [](const auto i) {
    return PulseWidth::from_duty(static_cast<float>(i.value()) / 510.0f);
  };
});
return 0; }

using AUTD3Sharp;
new PulseWidthEncoder(_dev => i => PulseWidth.FromDuty((float)i.Item1 / 510.0f));

from pyautd3 import PulseWidthEncoder, PulseWidth
PulseWidthEncoder(lambda _dev: lambda i: PulseWidth.from_duty(i.value / 510.0))

use autd3::prelude::*;
fn main() {
let _ =
GPIOOutputs::new(|_dev, gpio| {
    if gpio == GPIOOut::O0 {
        GPIOOutputType::BaseSignal
    } else {
        GPIOOutputType::None
    }
});
}

#include<autd3.hpp>
int main() {
using namespace autd3;
GPIOOutputs([](const auto& dev, const auto& gpio) {
  return gpio == GPIOOut::O0 ? GPIOOutputType::BaseSignal
                             : GPIOOutputType::None;
});
return 0; }

using AUTD3Sharp;
using AUTD3Sharp.Utils;
new GPIOOutputs(
    (dev, gpio) => gpio == GPIOOut.O0 ? GPIOOutputType.BaseSignal : GPIOOutputType.None
);

from pyautd3 import GPIOOutputs, GPIOOutputType, GPIOOut
GPIOOutputs(
    lambda _dev, gpio: (
        GPIOOutputType.BaseSignal if gpio == GPIOOut.O0 else GPIOOutputType.NONE
    ),
)

use autd3::prelude::*;
fn main() {
let _ =
ForceFan::new(|_dev| true);
}

#include<autd3.hpp>
int main() {
using namespace autd3;
ForceFan([](const auto&) { return true; });
return 0; }

using AUTD3Sharp;
new ForceFan(_ => true);

from pyautd3 import ForceFan
ForceFan(lambda _: True)

cargo add autd3-emulator

pip install pyautd3_emulator

use autd3::prelude::*;
use autd3_emulator::*;

fn main() {
let emulator = Emulator::new([AUTD3::default()]);
let df = emulator.transducer_table();
dbg!(df);
}

from pyautd3 import AUTD3
from pyautd3_emulator import Emulator

with Emulator([AUTD3()]) as emulator:
    df = emulator.transducer_table()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let record = emulator.record(|autd| {
    autd.send(Silencer::default())?;
    autd.send((
        Sine {
            freq: 200 * Hz,
            option: Default::default(),
        },
        Uniform {
            intensity: EmitIntensity::MAX,
            phase: Phase::ZERO,
        },
    ))?;
    autd.tick(Duration::from_millis(10))?;
    Ok(())
})?;
let df = record.phase();
dbg!(df);

let df = record.pulse_width();
dbg!(df);
Ok(())
}

from pyautd3 import (
    AUTD3,
    Duration,
    EmitIntensity,
    Hz,
    Phase,
    Silencer,
    Sine,
    SineOption,
    Uniform,
)
from pyautd3_emulator import Emulator, Recorder

with Emulator([AUTD3()]) as emulator:

    def f(autd: Recorder) -> None:
        autd.send(Silencer())
        autd.send(
            (
                Sine(freq=200.0 * Hz, option=SineOption()),
                Uniform(intensity=EmitIntensity.MAX, phase=Phase.ZERO),
            ),
        )
        autd.tick(Duration.from_millis(10))

    record = emulator.record(f)

    df = record.phase()
    print(df)

    df = record.pulse_width()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Uniform {
            intensity: EmitIntensity::MAX,
            phase: Phase(0x40),
        },
    ))?;
    autd.tick(Duration::from_millis(1))?;
    Ok(())
})?;

let df = record.output_voltage();
dbg!(df);
    Ok(())
}

from pyautd3 import AUTD3, Duration, EmitIntensity, Phase, Silencer, Static, Uniform
from pyautd3_emulator import Emulator, Recorder

with Emulator([AUTD3()]) as emulator:

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Uniform(phase=Phase(0x40), intensity=EmitIntensity.MAX)))
        autd.tick(Duration.from_millis(1))

    record = emulator.record(f)

    df = record.output_voltage()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Uniform {
            intensity: EmitIntensity::MAX,
            phase: Phase(0x40),
        },
    ))?;
    autd.tick(Duration::from_millis(1))?;
    Ok(())
})?;

let df = record.output_ultrasound();
dbg!(df);
    Ok(())
}

from pyautd3 import AUTD3, Duration, EmitIntensity, Phase, Silencer, Static, Uniform
from pyautd3_emulator import Emulator, Recorder

with Emulator([AUTD3()]) as emulator:

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Uniform(phase=Phase(0x40), intensity=EmitIntensity.MAX)))
        autd.tick(Duration.from_millis(1))

    record = emulator.record(f)

    df = record.output_ultrasound()
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let focus = emulator.center() + Vector3::new(0., 0., 150. * mm);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Focus {
            pos: focus,
            option: Default::default(),
        },
    ))?;
    autd.tick(Duration::from_millis(1))?;
    Ok(())
})?;

let mut sound_field = record.sound_field(
    RangeXY {
        x: focus.x - 20.0..=focus.x + 20.0,
        y: focus.y - 20.0..=focus.y + 20.0,
        z: focus.z,
        resolution: 1.,
    },
    InstantRecordOption {
        sound_speed: 340e3 * mm,
        time_step: Duration::from_micros(1),
        print_progress: true,
        memory_limits_hint_mb: 128,
        gpu: true,
    },
)?;

let df = sound_field.observe_points();
dbg!(df);

let df = sound_field
    .skip(Duration::from_micros(500))?
    .next(Duration::from_micros(500))?;
dbg!(df);
    Ok(())
}

NOTE: gpuオプションは, gpu featureを有効にしている場合のみ使用可能である.

import numpy as np
from pyautd3 import AUTD3, Focus, FocusOption, Silencer, Static, Duration
from pyautd3_emulator import Emulator, RangeXYZ, Recorder, InstantRecordOption

with Emulator([AUTD3()]) as emulator:
    focus = emulator.center() + np.array([0.0, 0.0, 150.0])

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Focus(pos=focus, option=FocusOption())))
        autd.tick(Duration.from_millis(1))

    record = emulator.record(f)

    sound_field = record.sound_field(
        RangeXYZ(
            x=(focus[0] - 20.0, focus[0] + 20.0),
            y=(focus[1] - 20.0, focus[1] + 20.0),
            z=(focus[2], focus[2]),
            resolution=1.0,
        ),
        InstantRecordOption(
            sound_speed=340e3,
            time_step=Duration.from_micros(1),
            print_progress=True,
            memory_limits_hint_mb=128,
            gpu=True,
        ),
    )

    df = sound_field.observe_points()
    print(df)

    df = sound_field.skip(Duration.from_micros(500)).next(
        Duration.from_micros(500),
    )
    print(df)

use autd3::prelude::*;
use autd3_emulator::*;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
let emulator = Emulator::new([AUTD3::default()]);

let focus = emulator.center() + Vector3::new(0., 0., 150. * mm);

let record = emulator.record(|autd| {
    autd.send(Silencer::disable())?;
    autd.send((
        Static { intensity: 0xFF },
        Focus {
            pos: focus,
            option: Default::default(),
        },
    ))?;
    autd.tick(Duration::from_micros(25))?;
    Ok(())
})?;

let mut sound_field = record.sound_field(
    RangeXY {
        x: focus.x - 20.0..=focus.x + 20.0,
        y: focus.y - 20.0..=focus.y + 20.0,
        z: focus.z,
        resolution: 1.,
    },
    RmsRecordOption {
        sound_speed: 340e3 * mm,
        print_progress: true,
        gpu: true,
    },
)?;

let df = sound_field.observe_points();
dbg!(df);

let df = sound_field.next(Duration::from_micros(25))?;
dbg!(df);
    Ok(())
}

NOTE: gpuオプションは, gpu featureを有効にしている場合のみ使用可能である.

import numpy as np
from pyautd3 import AUTD3, Duration, Focus, FocusOption, Silencer, Static
from pyautd3_emulator import Emulator, RangeXYZ, Recorder, RmsRecordOption

with Emulator([AUTD3()]) as emulator:
    focus = emulator.center() + np.array([0.0, 0.0, 150.0])

    def f(autd: Recorder) -> None:
        autd.send(Silencer.disable())
        autd.send((Static(), Focus(pos=focus, option=FocusOption())))
        autd.tick(Duration.from_micros(25))

    record = emulator.record(f)

    sound_field = record.sound_field(
        RangeXYZ(
            x=(focus[0] - 20.0, focus[0] + 20.0),
            y=(focus[1] - 20.0, focus[1] + 20.0),
            z=(focus[2], focus[2]),
            resolution=1.0,
        ),
        RmsRecordOption(
            sound_speed=340e3,
            print_progress=True,
            gpu=False,
        ),
    )

    df = sound_field.observe_points()
    print(df)

    df = sound_field.next(Duration.from_micros(25))
    print(df)

ログにはtracingを使用しているため, 以下のようにログ出力を有効化できる.

tracing_subscriber::fmt()
    .with_max_level(tracing::Level::INFO)
    .init();

RUST_LOG環境変数にautd3=<LEVEL>を設定した上で, tracing_initを呼び出すことでログ出力を有効化できる.

<LEVEL>には以下のいずれかを指定することができる. 下に行くほど詳細なログが出力される.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

#include <stdlib.h>

#ifdef WIN32
_putenv_s("RUST_LOG", "autd3=INFO");
#else
setenv("RUST_LOG", "autd3=INFO", false);
#endif

autd3::tracing_init();

RUST_LOG環境変数にautd3=<LEVEL>を設定した上で, Tracing.Initを呼び出すことでログ出力を有効化できる.

<LEVEL>には以下のいずれかを指定することができる. 下に行くほど詳細なログが出力される.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

System.Environment.SetEnvironmentVariable("RUST_LOG", "autd3=INFO");

AUTD3Sharp.Tracing.Init();

RUST_LOG環境変数にautd3=<LEVEL>を設定した上で, Tracing.Initの引数にログファイルへのパスを指定することでログ出力を有効化できる.

<LEVEL>には以下のいずれかを指定することができる. 下に行くほど詳細なログが出力される.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

System.Environment.SetEnvironmentVariable("RUST_LOG", "autd3=INFO");

AUTD3Sharp.Tracing.Init("<path to log file>");

また, AUTD3Sharp.Link.SOEMを使用する場合は, SOEMのログ出力を先に有効化すること.

AUTD3Sharp.Link.SOEM.Tracing.Init("<path to log file>");
AUTD3Sharp.Tracing.Init("<path to log file>");

RUST_LOG環境変数にautd3=<LEVEL>を設定した上で, tracing_initを呼び出すことでログ出力を有効化できる.

<LEVEL>には以下のいずれかを指定することができる. 下に行くほど詳細なログが出力される.

• ERROR
• WARN
• INFO
• DEBUG
• TRACE

from pyautd3 import tracing_init

os.environ["RUST_LOG"] = "autd3=INFO"

tracing_init()