Golang return or float or complex

I'm trying to write a cubic equation solver.

func (a,b,c,d float64) (returnType,err){
      
   if a<0{
     return complex, nil
   }
   if a>=0 {
     return float64, nil
   }
}

Is there a way to return and interface or something to manage this behavior?

Since real numbers (floats) are a subset of complex numbers, you may opt to always return a complex number, and where you would only return float64, you leave the imaginary part 0:

func abcd(a, b, c, d float64) (complex128, error) {
	if a < 0 {
		r, j := 1.0, 2.0
		return complex(r, j), nil
	}
	if a >= 0 {
		r := 3.0
		return complex(r, 0), nil
	}
	return 0 + 0i, nil
}

Testing it:

c, err := abcd(1, 0, 0, 0)
fmt.Println(c, err)
if imag(c) == 0 {
	fmt.Println("\treal:", real(c))
}

c, err = abcd(-1, 0, 0, 0)
fmt.Println(c, err)
if imag(c) == 0 {
	fmt.Println("\treal:", real(c))
}

Which outputs (try it on the Go Playground):

(3+0i) <nil>
	real: 3
(1+2i) <nil>

Yes, if a complex number would be returned whose imaginary part is 0, you can't distinguish this special case from the case where only a real number would be returned. Maybe you don't have to? If not, it's not a problem. If you do need to differentiate them, you may also return a 3rd value telling if the result is in fact a complex number:

func abcd(a, b, c, d float64) (x complex128, isComplex bool, err error) {
	if a < 0 {
		r, j := 1.0, 2.0
		return complex(r, j), true, nil
	}
	if a >= 0 {
		r := 3.0
		return complex(r, 0), false, nil
	}
	return 0 + 0i, false, nil
}

Testing it:

c, isC, err := abcd(1, 0, 0, 0)
fmt.Println(c, isC, err)
if !isC {
	fmt.Println("\treal:", real(c))
}

c, isC, err = abcd(-1, 0, 0, 0)
fmt.Println(c, err)
if !isC {
	fmt.Println("\treal:", real(c))
}

Output is the same. Try this one on the Go Playground.

The above solutions are possible because real numbers are a subset of complex numbers. In the general case you may use multiple return values, each being a pointer, and you may check which return value is not nil. Something like this:

func abcd(a, b, c, d float64) (*complex128, *float64, error) {
	if a < 0 {
		r, j := 1.0, 2.0
		x = :complex(r, j)
		return &x, nil, nil
	}
	if a >= 0 {
		f := 3.0
		return nil, &f, nil
	}
	return nil, nil, nil
}

Testing it:

c, f, err := abcd(1, 0, 0, 0)
fmt.Println(c, f, err)
if c != nil {
	fmt.Println("\tcmplx:", *c)
}
if f != nil {
	fmt.Println("\treal:", *f)
}

c, f, err = abcd(-1, 0, 0, 0)
fmt.Println(c, f, err)
if c != nil {
	fmt.Println("\tcmplx:", *c)
}
if f != nil {
	fmt.Println("\treal:", *f)
}

Output (try it on the Go Playground):

<nil> 0xc000018050 <nil>
	real: 3
0xc000018070 <nil> <nil>
	cmplx: (1+2i)

And you could also combine the last 2 solutions: you could return non-pointers and an isComplex flag telling which return value is valid.