MODULE Hello;
IMPORT 
    Out, 
    BubbleSort;

CONST 
    hello = "HELLO";
    m = 100000;
VAR 
    a : ARRAY m OF REAL;
    i : INTEGER;
    e : REAL;
BEGIN
    
    e := FLT(m);
    
    FOR i:=0 TO m - 1 DO
        a [ m  - i - 1 ] := e;
        e := e - 1.0;
    END;

    BubbleSort.Sort(a);
    
    Out.String(hello); 
    Out.Ln;
    
END Hello.

var m = 100_000;
var a = new double[m];
var s = (double)m;
for (var i = 0; i < m; i++)
{
    a[i] = s;
    s = s - 1;
}

Sort(a);

Console.WriteLine("HeLLO");

static void Sort(double[] a)
{
    var Swap = (ref double x, ref double y) =>
    {
        var t = x;
        x = y;
        y = t;
    };

    for (var i = 0; i < a.Length; i++)
        for (var j = 0; j < a.Length - 1 - i; j++)
            if (a[j + 1] < a[j])
                Swap(ref a[j + 1], ref a[j]);
}

let len = Array.length

let swap<'a> (arr: array<'a>, i, j) =
    let t = arr[i]
    arr[i] <- arr[j]
    arr[j] <- t

let sort arr =
    let ln = len(arr)
    for i = 0 to ln - 1 do
        for j = 0 to ln - 2 - i do
            if arr[j + 1] < arr[j] then
                swap (arr, j + 1, j)


let max = 100_000
let value = float(max)
let arr = Array.init max (fun i -> value - float (i))

sort arr
printfn "HELLO"

const std = @import("std");
const print = std.debug.print;

pub fn main() !void {
    const m = 100000;
    var arr: [m]f64 = undefined;
    var s: f64 = @floatCast(m);
    for (&arr) |*elem| {
        elem.* = s;
        s = s - 1.0;
    }
    //display(&arr);
    sort(&arr);
    print("HELLO\n", .{});
    // display(&arr);
}

fn swap(a: *f64, b: *f64) void {
    const t: f64 = a.*;
    a.* = b.*;
    b.* = t;
}

// fn display(a: []f64) void {
//     for (a) |value| {
//         print("{}\n", .{value});
//     }
// }

fn sort(a: []f64) void {
    var i: usize = 0;
    var j: usize = 0;
    while (i < a.len) : (i += 1) {
        j = 0;
        while (j < (a.len - 1 - i)) : (j += 1) {
            if (a[j + 1] < a[j]) {
                swap(&a[j + 1], &a[j]);
            }
        }
    }
}

static void Sort(double[] a)
{

    for (var i = 0; i < a.Length; i++)
        for (var j = 0; j < a.Length - 1 - i; j++)
            if (a[j + 1] < a[j])
                Swap(ref a[j + 1], ref a[j]);

//[MethodImpl(MethodImplOptions.AggressiveInlining)] можно попробовать. Хотя и так должен быть инлайнинг
     void Swap(ref double x, ref double y)
    {
        var t = x;
        x = y;
        y = t;
    }
  }

S>                Swap(ref a[j + 1], ref a[j]);

S>//[MethodImpl(MethodImplOptions.AggressiveInlining)] можно попробовать. Хотя и так должен быть инлайнинг
S>     void Swap(ref double x, ref double y)

S>>                Swap(ref a[j + 1], ref a[j]);

S>>//[MethodImpl(MethodImplOptions.AggressiveInlining)] можно попробовать. Хотя и так должен быть инлайнинг
S>>     void Swap(ref double x, ref double y)
_FR>

static void Sort(double[] a)
{
    var Swap = (ref double x, ref double y) =>
    {
        var t = x;
        x = y;
        y = t;
    };

    for (var i = 0; i < a.Length; i++)
        for (var j = 0; j < a.Length - 1 - i; j++)
            if (a[j + 1] < a[j])
                Swap(ref a[j + 1], ref a[j]);
}

using System.Diagnostics;

var m = 100_000;
var a = new double[m];
var s = (double)m;
for (var i = 0; i < m; i++)
{
    a[i] = s;
    s = s - 1;
}
var sw = new Stopwatch();
sw.Start();
Sort(a);

Console.WriteLine("HeLLO");
Console.WriteLine(sw.Elapsed);

static void Sort(double[] a)
{
    for (var i = 0; i < a.Length; i++)
        for (var j = 0; j < a.Length - 1 - i; j++)
            if (a[j + 1] < a[j])
            {
                var t = a[j+1];
                a[j + 1] = a[j];
                a[j] = t;
            }
}

(Measure-Command { dotnet run -c release | Out-Default }).ToString()

Р>(Measure-Command { dotnet run -c release | Out-Default }).ToString()

Р>

Исходный вариант автора в релизе — 9с, в дебаге — 30с
Ваш вариант: в релизе — 5,5с, в дебаге 26с
Вариант совсем без отдельного метода Swap: в релизе — 5,5с, в дебаге 21.5

Р>let sort arr =

Р>

let sort (arr: float array) = ()

S>for (var j = 0; j < a.Length - 1 - i; j++)
  {
    ref double current = ref a[j];
    ref double next = ref a[j + 1];
S>    if (next < current)
S>    {
S>        (next, current) = (current, next);
S>    }
  }

  [MethodImpl(MethodImplOptions.AggressiveInlining)]// можно попробовать. Хотя и так должен быть инлайнинг
   void Swap(ref double x, ref double y)

0) Expected statement 1 : 1

HELLO

real    2m37,695s
user    2m37,612s
sys    0m0,044s

/* Generated by Vostok - Oberon-07 translator */

#include <o7.h>

#include "Out.h"
#include "BubbleSort.h"

#define hello_cnst ((o7_char *)"HELLO")
#define m_cnst 100000

static double a[m_cnst];
static o7_int_t i;
static double e;

extern int main(int argc, char *argv[]) {
    o7_init(argc, argv);
    Out_init();
    BubbleSort_init();


    e = o7_flt(m_cnst);

    for (i = 0; i < m_cnst; ++i) {
        a[o7_ind(m_cnst, o7_sub(o7_sub(m_cnst, i), 1))] = e;
        e = o7_fsub(e, 1.0);
    }

    BubbleSort_Sort(m_cnst, a);

    Out_String(6, (o7_char *)"HELLO");
    Out_Ln();
    return o7_exit_code;
}

/* Generated by Vostok - Oberon-07 translator */

#include <o7.h>

#include "BubbleSort.h"

static void Sort_Swap(double *a, double *b) {
    double t;

    t = *a;
    *a = *b;
    *b = t;
}

extern void BubbleSort_Sort(o7_int_t a_len0, double a[/*len0*/]) {
    o7_int_t i, j;

    for (i = 0; i < a_len0; ++i) {
        for (j = 0; j <= o7_sub(o7_sub(a_len0, 2), i); ++j) {
            if (a[o7_ind(a_len0, o7_add(j, 1))] < a[o7_ind(a_len0, j)]) {
                Sort_Swap(&a[o7_ind(a_len0, o7_add(j, 1))], &a[o7_ind(a_len0, j)]);
            }
        }
    }
}