joelonsql

Karatsuba Multiplication for factors with significant length disparity.

The Half-Karatsuba Multiplication Algorithm is a specialized case of the normal Karatsuba multiplication algorithm, designed for the scenario where var2 has at least twice as many base digits as var1.

In this case var2 (the longer input) is split into high2 and low1, at m2 (half the length of var2) and var1 (the shorter input), is used directly without splitting.

joelonsql

Enhance Rust RFCs with a Minimal but Realistic Code Example

Imagine opening a Rust RFC and, right at the top, before any detailed discussion or jargon kicks in, you're met with a small, relatable code example. This snippet isn't just for show; it clearly demonstrates the existing problem, pinpoints why the current approach feels cumbersome or inelegant, and showcases the elegance introduced by the RFC's proposal.

The Idea: Start every Rust RFC with a succinct real-life code example. This example would:

1. Spotlight the Issue: Directly show what’s problematic in the current system.

joelonsql

Original version: 0243-trait-based-exception-handling.md

In this proposed improved version, the Illustrative Example section has been added to the beginning of the document

---

• Feature-gates: question_mark, try_catch
• Start Date: 2014-09-16
• RFC PR #: rust-lang/rfcs#243
• Rust Issue #: rust-lang/rust#31436

joelonsql

Flashback Logging

NOTE: Post-writing, I discovered a similar concept named Ring Buffer Logging. What sets Flashback Logging apart is its approach to handling the buffer. When a log event matches the standard log level threshold, such as 'INFO', the buffer is cleared. This behavior is based on the rationale that such a log event indicates the system's return to normal operations, eliminating the need to keep previously buffered entries.

Introduction

Flashback Logging is a design pattern in the logging and debugging domain. Its primary goal is to reduce the time spent on debugging by making verbose logs readily available during error occurrences without the storage overhead of always keeping verbose logs.

joelonsql

/*
 * ETALON v1.0
 *
 * Introducing Elon's Estimator: ETALON
 *
 * The ultimate tool for achieving maximum productivity!
 * 
 * With just a single command, you can now estimate the completion date of your
 * next big project, just like Elon himself. Say goodbye to endless project
 * planning and hello to efficiency!

joelonsql

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index a83feea396..dea55847fd 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -301,6 +301,7 @@ struct NumericData
  * This is feasible because the digit buffer is separate from the variable.
  * ----------
  */
+#define FIXED_BUF_LEN 8
 typedef struct NumericVar

joelonsql

CREATE OR REPLACE FUNCTION numeric_from_bytes(bytea)
RETURNS numeric
LANGUAGE plpgsql
AS $$
declare
  bits bit varying;
  result numeric := 0;
  exponent numeric := 0;
  bit_pos integer;
begin

joelonsql

--
-- Content-Addressed Functions
--
-- Inspired by Unison's concept of using a hash of a function's syntax tree
-- as its name, sometimes referred to as "content-addressed naming",
-- we can avoid the need to create/drop lots of different temp function,
-- by using the hash of its definition as its name,
-- and simply reuse the function for all tests that need the same function.
--
-- While Unison uses 512-bit SHA3, we use sha224() since the maximum length

joelonsql

const std = @import("std");
const bigint = std.math.big.int.Managed;

pub fn main() !void {
    var a = try bigint.initSet(std.heap.c_allocator, 5);
    try a.pow(&a, try std.math.powi(u32, 4, try std.math.powi(u32, 3, 2)));
    defer a.deinit();

    var as = try a.toString(std.heap.c_allocator, 10, .lower);
    defer std.heap.c_allocator.free(as);

joelonsql

CREATE OR REPLACE FUNCTION tarjan(from_nodes int4range[], to_nodes int[])
RETURNS SETOF int[]
LANGUAGE plpgsql
AS
$$
--
-- https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
--
DECLARE
current_index integer := 0;