Rust and C++ on Floating-Point Intensive Code

Post by nicoburns » Thu, Oct 24, 2019, 1:51 PM UTC

diamondlovesyou wrote: post #22

pedrocr wrote: post #21

Earlier quoted context omitted.

Maybe you can use chunks_exact() and chunks_exact_mut(). The _exact versions allow lifting the bounds checks out of the loop and gave me some great performance boosts in image processing code.

These blocks are non-continuous. It operates over a part of a row, where the start of the next row is the start of the current row + some stride. I mean maybe? But I probably wouldn't anyway for this case as a slice reference is actually a "fat" pointer (ie twice the size of a normal pointer) and the length of the slice won't be used (the block size is known per kernel); LLVM might delete the length part anyway. Thes…

Post by uryga » Thu, Oct 24, 2019, 1:53 PM UTC

leshow wrote: post #48

What's "almost" algebraic about enum? It can definitely be used to construct sum types, and you can make product types with struct or inline in an enum

  enum List {
    Nil,
    Cons(T, List)
  }

  enum List {
    Nil,
    Cons(T, Box>)
  }

Post by leshow » Thu, Oct 24, 2019, 2:00 PM UTC

uryga wrote: post #53

leshow wrote: post #48

What's "almost" algebraic about enum? It can definitely be used to construct sum types, and you can make product types with struct or inline in an enum

my best guess is that you can't do recursive enums without explicit boxing [edit: or other forms of indirection, like &T]¹. so you can't do this: enum List { Nil, Cons(T, List ) } instead, you have to box/reference-ify the recursive occurrence: enum List { Nil, Cons(T, Box >) } so in certain circumstances it doesn't let you "coproduct" two types together, you might need to modify one a bit, which makes it a technical…

Post by steveklabnik » Thu, Oct 24, 2019, 2:05 PM UTC

uryga wrote: post #53

leshow wrote: post #48

What's "almost" algebraic about enum? It can definitely be used to construct sum types, and you can make product types with struct or inline in an enum

my best guess is that you can't do recursive enums without explicit boxing [edit: or other forms of indirection, like &T]¹. so you can't do this: enum List { Nil, Cons(T, List ) } instead, you have to box/reference-ify the recursive occurrence: enum List { Nil, Cons(T, Box >) } so in certain circumstances it doesn't let you "coproduct" two types together, you might need to modify one a bit, which makes it a technical…

  enum List {
    Nil,
    Cons(T, &'a List)
  }
  
  fn main() {
      let list = List::Cons("hello", &List::Nil);
  }

Post by uryga » Thu, Oct 24, 2019, 2:11 PM UTC

steveklabnik wrote: post #57

uryga wrote: post #53

Earlier quoted context omitted.

my best guess is that you can't do recursive enums without explicit boxing [edit: or other forms of indirection, like &T]¹. so you can't do this: enum List { Nil, Cons(T, List ) } instead, you have to box/reference-ify the recursive occurrence: enum List { Nil, Cons(T, Box >) } so in certain circumstances it doesn't let you "coproduct" two types together, you might need to modify one a bit, which makes it a technical…

You don't have to box, but you do need some sort of type to make things sized. This is usually a pointer of some kind, but any kind of pointer works. Take references, for example: enum List { Nil, Cons(T, &'a List ) } fn main() { let list = List::Cons("hello", &List::Nil); } Box is usually chosen because it's a good default choice.