     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90

    use core::f32;
    use core::u32;

    #[inline]
    #[cfg_attr(all(test, assert_no_panic), no_panic::no_panic)]
    pub fn fmodf(x: f32, y: f32) -> f32 {
        let mut uxi = x.to_bits();
        let mut uyi = y.to_bits();
        let mut ex = (uxi >> 23 & 0xff) as i32;
        let mut ey = (uyi >> 23 & 0xff) as i32;
        let sx = uxi & 0x80000000;
        let mut i;

        if uyi << 1 == 0 || y.is_nan() || ex == 0xff {
            return (x * y) / (x * y);
        }

        if uxi << 1 <= uyi << 1 {
            if uxi << 1 == uyi << 1 {
                return 0.0 * x;
            }

            return x;
        }

        /* normalize x and y */
        if ex == 0 {
            i = uxi << 9;
            while i >> 31 == 0 {
                ex -= 1;
                i <<= 1;
            }

            uxi <<= -ex + 1;
        } else {
            uxi &= u32::MAX >> 9;
            uxi |= 1 << 23;
        }

        if ey == 0 {
            i = uyi << 9;
            while i >> 31 == 0 {
                ey -= 1;
                i <<= 1;
            }

            uyi <<= -ey + 1;
        } else {
            uyi &= u32::MAX >> 9;
            uyi |= 1 << 23;
        }

        /* x mod y */
        while ex > ey {
            i = uxi.wrapping_sub(uyi);
            if i >> 31 == 0 {
                if i == 0 {
                    return 0.0 * x;
                }
                uxi = i;
            }
            uxi <<= 1;

            ex -= 1;
        }

        i = uxi.wrapping_sub(uyi);
        if i >> 31 == 0 {
            if i == 0 {
                return 0.0 * x;
            }
            uxi = i;
        }

        while uxi >> 23 == 0 {
            uxi <<= 1;
            ex -= 1;
        }

        /* scale result up */
        if ex > 0 {
            uxi -= 1 << 23;
            uxi |= (ex as u32) << 23;
        } else {
            uxi >>= -ex + 1;
        }
        uxi |= sx;

        f32::from_bits(uxi)
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)