From 7413dc16572ffd672835c1391b08409472771093 Mon Sep 17 00:00:00 2001
From: antirez <antirez@gmail.com>
Date: Fri, 16 Mar 2018 16:57:53 +0100
Subject: [PATCH] Aesthetic changes to PR #4749.

---
 src/hyperloglog.c | 80 +++++++++++++++++++++++------------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/hyperloglog.c b/src/hyperloglog.c
index 77109c8..68d591c 100644
--- a/src/hyperloglog.c
+++ b/src/hyperloglog.c
@@ -403,7 +403,7 @@ uint64_t MurmurHash64A (const void * key, int len, unsigned int seed) {
 
 #if (BYTE_ORDER == LITTLE_ENDIAN)
 	#ifdef USE_ALIGNED_ACCESS
-	memcpy(&k,data,sizeof(uint64_t));
+            memcpy(&k,data,sizeof(uint64_t));
 	#else
         k = *((uint64_t*)data);
 	#endif
@@ -512,7 +512,7 @@ int hllDenseAdd(uint8_t *registers, unsigned char *ele, size_t elesize) {
 }
 
 /* Compute the register histogram in the dense representation. */
-void hllDenseRegHisto(uint8_t *registers, int* regHisto) {
+void hllDenseRegHisto(uint8_t *registers, int* reghisto) {
     int j;
 
     /* Redis default is to use 16384 registers 6 bits each. The code works
@@ -541,22 +541,22 @@ void hllDenseRegHisto(uint8_t *registers, int* regHisto) {
             r14 = (r[10] >> 4 | r[11] << 4) & 63;
             r15 = (r[11] >> 2) & 63;
 
-            regHisto[r0] += 1;
-            regHisto[r1] += 1;
-            regHisto[r2] += 1;
-            regHisto[r3] += 1;
-            regHisto[r4] += 1;
-            regHisto[r5] += 1;
-            regHisto[r6] += 1;
-            regHisto[r7] += 1;
-            regHisto[r8] += 1;
-            regHisto[r9] += 1;
-            regHisto[r10] += 1;
-            regHisto[r11] += 1;
-            regHisto[r12] += 1;
-            regHisto[r13] += 1;
-            regHisto[r14] += 1;
-            regHisto[r15] += 1;
+            reghisto[r0]++;
+            reghisto[r1]++;
+            reghisto[r2]++;
+            reghisto[r3]++;
+            reghisto[r4]++;
+            reghisto[r5]++;
+            reghisto[r6]++;
+            reghisto[r7]++;
+            reghisto[r8]++;
+            reghisto[r9]++;
+            reghisto[r10]++;
+            reghisto[r11]++;
+            reghisto[r12]++;
+            reghisto[r13]++;
+            reghisto[r14]++;
+            reghisto[r15]++;
 
             r += 12;
         }
@@ -564,7 +564,7 @@ void hllDenseRegHisto(uint8_t *registers, int* regHisto) {
         for(j = 0; j < HLL_REGISTERS; j++) {
             unsigned long reg;
             HLL_DENSE_GET_REGISTER(reg,registers,j);
-            regHisto[reg] += 1;
+            reghisto[reg]++;
         }
     }
 }
@@ -904,7 +904,7 @@ int hllSparseAdd(robj *o, unsigned char *ele, size_t elesize) {
 }
 
 /* Compute the register histogram in the sparse representation. */
-void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* regHisto) {
+void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* reghisto) {
     int idx = 0, runlen, regval;
     uint8_t *end = sparse+sparselen, *p = sparse;
 
@@ -912,18 +912,18 @@ void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* regHis
         if (HLL_SPARSE_IS_ZERO(p)) {
             runlen = HLL_SPARSE_ZERO_LEN(p);
             idx += runlen;
-            regHisto[0] += runlen;
+            reghisto[0] += runlen;
             p++;
         } else if (HLL_SPARSE_IS_XZERO(p)) {
             runlen = HLL_SPARSE_XZERO_LEN(p);
             idx += runlen;
-            regHisto[0] += runlen;
+            reghisto[0] += runlen;
             p += 2;
         } else {
             runlen = HLL_SPARSE_VAL_LEN(p);
             regval = HLL_SPARSE_VAL_VALUE(p);
             idx += runlen;
-            regHisto[regval] += runlen;
+            reghisto[regval] += runlen;
             p++;
         }
     }
@@ -938,24 +938,24 @@ void hllSparseRegHisto(uint8_t *sparse, int sparselen, int *invalid, int* regHis
 
 /* Implements the register histogram calculation for uint8_t data type
  * which is only used internally as speedup for PFCOUNT with multiple keys. */
-void hllRawRegHisto(uint8_t *registers, int* regHisto) {
+void hllRawRegHisto(uint8_t *registers, int* reghisto) {
     uint64_t *word = (uint64_t*) registers;
     uint8_t *bytes;
     int j;
 
     for (j = 0; j < HLL_REGISTERS/8; j++) {
         if (*word == 0) {
-            regHisto[0] += 8;
+            reghisto[0] += 8;
         } else {
             bytes = (uint8_t*) word;
-            regHisto[bytes[0]] += 1;
-            regHisto[bytes[1]] += 1;
-            regHisto[bytes[2]] += 1;
-            regHisto[bytes[3]] += 1;
-            regHisto[bytes[4]] += 1;
-            regHisto[bytes[5]] += 1;
-            regHisto[bytes[6]] += 1;
-            regHisto[bytes[7]] += 1;
+            reghisto[bytes[0]]++;
+            reghisto[bytes[1]]++;
+            reghisto[bytes[2]]++;
+            reghisto[bytes[3]]++;
+            reghisto[bytes[4]]++;
+            reghisto[bytes[5]]++;
+            reghisto[bytes[6]]++;
+            reghisto[bytes[7]]++;
         }
         word++;
     }
@@ -1011,16 +1011,16 @@ uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
     double E;
     int j;
     double alphaInf = 0.5 / log(2.);
-    int regHisto[HLL_Q+2] = {0};
+    int reghisto[HLL_Q+2] = {0};    
 
     /* Compute register histogram */
     if (hdr->encoding == HLL_DENSE) {
-        hllDenseRegHisto(hdr->registers,regHisto);
+        hllDenseRegHisto(hdr->registers,reghisto);
     } else if (hdr->encoding == HLL_SPARSE) {
         hllSparseRegHisto(hdr->registers,
-                         sdslen((sds)hdr)-HLL_HDR_SIZE,invalid,regHisto);
+                         sdslen((sds)hdr)-HLL_HDR_SIZE,invalid,reghisto);
     } else if (hdr->encoding == HLL_RAW) {
-        hllRawRegHisto(hdr->registers,regHisto);
+        hllRawRegHisto(hdr->registers,reghisto);	
     } else {
         serverPanic("Unknown HyperLogLog encoding in hllCount()");
     }
@@ -1028,12 +1028,12 @@ uint64_t hllCount(struct hllhdr *hdr, int *invalid) {
     /* Estimate cardinality form register histogram. See:
      * "New cardinality estimation algorithms for HyperLogLog sketches"
      * Otmar Ertl, arXiv:1702.01284 */
-    double z = m * hllTau((m-regHisto[HLL_Q+1])/(double)m);
+    double z = m * hllTau((m-reghisto[HLL_Q+1])/(double)m);
     for (j = HLL_Q; j >= 1; --j) {
-        z += regHisto[j];
+        z += reghisto[j];
         z *= 0.5;
     }
-    z += m * hllSigma(regHisto[0]/(double)m);
+    z += m * hllSigma(reghisto[0]/(double)m);
     E = llroundl(alphaInf*m*m/z);
 
     return (uint64_t) E;
-- 
2.23.0