golang calculate full precision float number

Used a decimal point of 200 as the precision, I need to calculate a number from atto to decimal number similar screenshot.

To get the values at precision of nano and atto you can use %.9f and %.18f in fmt.Printf() respectively,I created a small program to get your value of 0.000000000000099707 as follows:

package main

import (
	"fmt"
	"math"
)

func main() {

	powr := math.Pow(10, -18)
	numb := 99707 * powr
	fmt.Println("number", numb)
	fmt.Printf("\nthe value in atto %.18f\n", numb)
}

Output:

number 9.970700000000001e-14

the value in atto 0.000000000000099707

I was interested in how to do this so I found the apd package from cockroach that handles arbitrary precision calculations. You can use it like this:

import (
	"fmt"
	"github.com/cockroachdb/apd"
)

func main() {
	// 99707 * 10^(-18)
    n1 := apd.New(99707, 0)
    n2 := apd.New(10, 0)
    n3 := apd.New(-18, 0)
	c := apd.BaseContext.WithPrecision(200)
	res := apd.New(0,0)

	ctx, err := c.Pow(res, n2, n3)
	if err != nil {
		panic(err)
	}
	ctx, err = c.Mul(res, res, n1)
	if err != nil {
		panic(err)
	}
	
	fmt.Println(ctx.Inexact(), res.Text('f'))
}

And it will output:

false 0.000000000000099707

You will have to be careful with the loss of precision that may happen and look at the inexact field.

You can use the github.com/shopspring/decimal package for this as well. This library can represents numbers up to 2^31 (2147483648) digits. Here is a simple code to do the calculation:

d := decimal.NewFromInt(99707)
d10 := decimal.NewFromInt(10)
dpow := decimal.NewFromInt(-18)
d10pow := d10.Pow(dpow)
dmul := d.Mul(d10pow)
fmt.Println(dmul)

This can simplified to:

d := decimal.NewFromInt(99707).Mul(decimal.NewFromInt(10).Pow(decimal.NewFromInt(-18)))
fmt.Println(d)

Output: 0.000000000000099707

See playground