update examples

example/cs/Samples/Custom.cs

@@ -1,36 +1,26 @@
 using AUTD3Sharp;
+using AUTD3Sharp.Gain;
 using AUTD3Sharp.Modulation;
-using AUTD3Sharp.Derive;
-using AUTD3Sharp.Utils;
 using static AUTD3Sharp.Units;
 
 namespace Samples;
 
-[Gain]
-partial class MyFocus(Vector3d point)
-{
-    private Dictionary<int, Drive[]> Calc(Geometry geometry)
-    {
-        return Transform(geometry, (dev, tr) =>
-        {
-            var tp = tr.Position;
-            var dist = (tp - point).L2Norm;
-            var phase = Phase.FromRad(dist * dev.Wavenumber);
-            return new Drive { Phase = phase, Intensity = EmitIntensity.Max };
-        });
-    }
-}
-
-internal static class CustomTest
+internal static class TransTest
 {
     public static async Task Test<T>(Controller<T> autd)
     {
         var config = Silencer.Default();
         await autd.SendAsync(config);
 
         var m = new Sine(150 * Hz);
-        var g = new MyFocus(autd.Geometry.Center + new Vector3d(0, 0, 150));
-
+        var g = new Custom(
+            (dev, tr) => (dev.Idx, tr.Idx) switch
+            {
+                (0, 0) => new Drive(new Phase(0), EmitIntensity.Max),
+                (0, 248) => new Drive(new Phase(0), EmitIntensity.Max),
+                _ => Drive.Null
+            }
+        );
         await autd.SendAsync((m, g));
     }
 }

example/cs/Samples/SampleRunner.cs

@@ -17,9 +17,9 @@ public static async Task Run<T>(Controller<T> autd)
             (FocusSTMTest.Test, "FocusSTM test"),
             (GainSTMTest.Test, "GainSTM test"),
             (GainHoloTest.Test, "Multiple foci test"),
-            (CustomTest.Test, "Custom Gain & Modulation test"),
+            (UserDefinedTest.Test, "User-defined Gain & Modulation test"),
             (FlagTest.Test, "Flag test"),
-            (TransTest.Test, "TransducerTest test"),
+            (Custom.Test, "Custom gain test"),
             (GroupByTransducerTest.Test, "Group (by Transducer) test")
         };
         if (autd.Geometry.NumDevices >= 2) examples.Add((GroupByDeviceTest.Test, "Group (by Device) test"));

example/cs/Samples/UserDefined.cs

@@ -0,0 +1,36 @@
+using AUTD3Sharp;
+using AUTD3Sharp.Modulation;
+using AUTD3Sharp.Derive;
+using AUTD3Sharp.Utils;
+using static AUTD3Sharp.Units;
+
+namespace Samples;
+
+[Gain]
+partial class MyFocus(Vector3d point)
+{
+    private Dictionary<int, Drive[]> Calc(Geometry geometry)
+    {
+        return Transform(geometry, (dev, tr) =>
+        {
+            var tp = tr.Position;
+            var dist = (tp - point).L2Norm;
+            var phase = Phase.FromRad(dist * dev.Wavenumber);
+            return new Drive { Phase = phase, Intensity = EmitIntensity.Max };
+        });
+    }
+}
+
+internal static class UserDefinedTest
+{
+    public static async Task Test<T>(Controller<T> autd)
+    {
+        var config = Silencer.Default();
+        await autd.SendAsync(config);
+
+        var m = new Sine(150 * Hz);
+        var g = new MyFocus(autd.Geometry.Center + new Vector3d(0, 0, 150));
+
+        await autd.SendAsync((m, g));
+    }
+}

example/fs/Samples/BesselBeam.fs

@@ -5,12 +5,13 @@ open AUTD3Sharp
 open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation
 open AUTD3Sharp.Utils
+open type AUTD3Sharp.Units
 
 module BesselBeamTest =
     let Test<'T> (autd : Controller<'T>) = 
         (Silencer.Default()) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;
 
-        let m = new Sine 150;
+        let m = new Sine (150u * Hz);
 
         let start = autd.Geometry.Center;
         let dir = Vector3d.UnitZ;

example/fs/Samples/Flag.fs

@@ -3,6 +3,7 @@
 open AUTD3Sharp
 open System
 open System.Threading.Tasks
+open type AUTD3Sharp.Units
 
 module FlagTest =
     let Test<'T> (autd : Controller<'T>) = 

example/fs/Samples/FocusTest.fs

@@ -4,11 +4,12 @@ open AUTD3Sharp
 open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation
 open AUTD3Sharp.Utils
+open type AUTD3Sharp.Units
 
 module FocusTest =
     let Test<'T> (autd : Controller<'T>) = 
         (Silencer.Default()) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;
 
-        let m = new Sine 150;
+        let m = new Sine (150u * Hz);
         let g = new Focus(autd.Geometry.Center + Vector3d(0, 0, 150));
         (m, g) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;

example/fs/Samples/GainHoloTest.fs

@@ -4,17 +4,18 @@ open AUTD3Sharp
 open AUTD3Sharp.Gain.Holo
 open AUTD3Sharp.Modulation
 open AUTD3Sharp.Utils
+open type AUTD3Sharp.Units
 
 module GainHoloTest =
     let Test<'T> (autd : Controller<'T>) = 
         (Silencer.Default()) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;
 
-        let m = new Sine 150;
+        let m = new Sine (150u * Hz);
 
         let center = autd.Geometry.Center + Vector3d(0, 0, 150);
         let backend = new NalgebraBackend();
         let g = (new GSPAT<NalgebraBackend>(backend))
-                    .AddFocus(center + 20.0 * Vector3d.UnitX, 5e3 * Amplitude.Units.Pascal)
-                    .AddFocus(center - 20.0 * Vector3d.UnitX, 5e3 * Amplitude.Units.Pascal);
+                    .AddFocus(center + 20.0 * Vector3d.UnitX, 5e3 * Pa)
+                    .AddFocus(center - 20.0 * Vector3d.UnitX, 5e3 * Pa);
 
         (m, g) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;

example/fs/Samples/GroupTest.fs

@@ -4,6 +4,7 @@ open AUTD3Sharp
 open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation
 open AUTD3Sharp.Utils
+open type AUTD3Sharp.Units
 
 module GroupByDeviceTest =
     let Test<'T> (autd : Controller<'T>) = 
@@ -15,7 +16,7 @@ module GroupByDeviceTest =
                                 | _ ->  null
              )
             .Set("null", new Static(), new Null())
-            .Set("focus", new Sine(150 * Hz), new Focus(autd.Geometry.Center + new Vector3d(0,0,150)))
+            .Set("focus", new Sine(150u * Hz), new Focus(autd.Geometry.Center + new Vector3d(0,0,150)))
             .SendAsync()|> Async.AwaitTask |> Async.RunSynchronously |> ignore;
 
 module GroupByTransducerTest =
@@ -29,6 +30,6 @@ module GroupByTransducerTest =
         let grouping (dev: Device) (tr: Transducer) =
             if (tr.Position.X < cx) then "focus" :> obj else "null" :> obj
         let g = (new Group(grouping)).Set("focus", g1).Set("null", g2);
-        let m = new Sine(150 * Hz);
+        let m = new Sine(150u * Hz);
 
         (m, g) |> autd.SendAsync  |> Async.AwaitTask |> Async.RunSynchronously |> ignore;

example/fs/Samples/Plane.fs

@@ -4,11 +4,12 @@ open AUTD3Sharp
 open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation
 open AUTD3Sharp.Utils
+open type AUTD3Sharp.Units
 
 module PlaneTest =
     let Test<'T> (autd : Controller<'T>) = 
         (Silencer.Default()) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;
 
-        let m = new Sine(150 * Hz);
+        let m = new Sine(150u * Hz);
         let g = new Plane(new Vector3d(0,0,1));
         (m, g) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;

example/fs/Samples/STMTest.fs

@@ -6,6 +6,7 @@ open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation
 open AUTD3Sharp.Utils
 open System.Threading.Tasks
+open type AUTD3Sharp.Units
 
 module STMTest =
     let GainSTMTest<'T> (autd : Controller<'T>) = 
@@ -19,9 +20,8 @@ module STMTest =
             |> List.map (fun i -> (2.0 * Math.PI * (float)i / 200.0))
             |> List.map (fun theta -> (center + 30.0 * Vector3d(cos(theta), sin(theta), 0.0)))
             |> List.map (fun p -> (new Focus(p)))
-            |> List.fold (fun (acc: GainSTM) v -> acc.AddGain v) (GainSTM.FromFreq(1.))
+            |> List.fold (fun (acc: GainSTM) v -> acc.AddGain v) (GainSTM.FromFreq(1.0 * Hz))
 
-        printfn $"Actual frequency is {stm.Freq}";
         (stm )|> autd.SendAsync  |> Async.AwaitTask|> ignore
 
     let FocusSTMTest<'T> (autd : Controller<'T>) = 
@@ -34,7 +34,6 @@ module STMTest =
             [0..199]
             |> List.map (fun i -> (2.0 * Math.PI * (float)i / 200.0))
             |> List.map (fun theta -> (center + 30.0 * Vector3d(cos(theta), sin(theta), 0.0)))
-            |> List.fold (fun (acc: FocusSTM) v -> acc.AddFocus v) (FocusSTM.FromFreq(1.))
+            |> List.fold (fun (acc: FocusSTM) v -> acc.AddFocus v) (FocusSTM.FromFreq(1.0 * Hz))
 
-        printfn $"Actual frequency is {stm.Freq}";
         (stm)|> autd.SendAsync  |> Async.AwaitTask|> ignore

example/fs/Samples/Transtest.fs

@@ -3,14 +3,15 @@
 open AUTD3Sharp
 open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation
+open type AUTD3Sharp.Units
 
 module TransTest =
     let Test<'T> (autd : Controller<'T>) = 
         (Silencer.Default()) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;
 
-        let m = new Sine(150 * Hz);
-        let g = new TransducerTest(fun dev tr -> match (dev.Idx, tr.Idx) with
-                                                    | (0, 0) -> System.Nullable(new Drive(new Phase(byte(0)), EmitIntensity.Max))
-                                                    | (0, 248) -> System.Nullable(new Drive(new Phase(byte(0)), EmitIntensity.Max))
-                                                    | _ ->  System.Nullable());
+        let m = new Sine(150u * Hz);
+        let g = new Custom(fun dev tr -> match (dev.Idx, tr.Idx) with
+                                                    | (0, 0) -> new Drive(new Phase(byte(0)), EmitIntensity.Max)
+                                                    | (0, 248) -> new Drive(new Phase(byte(0)), EmitIntensity.Max)
+                                                    | _ ->  Drive.Null);
         (m, g) |> autd.SendAsync |> Async.AwaitTask |> Async.RunSynchronously |> ignore;

example/fs/Samples/Wav.fs

@@ -5,6 +5,7 @@ open AUTD3Sharp.Gain
 open AUTD3Sharp.Modulation.AudioFile
 open AUTD3Sharp.Utils
 open System.IO
+open type AUTD3Sharp.Units
 
 module WavTest =
     let Test<'T> (autd : Controller<'T>) =