Skip to main content
100%

Go Tour: Exercise: Loops and Functions (http://tour.golang.org/flowcontrol/8)

✓ Published0🌍 Public
Aadkdev
Last edited Aug 13, 2015
Created on Aug 13, 2015

This example demonstrates Newton’s method for computing square roots, comparing iterative guesses against Go’s `math.Sqrt` for values 2, 9, 612, 90 billion, and 160 billion. The `Sqrt` function loops up to 50 times, printing each iteration’s index and current approximation, and stops early when the change between steps falls below 0.000001. Using `math.Pow`, `math.Abs`, and `fmt.Println`, it shows convergence behavior across vastly different magnitudes. The code’s commented-out intermediate calculations highlight the method’s algebraic steps without altering output.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist fe03ac887568cbb468c1d93a0c33d307

This example estimates the value of pi using a Monte Carlo simulation implemented in Go, running ten parallel goroutines to generate ten million random point samples within a unit square. It calculates pi by comparing the fraction of points falling inside a quarter-circle to the total sample area. The visualization uses the `sync.WaitGroup` and channels to coordinate parallel workers, with `rand.Float64()` generating coordinates and `math.Pow` computing the distance check. The program prints the resulting pi estimate and the wall-clock execution time.

WWilliamNHarvey
60% match
Loading thumbnail…

Gist 4621876

This example demonstrates how to automate the setup of a Go workspace and package installation via a shell script, following the official Go documentation. The script creates a temporary directory structure with a `src/newmath` folder and writes a custom `sqrt.go` file implementing a basic square root function. It then runs `go install example/newmath` to compile and install the package, verifying the result by checking for zero output or errors. The code relies on the Go command-line tool and standard shell utilities like `echo` and `mkdir`; no external visualization libraries are involved.

HHoffmannP
60% match
Loading thumbnail…

Implementation of sqRoot

This example implements a square-root approximation function using a binary search algorithm. The calculation begins with a range from 1 to the input number, repeatedly narrowing the search interval by comparing the midpoint squared to the target. The code tracks all midpoints in an array, sorts them, and returns the largest successful approximation when the search converges. The visualization demonstrates the step-by-step narrowing process, with each midpoint calculation highlighted as the algorithm iterates toward the result.

YYonet
59% match
Loading thumbnail…

Gist 425738

This example demonstrates a Monte Carlo simulation for approximating the value of π by generating random points within a unit square and counting how many fall inside the unit circle. The code uses Go’s standard `rand` package for pseudo-random number generation and `flag` for command-line parameters, with concurrent goroutines and channels to parallelize the sampling across multiple processes. It reports the calculated π value and the execution time in milliseconds, though it produces no visual chart or plot.

Aaht
57% match
Loading thumbnail…

Gist 63d8bf6ae5ef850809c429573e052edc

This example demonstrates the computation of the 8181st Fibonacci number using an iterative method with Java’s `BigDecimal` class to handle arbitrarily large integer results. The code defines two functions: a naive recursive version that would be impractical for large inputs, and an optimized iterative loop that builds the sequence by adding the previous two values. The main method prints the final result for 8181, showcasing how `BigDecimal` enables precise arithmetic beyond standard primitive type limits.

HHsuHsiaoHsuan
54% match
Loading thumbnail…

Gist 23875167ddf54617f817bbd24632696b

This example shows a JavaScript function that counts down from a given number and logs each value as either “par” (even) or “impar” (odd) to the console. It uses a `while` loop with a modulo (`%`) operator to test each integer against `0` and then prints the corresponding label. The function `func(10)` is called to process numbers from 10 down to 1, producing a simple text-based output without any graphical or charting libraries. The data source is the hardcoded initial value passed as an argument.

MMistyBlunch
52% match
Loading thumbnail…

newton function to solve f(V)=0

This example demonstrates Newton’s method for solving systems of equations, showing how the algorithm iteratively converges to a root from an initial guess. The visualization likely plots the function’s behavior or the iterative path in a 2D or 3D space, with the code using the `Newton.Solve` and `Newton.Zero` functions to compute roots. The implementation relies on QR decomposition and backsubstitution for matrix operations, as seen in `Newton.QRDec` and `Newton.QRBack`, and includes a backtracking line search to improve convergence. The code adapts a numerical method from a public-domain textbook, with no external charting library, instead computing and displaying results via raw JavaScript math and likely custom SVG or canvas rendering.

PPhilippe Rivière
51% match
Loading thumbnail…

Gist 16f26cdfd47fc8110f64ba1f4e292ad2

This example demonstrates basic integer division and exponentiation in Python. It assigns the values 11 and 5 to variables x and y, then computes the floor division result (2) and prints it, with a comment noting that 2.2 would be the floating-point result. The code also calculates and prints 2 raised to the power of 3, yielding 8. The visualization relies on standard Python print statements rather than any external data-visualization libraries, serving as a simple scripted arithmetic demonstration.

MMistyBlunch
51% match