Show more

So apparently Joe has been president for a year now and surprise surprise, COVID levels are where they are at when things were at their worst under Trump.. Remind me again how Biden is so much better than Trump.

Do not go gentle into that good night,
Old age should burn and rave at close of day;
Rage, rage against the dying of the light.

Though wise men at their end know dark is right,
Because their words had forked no lightning they
Do not go gentle into that good night.

Good men, the last wave by, crying how bright
Their frail deeds might have danced in a green bay,
Rage, rage against the dying of the light.

Wild men who caught and sang the sun in flight,
And learn, too late, they grieved it on its way,
Do not go gentle into that good night.

Grave men, near death, who see with blinding sight
Blind eyes could blaze like meteors and be gay,
Rage, rage against the dying of the light.

And you, my father, there on the sad height,
Curse, bless, me now with your fierce tears, I pray.
Do not go gentle into that good night.
Rage, rage against the dying of the light.

– Dylan Thomas

@freemo @icedquinn
Gov Newsom says he's being attacked by Trumpism.

Since when did Trump start a religion? Wait, is there a Freemoism?

Just a reminder.. Biden has, so far, spent significantly more time on vacation than Trump did.

Biden has spent 74 days so far on vacation, in that same amount of time Trump only spent 42 days on vacation.

Remember all those cries about Trump golfing... now ask yourself why they are silent when Biden is spending so much **more** time doing the same?

Its almost like there might be a double standard or something... no way!

@freemo I wrote this 7 years ago. https://gist.github.com/veer66/8055128d63bbc609129d

It took me almost a week to write this dirty code. I need much more time to polish my skill.๐ŸงŽ๐Ÿฝ

@worldsendless

Proof of concept: We never really use the case lid except for added padding... why not stuff it with batts? This brainstorm originated from @KiloMike9Golf@twitter.com. So I made multiple QRP batts and paralellized with a #powerpole distribution block. denco.ad6dm.net/batts/denco-qr #hamradio ๐Ÿ”‹

Last month the Netherlands passed #RouterFreedom into law: all ISPs must let customers choose their own Internet hardware and still provide tech support at no extra cost. That little box is your home-internet gatekeeper, and now in NL it can work for you fsfe.org/news/2021/news-202108

re: AI 

A rough benchmark Quinn did comparing the HAM algorithm (I wrote it some years back) to the well known Spring algorithm.

Apparently on his test the Spring algorithm took 2s to complete and the HAM algorithm only 21ms, they are otherwise very similar algorithms in terms of their results. I've found these results are pretty typical of past benchmarks I've seen.
QT: blob.cat/objects/72009077-4cef

iced depresso  

re: AI 

re: AI 

@freemo interesting to note that if i put nim in total performance mode (these tests were run in the default debug mode, i did a second set with all the safeties off and all the speed settings on) HAM runs in 21ms and springy runs in 2s.

re: AI 

@freemo

# Module: Iced Quinn, 2021 # Algorithm: Jeffrey Phillips Freeman, 2017 # https://jeffreyfreeman.me/hyperassociative-map-explanation/ import math, random # chi: ideal distance between nodes # sigma: how strong unrelated nodes repel one another; smaller is stronger # nu: learning rate # beta: alignment threshold; stop when movement in an iteration falls below this # neighbors: any vertex connected by an edge to this one # non-neighbor: other vertices who are not connected by an edge # TODO don't take sqrts and use pre-squared values; saves time const Nu = 0.05 Beta = 0.005 type Vertex* = object x*, y*: float edges*: seq[int] Edge* = object v1*, v2*: int length*: float Solver* = object chi*, sigma*: float vertices*: seq[Vertex] edges*: seq[Edge] rng*: Rand func add*(self: var Solver; v: Vertex) {.inline.} = self.vertices.add v func add*(self: var Solver; e: Edge) {.inline.} = self.edges.add e self.vertices[e.v1].edges.add self.edges.high self.vertices[e.v2].edges.add self.edges.high func mag(s: varargs[float]): float = result = 0 for k in s: result += (k * k) result = sqrt(result) func relates(self: Edge; v: int): bool = result = false if self.v1 == v: return true if self.v2 == v: return true func opposite(self: Edge; v: int): int = if v == self.v1: return self.v2 if v == self.v2: return self.v1 # TODO find proper exception raise new_exception(Defect, "Vertex was not in edge") func set_defaults*(self: var Solver) = self.chi = 1 self.sigma = 2 func validate(self: Edge) = assert self.length > 0 func validate(self: Solver) = assert self.sigma > 1 func randomize(self: var Solver) = # TODO somehow check if the randomizer is uninitialized, as that will cause an infinite lockup for i in 0..<self.vertices.len: self.vertices[i].x = self.rng.gauss() self.vertices[i].y = self.rng.gauss() iterator neighbors(self: Solver; vi: int): lent Vertex = # yield only nodes which do share edges with v_i for ei in self.vertices[vi].edges: yield self.vertices[opposite(self.edges[ei], vi)] iterator neighbors_edge(self: Solver; vi: int): (lent Vertex, float) = # yield only nodes which do share edges with v_i for ei in self.vertices[vi].edges: yield (self.vertices[opposite(self.edges[ei], vi)], self.edges[ei].length) iterator not_neighbors(self: Solver; vi: int): lent Vertex = # yield only nodes which do not have edges with v_i for i in 0..<self.vertices.len: block mushroom: for ei in self.vertices[i].edges: if relates(self.edges[ei], vi): break mushroom yield self.vertices[i] func align(self: var Solver; vi: int): (float, float) = var v = addr self.vertices[vi] let px = v.x let py = v.y var dpx = 0.0 var dpy = 0.0 for (m, chi) in neighbors_edge(self, vi): let qx = m.x - px let qy = m.y - py let q = mag(qx, qy) dpx += qx * (((q - chi) * Nu) / q) dpy += qy * (((q - chi) * Nu) / q) for m in not_neighbors(self, vi): let qx = m.x - px let qy = m.y - py let q = mag(qx, qy) var cx = qx * (-Nu / (pow(q, self.sigma + 1))) var cy = qy * (-Nu / (pow(q, self.sigma + 1))) let c = mag(cx, cy) if c > self.chi: cx *= (self.chi / c) cy *= (self.chi / c) dpx += cx dpy += cy return (dpx, dpy) func align_all(self: var Solver): float = result = 0 for i in 0..<self.vertices.len: var v = addr self.vertices[i] let (dpx, dpy) = align(self, i) let dp = mag(dpx, dpy) if dp > result: result = dp v.x += dpx v.y += dpy func solve*(self: var Solver) = validate(self) debugecho "> randomizing" randomize(self) debugecho "> solving" var i = 0 let target = Beta * self.chi while true: let energy = align_all(self) inc i debugecho i, ",", energy if energy < target: break # optional: could recenter the graph if you wanted

Show more
Qoto Mastodon

QOTO: Question Others to Teach Ourselves
An inclusive, Academic Freedom, instance
All cultures welcome.
Hate speech and harassment strictly forbidden.