HAXY

▄▄▄▄▀▄ ▄▀▀▀▀▀▀▀▀ ▄▄▄▄ ▀▀▀▀▀▄▀▀▀▀▄ ▄▀▀▀▀▀▄ ▀▀▀▀▀▄▄▄▀▀▀ ▄▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀▄▄ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▄▀▀ ▀▀▀▀▀▀ ▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▄ ▀▀▀ ▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▄ ▀▀▀ ▄▀▀▀▀▄▀▀▀▀▀▀▀▀▀▄▄▀▀▀ ▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▄▄▄▄▀ ▀▀ ▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▄▀▀▀▀ ▀ ▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▄▀▀▀▄ ▄▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀ ▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀▄▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▄ ▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▄▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▄▀▄▄▀▀▄▀▀ ▀▀▀▀▀▀▄▄▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀ ▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▄▄▄▀▀▀▀▄▀▀▀▄▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▄▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▄ ▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀ ▀▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀▀▀▀ ▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▄▄▀▀ ▀▀▀▄▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀▀ ▀ ▄▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▄▀ ▀▄ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▄▀▀▀▀▀▀ ▀▀ ▀▀▀▀▀▀▀▄▄▄▀▀▀▀▀▀▀▀▀▀▀▀ ▀ ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀

╭ floatop.zig ──────────────────────────────────────────────────╮ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ ╰───────────────────────────────────────────────────────────────╯

╭ find file ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╮ ╭────╮ ╭ clone ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╮ │ │ │http│ ssh │ │ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─╯ ╰────╯ ╰ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ╯

1 const std = @import("std"); 2 const builtin = @import("builtin"); 3 const expect = std.testing.expect; 4 const math = std.math; 5 6 const epsilon_16 = 0.002; 7 const epsilon = 0.000001; 8 9 fn epsForType(comptime T: type) T { 10 return switch (T) { 11 f16 => @as(f16, epsilon_16), 12 else => @as(T, epsilon), 13 }; 14 } 15 16 test "add f16" { 17 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 18 19 try testAdd(f16); 20 try comptime testAdd(f16); 21 } 22 23 test "add f32/f64" { 24 try testAdd(f32); 25 try comptime testAdd(f32); 26 try testAdd(f64); 27 try comptime testAdd(f64); 28 } 29 30 test "add f80/f128/c_longdouble" { 31 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 32 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 33 34 try testAdd(f80); 35 try comptime testAdd(f80); 36 try testAdd(f128); 37 try comptime testAdd(f128); 38 try testAdd(c_longdouble); 39 try comptime testAdd(c_longdouble); 40 } 41 42 fn testAdd(comptime T: type) !void { 43 var one_point_two_five: T = 1.25; 44 var two_point_seven_five: T = 2.75; 45 _ = &one_point_two_five; 46 _ = &two_point_seven_five; 47 try expect(one_point_two_five + two_point_seven_five == 4); 48 } 49 50 test "sub f16" { 51 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 52 53 try testSub(f16); 54 try comptime testSub(f16); 55 } 56 57 test "sub f32/f64" { 58 try testSub(f32); 59 try comptime testSub(f32); 60 try testSub(f64); 61 try comptime testSub(f64); 62 } 63 64 test "sub f80/f128/c_longdouble" { 65 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 66 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 67 68 try testSub(f80); 69 try comptime testSub(f80); 70 try testSub(f128); 71 try comptime testSub(f128); 72 try testSub(c_longdouble); 73 try comptime testSub(c_longdouble); 74 } 75 76 fn testSub(comptime T: type) !void { 77 var one_point_two_five: T = 1.25; 78 var two_point_seven_five: T = 2.75; 79 _ = &one_point_two_five; 80 _ = &two_point_seven_five; 81 try expect(one_point_two_five - two_point_seven_five == -1.5); 82 } 83 84 test "mul f16" { 85 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 86 87 try testMul(f16); 88 try comptime testMul(f16); 89 } 90 91 test "mul f32/f64" { 92 try testMul(f32); 93 try comptime testMul(f32); 94 try testMul(f64); 95 try comptime testMul(f64); 96 } 97 98 test "mul f80/f128/c_longdouble" { 99 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 100 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 101 102 try testMul(f80); 103 try comptime testMul(f80); 104 try testMul(f128); 105 try comptime testMul(f128); 106 try testMul(c_longdouble); 107 try comptime testMul(c_longdouble); 108 } 109 110 fn testMul(comptime T: type) !void { 111 var one_point_two_five: T = 1.25; 112 var two_point_seven_five: T = 2.75; 113 _ = &one_point_two_five; 114 _ = &two_point_seven_five; 115 try expect(one_point_two_five * two_point_seven_five == 3.4375); 116 } 117 118 test "cmp f16" { 119 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 120 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 121 122 try testCmp(f16); 123 try comptime testCmp(f16); 124 } 125 126 test "cmp f32" { 127 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 128 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 129 if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 130 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 131 132 try testCmp(f32); 133 try comptime testCmp(f32); 134 } 135 136 test "cmp f64" { 137 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 138 if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 139 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 140 141 try testCmp(f64); 142 try comptime testCmp(f64); 143 } 144 145 test "cmp f128" { 146 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 147 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 148 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 149 150 try testCmp(f128); 151 try comptime testCmp(f128); 152 } 153 154 test "cmp f80/c_longdouble" { 155 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 156 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 157 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 158 159 try testCmp(f80); 160 try comptime testCmp(f80); 161 try testCmp(c_longdouble); 162 try comptime testCmp(c_longdouble); 163 } 164 165 fn testCmp(comptime T: type) !void { 166 { 167 // No decimal part 168 var x: T = 1.0; 169 _ = &x; 170 try expect(x == 1.0); 171 try expect(x != 0.0); 172 try expect(x > 0.0); 173 try expect(x < 2.0); 174 try expect(x >= 1.0); 175 try expect(x <= 1.0); 176 } 177 { 178 // Non-zero decimal part 179 var x: T = 1.5; 180 _ = &x; 181 try expect(x != 1.0); 182 try expect(x != 2.0); 183 try expect(x > 1.0); 184 try expect(x < 2.0); 185 try expect(x >= 1.0); 186 try expect(x <= 2.0); 187 } 188 189 @setEvalBranchQuota(2_000); 190 var edges = [_]T{ 191 -math.inf(T), 192 -math.floatMax(T), 193 -math.floatMin(T), 194 -math.floatTrueMin(T), 195 -0.0, 196 math.nan(T), 197 0.0, 198 math.floatTrueMin(T), 199 math.floatMin(T), 200 math.floatMax(T), 201 math.inf(T), 202 }; 203 _ = &edges; 204 for (edges, 0..) |rhs, rhs_i| { 205 for (edges, 0..) |lhs, lhs_i| { 206 const no_nan = lhs_i != 5 and rhs_i != 5; 207 const lhs_order = if (lhs_i < 5) lhs_i else lhs_i - 2; 208 const rhs_order = if (rhs_i < 5) rhs_i else rhs_i - 2; 209 try expect((lhs == rhs) == (no_nan and lhs_order == rhs_order)); 210 try expect((lhs != rhs) == !(no_nan and lhs_order == rhs_order)); 211 try expect((lhs < rhs) == (no_nan and lhs_order < rhs_order)); 212 try expect((lhs > rhs) == (no_nan and lhs_order > rhs_order)); 213 try expect((lhs <= rhs) == (no_nan and lhs_order <= rhs_order)); 214 try expect((lhs >= rhs) == (no_nan and lhs_order >= rhs_order)); 215 } 216 } 217 } 218 219 test "vector cmp f16" { 220 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 221 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 222 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 223 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; 224 225 try testCmpVector(f16); 226 try comptime testCmpVector(f16); 227 } 228 229 test "vector cmp f32" { 230 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 231 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 232 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 233 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 234 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isArm()) return error.SkipZigTest; 235 if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 236 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 237 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/214198 238 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; 239 240 try testCmpVector(f32); 241 try comptime testCmpVector(f32); 242 } 243 244 test "vector cmp f64" { 245 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 246 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 247 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 248 if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 249 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isAarch64() and builtin.os.tag == .netbsd) return error.SkipZigTest; // https://codeberg.org/ziglang/zig/issues/36765 250 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; 251 252 try testCmpVector(f64); 253 try comptime testCmpVector(f64); 254 } 255 256 test "vector cmp f128" { 257 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 258 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 259 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 260 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 261 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/214198 262 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; 263 264 try testCmpVector(f128); 265 try comptime testCmpVector(f128); 266 } 267 268 test "vector cmp f80/c_longdouble" { 269 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 270 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .hexagon) return error.SkipZigTest; 271 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest; // https://github.com/llvm/llvm-project/issues/214198 272 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 273 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 274 275 try testCmpVector(f80); 276 try comptime testCmpVector(f80); 277 try testCmpVector(c_longdouble); 278 try comptime testCmpVector(c_longdouble); 279 } 280 281 fn testCmpVector(comptime T: type) !void { 282 @setEvalBranchQuota(2_000); 283 var edges = [_]T{ 284 -math.inf(T), 285 -math.floatMax(T), 286 -math.floatMin(T), 287 -math.floatTrueMin(T), 288 -0.0, 289 math.nan(T), 290 0.0, 291 math.floatTrueMin(T), 292 math.floatMin(T), 293 math.floatMax(T), 294 math.inf(T), 295 }; 296 _ = &edges; 297 for (edges, 0..) |rhs, rhs_i| { 298 const rhs_v: @Vector(4, T) = .{ rhs, rhs, rhs, rhs }; 299 for (edges, 0..) |lhs, lhs_i| { 300 const no_nan = lhs_i != 5 and rhs_i != 5; 301 const lhs_order = if (lhs_i < 5) lhs_i else lhs_i - 2; 302 const rhs_order = if (rhs_i < 5) rhs_i else rhs_i - 2; 303 const lhs_v: @Vector(4, T) = .{ lhs, lhs, lhs, lhs }; 304 try expect(@reduce(.And, (lhs_v == rhs_v)) == (no_nan and lhs_order == rhs_order)); 305 try expect(@reduce(.And, (lhs_v != rhs_v)) == !(no_nan and lhs_order == rhs_order)); 306 try expect(@reduce(.And, (lhs_v < rhs_v)) == (no_nan and lhs_order < rhs_order)); 307 try expect(@reduce(.And, (lhs_v > rhs_v)) == (no_nan and lhs_order > rhs_order)); 308 try expect(@reduce(.And, (lhs_v <= rhs_v)) == (no_nan and lhs_order <= rhs_order)); 309 try expect(@reduce(.And, (lhs_v >= rhs_v)) == (no_nan and lhs_order >= rhs_order)); 310 } 311 } 312 } 313 314 test "different sized float comparisons" { 315 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 316 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 317 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 318 319 try testDifferentSizedFloatComparisons(); 320 try comptime testDifferentSizedFloatComparisons(); 321 } 322 323 fn testDifferentSizedFloatComparisons() !void { 324 var a: f16 = 1; 325 var b: f64 = 2; 326 _ = .{ &a, &b }; 327 try expect(a < b); 328 } 329 330 // TODO This is waiting on library support for the Windows build (not sure why the other's don't need it) 331 //test "@nearbyint" { 332 // comptime testNearbyInt(); 333 // testNearbyInt(); 334 //} 335 336 //fn testNearbyInt() void { 337 // // TODO test f16, f128, and c_longdouble 338 // // https://github.com/ziglang/zig/issues/4026 339 // { 340 // var a: f32 = 2.1; 341 // try expect(@nearbyint(a) == 2); 342 // } 343 // { 344 // var a: f64 = -3.75; 345 // try expect(@nearbyint(a) == -4); 346 // } 347 //} 348 349 test "negative f128 intFromFloat at compile-time" { 350 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 351 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 352 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 353 354 const a: f128 = -2; 355 var b: i64 = @intFromFloat(a); 356 _ = &b; 357 try expect(@as(i64, -2) == b); 358 } 359 360 test "@sqrt f16" { 361 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 362 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 363 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 364 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 365 366 try testSqrt(f16); 367 try comptime testSqrt(f16); 368 } 369 370 test "@sqrt f32/f64" { 371 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 372 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 373 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 374 375 try testSqrt(f32); 376 try comptime testSqrt(f32); 377 try testSqrt(f64); 378 try comptime testSqrt(f64); 379 } 380 381 test "@sqrt f80/f128/c_longdouble" { 382 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 383 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 384 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 385 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 386 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; 387 388 try testSqrt(f80); 389 try comptime testSqrt(f80); 390 try testSqrt(f128); 391 try comptime testSqrt(f128); 392 try testSqrt(c_longdouble); 393 try comptime testSqrt(c_longdouble); 394 } 395 396 fn testSqrt(comptime T: type) !void { 397 const eps = epsForType(T); 398 var four: T = 4.0; 399 try expect(@sqrt(four) == 2.0); 400 var nine: T = 9.0; 401 try expect(@sqrt(nine) == 3.0); 402 var twenty_five: T = 25.0; 403 try expect(@sqrt(twenty_five) == 5.0); 404 var sixty_four: T = 64.0; 405 try expect(@sqrt(sixty_four) == 8.0); 406 var one_point_one: T = 1.1; 407 408 try expect(math.approxEqAbs(T, @sqrt(one_point_one), 1.0488088481701516, eps)); 409 var two: T = 2.0; 410 try expect(math.approxEqAbs(T, @sqrt(two), 1.4142135623730950, eps)); 411 var three_point_six: T = 3.6; 412 try expect(math.approxEqAbs(T, @sqrt(three_point_six), 1.8973665961010276, eps)); 413 var sixty_four_point_one: T = 64.1; 414 try expect(math.approxEqAbs(T, @sqrt(sixty_four_point_one), 8.00624756049923802, eps)); 415 var twelve: T = 12.0; 416 try expect(math.approxEqAbs(T, @sqrt(twelve), 3.46410161513775459, eps)); 417 var thirteen: T = 13.0; 418 try expect(math.approxEqAbs(T, @sqrt(thirteen), 3.60555127546398929, eps)); 419 var fourteen: T = 14.0; 420 try expect(math.approxEqAbs(T, @sqrt(fourteen), 3.74165738677394139, eps)); 421 var a: T = 7.539840; 422 try expect(math.approxEqAbs(T, @sqrt(a), 2.74587690911300684, eps)); 423 var b: T = 19.230934; 424 try expect(math.approxEqAbs(T, @sqrt(b), 4.38530888307767894, eps)); 425 var c: T = 8942.230469; 426 try expect(math.approxEqAbs(T, @sqrt(c), 94.5633674791671111, eps)); 427 428 // special cases 429 var inf: T = math.inf(T); 430 try expect(math.isPositiveInf(@sqrt(inf))); 431 var zero: T = 0.0; 432 try expect(math.isPositiveZero(@sqrt(zero))); 433 var neg_zero: T = -0.0; 434 try expect(math.isNegativeZero(@sqrt(neg_zero))); 435 var neg_one: T = -1.0; 436 try expect(math.isNan(@sqrt(neg_one))); 437 var nan: T = math.nan(T); 438 try expect(math.isNan(@sqrt(nan))); 439 440 _ = .{ 441 &four, 442 &nine, 443 &twenty_five, 444 &sixty_four, 445 &one_point_one, 446 &two, 447 &three_point_six, 448 &sixty_four_point_one, 449 &twelve, 450 &thirteen, 451 &fourteen, 452 &a, 453 &b, 454 &c, 455 &inf, 456 &zero, 457 &neg_zero, 458 &neg_one, 459 &nan, 460 }; 461 } 462 463 test "@sqrt with vectors" { 464 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 465 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 466 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 467 468 try testSqrtWithVectors(); 469 try comptime testSqrtWithVectors(); 470 } 471 472 fn testSqrtWithVectors() !void { 473 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; 474 _ = &v; 475 const result = @sqrt(v); 476 try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 1.1)), result[0], epsilon)); 477 try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 2.2)), result[1], epsilon)); 478 try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 3.3)), result[2], epsilon)); 479 try expect(math.approxEqAbs(f32, @sqrt(@as(f32, 4.4)), result[3], epsilon)); 480 } 481 482 test "@sin f16" { 483 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 484 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 485 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 486 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 487 488 try testSin(f16); 489 try comptime testSin(f16); 490 } 491 492 test "@sin f32/f64" { 493 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 494 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 495 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 496 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 497 498 try testSin(f32); 499 comptime try testSin(f32); 500 try testSin(f64); 501 comptime try testSin(f64); 502 } 503 504 test "@sin f80/f128/c_longdouble" { 505 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 506 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 507 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 508 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 509 510 try testSin(f80); 511 comptime try testSin(f80); 512 try testSin(f128); 513 comptime try testSin(f128); 514 try testSin(c_longdouble); 515 comptime try testSin(c_longdouble); 516 } 517 518 fn testSin(comptime T: type) !void { 519 const eps = epsForType(T); 520 var zero: T = 0; 521 _ = &zero; 522 try expect(@sin(zero) == 0); 523 var pi: T = math.pi; 524 _ = π 525 try expect(math.approxEqAbs(T, @sin(pi), 0, eps)); 526 try expect(math.approxEqAbs(T, @sin(pi / 2.0), 1, eps)); 527 try expect(math.approxEqAbs(T, @sin(pi / 4.0), 0.7071067811865475, eps)); 528 } 529 530 test "@sin with vectors" { 531 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 532 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 533 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 534 535 try testSinWithVectors(); 536 try comptime testSinWithVectors(); 537 } 538 539 fn testSinWithVectors() !void { 540 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; 541 _ = &v; 542 const result = @sin(v); 543 try expect(math.approxEqAbs(f32, @sin(@as(f32, 1.1)), result[0], epsilon)); 544 try expect(math.approxEqAbs(f32, @sin(@as(f32, 2.2)), result[1], epsilon)); 545 try expect(math.approxEqAbs(f32, @sin(@as(f32, 3.3)), result[2], epsilon)); 546 try expect(math.approxEqAbs(f32, @sin(@as(f32, 4.4)), result[3], epsilon)); 547 } 548 549 test "@cos f16" { 550 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 551 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 552 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 553 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 554 555 try testCos(f16); 556 try comptime testCos(f16); 557 } 558 559 test "@cos f32/f64" { 560 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 561 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 562 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 563 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 564 565 try testCos(f32); 566 try comptime testCos(f32); 567 try testCos(f64); 568 try comptime testCos(f64); 569 } 570 571 test "@cos f80/f128/c_longdouble" { 572 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 573 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 574 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 575 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 576 577 try testCos(f80); 578 try comptime testCos(f80); 579 try testCos(f128); 580 try comptime testCos(f128); 581 try testCos(c_longdouble); 582 try comptime testCos(c_longdouble); 583 } 584 585 fn testCos(comptime T: type) !void { 586 const eps = epsForType(T); 587 var zero: T = 0; 588 _ = &zero; 589 try expect(@cos(zero) == 1); 590 var pi: T = math.pi; 591 _ = π 592 try expect(math.approxEqAbs(T, @cos(pi), -1, eps)); 593 try expect(math.approxEqAbs(T, @cos(pi / 2.0), 0, eps)); 594 try expect(math.approxEqAbs(T, @cos(pi / 4.0), 0.7071067811865475, eps)); 595 } 596 597 test "@cos with vectors" { 598 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 599 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 600 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 601 602 try testCosWithVectors(); 603 try comptime testCosWithVectors(); 604 } 605 606 fn testCosWithVectors() !void { 607 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; 608 _ = &v; 609 const result = @cos(v); 610 try expect(math.approxEqAbs(f32, @cos(@as(f32, 1.1)), result[0], epsilon)); 611 try expect(math.approxEqAbs(f32, @cos(@as(f32, 2.2)), result[1], epsilon)); 612 try expect(math.approxEqAbs(f32, @cos(@as(f32, 3.3)), result[2], epsilon)); 613 try expect(math.approxEqAbs(f32, @cos(@as(f32, 4.4)), result[3], epsilon)); 614 } 615 616 test "@tan f16" { 617 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 618 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 619 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 620 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 621 622 try testTan(f16); 623 try comptime testTan(f16); 624 } 625 626 test "@tan f32/f64" { 627 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 628 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 629 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 630 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 631 632 try testTan(f32); 633 try comptime testTan(f32); 634 try testTan(f64); 635 try comptime testTan(f64); 636 } 637 638 test "@tan f80/f128/c_longdouble" { 639 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 640 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 641 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 642 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 643 644 try testTan(f80); 645 try comptime testTan(f80); 646 try testTan(f128); 647 try comptime testTan(f128); 648 try testTan(c_longdouble); 649 try comptime testTan(c_longdouble); 650 } 651 652 fn testTan(comptime T: type) !void { 653 const eps = epsForType(T); 654 var zero: T = 0; 655 _ = &zero; 656 try expect(@tan(zero) == 0); 657 var pi: T = math.pi; 658 _ = π 659 try expect(math.approxEqAbs(T, @tan(pi), 0, eps)); 660 try expect(math.approxEqAbs(T, @tan(pi / 3.0), 1.732050807568878, eps)); 661 try expect(math.approxEqAbs(T, @tan(pi / 4.0), 1, eps)); 662 } 663 664 test "@tan with vectors" { 665 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 666 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 667 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 668 669 try testTanWithVectors(); 670 try comptime testTanWithVectors(); 671 } 672 673 fn testTanWithVectors() !void { 674 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 3.3, 4.4 }; 675 _ = &v; 676 const result = @tan(v); 677 try expect(math.approxEqAbs(f32, @tan(@as(f32, 1.1)), result[0], epsilon)); 678 try expect(math.approxEqAbs(f32, @tan(@as(f32, 2.2)), result[1], epsilon)); 679 try expect(math.approxEqAbs(f32, @tan(@as(f32, 3.3)), result[2], epsilon)); 680 try expect(math.approxEqAbs(f32, @tan(@as(f32, 4.4)), result[3], epsilon)); 681 } 682 683 test "@exp f16" { 684 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 685 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 686 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 687 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 688 689 try testExp(f16); 690 try comptime testExp(f16); 691 } 692 693 test "@exp f32/f64" { 694 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 695 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 696 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 697 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 698 699 try testExp(f32); 700 try comptime testExp(f32); 701 try testExp(f64); 702 try comptime testExp(f64); 703 } 704 705 test "@exp f80/f128/c_longdouble" { 706 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 707 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 708 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 709 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 710 711 try testExp(f80); 712 try comptime testExp(f80); 713 try testExp(f128); 714 try comptime testExp(f128); 715 try testExp(c_longdouble); 716 try comptime testExp(c_longdouble); 717 } 718 719 fn testExp(comptime T: type) !void { 720 const eps = epsForType(T); 721 722 var zero: T = 0; 723 _ = &zero; 724 try expect(@exp(zero) == 1); 725 726 var two: T = 2; 727 _ = &two; 728 try expect(math.approxEqAbs(T, @exp(two), 7.389056098930650, eps)); 729 730 var five: T = 5; 731 _ = &five; 732 try expect(math.approxEqAbs(T, @exp(five), 148.4131591025766, eps)); 733 } 734 735 test "@exp with vectors" { 736 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 737 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 738 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 739 740 try testExpWithVectors(); 741 try comptime testExpWithVectors(); 742 } 743 744 fn testExpWithVectors() !void { 745 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; 746 _ = &v; 747 const result = @exp(v); 748 try expect(math.approxEqAbs(f32, @exp(@as(f32, 1.1)), result[0], epsilon)); 749 try expect(math.approxEqAbs(f32, @exp(@as(f32, 2.2)), result[1], epsilon)); 750 try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.3)), result[2], epsilon)); 751 try expect(math.approxEqAbs(f32, @exp(@as(f32, 0.4)), result[3], epsilon)); 752 } 753 754 test "@exp2 f16" { 755 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 756 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 757 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 758 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 759 760 try testExp2(f16); 761 try comptime testExp2(f16); 762 } 763 764 test "@exp2 f32/f64" { 765 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 766 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 767 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 768 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 769 770 try testExp2(f32); 771 try comptime testExp2(f32); 772 try testExp2(f64); 773 try comptime testExp2(f64); 774 } 775 776 test "@exp2 f80/f128/c_longdouble" { 777 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 778 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 779 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 780 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 781 782 try testExp2(f80); 783 try comptime testExp2(f80); 784 try testExp2(f128); 785 try comptime testExp2(f128); 786 try testExp2(c_longdouble); 787 try comptime testExp2(c_longdouble); 788 } 789 790 fn testExp2(comptime T: type) !void { 791 const eps = epsForType(T); 792 var two: T = 2; 793 try expect(@exp2(two) == 4); 794 var one_point_five: T = 1.5; 795 try expect(math.approxEqAbs(T, @exp2(one_point_five), 2.8284271247462, eps)); 796 var four_point_five: T = 4.5; 797 try expect(math.approxEqAbs(T, @exp2(four_point_five), 22.627416997969, eps)); 798 _ = .{ &two, &one_point_five, &four_point_five }; 799 } 800 801 test "@exp2 with @vectors" { 802 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 803 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 804 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 805 806 try testExp2WithVectors(); 807 try comptime testExp2WithVectors(); 808 } 809 810 fn testExp2WithVectors() !void { 811 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; 812 _ = &v; 813 const result = @exp2(v); 814 try expect(math.approxEqAbs(f32, @exp2(@as(f32, 1.1)), result[0], epsilon)); 815 try expect(math.approxEqAbs(f32, @exp2(@as(f32, 2.2)), result[1], epsilon)); 816 try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.3)), result[2], epsilon)); 817 try expect(math.approxEqAbs(f32, @exp2(@as(f32, 0.4)), result[3], epsilon)); 818 } 819 820 test "@log f16" { 821 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 822 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 823 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 824 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 825 826 try testLog(f16); 827 try comptime testLog(f16); 828 } 829 830 test "@log f32/f64" { 831 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 832 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 833 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 834 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 835 836 try testLog(f32); 837 try comptime testLog(f32); 838 try testLog(f64); 839 try comptime testLog(f64); 840 } 841 842 test "@log f80/f128/c_longdouble" { 843 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 844 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 845 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 846 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 847 848 try testLog(f80); 849 try comptime testLog(f80); 850 try testLog(f128); 851 try comptime testLog(f128); 852 try testLog(c_longdouble); 853 try comptime testLog(c_longdouble); 854 } 855 856 fn testLog(comptime T: type) !void { 857 const eps = epsForType(T); 858 var e: T = math.e; 859 try expect(math.approxEqAbs(T, @log(e), 1, eps)); 860 var two: T = 2; 861 try expect(math.approxEqAbs(T, @log(two), 0.6931471805599, eps)); 862 var five: T = 5; 863 try expect(math.approxEqAbs(T, @log(five), 1.6094379124341, eps)); 864 _ = .{ &e, &two, &five }; 865 } 866 867 test "@log with @vectors" { 868 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 869 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 870 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 871 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 872 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 873 874 { 875 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; 876 _ = &v; 877 const result = @log(v); 878 try expect(@log(@as(f32, 1.1)) == result[0]); 879 try expect(@log(@as(f32, 2.2)) == result[1]); 880 try expect(@log(@as(f32, 0.3)) == result[2]); 881 try expect(@log(@as(f32, 0.4)) == result[3]); 882 } 883 } 884 885 test "@log2 f16" { 886 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 887 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 888 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 889 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 890 891 try testLog2(f16); 892 try comptime testLog2(f16); 893 } 894 895 test "@log2 f32/f64" { 896 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 897 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 898 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 899 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 900 901 try testLog2(f32); 902 try comptime testLog2(f32); 903 try testLog2(f64); 904 try comptime testLog2(f64); 905 } 906 907 test "@log2 f80/f128/c_longdouble" { 908 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 909 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 910 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 911 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 912 913 try testLog2(f80); 914 try comptime testLog2(f80); 915 try testLog2(f128); 916 try comptime testLog2(f128); 917 try testLog2(c_longdouble); 918 try comptime testLog2(c_longdouble); 919 } 920 921 fn testLog2(comptime T: type) !void { 922 const eps = epsForType(T); 923 var four: T = 4; 924 try expect(@log2(four) == 2); 925 var six: T = 6; 926 try expect(math.approxEqAbs(T, @log2(six), 2.5849625007212, eps)); 927 var ten: T = 10; 928 try expect(math.approxEqAbs(T, @log2(ten), 3.3219280948874, eps)); 929 _ = .{ &four, &six, &ten }; 930 } 931 932 test "@log2 with vectors" { 933 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 934 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 935 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 936 // https://github.com/ziglang/zig/issues/13681 937 if (builtin.zig_backend == .stage2_llvm and 938 builtin.cpu.arch == .aarch64 and 939 builtin.os.tag == .windows) return error.SkipZigTest; 940 941 if (builtin.os.tag == .windows and builtin.cpu.arch == .x86 and builtin.abi == .msvc) { 942 // https://codeberg.org/ziglang/zig/issues/35518 943 return error.SkipZigTest; 944 } 945 946 try testLog2WithVectors(); 947 try comptime testLog2WithVectors(); 948 } 949 950 fn testLog2WithVectors() !void { 951 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; 952 _ = &v; 953 const result = @log2(v); 954 try expect(@log2(@as(f32, 1.1)) == result[0]); 955 try expect(@log2(@as(f32, 2.2)) == result[1]); 956 try expect(@log2(@as(f32, 0.3)) == result[2]); 957 try expect(@log2(@as(f32, 0.4)) == result[3]); 958 } 959 960 test "@log10 f16" { 961 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 962 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 963 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 964 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 965 966 try testLog10(f16); 967 try comptime testLog10(f16); 968 } 969 970 test "@log10 f32/f64" { 971 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 972 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 973 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 974 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 975 976 try testLog10(f32); 977 try comptime testLog10(f32); 978 try testLog10(f64); 979 try comptime testLog10(f64); 980 } 981 982 test "@log10 f80/f128/c_longdouble" { 983 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 984 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 985 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 986 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 987 988 try testLog10(f80); 989 try comptime testLog10(f80); 990 try testLog10(f128); 991 try comptime testLog10(f128); 992 try testLog10(c_longdouble); 993 try comptime testLog10(c_longdouble); 994 } 995 996 fn testLog10(comptime T: type) !void { 997 const eps = epsForType(T); 998 var hundred: T = 100; 999 try expect(@log10(hundred) == 2); 1000 var fifteen: T = 15; 1001 try expect(math.approxEqAbs(T, @log10(fifteen), 1.176091259056, eps)); 1002 var fifty: T = 50; 1003 try expect(math.approxEqAbs(T, @log10(fifty), 1.698970004336, eps)); 1004 _ = .{ &hundred, &fifteen, &fifty }; 1005 } 1006 1007 test "@log10 with vectors" { 1008 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 1009 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1010 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1011 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1012 1013 try testLog10WithVectors(); 1014 try comptime testLog10WithVectors(); 1015 } 1016 1017 fn testLog10WithVectors() !void { 1018 var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 }; 1019 _ = &v; 1020 const result = @log10(v); 1021 try expect(@log10(@as(f32, 1.1)) == result[0]); 1022 try expect(@log10(@as(f32, 2.2)) == result[1]); 1023 try expect(@log10(@as(f32, 0.3)) == result[2]); 1024 try expect(@log10(@as(f32, 0.4)) == result[3]); 1025 } 1026 1027 test "@abs f16" { 1028 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1029 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1030 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1031 1032 try testFabs(f16); 1033 try comptime testFabs(f16); 1034 } 1035 1036 test "@abs f32/f64" { 1037 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1038 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1039 1040 try testFabs(f32); 1041 try comptime testFabs(f32); 1042 try testFabs(f64); 1043 try comptime testFabs(f64); 1044 } 1045 1046 test "@abs f80/f128/c_longdouble" { 1047 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1048 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1049 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1050 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1051 1052 try testFabs(f80); 1053 try comptime testFabs(f80); 1054 try testFabs(f128); 1055 try comptime testFabs(f128); 1056 try testFabs(c_longdouble); 1057 try comptime testFabs(c_longdouble); 1058 } 1059 1060 fn testFabs(comptime T: type) !void { 1061 var two_point_five: T = 2.5; 1062 try expect(@abs(two_point_five) == 2.5); 1063 var neg_two_point_five: T = -2.5; 1064 try expect(@abs(neg_two_point_five) == 2.5); 1065 1066 var twelve: T = 12.0; 1067 try expect(@abs(twelve) == 12.0); 1068 var neg_fourteen: T = -14.0; 1069 try expect(@abs(neg_fourteen) == 14.0); 1070 1071 // normals 1072 var one: T = 1.0; 1073 try expect(@abs(one) == 1.0); 1074 var neg_one: T = -1.0; 1075 try expect(@abs(neg_one) == 1.0); 1076 var min: T = math.floatMin(T); 1077 try expect(@abs(min) == math.floatMin(T)); 1078 var neg_min: T = -math.floatMin(T); 1079 try expect(@abs(neg_min) == math.floatMin(T)); 1080 var max: T = math.floatMax(T); 1081 try expect(@abs(max) == math.floatMax(T)); 1082 var neg_max: T = -math.floatMax(T); 1083 try expect(@abs(neg_max) == math.floatMax(T)); 1084 1085 // subnormals 1086 var zero: T = 0.0; 1087 try expect(@abs(zero) == 0.0); 1088 var neg_zero: T = -0.0; 1089 try expect(@abs(neg_zero) == 0.0); 1090 var true_min: T = math.floatTrueMin(T); 1091 try expect(@abs(true_min) == math.floatTrueMin(T)); 1092 var neg_true_min: T = -math.floatTrueMin(T); 1093 try expect(@abs(neg_true_min) == math.floatTrueMin(T)); 1094 1095 // non-finite numbers 1096 var inf: T = math.inf(T); 1097 try expect(math.isPositiveInf(@abs(inf))); 1098 var neg_inf: T = -math.inf(T); 1099 try expect(math.isPositiveInf(@abs(neg_inf))); 1100 var nan: T = math.nan(T); 1101 try expect(math.isNan(@abs(nan))); 1102 1103 _ = .{ 1104 &two_point_five, 1105 &neg_two_point_five, 1106 &twelve, 1107 &neg_fourteen, 1108 &one, 1109 &neg_one, 1110 &min, 1111 &neg_min, 1112 &max, 1113 &neg_max, 1114 &zero, 1115 &neg_zero, 1116 &true_min, 1117 &neg_true_min, 1118 &inf, 1119 &neg_inf, 1120 &nan, 1121 }; 1122 } 1123 1124 test "@abs with vectors" { 1125 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 1126 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1127 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1128 1129 try testFabsWithVectors(); 1130 try comptime testFabsWithVectors(); 1131 } 1132 1133 fn testFabsWithVectors() !void { 1134 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; 1135 _ = &v; 1136 const result = @abs(v); 1137 try expect(math.approxEqAbs(f32, @abs(@as(f32, 1.1)), result[0], epsilon)); 1138 try expect(math.approxEqAbs(f32, @abs(@as(f32, -2.2)), result[1], epsilon)); 1139 try expect(math.approxEqAbs(f32, @abs(@as(f32, 0.3)), result[2], epsilon)); 1140 try expect(math.approxEqAbs(f32, @abs(@as(f32, -0.4)), result[3], epsilon)); 1141 } 1142 1143 test "@floor f16" { 1144 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1145 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1146 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1147 1148 try testFloor(f16); 1149 try comptime testFloor(f16); 1150 } 1151 1152 test "@floor f32/f64" { 1153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1154 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1155 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1156 1157 try testFloor(f32); 1158 try comptime testFloor(f32); 1159 try testFloor(f64); 1160 try comptime testFloor(f64); 1161 } 1162 1163 test "@floor f80/f128/c_longdouble" { 1164 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1165 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1166 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1167 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1168 1169 try testFloor(f80); 1170 try comptime testFloor(f80); 1171 try testFloor(f128); 1172 try comptime testFloor(f128); 1173 try testFloor(c_longdouble); 1174 try comptime testFloor(c_longdouble); 1175 } 1176 1177 fn testFloor(comptime T: type) !void { 1178 var two_point_one: T = 2.1; 1179 try expect(@floor(two_point_one) == 2.0); 1180 var neg_two_point_one: T = -2.1; 1181 try expect(@floor(neg_two_point_one) == -3.0); 1182 var three_point_five: T = 3.5; 1183 try expect(@floor(three_point_five) == 3.0); 1184 var neg_three_point_five: T = -3.5; 1185 try expect(@floor(neg_three_point_five) == -4.0); 1186 var twelve: T = 12.0; 1187 try expect(@floor(twelve) == 12.0); 1188 var neg_twelve: T = -12.0; 1189 try expect(@floor(neg_twelve) == -12.0); 1190 var fourteen_point_seven: T = 14.7; 1191 try expect(@floor(fourteen_point_seven) == 14.0); 1192 var neg_fourteen_point_seven: T = -14.7; 1193 try expect(@floor(neg_fourteen_point_seven) == -15.0); 1194 1195 _ = .{ 1196 &two_point_one, 1197 &neg_two_point_one, 1198 &three_point_five, 1199 &neg_three_point_five, 1200 &twelve, 1201 &neg_twelve, 1202 &fourteen_point_seven, 1203 &neg_fourteen_point_seven, 1204 }; 1205 } 1206 1207 test "@floor with vectors" { 1208 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 1209 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1210 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1211 1212 try testFloorWithVectors(); 1213 try comptime testFloorWithVectors(); 1214 } 1215 1216 fn testFloorWithVectors() !void { 1217 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; 1218 _ = &v; 1219 const result = @floor(v); 1220 try expect(math.approxEqAbs(f32, @floor(@as(f32, 1.1)), result[0], epsilon)); 1221 try expect(math.approxEqAbs(f32, @floor(@as(f32, -2.2)), result[1], epsilon)); 1222 try expect(math.approxEqAbs(f32, @floor(@as(f32, 0.3)), result[2], epsilon)); 1223 try expect(math.approxEqAbs(f32, @floor(@as(f32, -0.4)), result[3], epsilon)); 1224 } 1225 1226 test "@ceil f16" { 1227 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1228 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1229 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1230 1231 try testCeil(f16); 1232 try comptime testCeil(f16); 1233 } 1234 1235 test "@ceil f32/f64" { 1236 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1237 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1238 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1239 1240 try testCeil(f32); 1241 try comptime testCeil(f32); 1242 try testCeil(f64); 1243 try comptime testCeil(f64); 1244 } 1245 1246 test "@ceil f80/f128/c_longdouble" { 1247 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1248 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1249 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1250 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1251 1252 try testCeil(f80); 1253 try comptime testCeil(f80); 1254 try testCeil(f128); 1255 try comptime testCeil(f128); 1256 try testCeil(c_longdouble); 1257 try comptime testCeil(c_longdouble); 1258 } 1259 1260 test "@ceil f80 maxInt(u64)" { 1261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1262 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1263 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1264 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1265 1266 var x: u64 = std.math.maxInt(u64); 1267 x = x; 1268 const float: f80 = @floatFromInt(x); 1269 try std.testing.expect(float == @ceil(float)); 1270 } 1271 1272 fn testCeil(comptime T: type) !void { 1273 var two_point_one: T = 2.1; 1274 try expect(@ceil(two_point_one) == 3.0); 1275 var neg_two_point_one: T = -2.1; 1276 try expect(@ceil(neg_two_point_one) == -2.0); 1277 var three_point_five: T = 3.5; 1278 try expect(@ceil(three_point_five) == 4.0); 1279 var neg_three_point_five: T = -3.5; 1280 try expect(@ceil(neg_three_point_five) == -3.0); 1281 var twelve: T = 12.0; 1282 try expect(@ceil(twelve) == 12.0); 1283 var neg_twelve: T = -12.0; 1284 try expect(@ceil(neg_twelve) == -12.0); 1285 var fourteen_point_seven: T = 14.7; 1286 try expect(@ceil(fourteen_point_seven) == 15.0); 1287 var neg_fourteen_point_seven: T = -14.7; 1288 try expect(@ceil(neg_fourteen_point_seven) == -14.0); 1289 1290 _ = .{ 1291 &two_point_one, 1292 &neg_two_point_one, 1293 &three_point_five, 1294 &neg_three_point_five, 1295 &twelve, 1296 &neg_twelve, 1297 &fourteen_point_seven, 1298 &neg_fourteen_point_seven, 1299 }; 1300 } 1301 1302 test "@ceil with vectors" { 1303 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 1304 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1305 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1306 1307 try testCeilWithVectors(); 1308 try comptime testCeilWithVectors(); 1309 } 1310 1311 fn testCeilWithVectors() !void { 1312 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; 1313 _ = &v; 1314 const result = @ceil(v); 1315 try expect(math.approxEqAbs(f32, @ceil(@as(f32, 1.1)), result[0], epsilon)); 1316 try expect(math.approxEqAbs(f32, @ceil(@as(f32, -2.2)), result[1], epsilon)); 1317 try expect(math.approxEqAbs(f32, @ceil(@as(f32, 0.3)), result[2], epsilon)); 1318 try expect(math.approxEqAbs(f32, @ceil(@as(f32, -0.4)), result[3], epsilon)); 1319 } 1320 1321 test "@trunc f16" { 1322 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1323 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1324 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1325 1326 try testTrunc(f16); 1327 try comptime testTrunc(f16); 1328 } 1329 1330 test "@trunc f32/f64" { 1331 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1332 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1333 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1334 1335 try testTrunc(f32); 1336 try comptime testTrunc(f32); 1337 try testTrunc(f64); 1338 try comptime testTrunc(f64); 1339 } 1340 1341 test "@trunc f80/f128/c_longdouble" { 1342 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1343 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1344 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1345 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1346 1347 try testTrunc(f80); 1348 try comptime testTrunc(f80); 1349 try testTrunc(f128); 1350 try comptime testTrunc(f128); 1351 try testTrunc(c_longdouble); 1352 try comptime testTrunc(c_longdouble); 1353 } 1354 1355 fn testTrunc(comptime T: type) !void { 1356 var two_point_one: T = 2.1; 1357 try expect(@trunc(two_point_one) == 2.0); 1358 var neg_two_point_one: T = -2.1; 1359 try expect(@trunc(neg_two_point_one) == -2.0); 1360 var three_point_five: T = 3.5; 1361 try expect(@trunc(three_point_five) == 3.0); 1362 var neg_three_point_five: T = -3.5; 1363 try expect(@trunc(neg_three_point_five) == -3.0); 1364 var twelve: T = 12.0; 1365 try expect(@trunc(twelve) == 12.0); 1366 var neg_twelve: T = -12.0; 1367 try expect(@trunc(neg_twelve) == -12.0); 1368 var fourteen_point_seven: T = 14.7; 1369 try expect(@trunc(fourteen_point_seven) == 14.0); 1370 var neg_fourteen_point_seven: T = -14.7; 1371 try expect(@trunc(neg_fourteen_point_seven) == -14.0); 1372 1373 _ = .{ 1374 &two_point_one, 1375 &neg_two_point_one, 1376 &three_point_five, 1377 &neg_three_point_five, 1378 &twelve, 1379 &neg_twelve, 1380 &fourteen_point_seven, 1381 &neg_fourteen_point_seven, 1382 }; 1383 } 1384 1385 test "@trunc with vectors" { 1386 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; 1387 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1388 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1389 1390 try testTruncWithVectors(); 1391 try comptime testTruncWithVectors(); 1392 } 1393 1394 fn testTruncWithVectors() !void { 1395 var v: @Vector(4, f32) = [_]f32{ 1.1, -2.2, 0.3, -0.4 }; 1396 _ = &v; 1397 const result = @trunc(v); 1398 try expect(math.approxEqAbs(f32, @trunc(@as(f32, 1.1)), result[0], epsilon)); 1399 try expect(math.approxEqAbs(f32, @trunc(@as(f32, -2.2)), result[1], epsilon)); 1400 try expect(math.approxEqAbs(f32, @trunc(@as(f32, 0.3)), result[2], epsilon)); 1401 try expect(math.approxEqAbs(f32, @trunc(@as(f32, -0.4)), result[3], epsilon)); 1402 } 1403 1404 test "neg f16" { 1405 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1406 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1407 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1408 1409 try testNeg(f16); 1410 try comptime testNeg(f16); 1411 } 1412 1413 test "neg f32/f64" { 1414 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1415 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1416 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1417 1418 try testNeg(f32); 1419 try comptime testNeg(f32); 1420 try testNeg(f64); 1421 try comptime testNeg(f64); 1422 } 1423 1424 test "neg f80/f128/c_longdouble" { 1425 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1426 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1427 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1428 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1429 1430 try testNeg(f80); 1431 try comptime testNeg(f80); 1432 try testNeg(f128); 1433 try comptime testNeg(f128); 1434 try testNeg(c_longdouble); 1435 try comptime testNeg(c_longdouble); 1436 } 1437 1438 fn testNeg(comptime T: type) !void { 1439 var two_point_five: T = 2.5; 1440 try expect(-two_point_five == -2.5); 1441 var neg_two_point_five: T = -2.5; 1442 try expect(-neg_two_point_five == 2.5); 1443 1444 var twelve: T = 12.0; 1445 try expect(-twelve == -12.0); 1446 var neg_fourteen: T = -14.0; 1447 try expect(-neg_fourteen == 14.0); 1448 1449 // normals 1450 var one: T = 1.0; 1451 try expect(-one == -1.0); 1452 var neg_one: T = -1.0; 1453 try expect(-neg_one == 1.0); 1454 var min: T = math.floatMin(T); 1455 try expect(-min == -math.floatMin(T)); 1456 var neg_min: T = -math.floatMin(T); 1457 try expect(-neg_min == math.floatMin(T)); 1458 var max: T = math.floatMax(T); 1459 try expect(-max == -math.floatMax(T)); 1460 var neg_max: T = -math.floatMax(T); 1461 try expect(-neg_max == math.floatMax(T)); 1462 1463 // subnormals 1464 var zero: T = 0.0; 1465 try expect(math.isNegativeZero(-zero)); 1466 var neg_zero: T = -0.0; 1467 try expect(math.isPositiveZero(-neg_zero)); 1468 var true_min: T = math.floatTrueMin(T); 1469 try expect(-true_min == -math.floatTrueMin(T)); 1470 var neg_true_min: T = -math.floatTrueMin(T); 1471 try expect(-neg_true_min == math.floatTrueMin(T)); 1472 1473 // non-finite numbers 1474 var inf: T = math.inf(T); 1475 try expect(math.isNegativeInf(-inf)); 1476 var neg_inf: T = -math.inf(T); 1477 try expect(math.isPositiveInf(-neg_inf)); 1478 var nan: T = math.nan(T); 1479 try expect(math.isNan(-nan)); 1480 try expect(math.signbit(-nan)); 1481 var neg_nan: T = -math.nan(T); 1482 try expect(math.isNan(-neg_nan)); 1483 try expect(!math.signbit(-neg_nan)); 1484 1485 _ = .{ 1486 &two_point_five, 1487 &neg_two_point_five, 1488 &twelve, 1489 &neg_fourteen, 1490 &one, 1491 &neg_one, 1492 &min, 1493 &neg_min, 1494 &max, 1495 &neg_max, 1496 &zero, 1497 &neg_zero, 1498 &true_min, 1499 &neg_true_min, 1500 &inf, 1501 &neg_inf, 1502 &nan, 1503 &neg_nan, 1504 }; 1505 } 1506 1507 test "negate f80" { 1508 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1509 1510 var f: f80 = 0.0; 1511 const a: u80 = @bitCast(f); 1512 try expect(a == 0); 1513 f = -f; 1514 const b: u80 = @bitCast(f); 1515 try expect(b == 0x8000_00000000_00000000); 1516 } 1517 1518 test "eval @setFloatMode at compile-time" { 1519 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1520 1521 const result = comptime fnWithFloatMode(); 1522 try expect(result == 1234.0); 1523 } 1524 1525 fn fnWithFloatMode() f32 { 1526 @setFloatMode(std.builtin.FloatMode.strict); 1527 return 1234.0; 1528 } 1529 1530 test "float literal at compile time not lossy" { 1531 try expect(16777216.0 + 1.0 == 16777217.0); 1532 try expect(9007199254740992.0 + 1.0 == 9007199254740993.0); 1533 } 1534 1535 test "f128 at compile time is lossy" { 1536 try expect(@as(f128, 10384593717069655257060992658440192.0) + 1 == 10384593717069655257060992658440192.0); 1537 } 1538 1539 test "comptime fixed-width float zero divided by zero produces NaN" { 1540 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1541 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1542 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1543 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1544 1545 inline for (.{ f16, f32, f64, f80, f128 }) |F| { 1546 try expect(math.isNan(@as(F, 0) / @as(F, 0))); 1547 } 1548 } 1549 1550 test "comptime fixed-width float non-zero divided by zero produces signed Inf" { 1551 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1552 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO 1553 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1554 1555 inline for (.{ f16, f32, f64, f80, f128 }) |F| { 1556 const pos = @as(F, 1) / @as(F, 0); 1557 const neg = @as(F, -1) / @as(F, 0); 1558 try expect(math.isInf(pos)); 1559 try expect(math.isInf(neg)); 1560 try expect(pos > 0); 1561 try expect(neg < 0); 1562 } 1563 } 1564 1565 test "comptime float compared with runtime int" { 1566 const f = 10.0; 1567 var i: usize = 0; 1568 _ = &i; 1569 try std.testing.expect(i < f); 1570 } 1571 test "comptime nan < runtime 0" { 1572 const f = comptime std.math.nan(f64); 1573 var i: usize = 0; 1574 _ = &i; 1575 try std.testing.expect(!(f < i)); 1576 } 1577 test "comptime inf > runtime 0" { 1578 const f = comptime std.math.inf(f64); 1579 var i: usize = 0; 1580 _ = &i; 1581 try std.testing.expect(f > i); 1582 } 1583 test "comptime -inf < runtime 0" { 1584 const f = comptime -std.math.inf(f64); 1585 var i: usize = 0; 1586 _ = &i; 1587 try std.testing.expect(f < i); 1588 } 1589 test "comptime inf >= runtime 1" { 1590 const f = comptime std.math.inf(f64); 1591 var i: usize = 1; 1592 _ = &i; 1593 try std.testing.expect(f >= i); 1594 } 1595 test "comptime isNan(nan * 1)" { 1596 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1597 1598 const nan_times_one = comptime std.math.nan(f64) * 1; 1599 try std.testing.expect(std.math.isNan(nan_times_one)); 1600 } 1601 test "runtime isNan(nan * 1)" { 1602 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1603 1604 const nan_times_one = std.math.nan(f64) * 1; 1605 try std.testing.expect(std.math.isNan(nan_times_one)); 1606 } 1607 test "comptime isNan(nan * 0)" { 1608 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1609 1610 const nan_times_zero = comptime std.math.nan(f64) * 0; 1611 try std.testing.expect(std.math.isNan(nan_times_zero)); 1612 const zero_times_nan = 0 * comptime std.math.nan(f64); 1613 try std.testing.expect(std.math.isNan(zero_times_nan)); 1614 } 1615 test "runtime isNan(nan * 0)" { 1616 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1617 1618 const nan_times_zero = std.math.nan(f64) * 0; 1619 try std.testing.expect(std.math.isNan(nan_times_zero)); 1620 const zero_times_nan = 0 * std.math.nan(f64); 1621 try std.testing.expect(std.math.isNan(zero_times_nan)); 1622 } 1623 test "comptime isNan(inf * 0)" { 1624 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1625 1626 const inf_times_zero = comptime std.math.inf(f64) * 0; 1627 try std.testing.expect(std.math.isNan(inf_times_zero)); 1628 const zero_times_inf = 0 * comptime std.math.inf(f64); 1629 try std.testing.expect(std.math.isNan(zero_times_inf)); 1630 } 1631 test "runtime isNan(inf * 0)" { 1632 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1633 1634 const inf_times_zero = std.math.inf(f64) * 0; 1635 try std.testing.expect(std.math.isNan(inf_times_zero)); 1636 const zero_times_inf = 0 * std.math.inf(f64); 1637 try std.testing.expect(std.math.isNan(zero_times_inf)); 1638 } 1639 1640 test "optimized float mode" { 1641 if (builtin.zig_backend != .stage2_llvm) return error.SkipZigTest; 1642 if (builtin.mode == .debug) return error.SkipZigTest; 1643 1644 const big = 0x1p40; 1645 const small = 0.001; 1646 const tiny = 0x1p-10; 1647 1648 const S = struct { 1649 fn strict(x: f64) f64 { 1650 @setFloatMode(.strict); 1651 return x + big - big; 1652 } 1653 fn optimized(x: f64) f64 { 1654 @setFloatMode(.optimized); 1655 return x + big - big; 1656 } 1657 }; 1658 try expect(S.optimized(small) == small); 1659 try expect(S.strict(small) == tiny); 1660 } 1661 1662 fn MakeType(comptime x: anytype) type { 1663 return struct { 1664 fn get() @TypeOf(x) { 1665 return x; 1666 } 1667 }; 1668 } 1669 1670 const nan_a: f32 = @bitCast(@as(u32, 0xffc00000)); 1671 const nan_b: f32 = @bitCast(@as(u32, 0xffe00000)); 1672 1673 fn testMemoization() !void { 1674 try expect(MakeType(nan_a) == MakeType(nan_a)); 1675 try expect(MakeType(nan_b) == MakeType(nan_b)); 1676 try expect(MakeType(nan_a) != MakeType(nan_b)); 1677 } 1678 1679 fn testVectorMemoization(comptime T: type) !void { 1680 const nan_a_v: T = @splat(nan_a); 1681 const nan_b_v: T = @splat(nan_b); 1682 try expect(MakeType(nan_a_v) == MakeType(nan_a_v)); 1683 try expect(MakeType(nan_b_v) == MakeType(nan_b_v)); 1684 try expect(MakeType(nan_a_v) != MakeType(nan_b_v)); 1685 } 1686 1687 test "comptime calls are only memoized when float arguments are bit-for-bit equal" { 1688 try comptime testMemoization(); 1689 try comptime testVectorMemoization(@Vector(4, f32)); 1690 } 1691 1692 test "result location forwarded through unary float builtins" { 1693 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO 1694 if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; 1695 if (builtin.zig_backend == .stage2_spirv) return error.SkipZigTest; 1696 1697 const S = struct { 1698 var x: u32 = 10; 1699 }; 1700 1701 var y: f64 = 0.0; 1702 y = @sqrt(@floatFromInt(S.x)); 1703 y = @sin(@floatFromInt(S.x)); 1704 y = @cos(@floatFromInt(S.x)); 1705 y = @tan(@floatFromInt(S.x)); 1706 y = @exp(@floatFromInt(S.x)); 1707 y = @exp2(@floatFromInt(S.x)); 1708 y = @log(@floatFromInt(S.x)); 1709 y = @log2(@floatFromInt(S.x)); 1710 y = @log10(@floatFromInt(S.x)); 1711 y = @floor(@floatFromInt(S.x)); 1712 y = @ceil(@floatFromInt(S.x)); 1713 y = @trunc(@floatFromInt(S.x)); 1714 y = @round(@floatFromInt(S.x)); 1715 } 1716