tetsuok/answer_exercise_gotour.go

ur0 · 2015-11-02T09:46:52Z

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 · 2017-03-27T06:08:34Z

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)
}

nickdotht · 2017-04-23T01:09:44Z

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 · 2017-05-01T03:03:18Z

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 · 2017-06-15T20:06:58Z

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 · 2017-11-21T18:36:53Z

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 · 2018-02-28T07:16:26Z

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 · 2018-03-28T00:02:57Z


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 · 2018-07-09T08:26:50Z

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 · 2018-07-22T04:34:55Z

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 · 2019-09-08T21:06:23Z

// 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 · 2020-07-04T03:08:27Z

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 · 2020-12-09T09:24:37Z


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 · 2022-02-01T10:51:31Z

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 · 2022-03-20T15:42:46Z

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 · 2022-07-19T11:56:35Z

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 · 2022-10-09T00:42:46Z

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 · 2022-12-13T02:51:44Z

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 · 2023-01-21T18:55:18Z

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 · 2023-03-08T18:36:07Z

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 · 2023-03-27T10:37:49Z

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 · 2024-01-30T04:08:27Z

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 · 2024-06-10T15:27:06Z

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))
}

	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)
	}

tetsuok/answer_exercise_gotour.go

ur0 commented Nov 2, 2015

cahitbeyaz commented Mar 27, 2017

nickdotht commented Apr 23, 2017

acesaif commented May 1, 2017 •

edited

Loading

tufank commented Jun 15, 2017 •

edited

Loading

donbr commented Nov 21, 2017 •

edited

Loading

ceaksan commented Feb 28, 2018 •

edited

Loading

danong commented Mar 28, 2018

DersioK commented Jul 9, 2018 •

edited

Loading

justinpage commented Jul 22, 2018 •

edited

Loading

TomYeoman commented Sep 8, 2019

igagankalra commented Jul 4, 2020 •

edited

Loading

horizon365 commented Dec 9, 2020 •

edited

Loading

tiomno commented Feb 1, 2022 •

edited

Loading

bboy114crew commented Mar 20, 2022 •

edited

Loading

keshabagadia commented Jul 19, 2022

thaiquangquy commented Oct 9, 2022

gozilla-paradise commented Dec 13, 2022 •

edited

Loading

nikurasutan commented Jan 21, 2023

maricarmendev commented Mar 8, 2023

ankitkumar5422 commented Mar 27, 2023

vishwa5854 commented Jan 30, 2024

masiunas commented Jun 10, 2024

tetsuok/answer_exercise_gotour.go

ur0 commented Nov 2, 2015

cahitbeyaz commented Mar 27, 2017

nickdotht commented Apr 23, 2017

acesaif commented May 1, 2017 • edited Loading

tufank commented Jun 15, 2017 • edited Loading

donbr commented Nov 21, 2017 • edited Loading

ceaksan commented Feb 28, 2018 • edited Loading

danong commented Mar 28, 2018

DersioK commented Jul 9, 2018 • edited Loading

justinpage commented Jul 22, 2018 • edited Loading

TomYeoman commented Sep 8, 2019

igagankalra commented Jul 4, 2020 • edited Loading

horizon365 commented Dec 9, 2020 • edited Loading

tiomno commented Feb 1, 2022 • edited Loading

bboy114crew commented Mar 20, 2022 • edited Loading

keshabagadia commented Jul 19, 2022

thaiquangquy commented Oct 9, 2022

gozilla-paradise commented Dec 13, 2022 • edited Loading

nikurasutan commented Jan 21, 2023

maricarmendev commented Mar 8, 2023

ankitkumar5422 commented Mar 27, 2023

vishwa5854 commented Jan 30, 2024

masiunas commented Jun 10, 2024

acesaif commented May 1, 2017 •

edited

Loading

tufank commented Jun 15, 2017 •

edited

Loading

donbr commented Nov 21, 2017 •

edited

Loading

ceaksan commented Feb 28, 2018 •

edited

Loading

DersioK commented Jul 9, 2018 •

edited

Loading

justinpage commented Jul 22, 2018 •

edited

Loading

igagankalra commented Jul 4, 2020 •

edited

Loading

horizon365 commented Dec 9, 2020 •

edited

Loading

tiomno commented Feb 1, 2022 •

edited

Loading

bboy114crew commented Mar 20, 2022 •

edited

Loading

gozilla-paradise commented Dec 13, 2022 •

edited

Loading