| const std = @import("std"); | |
| fn mergeInPlace(comptime T: type, s: []T, midpoint: usize) void { | |
| std.debug.assert(midpoint <= s.len); | |
| if (midpoint == 0 or midpoint == s.len) return; | |
| var a: usize = 0; | |
| var b: usize = midpoint; | |
| var c: usize = midpoint; |
| ({ lib, newScope, stdenv, pkgs }: let | |
| # nicer aliases | |
| derive = stdenv.mkDerivation; | |
| concat = builtins.concatStringsSep " "; | |
| # vendored libuvc: don't build, just make sources available | |
| libuvc-src = derive { | |
| name = "libuvc-src"; | |
| # using fetchgit instead fetchFromGitHub because |
| {-# LANGUAGE OverloadedStrings #-} | |
| import qualified Data.Text as T | |
| import Data.Attoparsec.Text | |
| data Op | |
| = Add Op Op | |
| | Sub Op Op | |
| | Mul Op Op | |
| | Div Op Op | |
| | Const Double |
| local camera = workspace.CurrentCamera | |
| local fixedCFrame = CFrame.new(0, 100, 0) -- CFrame of default looking direction/position | |
| local rate = 1/5 -- Speed at which the camera will sway | |
| local xSwayAngle = math.pi/9 -- X angle change interval | |
| local ySwayAngle = math.pi/9 -- Y angle change interval | |
| local rollAngle = math.pi/18 -- Roll angle change interval | |
| function update(t) | |
| local phi = math.pi/2 + math.noise(t*rate, 0) * xSwayAngle | |
| local theta = math.pi/2 + math.noise(t*rate, 10) * ySwayAngle |
| define-command sort-selections -params 0.. -override -docstring ' | |
| sort-selections: Sort current selections using GNU sort utility | |
| All parameters will be passed to the GNU sort utility | |
| ' %{ | |
| # Copy current selections to a temporary sort buffer | |
| execute-keys %{"sy} | |
| edit -scratch *sort-selections* | |
| execute-keys %{"s<a-p>} | |
| # Seperate selections with null characters |
| proc planeFit(cluster: Tensor[float], threshold = 10e-2): Option[Plane] = | |
| ## Fit points to a 3D plane | |
| # At least 3 points are required to fit a plane | |
| if cluster.shape[0] < 3: return | |
| let points = cluster[_, 0..2] | |
| let mean = points.mean(axis=0) | |
| let delta = points .- mean | |
| let covarMatrix = delta.covariance |
| for slice in inputTensor.axis(0): | |
| if slice[0, dotProductColumn] >= 0: | |
| a.add(slice) | |
| else: | |
| b.add(slice) |
| import macros | |
| proc replaceIdent(node, ident: NimNode, replacement: NimNode) = | |
| for i, child in node: | |
| if child == ident: | |
| node[i] = replacement.copy() | |
| if child.len > 0: | |
| child.replaceIdent(ident, replacement) |
Recently I stumbled upon a post which takes a closer look at the yes command line tool. The main purpose of it is to write endless stream of a single letter y at a ridiculous speed.
On the first glance this seems like a really simple problem, just two lines of Nim and you're done, right?
while true:
echo "y"And indeed, this gives us plenty of y's. But when we take a look at the write speed..
| import os | |
| # Handle Ctrl-C signal | |
| setControlCHook(proc() {.noconv.} = quit 0) | |
| # Use POSIX write | |
| proc write(fd: cint, buffer: pointer, count: cint) {.header: "<unistd.h>", importc: "write".} | |
| const pageSize = 4096 | |
| var yes: string |