func main() { var ( ctx decnum.Context a decnum.Quad b decnum.Quad r decnum.Quad ) if len(os.Args) != 3 { log.Fatal("2 numbers are required as argument") } fmt.Println(decnum.DecNumber_C_Version()) fmt.Println(decnum.DecNumber_C_MACROS()) // just for info about the macros defined in C decQuad module //========================= division a/b ================================== fmt.Println("") fmt.Println("========= division a/b ==========") ctx.InitDefaultQuad() // initialize context with default settings for Quad operations. Essentially, it contains the rounding mode. fmt.Printf("rounding: %s\n", ctx.Rounding()) // display default rounding mode ctx.SetRounding(decnum.ROUND_UP) // we can change it fmt.Printf("rounding: %s\n", ctx.Rounding()) ctx.SetRounding(decnum.ROUND_HALF_EVEN) // we can change it again fmt.Printf("rounding: %s\n", ctx.Rounding()) a = ctx.FromString(os.Args[1]) // convert first argument to Quad b = ctx.FromString(os.Args[2]) // convert 2nd argument to Quad if err := ctx.Error(); err != nil { // check if string conversion succeeded fmt.Println("ERROR: incorrect string input...") } fmt.Println("") fmt.Println("a is: ", a) fmt.Println("b is: ", b) fmt.Println("") fmt.Println("r is: ", r, "we see that an uninitialized Quad contains garbage.") r = ctx.Divide(a, b) // but no need to initialize r with decnum.Zero(), because its value is overwritten by the operation // ... // you can put other operations here, you will check for error after the series of operations // ... fmt.Println("r = a/b; r = ", r) status := ctx.Status() fmt.Printf("status: %s\n", status) if err := ctx.Error(); err != nil { // check if an error flag has been set. No need to check for error after each operation, wee can just check it after a series of operations have been done. log.Printf("ERROR OCCURED !!!!!!! %v\n", err) } //=========================== convert 'a' to int64 ================================= fmt.Println("") fmt.Println("========= convert 'a' to int64 ==========") ctx.ResetStatus() // clear the status // you can put another series of operations here // ... var x int64 x = ctx.ToInt64(a, decnum.ROUND_HALF_EVEN) if err := ctx.Error(); err != nil { // check for errors log.Printf("ERROR OCCURED !!!!!!! %v\n", err) } fmt.Printf("%s converted to int64 is %d\n", a, x) // you can always print a Quad, it always contains a valid value, even after errors //============================ compare 'a' and 'b' ================================ fmt.Println("") fmt.Println("========= compare 'a' and 'b' ==========") ctx.ResetStatus() // clear the status // you can put another series of operations here // ... var comp decnum.Cmp_t comp = ctx.Compare(a, b) // note: Compare doesn't set status flag if err := ctx.Error(); err != nil { log.Fatalf("ERROR OCCURED !!!!!!! %v\n", err) } fmt.Printf("comparison of %s and %s is %s\n", a, b, comp) //============================ quantize 'a' with pattern 'b' ================================ fmt.Println("") fmt.Println("========= quantize 'a' with pattern 'b' ==========") ctx.ResetStatus() // clear the status // you can put another series of operations here // ... var q decnum.Quad q = ctx.Quantize(a, b) if err := ctx.Error(); err != nil { log.Printf("ERROR OCCURED !!!!!!! %v\n", err) } fmt.Printf("quantization of %s with %s is %s\n", a, b, q) //============================ loop ================================ fmt.Println("") fmt.Println("========= loop ==========") ctx.ResetStatus() // clear the status var h decnum.Quad = decnum.Zero() var hh decnum.Quad = ctx.FromInt32(1000000000) for i := 0; i < 7; i++ { h = ctx.Add(h, hh) fmt.Printf("%d %s\n", i, h) } if err := ctx.Error(); err != nil { log.Printf("ERROR OCCURED !!!!!!! %v\n", err) } //============================ rounding ================================ fmt.Println("") fmt.Println("========= rounding (quantizing) ==========") ctx.ResetStatus() // clear the status var g_up decnum.Quad var g_down decnum.Quad ctx.SetRounding(decnum.ROUND_UP) assert(ctx.Rounding() == decnum.ROUND_UP) g_up = ctx.Quantize(a, decnum.One()) ctx.SetRounding(decnum.ROUND_DOWN) assert(ctx.Rounding() == decnum.ROUND_DOWN) g_down = ctx.Quantize(a, decnum.One()) ctx.SetRounding(decnum.ROUND_DEFAULT) assert(ctx.Rounding() == decnum.ROUND_HALF_EVEN) if err := ctx.Error(); err != nil { log.Printf("ERROR OCCURED !!!!!!! %v\n", err) } fmt.Printf("%s rounded up is %s\n", a, g_up) fmt.Printf("%s rounded down is %s\n", a, g_down) }