Baseline: tree as shared
This commit is contained in:
1679 files changed
+1024562
No files matched your search
@@ -0,0 +1,85 @@
|
||||
struct Span[mut: Bool, //, T: Copyable, origin: Origin[mut]]:
|
||||
# ... implementation omitted
|
||||
```
|
||||
|
||||
Here, the `mut` parameter is infer-only. The value is usually inferred when you
|
||||
create an instance of `Span`. Binding the `mut` parameter by keyword lets you
|
||||
define a `Span` that requires a mutable origin.
|
||||
|
||||
```mojo
|
||||
def mutate_span(span: Span[mut=True, Byte, _]):
|
||||
for i in range(0, len(span), 2):
|
||||
if i + 1 < len(span):
|
||||
span.swap_elements(i, i + 1)
|
||||
```
|
||||
|
||||
If the compiler can't infer the value of an infer-only parameter, and it's not
|
||||
specified by keyword, compilation fails.
|
||||
|
||||
## Parameter expressions are just Mojo code
|
||||
|
||||
A parameter expression is any code expression (such as `a+b`) that occurs where
|
||||
a parameter is expected. Parameter expressions support operators and function
|
||||
calls, just like run-time code, and all parameter types use the same type
|
||||
system as the run-time program (such as `Int` and `DType`).
|
||||
|
||||
Because parameter expressions use the same grammar and types as run-time
|
||||
Mojo code, you can use many
|
||||
["dependent type"](https://en.wikipedia.org/wiki/Dependent_type) features. For
|
||||
example, you might want to define a helper function to concatenate two SIMD
|
||||
vectors:
|
||||
|
||||
```mojo
|
||||
def concat[
|
||||
dtype: DType, ls_size: Int, rh_size: Int, //
|
||||
](lhs: SIMD[dtype, ls_size], rhs: SIMD[dtype, rh_size]) -> SIMD[
|
||||
dtype, ls_size + rh_size
|
||||
]:
|
||||
var result = SIMD[dtype, ls_size + rh_size]()
|
||||
|
||||
comptime for i in range(ls_size):
|
||||
result[i] = lhs[i]
|
||||
|
||||
comptime for j in range(rh_size):
|
||||
result[ls_size + j] = rhs[j]
|
||||
return result
|
||||
```
|
||||
|
||||
Note that the resulting length is the sum of the input vector lengths, and a
|
||||
simple `+` operation expresses this.
|
||||
|
||||
### Powerful compile-time programming
|
||||
|
||||
While simple expressions are useful, sometimes you want to write imperative
|
||||
compile-time logic with control flow. You can even do compile-time recursion.
|
||||
For instance, here is an example "tree reduction" algorithm that sums all
|
||||
elements of a vector recursively into a scalar:
|
||||
|
||||
```mojo
|
||||
def slice[
|
||||
dtype: DType, size: Int, //
|
||||
](x: SIMD[dtype, size], offset: Int) -> SIMD[dtype, size // 2]:
|
||||
comptime new_size = size // 2
|
||||
var result = SIMD[dtype, new_size]()
|
||||
for i in range(new_size):
|
||||
result[i] = Scalar[dtype](x[i + offset])
|
||||
return result
|
||||
|
||||
|
||||
def reduce_add(x: SIMD) -> Int:
|
||||
comptime if x.length == 1:
|
||||
return Int(x[0])
|
||||
elif x.length == 2:
|
||||
return Int(x[0]) + Int(x[1])
|
||||
|
||||
# Extract the top/bottom halves, add them, sum the elements.
|
||||
comptime half_size = x.length // 2
|
||||
var lhs = slice(x, 0)
|
||||
var rhs = slice(x, half_size)
|
||||
return reduce_add(lhs + rhs)
|
||||
|
||||
|
||||
def main():
|
||||
var x = SIMD[DType.int, 4](1, 2, 3, 4)
|
||||
print(x)
|
||||
print("Elements sum:", reduce_add(x))
|
||||
Reference in new issue
Block a user