1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
package main
import (
"fmt"
"strconv"
"os"
"time"
// "path/filepath"
xl "anyxcelize"
// "git.gabbott.dev/george/excelize/v2"
st "saggytrousers"
bt "badtudexo"
)
func usage() {
fmt.Println(`bt-eqpct: check fields calculated from percentages
Usage:
bt-eqpct FILE -b BASE -p PERCENT -r RESULT -t TOLERANCE
-s SHEET -o OUTPUT
As an example, -b can be a price, -p can be discount %, and -r discount value.
Then it is calculated: BASE * (PERCENT ± TOLERANCE), and checked if RESULT is
in this range. This checks the discount amount is always within the tolerance
of what the percentage should be; if out, either the percentage or the value
(either -p or -r) are probably wrong and need correcting in the data.
The fields -b, -p and -r are required. If they are not passed, they will be
prompted for. The function Locate() is used to find these and is passed the
strings you passed in as params.
`)
os.Exit(0)
}
func parseArgs(args []string) {
if len(args) < 2 {
usage()
}
for i := 0; i < len(args); i++ {
arg := args[i]
switch arg {
case "--help", "-h", "help", "helpme":
usage()
case "-b", "--base":
i++
base = args[i]
case "-p", "--pct", "--percent", "--percentage":
i++
percent = args[i]
case "-r", "--result":
i++
result = args[i]
case "-t", "--tol", "--tolerance":
i++
t, err := strconv.ParseFloat(args[i], 64)
if err != nil {
fmt.Printf("Tolerance passed with -t could not be parsed into a float64\n")
os.Exit(-1)
}
tol = t
case "-s", "--sheet":
i++
sheet = args[i]
case "--time", "--timings":
timeme = true
case "-o", "--out", "--output":
i++
out = args[i]
case "-v", "--verbose":
verbose = true
default:
filename = arg
}
}
}
// Constants
const ToleranceNotSetValue float64 = 420.69
// Globals
var base string
var percent string
var result string
var tol float64 = ToleranceNotSetValue
var timeme bool = false
var verbose bool = false
var out string
var sheet string
var filename string
func main() {
args := os.Args
parseArgs(args)
file, err := xl.OpenFile(filename)
if err != nil {
fmt.Printf("Cannot open file [%s], err [%v].\n", filename, err)
return
}
/* Ask user to select the sheet */
sheet = st.SelectSheet(file, sheet)
/* Try find base, percent, result rows, else prompt for them */
header := st.GetHeader(file, sheet)
baseIdx := bt.LocateOrAsk(header, base, "Please choose the base: ")
percentIdx := bt.LocateOrAsk(header, percent, "Please choose the percent: ")
resultIdx := bt.LocateOrAsk(header, result, "Please choose the resultant value: ")
if tol == ToleranceNotSetValue {
tol = st.GetFloat64("Please set the tolerance: ")
}
if verbose {
fmt.Printf("base index: %v\n", baseIdx)
fmt.Printf("percent index: %v\n", percentIdx)
fmt.Printf("result index: %v\n", resultIdx)
}
/* Now load all rows in. */
st.Log(verbose, "Loading rows...")
loadStart := time.Now()
rows := st.GetRows(file, sheet) // panics if fails, which is ok
loadTime := time.Since(loadStart)
st.Log(verbose, " done!\n")
/* Get columns from rows as []float64 for call to EqPct. */
var wasError bool = false
start := time.Now()
db, err := st.DowncastF64(st.TransmogrifyRows(rows, baseIdx))
if err != nil {
wasError = true
fmt.Printf("%v\n", err)
}
dp, err := st.DowncastF64(st.TransmogrifyRows(rows, percentIdx))
if err != nil {
wasError = true
fmt.Printf("%v\n", err)
}
dr, err := st.DowncastF64(st.TransmogrifyRows(rows, resultIdx))
if err != nil {
wasError = true
fmt.Printf("%v\n", err)
}
st.Log(verbose, "About to call bt.EqPct.\n")
if len(db) != len(dp) || len(dp) != len(dr) {
st.ErrLog(verbose,
fmt.Sprintf("Length mismatch: db = %v, dp = %v, dr = %v",
len(db), len(dp), len(dr)))
} else {
st.Log(verbose, fmt.Sprintf("Lengths are %v\n", len(db)))
}
indexes, err := bt.EqPct(db, dp, dr, tol)
if err != nil {
wasError = true
fmt.Printf("There was an error [%v]\n", err)
os.Exit(-1)
}
st.Log(verbose, "bt.EqPct completed successfully.\n")
end := time.Since(start)
// lenMax := len(string(len(db)))
for _, v := range indexes {
st.Log(true, fmt.Sprintf("%7v: %v * %v pct should be %v but found %v.\n",
v,
db[v],
dp[v],
(db[v] * dp[v])/100.00,
dr[v]))
}
if verbose {
fmt.Printf("base index: %v\n", baseIdx)
fmt.Printf("percent index: %v\n", percentIdx)
fmt.Printf("result index: %v\n", resultIdx)
}
if timeme {
fmt.Printf("Time to load: %v\n", loadTime)
fmt.Printf("Time to process: %v\n", end)
}
if verbose {
fmt.Printf("Was error: %v\n", wasError)
}
}
|
