Learning Go -- Scope

Hi I am new to Go programing language.

I am learning from http://www.golang-book.com/

In chapter 4, under Exercises, there is a question on converting from Fahrenheit to Centigrade.

I coded up the answer as follows

    package main

import "fmt"

func main(){
	
	fmt.Println("Enter temperature in Farentheit ");
	
	var input float64
	
	fmt.Scanf("%f",&input)
		
	var outpu1 float64 = ( ( (input-32)* (5) ) /9)
	var outpu2 float64=  (input-32) * (5/9)
	var outpu3 float64= (input -32) * 5/9
	var outpu4 float64=  ( (input-32) * (5/9) )	

	fmt.Println("the temperature in Centigrade is ",outpu1)
	fmt.Println("the temperature in Centigrade is ",outpu2)
	fmt.Println("the temperature in Centigrade is ",outpu3)
	fmt.Println("the temperature in Centigrade is ",outpu4)	
}

The output was as follows

sreeprasad:projectsInGo sreeprasad$ go run convertFarentheitToCentigrade.go 
Enter temperature in Farentheit 
12.234234
the temperature in Centigrade is  -10.980981111111111
the temperature in Centigrade is  -0
the temperature in Centigrade is  -10.980981111111111
the temperature in Centigrade is  -0

My question is with outpu2 and outpu4. The parenthesizes are correct but how or why does it print -0.

Could anyone please explain

Quite simply, the expression (5/9) is evaluated as (int(5)/int(9)) which equals 0. Try (5./9)

And to clarify why this is happening, it deals with the order in which the expression variable's types are determined.

I would guess that b/c (5/9) exists without regards to input in case 2 and 4 above, the compiler interprets them as int and simply replaces the expression with 0, at which point then the zero is considered dependent on input and thus takes on the type float64 before final compilation.

Generally speaking, Go does not convert numeric types for you, so this is the only explanation that would make sense to me.

The Go language Spec indicates that float32 and float64 are signed floating numbers that follow IEEE-754 standard. Following text is quoted from Wikipedia - Signed zero:

> The IEEE 754 standard for floating point arithmetic (presently used by most computers and programming languages that support floating point numbers) requires both +0 and −0. The zeroes can be considered as a variant of the extended real number line such that 1/−0 = −∞ and 1/+0 = +∞, division by zero is only undefined for ±0/±0 and ±∞/±∞.

Clearly, input, as a float64, when applied minus 32, turns into another float64 which is negative. 5/9 evaluates into 0. A negative float64 timed by 0 is -0.

Interestingly, if you replace input with an integer, e.g. 1, you'll get 0 instead of -0. It seems that in Go, floating numbers have both +0 and -0, but integers don't.

EDIT: PhiLho explains in comment about the reason why floating numbers have such thing while integers don't: normalized floating point numbers have special representations of +0, -0, NaN, +Infinity and -Infinity, while you cannot reserve some bit combinations of an integer number to have such meanings.