Vektor Flow

A compact mathematical language for working with values, dimensions and functions.

Examples · Syntax · Features · Download · Performance

Write the relationships in your data. Named dimensions align values; explicit reductions combine them. Functions work over compatible structures, and demand selects what must be computed.

Examples

Edit and run these examples in your browser. This compiler is incomplete; the examples below are verified.

Named dimensions and reductions

Names align dimensions. Repeating a name selects a diagonal; summation is explicit.

A:[[1,2],[3,4]]_ij
::sum_j(A)
::A_ii

[3, 7]
[1, 4]

Matrix contraction

A:[[1,2],[3,4]]_ij
B:[[5,6],[7,8]]_jk
::sum_j(A*B)

[[19, 22], [43, 50]]

Calls and specialization

Parentheses call a function. Square brackets bind arguments into a callable.

f(x,step):x+step
g:f[step:2]
::g(3)

5

Ordered folds

A fold takes one binary reducer, one indexed value and one initial accumulator.

step(z,c):z+c
c:[1,2,3]_i
::reduce_i(step,c,0)

6

Function values and composition

add(x):x+1
double(x):2*x
F_i:[add,double]_i
::F_i(3)
h:add&double
::h(3)

[4, 6]
8

Composition applies add before double.

Exact derivatives

square(x):x^2
slope:square'x
::slope(3)

6

Lazy demand

values:..
values.(0..3) >> ::$

0
1
2
3

The consumer selects a finite prefix.

Loop indices

$ is the current value, $i the named coordinate, and $0 the outermost loop's iteration index. Nested loops use $1, $2 and later depths.

[10,20]_i >>
    ::$i
    ::$0
    ::$

0
0
10
1
1
20

Scalar scopes do not add a loop. Loop indices are read-only and scoped to their loop.

Nominal reconstruction

Point(x:num,y:num):
    : [x,y]
p:Point(1,2)
q:p+1
::q.x
::q.y

2
3

Compatible operations reconstruct through the constructor. Different nominal types do not implicitly unify.

Captured function values

Factories preserve each callable's concrete captures, including owned strings.

make(c):((x):str(c)&str(x))
f:make(2)
g:make("A")
::f(3)
::g(4)

23
A4

Callable selection

run(i:int):
 ::[+,*].(i)(2,3)
 0
run(0)
run(1)

5
6

The index selects a callable before its arguments execute.

Forward function declarations

f:make(2)
::f(3)
make(c:int):((x):x+c)

5

Declaration planning preserves executable source order.

Complex contractions

run():
 A_ij:[[num(1,1),num(2,-1),num(3,0)],[num(4,2),num(5,0),num(6,-2)]]
 B_jk:[[7,8],[9,10],[11,12]]
 C_ik:sum_j(A_ij * B_jk)
 :: C
 0
run()

[[58 - 2i, 64 - 2i], [139 - 8i, 154 - 8i]]

Tuples and vector rank

Tuples describe records; square brackets add vector dimensions.

pairs:[(1,2),(3,4)]_a
matrix:[[1,2],[3,4]]_ab
::pairs
::matrix

[(1, 2), (3, 4)]
[[1, 2], [3, 4]]

pairs has rank one; matrix has rank two.

Anonymous and named dimensions

Names align by identity. Anonymous dimensions align positionally with other anonymous dimensions. A suffix names the complete rank; ... explicitly preserves the remaining anonymous dimensions.

A:[[1,2],[3,4]]_ij
::A
B:[[[1,2],[3,4]],[[5,6],[7,8]]]_i...k
::B

[[1, 2], [3, 4]]
[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

A repeated dimension in an access selects a diagonal. A reduction removes only the dimensions explicitly selected. Mismatched aligned sizes are errors.

Structural calls

A selected dimension enters the function intact; the other dimensions lift.

stat:.stat
span(x):stat.max(x)-stat.min(x)
A:[[1,4],[2,8]]_ij
::span_i(A)

[1, 4]

The function receives each column.

Indexing and slicing

Inside .(), : preserves one dimension, ... preserves the remainder and :: inserts a size-one dimension.

A:[[1,2],[3,4]]
::A.(1,:)
::A.(...,0)
::A.(::,:,:)

[3, 4]
[1, 3]
[[[1, 2], [3, 4]]]

Concatenation

left:[1,2]_i
right:[3,4]_i
::left &_i right

[1, 2, 3, 4]

Physical quantities

Units belong to the whole value. Arithmetic checks physical dimensions and converts compatible quantities; addition keeps the left operand's preferred unit.

: .units
::2m+30cm
::30cm+2m
::([1,2,3]m).to(cm)

2.3 m
230 cm
[100, 200, 300] cm

Unit-aware helpers

Ordinary functions preserve quantity information. Conversion changes display, while storage retains the same physical quantity.

: .units
convert(x):x.to(cm)
x:[1,2,3]m
::convert(x)
::x

[100, 200, 300] cm
[1, 2, 3] m

Empty values and demand

An empty computation retains its type and shape, and performs no element work. An explicit whole-value conversion retains its display preference at zero length.

: .units
run(n:int):
    x:[2m:n]
    y:x.to(cm)
    ::y
    0
run(0)
run(2)

[] cm
[200, 200] cm

Units and powers

: .units
area(side):side^2
::area(3m).to(m^2)
::(6m/2s).to(m/s)

9 m^2
3 m/s

Angles and complex values

Angles are physically dimensionless, with radians as their canonical magnitude.

: .units
: .math
::sin(90deg)
::exp(num(0,1)*180deg)

1
-1 + 1.2246467991473532e-16i

Floating-point evaluation retains the small imaginary residue.

Domains and physical dimensions

A numerical domain, physical dimension and display unit carry different information.

: .units
position(t):2m*(t/1s)^2
velocity:deriv_t(position)
acceleration:deriv_t(velocity)
::position(3s).to(m)
::velocity(3s).to(m/s)
::acceleration(3s).to(m/s^2)

18 m
12 m/s
4 m/s^2

The intended symbolic domains x:R[L] and t:R[T] describe length and time; symbolic domain-variable differentiation is still planned. Function transforms already derive velocity and acceleration from the position function.

Templates

Double quotes interpolate immediately. Single quotes defer interpolation until .format(...). A prefix : spills runtime arguments.

x:1.26
::"x = $x.1f"
s:(x:1.26,y:2.5)
::'[$x.1f, $y.1f]'.format(:s)

x = 1.3
[1.3, 2.5]

Binding function arguments

Declare ordinary parameters in parentheses. Square brackets bind named arguments into a callable; parentheses evaluate the remaining arguments.

power(x,n):x^n
cube:power[n:3]
::cube(2)

8

Ordinary names such as x_min and particle_count remain identifiers; alphabetic suffixes select structural dimensions where applicable.

Geometry and physics

Properties describe meaning; dimensions describe structure. Connected dimensions u, v, w describe curves, surfaces and volumes. c describes components; t describes time. Other letters group values without naming an object category.

Connected geometry

One add call creates one layer. Three coordinate components make this a 3D curve:

frame:.ui.viewport
p:[[0,0,0],[1,1,2],[2,0,1]]_uc
frame.add(p:p)
frame.push()
frame.show()

set changes defaults, add creates a layer, push freezes the composed state, append adds and pushes, and plot appends and shows.

Explicit topology

References connect independent groups. The m dimension holds member slots.

frame:.ui.viewport
p:[[0,0,0],[1,0,1],[1,1,2],[0,1,3]]_ic
frame.add(p:p,edge:[[0,2],[2,3]]_bm)
frame.push()
frame.show()

Here i groups vertices and b groups edges; reference values connect them. The group letters themselves have no built-in vertex or edge meaning.

Unit-aware state evolution

A Law is an ordinary function over physical state. For constant acceleration:

: .units
advance(p,v,a,dt):(
    p:p+v*dt+a*dt^2/2,
    v:v+a*dt
)
state:advance(0m,2m/1s,1m/1s^2,2s)
::state.p
::state.v.to(m/s)

6 m
4 m/s

The same semantics should support compiler-selected CPU or GPU execution without user-written kernels or memory transfers.

Motion fields

One ordinary function advances positions across entity and component dimensions:

:.physics.units
advance(p,v,dt):(p:p+v*dt,v:v)
p_ic:[[0,0,0],[1,0,0]]m
v_ic:[[0,1,0],[0,2,0]]m/1s
state:advance_ic(p,v,2s)
::state.p
::state.v.to(m/s)

[[0, 2, 0], [1, 4, 0]] m
[[0, 1, 0], [0, 2, 0]] m/s

World integration is incomplete. Its design treats motion without _t as initial state and motion with _t as prescribed state. Prescribed position takes precedence over velocity, then acceleration, then Laws.

Shared geometry, multiple views

Two viewports use the same geometry with different cameras:

front:.ui.viewport
side:.ui.viewport
p:[[0,0,0],[1,0,0],[1,1,0],[0,1,0]]_uc
front.add(p:p)
front.add_camera(p:[0,0,4],target:[0,0,0],projection:"orthographic")
side.add(p:p)
side.add_camera(p:[4,0,1],target:[0,0,0],projection:"orthographic")
front.show()
side.show()

Grouped camera:cameras_a and view:views_a remain intended syntax. The current compiler uses separate viewports; geometry stays independent of the view.

Event and I/O concurrency

Compute scheduling belongs to the compiler. Event and I/O concurrency uses ordinary functions with queues, broadcasts, processes and shared values.

Queue and process

concurrent:.concurrent
worker(events):events.get()
events:concurrent.queue()
p:concurrent.process(worker,events)
events.put(42)
::p.join()

42

A queue delivers each item to one consumer; get() waits efficiently.

Broadcast and shared values

concurrent:.concurrent
updates:concurrent.broadcast()
ui_updates:updates.subscribe()
log_updates:updates.subscribe()
updates.put("ready")
::ui_updates.get()
::log_updates.get()
state:concurrent.shared((p:[1,2,3],mode:"run"))

ready
ready

Both active subscribers receive ready. shared accepts one ordinary value; published generations are immutable. Its update API remains a separate design decision.

VKF is experimental. These examples define intended behavior; compiler support and target verification are tracked independently.