      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
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121

    // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
    // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
    // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
    // option. This file may not be copied, modified, or distributed
    // except according to those terms.

    pub use self::fake::*;

    pub trait SimdExt {
        fn simd_eq(self, rhs: Self) -> Self;
    }

    impl SimdExt for fake::u32x4 {
        fn simd_eq(self, rhs: Self) -> Self {
            if self == rhs {
                fake::u32x4(0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff)
            } else {
                fake::u32x4(0, 0, 0, 0)
            }
        }
    }

    mod fake {
        use std::ops::{Add, BitAnd, BitOr, BitXor, Shl, Shr, Sub};

        #[derive(Clone, Copy, PartialEq, Eq)]
        #[allow(non_camel_case_types)]
        pub struct u32x4(pub u32, pub u32, pub u32, pub u32);

        impl Add for u32x4 {
            type Output = u32x4;

            fn add(self, rhs: u32x4) -> u32x4 {
                u32x4(
                    self.0.wrapping_add(rhs.0),
                    self.1.wrapping_add(rhs.1),
                    self.2.wrapping_add(rhs.2),
                    self.3.wrapping_add(rhs.3))
            }
        }

        impl Sub for u32x4 {
            type Output = u32x4;

            fn sub(self, rhs: u32x4) -> u32x4 {
                u32x4(
                    self.0.wrapping_sub(rhs.0),
                    self.1.wrapping_sub(rhs.1),
                    self.2.wrapping_sub(rhs.2),
                    self.3.wrapping_sub(rhs.3))
            }
        }

        impl BitAnd for u32x4 {
            type Output = u32x4;

            fn bitand(self, rhs: u32x4) -> u32x4 {
                u32x4(self.0 & rhs.0, self.1 & rhs.1, self.2 & rhs.2, self.3 & rhs.3)
            }
        }

        impl BitOr for u32x4 {
            type Output = u32x4;

            fn bitor(self, rhs: u32x4) -> u32x4 {
                u32x4(self.0 | rhs.0, self.1 | rhs.1, self.2 | rhs.2, self.3 | rhs.3)
            }
        }

        impl BitXor for u32x4 {
            type Output = u32x4;

            fn bitxor(self, rhs: u32x4) -> u32x4 {
                u32x4(self.0 ^ rhs.0, self.1 ^ rhs.1, self.2 ^ rhs.2, self.3 ^ rhs.3)
            }
        }

        impl Shl<usize> for u32x4 {
            type Output = u32x4;

            fn shl(self, amt: usize) -> u32x4 {
                u32x4(self.0 << amt, self.1 << amt, self.2 << amt, self.3 << amt)
            }
        }

        impl Shl<u32x4> for u32x4 {
            type Output = u32x4;

            fn shl(self, rhs: u32x4) -> u32x4 {
                u32x4(self.0 << rhs.0, self.1 << rhs.1, self.2 << rhs.2, self.3 << rhs.3)
            }
        }

        impl Shr<usize> for u32x4 {
            type Output = u32x4;

            fn shr(self, amt: usize) -> u32x4 {
                u32x4(self.0 >> amt, self.1 >> amt, self.2 >> amt, self.3 >> amt)
            }
        }

        impl Shr<u32x4> for u32x4 {
            type Output = u32x4;

            fn shr(self, rhs: u32x4) -> u32x4 {
                u32x4(self.0 >> rhs.0, self.1 >> rhs.1, self.2 >> rhs.2, self.3 >> rhs.3)
            }
        }

        #[derive(Clone, Copy)]
        #[allow(non_camel_case_types)]
        pub struct u64x2(pub u64, pub u64);

        impl Add for u64x2 {
            type Output = u64x2;

            fn add(self, rhs: u64x2) -> u64x2 {
                u64x2(self.0.wrapping_add(rhs.0), self.1.wrapping_add(rhs.1))
            }
        }
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand 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`)