fix: rename AccuracyPrecision to ElectionPrecision

consensus/state_test.go

@@ -1919,7 +1919,7 @@ func TestStateFullRoundWithSelectedVoter(t *testing.T) {
 	cs, vss := randStateWithVoterParams(10, &types.VoterParams{
 		VoterElectionThreshold:          5,
 		MaxTolerableByzantinePercentage: 20,
-		AccuracyPrecision:               2})
+		ElectionPrecision:               2})
 	vss[0].Height = 1 // this is needed because of `incrementHeight(vss[1:]...)` of randStateWithVoterParams()
 	vssMap := makeVssMap(vss)
 	height, round := cs.Height, cs.Round

types/genesis.go

@@ -40,7 +40,7 @@ type VoterParams struct {
 
 	// As a unit of precision, if it is 1, it is 0.9, and if it is 2, it is 0.99.
 	// The default is 5, with a precision of 0.99999.
-	AccuracyPrecision int `json:"accuracy_precision"`
+	ElectionPrecision int `json:"election_precision"`
 }
 
 // GenesisDoc defines the initial conditions for a tendermint blockchain, in particular its validator set.

types/params.go

@@ -22,7 +22,7 @@ const (
 
 	DefaultVoterElectionThreshold          = 33
 	DefaultMaxTolerableByzantinePercentage = 20
-	DefaultAccuracyPrecision               = 5 // 5 is 0.99999
+	DefaultElectionPrecision               = 5 // 5 is 0.99999
 )
 
 // ConsensusParams contains consensus critical parameters that determine the
@@ -77,7 +77,7 @@ func DefaultVoterParams() *VoterParams {
 	return &VoterParams{
 		VoterElectionThreshold:          DefaultVoterElectionThreshold,
 		MaxTolerableByzantinePercentage: DefaultMaxTolerableByzantinePercentage,
-		AccuracyPrecision:               DefaultAccuracyPrecision}
+		ElectionPrecision:               DefaultElectionPrecision}
 }
 
 func (params *VoterParams) Validate() error {
@@ -89,8 +89,8 @@ func (params *VoterParams) Validate() error {
 		return errors.Errorf("MaxTolerableByzantinePercentage must be in between 1 and 33. Got %d",
 			params.MaxTolerableByzantinePercentage)
 	}
-	if params.AccuracyPrecision <= 1 || params.AccuracyPrecision > 15 {
-		return errors.Errorf("AccuracyPrecision must be in 2~15(including). Got %d", params.AccuracyPrecision)
+	if params.ElectionPrecision <= 1 || params.ElectionPrecision > 15 {
+		return errors.Errorf("ElectionPrecision must be in 2~15(including). Got %d", params.ElectionPrecision)
 	}
 	return nil
 }

types/params_test.go

@@ -138,49 +138,49 @@ func TestVoterParamsValidate(t *testing.T) {
 		{
 			VoterElectionThreshold:          -1,
 			MaxTolerableByzantinePercentage: 1,
-			AccuracyPrecision:               2,
+			ElectionPrecision:               2,
 		},
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 0,
-			AccuracyPrecision:               2,
+			ElectionPrecision:               2,
 		},
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 34,
-			AccuracyPrecision:               2,
+			ElectionPrecision:               2,
 		},
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 33,
-			AccuracyPrecision:               1,
+			ElectionPrecision:               1,
 		},
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 33,
-			AccuracyPrecision:               17,
+			ElectionPrecision:               17,
 		},
 	}
 	normalCases := []VoterParams{
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 1,
-			AccuracyPrecision:               2,
+			ElectionPrecision:               2,
 		},
 		{
 			VoterElectionThreshold:          99999999,
 			MaxTolerableByzantinePercentage: 1,
-			AccuracyPrecision:               2,
+			ElectionPrecision:               2,
 		},
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 33,
-			AccuracyPrecision:               2,
+			ElectionPrecision:               2,
 		},
 		{
 			VoterElectionThreshold:          0,
 			MaxTolerableByzantinePercentage: 1,
-			AccuracyPrecision:               15,
+			ElectionPrecision:               15,
 		},
 	}
 	for _, tc := range errorCases {

types/voter_set.go

@@ -404,7 +404,7 @@ func (c *candidate) SetWinPoint(winPoint int64) {
 	c.val.VotingPower = winPoint
 }
 
-func accuracyFromAccuracyPrecision(precision int) float64 {
+func accuracyFromElectionPrecision(precision int) float64 {
 	base := math.Pow10(precision)
 	result := (base - 1) / base
 	return result
@@ -425,7 +425,7 @@ func SelectVoter(validators *ValidatorSet, proofHash []byte, voterParams *VoterP
 	}
 
 	minVoters := CalNumOfVoterToElect(int64(len(candidates)), float64(voterParams.MaxTolerableByzantinePercentage)/100,
-		accuracyFromAccuracyPrecision(voterParams.AccuracyPrecision))
+		accuracyFromElectionPrecision(voterParams.ElectionPrecision))
 	if minVoters > math.MaxInt32 {
 		panic("CalNumOfVoterToElect is overflow for MaxInt32")
 	}

types/voter_set_test.go

@@ -260,9 +260,9 @@ func electVotersForLoop(t *testing.T, hash []byte, valSet *ValidatorSet, privMap
 		proof, _ := privMap[proposer.Address.String()].GenerateVRFProof(message)
 		hash, _ = vrf.ProofToHash(proof)
 	}
-	t.Logf("[accuracy=%f] voters=%d, fault=%d, avg byzantines=%f", accuracyFromAccuracyPrecision(accuracy),
+	t.Logf("[accuracy=%f] voters=%d, fault=%d, avg byzantines=%f", accuracyFromElectionPrecision(accuracy),
 		totalVoters/loopCount, byzantineFault, float64(totalByzantines)/float64(loopCount))
-	assert.True(t, float64(byzantineFault) < float64(loopCount)*(1.0-accuracyFromAccuracyPrecision(accuracy)))
+	assert.True(t, float64(byzantineFault) < float64(loopCount)*(1.0-accuracyFromElectionPrecision(accuracy)))
 }
 
 func TestCalVotersNum2(t *testing.T) {
@@ -284,19 +284,19 @@ func TestCalVotersNum2(t *testing.T) {
 	electVotersForLoop(t, hash, valSet, privMap, byzantines, loopCount, byzantinePercent, 5)
 }
 
-func TestAccuracyFromAccuracyPrecision(t *testing.T) {
-	assert.True(t, accuracyFromAccuracyPrecision(2) == 0.99)
-	assert.True(t, accuracyFromAccuracyPrecision(3) == 0.999)
-	assert.True(t, accuracyFromAccuracyPrecision(4) == 0.9999)
-	assert.True(t, accuracyFromAccuracyPrecision(5) == 0.99999)
-	assert.True(t, accuracyFromAccuracyPrecision(6) == 0.999999)
-	assert.True(t, accuracyFromAccuracyPrecision(7) == 0.9999999)
-	assert.True(t, accuracyFromAccuracyPrecision(8) == 0.99999999)
-	assert.True(t, accuracyFromAccuracyPrecision(9) == 0.999999999)
-	assert.True(t, accuracyFromAccuracyPrecision(10) == 0.9999999999)
-	assert.True(t, accuracyFromAccuracyPrecision(11) == 0.99999999999)
-	assert.True(t, accuracyFromAccuracyPrecision(12) == 0.999999999999)
-	assert.True(t, accuracyFromAccuracyPrecision(13) == 0.9999999999999)
-	assert.True(t, accuracyFromAccuracyPrecision(14) == 0.99999999999999)
-	assert.True(t, accuracyFromAccuracyPrecision(15) == 0.999999999999999)
+func TestAccuracyFromElectionPrecision(t *testing.T) {
+	assert.True(t, accuracyFromElectionPrecision(2) == 0.99)
+	assert.True(t, accuracyFromElectionPrecision(3) == 0.999)
+	assert.True(t, accuracyFromElectionPrecision(4) == 0.9999)
+	assert.True(t, accuracyFromElectionPrecision(5) == 0.99999)
+	assert.True(t, accuracyFromElectionPrecision(6) == 0.999999)
+	assert.True(t, accuracyFromElectionPrecision(7) == 0.9999999)
+	assert.True(t, accuracyFromElectionPrecision(8) == 0.99999999)
+	assert.True(t, accuracyFromElectionPrecision(9) == 0.999999999)
+	assert.True(t, accuracyFromElectionPrecision(10) == 0.9999999999)
+	assert.True(t, accuracyFromElectionPrecision(11) == 0.99999999999)
+	assert.True(t, accuracyFromElectionPrecision(12) == 0.999999999999)
+	assert.True(t, accuracyFromElectionPrecision(13) == 0.9999999999999)
+	assert.True(t, accuracyFromElectionPrecision(14) == 0.99999999999999)
+	assert.True(t, accuracyFromElectionPrecision(15) == 0.999999999999999)
 }