Implicitly cast "float" to "complex" in complex arithmetic

[goldenbergdaniel]

Currently, in order to perform arithmetic between a numeric and a complex number, the numeric type must be explicitly cast to a complex type. This can be observed in the DFT example below, where x is of type []f32 and H is of type []complex64:

H[i] += complex64(x[j]) * complex(math.cos(f32(j))*f32(i)*math.TAU/f32(N)), -math.sin(f32(j)*f32(i)*math.TAU/f32(N)))

My proposal is to implicitly cast the scalar part (which can be either real or imaginary) to a complex number. This would simplify the code into this:

H[i] += x[j] * (math.cos(f32(j)*f32(i)*math.TAU/f32(N) - 1i*math.sin(f32(j)*f32(i)*math.TAU/f32(N)))

In addition to providing an ergonomic benefit, this behavior would be consistent with existing behavior that allows implicitly casting a scalar type to complex type on assignment.

a: f32 = 5
b: complex64 = a

[irremnent]

If this is intended behavior (arithmetic operators refuse to convert up to complex/quaternion), I think it would be worth adding that functionality to the arithmetic operators. You can already convert up to complex numbers in procedure arguments as shown below. Is there a reason why this shouldn't extend to arithmetic operators?

package main

main :: proc() {
    real_num : f32 = 5
    comp_num : complex64 = 3 + 2i

    // "real_num * comp_num" wouldn't work here
    result : complex64 = comp64_mult(real_num, comp_num)
    assert(result == 15 + 10i)
}

comp64_mult :: proc(num1: complex64, num2: complex64) -> complex64 {
    return num1 * num2
}