From 1120161286ee5c855b630bccc9e0b37bb8a3ee65 Mon Sep 17 00:00:00 2001
From: Joshua Bakita <jbakita@cs.unc.edu>
Date: Sat, 17 Oct 2020 19:07:11 -0400
Subject: Fix DIS coding style by running them all through clang-format

Also fixes a missing header in DISstressmarkRNG.h and the "all"
make target. No functional changes.
---
 dis/Neighborhood/utili.h | 435 +++++++++++++++++++++--------------------------
 1 file changed, 198 insertions(+), 237 deletions(-)

(limited to 'dis/Neighborhood/utili.h')

diff --git a/dis/Neighborhood/utili.h b/dis/Neighborhood/utili.h
index 5b54d9b..b5a7498 100644
--- a/dis/Neighborhood/utili.h
+++ b/dis/Neighborhood/utili.h
@@ -1,12 +1,12 @@
 /*
  *  Sample code for the DIS Pointer Stressmark
  *
- * This source code is the completely correct source code based on 
- * the example codes provided by Atlantic Aerospace Division, Titan 
+ * This source code is the completely correct source code based on
+ * the example codes provided by Atlantic Aerospace Division, Titan
  * Systems Corporation, 2000.
- * 
- * If you just compile and generate the executables from this source 
- * code, this code would be enough. However, if you wish to get a complete 
+ *
+ * If you just compile and generate the executables from this source
+ * code, this code would be enough. However, if you wish to get a complete
  * understanding of this stressmark, it is strongly suggested that you
  * read the Benchmark Analysis and Specifications Document Version 1.0
  * before going on since the detailed comments are given in this documents.
@@ -22,287 +22,248 @@
 
 #define MIN_PIXEL 0
 #define MAX_DIMENSION 32768
-#define MIN_SEED  -2147483647
-#define MAX_SEED  -1
+#define MIN_SEED -2147483647
+#define MAX_SEED -1
 #define MAX_NUMBER_LINES 65536
-#define MIN_BIT_DEPTH    7
-#define MAX_BIT_DEPTH    15
+#define MIN_BIT_DEPTH 7
+#define MAX_BIT_DEPTH 15
 
 typedef struct {
   int column;
   int row;
-}Coord;
+} Coord;
 
-/* 
+/*
  * Neighborhood structure consists of the GLCM descriptors entropy and
- * energy for each of 2 distance and 4 angels 
+ * energy for each of 2 distance and 4 angels
  */
 typedef struct {
   float entropy;
   float energy;
-}Descriptors;
+} Descriptors;
 
 typedef struct {
   Descriptors deg0;
   Descriptors deg45;
   Descriptors deg90;
   Descriptors deg135;
-}Angeles;
+} Angeles;
 
 typedef struct {
   Angeles distShort;
   Angeles distLong;
-}Neighborhood;
+} Neighborhood;
 
 typedef short int Pixel; /* short int;*/
 
 typedef struct {
-  int           numColumns;     /* number of columns in image */
-  int           numRows;        /* number of rows in image */
-  Pixel         maxImageValue;  /* max legal image value */
-  Pixel         *data;          /* data pointer */
+  int numColumns;      /* number of columns in image */
+  int numRows;         /* number of rows in image */
+  Pixel maxImageValue; /* max legal image value */
+  Pixel *data;         /* data pointer */
 } Image;
 
 // For correct implementation of drawLineSegment
 #include "initializeImage.c"
 
-Pixel *createImage (Pixel *image,
-            int dimension,
-		    Pixel maxPixel,
-		    int numberLines,
-		    int minThickness,
-		    int maxThickness)
-  {
-    int i;
-    
-    Coord startPoint;
-    Coord endPoint;
-    int thickness;
-    int startValue;
-    int endValue;
-    Image img;
-    img.numColumns = dimension;
-    img.numRows = dimension;
-    img.maxImageValue = maxPixel;
-    img.data = image;
-
-    for (i=0; i<dimension*dimension; i++){
-      image[i] = 0;
-    }
+Pixel *createImage(Pixel *image, int dimension, Pixel maxPixel, int numberLines,
+                   int minThickness, int maxThickness) {
+  int i;
+
+  Coord startPoint;
+  Coord endPoint;
+  int thickness;
+  int startValue;
+  int endValue;
+  Image img;
+  img.numColumns = dimension;
+  img.numRows = dimension;
+  img.maxImageValue = maxPixel;
+  img.data = image;
+
+  for (i = 0; i < dimension * dimension; i++) {
+    image[i] = 0;
+  }
 
-    for (i=0; i<numberLines; i++){
-      float temp;
-      float prev;
+  for (i = 0; i < numberLines; i++) {
+    float temp;
+    float prev;
 
-      temp = randomUInt(0, dimension*dimension - 1);
-      startPoint.row = (int) temp/dimension;
-      startPoint.column = (int) temp % dimension;
-      prev = temp;
+    temp = randomUInt(0, dimension * dimension - 1);
+    startPoint.row = (int)temp / dimension;
+    startPoint.column = (int)temp % dimension;
+    prev = temp;
 
-      // Make sure that the end is different than the start
-      while((temp = randomUInt(0, dimension*dimension -1)) == prev);
+    // Make sure that the end is different than the start
+    while ((temp = randomUInt(0, dimension * dimension - 1)) == prev)
+      ;
 
-      endPoint.row = (int) temp/dimension;
-      endPoint.column = (int) temp% dimension;
+    endPoint.row = (int)temp / dimension;
+    endPoint.column = (int)temp % dimension;
 
-      thickness = randomUInt(minThickness, maxThickness);
-      startValue = randomUInt(MIN_PIXEL, maxPixel);
-      endValue = randomUInt(MIN_PIXEL, maxPixel);
+    thickness = randomUInt(minThickness, maxThickness);
+    startValue = randomUInt(MIN_PIXEL, maxPixel);
+    endValue = randomUInt(MIN_PIXEL, maxPixel);
 
-      drawLineSegment(&startPoint, &endPoint,
-		      startValue, endValue, thickness, &img);
-    }
-    return(image);
+    drawLineSegment(&startPoint, &endPoint, startValue, endValue, thickness,
+                    &img);
+  }
+  return (image);
 }
 
+void calcEntropyEnergy(int *sumHist, int *diffHist, Pixel *image, int numBins,
+                       int dx, int dy, float *entropy, float *energy,
+                       int dimension, Pixel maxPixel) {
+  int index;
+  int totalNumPixels;
+  int rowIndex;
+  int rowLow, rowHigh;
+  int columnIndex;
+  int columnLow, columnHigh;
+  int columnForPixelAtDistance;
+  int rowForPixelAtDistance;
+  int value0RowOffset;
+  int value1RowOffset;
+
+  *entropy = 0.0;
+  *energy = 0.0;
+
+  for (index = 0; index < numBins; index++) {
+    sumHist[index] = 0;
+    diffHist[index] = 0;
+  }
 
-void calcEntropyEnergy(
-		       int *sumHist,
-		       int *diffHist,
-		       Pixel *image,
-		       int numBins,
-		       int dx,
-		       int dy,
-		       float *entropy,
-		       float *energy,
-		       int dimension,
-		        Pixel maxPixel)
-  {
-    int index;
-    int totalNumPixels;
-    int rowIndex;
-    int rowLow, rowHigh;
-    int columnIndex;
-    int columnLow, columnHigh;
-    int columnForPixelAtDistance;
-    int rowForPixelAtDistance;
-    int value0RowOffset;
-    int value1RowOffset;
-
-    *entropy = 0.0;
-    *energy = 0.0;
-    
-    for (index = 0; index < numBins; index++){
-      sumHist[index] = 0;
-      diffHist[index] = 0;
-    }
-    
-    if (dy < 0){
-      rowLow = -dy;
-      rowHigh = dimension;
-    }
-    else {
-      rowLow = 0;
-      rowHigh = dimension - dy;
-    }
-    if (dx < 0){
-      columnLow = -dx;
-      columnHigh = dimension;
-    }
-    else
-    {
-      columnLow = 0;
-      columnHigh = dimension - dx;
-    }
+  if (dy < 0) {
+    rowLow = -dy;
+    rowHigh = dimension;
+  } else {
+    rowLow = 0;
+    rowHigh = dimension - dy;
+  }
+  if (dx < 0) {
+    columnLow = -dx;
+    columnHigh = dimension;
+  } else {
+    columnLow = 0;
+    columnHigh = dimension - dx;
+  }
 
-    totalNumPixels = 0;
-    value0RowOffset = rowLow * dimension;
-    value1RowOffset = (rowLow + dy) * dimension;
+  totalNumPixels = 0;
+  value0RowOffset = rowLow * dimension;
+  value1RowOffset = (rowLow + dy) * dimension;
 
-    for (rowIndex = rowLow; rowIndex<rowHigh; rowIndex++){
-      for (columnIndex= columnLow; columnIndex<columnHigh;
-           columnIndex++){
-        int value0;
-        int value1;
-        int binIndex;
+  for (rowIndex = rowLow; rowIndex < rowHigh; rowIndex++) {
+    for (columnIndex = columnLow; columnIndex < columnHigh; columnIndex++) {
+      int value0;
+      int value1;
+      int binIndex;
 
-        rowForPixelAtDistance = rowIndex + dy;
-        columnForPixelAtDistance = columnIndex + dx;
+      rowForPixelAtDistance = rowIndex + dy;
+      columnForPixelAtDistance = columnIndex + dx;
 
-        value0 = *(image + value0RowOffset + columnIndex);
-        value1 = *(image + value1RowOffset + 
-               columnForPixelAtDistance);
+      value0 = *(image + value0RowOffset + columnIndex);
+      value1 = *(image + value1RowOffset + columnForPixelAtDistance);
 
-        binIndex = value0 + value1 - 2*MIN_PIXEL;
-        assert((binIndex >= 0) && (binIndex < numBins));
-        sumHist[binIndex] += 1;
-        binIndex = value0 - value1 + maxPixel - MIN_PIXEL;
+      binIndex = value0 + value1 - 2 * MIN_PIXEL;
+      assert((binIndex >= 0) && (binIndex < numBins));
+      sumHist[binIndex] += 1;
+      binIndex = value0 - value1 + maxPixel - MIN_PIXEL;
 
-        assert((binIndex >= 0) && (binIndex < numBins));
+      assert((binIndex >= 0) && (binIndex < numBins));
 
-        diffHist[binIndex] += 1;
-        totalNumPixels += 1;
+      diffHist[binIndex] += 1;
+      totalNumPixels += 1;
+    }
 
-      }
-      
-      value0RowOffset += dimension;
-      value1RowOffset += dimension;
+    value0RowOffset += dimension;
+    value1RowOffset += dimension;
+  }
 
-    }
-    
-
-    if (totalNumPixels > 0){
-      int index;
-      double energySum;
-      double energyDifference;
-      double entropyValue;
-      double sumNormalized;
-      double diffNormalized;
-      double scale;
-
-      energySum = (double) 0;
-      energyDifference = (double) 0;
-      entropyValue = (double) 0;
-      scale = 1.e0/totalNumPixels;
-      for (index = 0; index<numBins; index++){
-        if (sumHist[index] > 0){
-          sumNormalized = (double) sumHist[index]*scale;
-          entropyValue = entropyValue - sumNormalized * 
-            log((double)sumNormalized);
-          energySum = energySum + sumNormalized * sumNormalized ;
-        }
-        if (diffHist[index] > 0){
-          diffNormalized = (double)diffHist[index]*scale;
-          entropyValue = entropyValue - diffNormalized * log(diffNormalized);
-          energyDifference = energyDifference +
-            diffNormalized * diffNormalized;
-        }
+  if (totalNumPixels > 0) {
+    int index;
+    double energySum;
+    double energyDifference;
+    double entropyValue;
+    double sumNormalized;
+    double diffNormalized;
+    double scale;
+
+    energySum = (double)0;
+    energyDifference = (double)0;
+    entropyValue = (double)0;
+    scale = 1.e0 / totalNumPixels;
+    for (index = 0; index < numBins; index++) {
+      if (sumHist[index] > 0) {
+        sumNormalized = (double)sumHist[index] * scale;
+        entropyValue =
+            entropyValue - sumNormalized * log((double)sumNormalized);
+        energySum = energySum + sumNormalized * sumNormalized;
+      }
+      if (diffHist[index] > 0) {
+        diffNormalized = (double)diffHist[index] * scale;
+        entropyValue = entropyValue - diffNormalized * log(diffNormalized);
+        energyDifference = energyDifference + diffNormalized * diffNormalized;
       }
-      *energy = energySum * energyDifference;
-      *entropy = entropyValue;
     }
-    return;
-}
-
-
-void neighborhoodCalculation
-  (Pixel *image,
-   int dimension,
-   int distanceShort,
-   int distanceLong,
-   Neighborhood *neighborhood,
-   Pixel maxPixel)
-  {
-    int *sumHist, *diffHist;
-    int numBins;
-
-    numBins = (2 * (maxPixel - MIN_PIXEL + 1) -1);
-    sumHist = (int *) malloc(numBins * sizeof(int));
-    assert (sumHist != NULL);
-    diffHist = (int *)malloc(numBins * sizeof(int));
-    assert(diffHist != NULL);
-    
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      distanceShort, 0,
-		      &(neighborhood->distShort.deg0.entropy),
-		      &(neighborhood->distShort.deg0.energy), dimension,
-		      maxPixel);
-  
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      distanceShort, distanceShort,
-		      &(neighborhood->distShort.deg45.entropy),
-		      &(neighborhood->distShort.deg45.energy), dimension,
-		      maxPixel);
-   
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      0, distanceShort,
-		      &(neighborhood->distShort.deg90.entropy),
-		      &(neighborhood->distShort.deg90.energy), dimension,
-		      maxPixel);
-   
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      -distanceShort, distanceShort,
-		      &(neighborhood->distShort.deg135.entropy),
-		      &(neighborhood->distShort.deg135.energy), dimension,
-		      maxPixel);
-
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      distanceLong, 0,
-		      &(neighborhood->distLong.deg0.entropy),
-		      &(neighborhood->distLong.deg0.energy), dimension,
-		      maxPixel);
-  
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      distanceLong, distanceLong,
-		      &(neighborhood->distLong.deg45.entropy),
-		      &(neighborhood->distLong.deg45.energy), dimension,
-		      maxPixel);
-      
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      0, distanceLong,
-		      &(neighborhood->distLong.deg90.entropy),
-		      &(neighborhood->distLong.deg90.energy), dimension,
-		      maxPixel);
-
-    calcEntropyEnergy(sumHist, diffHist, image, numBins,
-		      -distanceLong, distanceLong,
-		      &(neighborhood->distLong.deg135.entropy),
-		      &(neighborhood->distLong.deg135.energy), dimension,
-		      maxPixel);
-
-    free(sumHist);
-    free(diffHist);
-    
-    return;
+    *energy = energySum * energyDifference;
+    *entropy = entropyValue;
   }
+  return;
+}
 
+void neighborhoodCalculation(Pixel *image, int dimension, int distanceShort,
+                             int distanceLong, Neighborhood *neighborhood,
+                             Pixel maxPixel) {
+  int *sumHist, *diffHist;
+  int numBins;
+
+  numBins = (2 * (maxPixel - MIN_PIXEL + 1) - 1);
+  sumHist = (int *)malloc(numBins * sizeof(int));
+  assert(sumHist != NULL);
+  diffHist = (int *)malloc(numBins * sizeof(int));
+  assert(diffHist != NULL);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, distanceShort, 0,
+                    &(neighborhood->distShort.deg0.entropy),
+                    &(neighborhood->distShort.deg0.energy), dimension,
+                    maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, distanceShort,
+                    distanceShort, &(neighborhood->distShort.deg45.entropy),
+                    &(neighborhood->distShort.deg45.energy), dimension,
+                    maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, 0, distanceShort,
+                    &(neighborhood->distShort.deg90.entropy),
+                    &(neighborhood->distShort.deg90.energy), dimension,
+                    maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, -distanceShort,
+                    distanceShort, &(neighborhood->distShort.deg135.entropy),
+                    &(neighborhood->distShort.deg135.energy), dimension,
+                    maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, distanceLong, 0,
+                    &(neighborhood->distLong.deg0.entropy),
+                    &(neighborhood->distLong.deg0.energy), dimension, maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, distanceLong,
+                    distanceLong, &(neighborhood->distLong.deg45.entropy),
+                    &(neighborhood->distLong.deg45.energy), dimension,
+                    maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, 0, distanceLong,
+                    &(neighborhood->distLong.deg90.entropy),
+                    &(neighborhood->distLong.deg90.energy), dimension,
+                    maxPixel);
+
+  calcEntropyEnergy(sumHist, diffHist, image, numBins, -distanceLong,
+                    distanceLong, &(neighborhood->distLong.deg135.entropy),
+                    &(neighborhood->distLong.deg135.energy), dimension,
+                    maxPixel);
+
+  free(sumHist);
+  free(diffHist);
+
+  return;
+}
-- 
cgit v1.2.2