Skip to content

Instantly share code, notes, and snippets.

@tetsuok

tetsuok/answer_exercise_gotour.go

Created April 2, 2012 01:58
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save tetsuok/2279991 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save tetsuok/2279991 to your computer and use it in GitHub Desktop.
Download ZIP
An answer of the exercise: Loops and Functions on a tour of Go
Raw
answer_exercise_gotour.go
package main
import (
"fmt"
"math"
)
const Delta = 0.0001
func isConverged(d float64) bool {
if d < 0.0 {
d = -d
}
if d < Delta {
return true
}
return false
}
func Sqrt(x float64) float64 {
z := 1.0
tmp := 0.0
for {
tmp = z - (z * z - x) / 2 * z
if d := tmp - z; isConverged(d) {
return tmp
}
z = tmp
}
return z
}
func main() {
attempt := Sqrt(2)
expected := math.Sqrt(2)
fmt.Printf("attempt = %g (expected = %g) error = %g\n",
attempt, expected, attempt - expected)
}
@ur0

ur0 commented Nov 2, 2015

Copy link
Copy Markdown

Here _go_es another one.

package main

import (
  "fmt"
  "math"
)

const Delta = 1e-3

func sqrt(x float64) float64 {
  // x is the input, float64
  // g is the guess, float64
  g := float64(1)
  for {
    // t, what we're looking at
    t := g - (g*g - x)/2 * g
    // d is the delta
    if d := math.Abs(g - t); d < Delta {
      return  t
      break
    }
    g = t
  }
  return g
}

func main() {
  i := 2
  guess := sqrt(2)
  actual := math.Sqrt(2)
  fmt.Printf("Number: %v, Guess: %g, Actual: %g, Delta: %g", i, guess, actual, math.Abs(guess - actual))
}

@cahitbeyaz

cahitbeyaz commented Mar 27, 2017

Copy link
Copy Markdown

Solution for 10 iterations:

package main

import ("fmt"
		"math"
		)

func Sqrt(x float64) float64 {
	var zN, zNp1 float64
	zN = 1
	for i:=0;i<10;i++{
		zNp1 = zN - ((zN*zN - x) / (2 * zN))
		zN=zNp1
	}
	return float64(zNp1)
}

func main() {
	nmr:=float64(2)
	guess:=Sqrt(nmr)
	actual:=math.Sqrt(nmr)
	delta:=math.Abs(guess-actual)
	fmt.Println("Number Guess:  Actual   Delta " ,nmr ,guess ,actual,delta)
}

@meaudotme

meaudotme commented Apr 23, 2017

Copy link
Copy Markdown

For 10 iterations too:

package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	res := 1.0
	for n := 0; n < 10; n++ {
		res = res - ((res*res - x) / (2 * res))
	}
	return res
}

func main() {
	z := 169.
	fmt.Println(Sqrt(z))
	fmt.Println(math.Sqrt(z))
}

@acesaif

acesaif commented May 1, 2017 •
edited
Loading

Copy link
Copy Markdown

this is nice algorithm to find sqrt programmatically ... Before I didn't know this ...

package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z := float64(1)
	for i := 1; i <= 10; i++ {
		z = z - (z*z-x)/(2*z)
	}
	return z
}

func main() {
	p := 6.0
	fmt.Println(Sqrt(p)) // newton's technique  
	fmt.Println(math.Sqrt(p)) // validation by an inbuilt function 
}

@tufank

tufank commented Jun 15, 2017 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
)

const diff = 1e-6

func Sqrt(x float64) float64 {
	z := x
	var oldz = 0.0
	for {
		if v := z - oldz; -diff < v && v < diff {
			return z
		} else {
			oldz = z
			z -= (z*z - x) / (2 * z)
		}
	}
}

func main() {
	fmt.Println(Sqrt(2))
}

@donbr

donbr commented Nov 21, 2017 •
edited
Loading

Copy link
Copy Markdown

I used the statement to calculate 'z' provided in the tutorial. Works very well.

package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z := x / 2
	for i := 1; i <= 10; i++ {
		z -= (z*z - x) / (2 * z)
		fmt.Printf("Sqrt approximation of %v attempt %v = %v\n", x, i, z)
	}
	return z
}

func main() {
	x := 1525.0
	fmt.Printf("\n*** Newton Sqrt approximation for %v = %v\n", x, Sqrt(x))
	fmt.Printf("*** math.Sqrt response for %v = %v\n", x, math.Sqrt(x))
}

@ceaksan

ceaksan commented Feb 28, 2018 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z := float64(1)
	for i := 0; i < 10; i++ {
		z = z - (z * z-x) / (2 * z)
	}
	return z
}

func main() {
	i := float64(169)
	fmt.Println(Sqrt(i), Sqrt(i) == math.Sqrt(i))
}

@danong

danong commented Mar 28, 2018

Copy link
Copy Markdown 

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z := x / 2
	for prev := 0.0; math.Abs(prev-z) > 1e-8; {
		prev = z
		z -= (z*z - x) / (2 * z)
	}
	return z
}

func main() {
	fmt.Println(Sqrt(8))
}

@DersioK

DersioK commented Jul 9, 2018 •
edited
Loading

Copy link
Copy Markdown

Simplest way to implement the code is as follows:

import "fmt"

func Sqrt(x float64) float64 {
z := float64(1)
for i:=0;i<10;i++{
z -= (zz - x) / (2z)
fmt.Println(z) //Just to view each iteration of z
}
return z
}

func main() {
fmt.Println(Sqrt(2))
}

@justinpage

justinpage commented Jul 22, 2018 •
edited
Loading

Copy link
Copy Markdown

Here's another take. Instead of fooling around with the delta and absolute values, let's convert the type to something more finite.

package main

import (
	"fmt"
	"math"
)

func Sqrt(start float64) float64 {
	for guess := 1.0; ; {
		state := guess
		guess -= (guess*guess - start) / (2 * guess)

		if float32(state) == float32(guess) {
			return guess
		}
	}
}

func main() {
	fmt.Println(Sqrt(6.0) == math.Sqrt(6.0)) // true
	fmt.Println(Sqrt(2) == math.Sqrt(2))     // true
	fmt.Println(Sqrt(866) == math.Sqrt(866)) // true
}

@TomYeoman

TomYeoman commented Sep 8, 2019

Copy link
Copy Markdown 
// SquareRoot x
func SquareRoot(x float64) float64 {
	z, count, thresh := float64(1), 10, float64(0.1)

	for index := 0; index < count; index++ {
		z = z - ((z*z - x) / (2 * z))

		fmt.Printf("Z Val [ %v ] , Predicted [ %v ], Actual [ %v ] \n", z, z*z, x)

		if guess := z * z; math.Abs(guess-x) < thresh {
			fmt.Printf("Fell within threshold of [ %v ] within [ %v ] counts \n", thresh, index)
			break
		}
	}

	return z
}

Sample output

Z Val [ 327 ] , Predicted [ 106929 ], Actual [ 653 ]
Z Val [ 164.49847094801223 ] , Predicted [ 27059.746944234023 ], Actual [ 653 ]
Z Val [ 84.23405635482261 ] , Predicted [ 7095.376249987432 ], Actual [ 653 ]
Z Val [ 45.99313261935662 ] , Predicted [ 2115.3682481417263 ], Actual [ 653 ]
Z Val [ 30.095452195580968 ] , Predicted [ 905.7362428564993 ], Actual [ 653 ]
Z Val [ 25.896541323366037 ] , Predicted [ 670.6308525128048 ], Actual [ 653 ]
Z Val [ 25.556131917093378 ] , Predicted [ 653.1158785638788 ], Actual [ 653 ]
Z Val [ 25.553864778931494 ] , Predicted [ 653.0000051399155 ], Actual [ 653 ]
Fell within threshold of [ 0.1 ] within [ 7 ] counts

@igagankalra

igagankalra commented Jul 4, 2020 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z := 1.0
	for x >= z {
		z -= (z*z - x) / (2 * z)
		fmt.Println(z)
		if z == math.Sqrt(x) {
			break
		}

	}
	return z

}

func main() {
	fmt.Println(Sqrt(9999800001))

	fmt.Println("printing")

	fmt.Println(math.Sqrt(9999800001))

}

@horizon365

horizon365 commented Dec 9, 2020 •
edited
Loading

Copy link
Copy Markdown 

import "fmt"

func Sqrt(x float64) float64{
	z := float64(1)
	mydict := make(map[float64]float64)
	for  {
		z -= (z*z - x) / (x * z)
		_, ok := mydict[z]
		if !ok{
			mydict[z] = z
		} else {
			break
		}
		fmt.Println(z)
	}
	return z
}

func main() {
	fmt.Println(Sqrt(3))
}

@tiomno

tiomno commented Feb 1, 2022 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
)

func Sqrt(x float64) float64 {
	z := 1.0

	for {
		distance := z*z - x
		
		if distance > -.000000001 && distance < ..000000001 {
			break
		}
		
		z -= distance / (2*z)
		
		fmt.Println(z)
	}

	return z
}

func main() {
	fmt.Println(Sqrt(2))
}

@bboy114crew

bboy114crew commented Mar 20, 2022 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

const epison = 0.00001

func Sqrt(x float64) float64 {
	result := 1.
	for {
		result = result + (x / (2 * result) - result / 2)
		if math.Abs(result * result - x) < epison {
			break
		}
	}
	return result
}

func main() {
	fmt.Println(Sqrt(2))
}

@keshabagadia

keshabagadia commented Jul 19, 2022

Copy link
Copy Markdown

package main
import (
"fmt"
"math"
)

func Sqrt(x float64) float64 {
z,t := 1.,0.

for math.Abs(t-z) >= 1e-8 {
    t,z = z, z - (z*z - x) / (2*z)
}
return z

}
func main() {
guess := Sqrt(2)
expected := math.Sqrt(2)
fmt.Printf("Guess: %v, Expected: %v, Error: %v", guess, expected, math.Abs(guess - expected))
}

@thaiquangquy

thaiquangquy commented Oct 9, 2022

Copy link
Copy Markdown

Can anyone let me know the different of z -= (z*z - x) / (2 * x) and z -= (z * z - x)/(2 * z) in attached example?
The result is different between these expressions which make me very confuse

You can find the full code here https://go.dev/play/p/ff8LzDMIg8c

@gozilla-paradise

gozilla-paradise commented Dec 13, 2022 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z,p := 1.0, 0.0
	for math.Abs(p-z) >= 1e-8 {
		p,z = z, z - (z*z - x) / (2*z)
	}
	return z
}

func main() {
	fmt.Println(Sqrt(2))
}

@nikurasutan

nikurasutan commented Jan 21, 2023

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) (z float64, iterations int) {
	z = 1.0
	iterations = 0
	for {
		iterations++
		temp := z - (z*z - x) / (2*z)
		if math.Round(temp * 100000) / 100000 == math.Round(z * 100000) / 100000 {
			break
		}
		z = temp
	}
	return
}

func main() {
	fmt.Println(Sqrt(2))
	fmt.Println(math.Sqrt(2))
}

As a total beginner I've done it with rounding

@maricarmendev

maricarmendev commented Mar 8, 2023

Copy link
Copy Markdown 
package main

import (
	"fmt"
)

func Sqrt(x float64) float64 {
	z := 1.0
	for i := 0; i <= 10; i++ {
		z -= (z*z - x) / (2 * z)
	}
	return z
}

func main() {
	fmt.Println(Sqrt(23123))
}

@ankitkumar5422

ankitkumar5422 commented Mar 27, 2023

Copy link
Copy Markdown

package main

import (
"fmt"
"math"
)

func Sqrt(x float64) float64 {
z:=1.0

for n:= 1;n < 10;n++ {
	z = z - ((z*z - x) / (2*z))
}
return z

}

func main() {
y := 169.
fmt.Println(Sqrt(y))
fmt.Println(math.Sqrt(y))
}

@vishwa5854

vishwa5854 commented Jan 30, 2024

Copy link
Copy Markdown

func Sqrt(x float64) float64 {
var z, tmp float64 = 1.0, 0.
for ; math.Abs(z - tmp) >= 1e-8 ; z, tmp = z - (zz-x)/(2z), z {}
return z
}

@masiunas

masiunas commented Jun 10, 2024

Copy link
Copy Markdown

package main

import (
"fmt"
)

func Sqrt(x float64) float64 {
z := float64(1)
for i := 1; i <= 10; i++ {
nextZ := z - (zz-x)/(2z)
if nextZ == z {
return z
} else {
z = nextZ
fmt.Println(z, i)
}
}
return z
}

func main() {
p := 2.0
fmt.Println(Sqrt(p))
}

@NATSUNOAME1337

NATSUNOAME1337 commented Mar 15, 2025

Copy link
Copy Markdown

package main

import (
"fmt"
"math"
)

func Sqrt(x float64) float64 {
z := 1.0
iterations := 0

for i := 0; i <= 100; i++ {

	z -= (z*z - x) / (2 * z)
	iterations += 1

	if z == math.Sqrt(x) {
		break
	}
}
fmt.Println(z, "iterations: ", iterations)
return z

}

func main() {
var x float64 = 102444
fmt.Println("Guess: ", Sqrt(x))
fmt.Println("Math module: ", math.Sqrt(x))
}

@filipcvejic

filipcvejic commented Apr 29, 2025 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	prev, z := 0.0, 1.0
	
	for math.Abs(prev - z) > 1e-3 {
		prev = z
		z -= (z*z - x) / (2*z)
	}
	
	return z
}

func main() {
	n := 2.0
	g := Sqrt(n)
	a := math.Sqrt(n)
	d := math.Abs(g - a)
	fmt.Printf("Guessed: %f  Actual: %f  Delta: %f\n", g, a, d)
}

@ArturSultanov

ArturSultanov commented Sep 15, 2025 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt";
	"math"
)

func Sqrt(x float64) float64 {
	z := 1.0
	for math.Abs(z*z-x) > 1e-8 {
		z -= (z*z - x) / (2*z)
	}
	return z
}

func main() {
	x := float64(2)
	fmt.Println(Sqrt(x))
}

@gmyrianthous

gmyrianthous commented Oct 26, 2025 •
edited
Loading

Copy link
Copy Markdown 
package main

import (
	"fmt"
	"math"
)

func Sqrt(x float64) float64 {
	z := 1.0
	
	for math.Abs(z * z - x) > 1e-15 {
		z -= (z * z - x) / (2 * z)
	}
	
	return z
}

func main() {
	fmt.Printf("Own implementation result:\t %v\n", Sqrt(2))
	fmt.Printf("math package result:\t\t %v", math.Sqrt(2))
}

@ayclqt

ayclqt commented Dec 16, 2025

Copy link
Copy Markdown 
package main

import (
	"fmt"
)

func Sqrt(x float64) float64 {
	z := 1.
	for i:=0; i<10; i++ { // for 10 iterations
		z -= (z*z - x) / (2*z)
		if z*z == x {
			return z
		}
	}
	return z
}

func main() {
	fmt.Println(Sqrt(2))
}

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment