about on about me

rust ray tracer

Tue, 08 Aug 2023 00:00:00 +0000

what?

good old ray tracer again

why?

earlier last year i followed Ray Tracing in One Weekend and implemented it in go to get a hang of the language. it was all nice and fun but rendering the final scene took arround 20 minutes in my M1 Macbook Air, so i was left feeling a little disatisfied.
i have been solving many kattis problems in rust (particularly those that are just too slow to run in python), and i wanted to try rust on a slightly more complicated ‘project’
i really wanted to see how rust concurrency feels.

conclusions

computer graphics are very hard to debug. really. really. hard. i spent days fixing a very subtle bug.
i started defining a trait ‘hitable’ and was planning to just extend types as i needed them, but as i started testing it, it really wasn’t any faster than the go version. so i decided to replace as many allocations as possible and not use any dynamic dispatch and i think i’m happy with the results. i think rust enums make up for the lack of abstractness in this scenario
rayon is cool and very very simple

todo

lights!
more materials!
more geometries!
textures!
Ray Tracing: The Next Week
Ray Tracing: The Rest of Your Life

mandelrust

Tue, 10 May 2022 00:00:00 +0000

what?

i basically wanted to have a random zoom on an interesting mandelbrot point:

-0.761574 + -0.0847596i

why?

i wanted to try out rust in an aws lambda function
i wanted to build that lambda function with cdk (i’m kinda procrastinating from learning/using terraform)
i was kinda hyped to use rust after reading about it

conclusions

i’m starting to dig aws hehe.
i really like rust and will keep using it as much as i can
i will never ever find mandelbrot set uninteresting
rust lambda startup time is unlike anything i’ve ever seen. it draws (for me, at least) the line between server and serverless kinda blurry

todo

well this seems obvious but i don’t want to use a single point and a random zoom but rather a set of interesting points and a random zoom! all this seems kinda time consuming so i guess i’ll leave it like this for a while
i also want to optimize mb allocated for each lambda execution. 128mb takes arround 13 seconds to finish, while 1gb takes arround 3.

update 10-5-2022

i’ve been consuming a lot of terraform content. but as you may know by now, in the realm of programming you learn mostly by getting your hands dirty, so i tried importing (this is the single feature i liked the most) most of the resources i used on cdk and got them up & running in terraform. it is beautiful.

go ray tracer

Mon, 21 Feb 2022 00:00:00 +0000

what?

a ray tracer of course! if you are not familiar with the term, it is basically a rendering technique that is very intuitive, and fairly easy to implement naively (and yields very decent results), but tends to be computationally expensive.

why?

back in my Modeling and Programming course, we were asked to implement a ray tracer in order to get one extra credit. back then, though, even fairly easy problems seemed very scary and alien to me (plus, i had a pretty good score already). i came across Ray Tracing in One Weekend recently and i thought i owed it to my old self to get it done as soon as possible.
this should come as not surprise if you’ve read anything i post in this website, but i wanted to see how go felt when programming something bigger than a leetcode problem.

conclusions

this was really really fun. if you haven’t already give it a go (pun intended)! it is supremely well written and if you’re anything like me, you’ll have a blast.
i implemented some very simple concurrency and i’m in awe of how easy goroutines and channels make for concurrent design. (also, i saw this long ago and it was in my mind throughout this project)
i think i’m starting to like go (i mean, it is as simple as it gets). plus generics!.

todo

while making it concurrent and giving it more cores to run in parallel made it significantly faster, i’m still not satisfied by the results. rendering the final scene of the project takes about 15 minutes in my M1 Macbook Air with the full 8 cores. i think i can squeeze some performance by making garbage collector do less work. we’ll see how it goes.
lights!
more materials!
more geometries!
textures!
Ray Tracing: The Next Week
Ray Tracing: The Rest of Your Life

day 12

Sun, 12 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

as long as there are no upper-cased direct loops (ie, A - B), simple dfs works for both cases:

for part 1:

def dfs1(g, node, visited):
    if node == "end":
        return 1
    res = 0
    for nn in g[node]:    
        if nn.isupper() or nn not in visited:
            visited.add(nn) 
            res += dfs1(g, nn, visited)
            visited.discard(nn)    
    return res

for part 2:

def dfs2(g, node, visited, used):
    if node == "end":        
        return 1
    res = 0
    for nn in g[node]:
        if nn.isupper():    
            res += dfs2(g, nn, visited, used)    
        elif nn in visited and nn != "start" and not used:
            res += dfs2(g, nn, visited, True)
        elif nn not in visited:
            visited.add(nn)
            res += dfs2(g, nn, visited, used)
            visited.discard(nn)
    return res

day 11

Sat, 11 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

the only thing we have to be careful about in this problem is avoid counting octopuses more than once

but otherwise, just simulate the steps

here’s the step function i used, that returns the number of flashes that happened during each time period

# mutates grid
def step(grid):
    n, m = len(grid), len(grid[0])
    s = []
    for r, c in product(range(n), range(m)):   
        grid[r][c] += 1        
        if grid[r][c] == 10: 
            s.extend(neighbors(grid, r, c))
    while s:
        r, c = s.pop()    
        grid[r][c] += 1   
        if grid[r][c] == 10:
            s.extend(neighbors(grid, r, c))    

    flashes = 0
    for r, c in product(range(n), range(m)):
        if grid[r][c] > 9:
            grid[r][c] = 0    
            flashes += 1
    return flashes

day 10

Fri, 10 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

using a stack, you can figure out exactly where does the string become invalid, if at all

m = {"{":"}", "(":")", "[":"]", "<":">"}
def parse(l):
    s = []
    for c in l:
        if c in m:
            s.append(c)    
        elif s and m[s[-1]] == c:
            s.pop()
        else:
            return s, c
    return s, None

if the stack is not empty at the end, it means it is incomplete and that the only way to complete it would be to reverse the stack and append it to the original string

day 9

Thu, 09 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

for part one, simply count the number of cells in which all neighbors are strictly greater.

for part two, floodfill until you have previously visited or until you find a height 9

def floodfill(grid, r, c):
    if grid[r][c] is None or grid[r][c] == 9: 
        return 0    
    s, grid[r][c] = 1, None
    for nr, nc in neighbors(grid, r, c):
        s += floodfill(grid, nr, nc)    
    return s

day 8

Wed, 08 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

for the first part, simply count the number of words in the output section that have lengths 2, 3, 4 or 7

for the second part, i couldn’t think of a better solution than just try permutations until the wires make sense

day 7

Tue, 07 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

def cost(l, n, f):
    return sum(f(e, n) for e in l)

for the first part, the solution is the median.

def median(l):
    return l[len(l) >> 1]

def part1(l):
    m = median(l)
    return cost(l, m, lambda x, y: abs(x - y))

for the second part, the solution is the average.

def part2(l):
    avg = sum(l) / len(l)
    f = lambda x, y: gauss(abs(x - y))
    return min(cost(l, ceil(avg), f), cost(l, floor(avg), f))

day 6

Mon, 06 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

this was very fun!

my first solution consisted on a simple simulation on a double ended queue. this solution is linear on the number of days and it handles both parts without a problem.

# mutates q
def step(q):
    n, last = q[0], q.pop()    
    q[-1] += n
    q.append(last)
    q.rotate(-1)

however, it ocurred to me while working, that i could simply simulate a single step of this as a matrix multiplication. and well, if you have repeated matrix multiplication, you have matrix exponentation. and if you have matrix exponentiation you have fast matrix exponentiation.

day 5

Sun, 05 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

nothing interesting for this problem. just walk from p1 to p2 and add all the points you walk to a counter. for part one, simply filter those who are diagonal (start[1] == end[1] or start[0] == end[0])

for part two, don’t filter.

def span(p1, p2):
    sx, sy = p1 
    ex, ey = p2
    dx = delta(sx, ex)
    dy = delta(sy, ey)
    while p1 != p2:
        yield p1    
        p1 = (p1[0] + dx, p1[1] + dy)
    yield p1

def count_points(segments):
    c = Counter()
    for p1, p2 in segments:
        for p in span(p1, p2):
            c[p] += 1
    return c

day 4

Sat, 04 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

ok. this was fun!

for both parts, i just simulated all boards with a class. only interesting thing is i kept track of all numbers contained in a board and added a rows and cols array, containing how many remaining numbers until a bingo in each row/col. this made it very easy to know if marking a number in a board yields a bingo.

day 3

Fri, 03 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

to solve each part, we basically need a function that can give us the number of bits turned on for a certain digit index:

def count_by_index(nums, i):
    total = len(nums)
    res = ones = 0
    for n in nums:            
        if (n >> i) & 1:
            ones += 1    
    return ones, total - ones

you can get the gamma rate by simply iterating over each possible index and assigning that index to be the digit of the most common digit of all numbers for that index.

day 2

Thu, 02 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

for part one, it is a very straight forward simulation.

(defn step-part1 [x y cmd i]
  (cond
    (= cmd "forward") [(+ x i) y]
    (= cmd "up") [x (- y i)]
    :else [x (+ y i)]))

part two is very similar but we also need to keep track of the aim

(defn step-part2 [x y aim cmd i]
  (cond
    (= cmd "forward") [(+ x i) (- y (* aim i)) aim]
    (= cmd "up") [x y (+ aim i)]
    :else [x y (- aim i)]))

day 1

Wed, 01 Dec 2021 00:00:00 +0000

you can find the description here and you can find the code here

well my solution uses a very simple (fixed size) sliding window technique, with the first part being a size 1 window and the second part a size 3 window.

def solve(l: [int], k: int):
    s = sum(l[:k])    
    res = 0
    for i in range(k, len(l)):
        ss = s - l[i - k] + l[i]
        res += s < ss
        s = ss
    return res

reading log

Mon, 01 Jan 0001 00:00:00 +0000

2022

Terraform: Up & Running: Writing Infrastructure as Code: terraform is really cool. good book!
Building Event-Driven Microservices: Leveraging Organizational Data at Scale: currently reading it.
The Man from the Future: currently reading it.
Deep Learning with Python: currently reading it.

2021

Designing data intensive applications: can’t recomend it enough.
Programming Rust: Fast, Safe Systems Development: i love rust and this is a great book but afaik outside of all the (wonderful) cli tooling being built in rust, i see more interesting projects being built with go (if you could point me to some interesting rust projects, i would love to see them!). which led me to the my next book
Learning Go: An Idiomatic Approach to Real-World Go Programming: the book is ok but as much as i try i can’t seem to get really excited about go.
The joy of Clojure: i had a really really good time both reading this book and learning clojure overall. there are some very interesting concepts in this languages and it pushed me outside of my comfort zone at first (this was also my first lisp, so yeah…).
Purely Functional Data Structures: if only the book was based on haskell… i have not finished this book but i REALLY want to both finish it and get a little more used to Standard ML
I’ll finish this list later :p

about on about me

rust ray tracer

what?

why?

conclusions

todo

links

mandelrust

what?

why?

conclusions

todo

update 10-5-2022

links

go ray tracer

what?

why?

conclusions

todo

links

day 12

day 11

day 10

day 9

day 8

day 7

day 6

day 5

day 4

day 3

day 2

day 1

reading log

2022

2021