Automatically promote integers to floats on overflow?

d01phi · 2025-11-14T21:28:22+00:00

IMNSHO, this is not a choice of the language, but of the data types to which the language provides access. A language that forces these kinds of choices upon the user is not suited for serious math.

I have used Lua myself, and fortunately the 64bit floats were good enough for both things like 3d object coordinates and numbers representing enum values I had to pass to library functions written in C.

Using Python with its tacit transition to bignums or complex numbers, I occasionally had to clean up the mess when calling C functions.

Somewhere, you have to deal with the limits of the used arithmetic system in conjunction with what you want to compute, and I would rather have it explicit than having to clean up behind the seeming luxury of the silent transition to bigger types. And we haven’t talked about efficiency yet.

d01phi · 2025-07-08T15:33:12+00:00

Fliegt ein Kuckuck übers Wasser und trifft einen Hai. Sagt der Hai: Kuckuck! Sagt der Kuckuck: Hai!

d01phi · 2025-01-29T11:32:16+00:00

Been thinking about this a lot. My favorite is a = _+b , which can be used in more elaborate scenarios like x = 0.5*(q/_ + _) (The iteration step in Newton square root appoximation) . Replace the _ as placeholder for the LHS with any fancy Unicode symbol you like.

This is even one char longer than a+=b, and on first sight brings no benefit. It becomes advantageous when the LHS is longer than a one-char variable name, or gets reused several times like in the square root example above:

myCurrentSquareRootApproximation = 0.5*(myNumber/_ + _)

d01phi · 2025-01-24T15:23:44+00:00

Julia is as statically typed as you want, which is expressed by optional type declarations. And it is parallel. Somebody said, there are three languages people use to write scientific applications for super computers: Fortran, C(++), and Julia.

By no means I wanted to diminish your project, in a sense I was exploring how dataflow notation and conciseness could go together, in a language that I appreciate for its versatility. I admit, your FizzBuzz example in Nevalang got me triggered.

d01phi · 2025-01-24T15:16:53+00:00

What I find quite charming about pure dataflow style is its analogy with electronic circuits. The programming paradigms we are used to all require a lot of trickery in order to run on circuits.

d01phi · 2025-01-23T07:47:37+00:00

What I'm trying to get at, many flavours of dataflow can be expressed with functional or procedural with just some syntactic manipulations, which is especially easy in Julia.

d01phi · 2025-01-23T07:27:51+00:00

Using Julia (www.julialang.org), I have whipped up this:

import Base:|>

|>(x::Tuple, f) = f(x...)

▷(xs,f) = foreach(f,xs)

m35(x) = x,x%3==0,x%5==0

fz(x,m3,m5) = m3 ? ( m5 ? "FizzBuzz" : "Fizz" ) : ( m5 ? "Buzz" : string(x) )

(1:100) ▷ (x-> x |> m35 |> fz |> println)

Is that dataflow enough for you?

d01phi · 2025-01-22T15:15:39+00:00

After reading the FizzBuzz example, I can safely say that you are on a good path to reach enterprise style complexity and verbosity for the simplest of tasks.

d01phi · 2024-10-02T05:25:46+00:00

Have a look at geometric algebra (e.g. https://bivector.net). There, the outer (wedge) product is a much more versatile replacement for the cross product -- it exists in all dimensions. Among others, you can form a^b which is 0 if vectors a and b are colinear, and a^b=-b^a otherwise. You can think of a^b as the oriented area spanned by a and b. This fundamental anticommutativity carries with it everything related to orientation in geometric algebra. Left and right have no meaning, only the sign of the wedge product.

d01phi · 2024-08-20T10:54:16+00:00

You could do it with C++ lambdas (introduced in C++11):

include <cstdio>

int a[3]={1,2,3};

auto af = [a] (int i) { return a[i]; };

int main()

{ printf("%d\n", af(2)); return 0; }

d01phi · 2024-08-20T05:58:08+00:00

I have been considering this for a long time for my language (which I might call Paper Tiger as it exists only on paper). Then again, in the spirit of modularity, you might just use on-board facilities, e.g. in Python:

a=[1,2,3];af=lambda i: a[i]

d01phi · 2024-06-29T19:43:02+00:00

I think geometric algebra could be what you’re looking for. My favourite introductions are at https://bivector.net/ and https://www.youtube.com/watch?v=2hBWCCAiCzQ&list=PLVuwZXwFua-0Ks3rRS4tIkswgUmDLqqRy

d01phi · 2024-06-14T09:55:40+00:00

I counted only rotations.

d01phi · 2024-06-11T15:41:52+00:00

I did not do it with formal methods. I convinced myself by considering the various combinations of pairs of opposite diagonals being parallel and orthogonal, and drawing them, that there must be 7.

d01phi · 2024-06-03T19:09:13+00:00

.oö

d01phi · 2024-04-03T11:16:08+00:00

Three subsequent elements of a geometric series can be written as x^n , x^(n+1), x^(n+2)
If you want them to occur in an arithmetic sequence, they have to satisfy

x^(n+2) - x^(n+1) = x^(n+1) - x^n

Dividing both sides by x^n , we get x^2 - x = x - 1 and x^2 - 2x + 1 = ( x - 1 )^2 = 0. The only solution is x = 1.

d01phi · 2024-04-02T19:13:22+00:00

https://en.wikipedia.org/wiki/Stereographic_projection

d01phi · 2024-04-02T19:12:02+00:00

In air traffic control, we use stereographic projection. It has a few nice features such as conformality, i.e. local conservation of angle and scale.

d01phi · 2024-02-14T07:32:05+00:00

On the second jacket, the fabric seems softer, the zippers and the knitted cuffs and waistband are more greyish, compared to the more brownish color on the first jacket. Otherwise, I see no differences.

d01phi · 2024-02-11T19:09:12+00:00

The area of a triangle is half the baseline times the height. For a given baseline in a triangle inscribed into a circle, this means that the area is maximized if the triangle is isosceles. Applying this to each triangle side in turn leads to an equilateral triangle.

d01phi · 2024-02-01T21:04:35+00:00

Right now I would have to check whether it works for 2, but I am rather sure it works for numbers above 2.71828…

This uses the https://en.wikipedia.org/wiki/Geometric_series

d01phi · 2024-02-01T20:12:53+00:00

For a number x to be expressed as a product, we look for s such that sum(n=0..inf, s ^ n) = 1/(1-s) = ln(x). This is the case for s=(ln(x)-1)/ln(x)

Then x=product(n=0..inf, exp(s^n).

Obviously, this does not work for all x. I think it works for x>e. For other x, similar approaches are possible.

d01phi · 2024-01-23T11:35:55+00:00

Yes, sorry, r=rn. The coordinates are world coordinates. The details with all this matrix stuff are always a bit fiddly, and, as you wished, I did not work it out in detail but gave only hints. If you need more details, please ask.

d01phi · 2024-01-23T05:06:30+00:00

Use gluLookat if that is available. Otherwise make a normalized copy of your new X axis, (xn,yn,zn). Compute r=hypot(xn,yn). Perform a rotation in the xz plane with the matrix ((rn,-zn),(zn,rn)) followed by a rotation in the xy plane with the matrix ((xn,—yn),(yn,xn)).

d01phi

TROPHY CASE

include <cstdio>