CLN: Code formatting for py/c/h files

Improve format of all file types

Author: Sheppard, Kevin

randomstate/distributions.c

@@ -1377,7 +1377,7 @@ void random_gauss_zig_julia_fill(aug_state *state, int count, double *out) {
                     xx = -ziggurat_nor_inv_r*log(random_double(state));
                     yy = -log(random_double(state));
                 } while (yy+yy <= xx*xx);
-                
+
                 out[i] = ((rabs >> 8) & 0x1) ? -(ziggurat_nor_r+xx) : ziggurat_nor_r+xx;
                 break;
             }

randomstate/performance.py

@@ -1,9 +1,10 @@
-import struct
 import os
+import struct
 import timeit
 
 import pandas as pd
 from numpy.random import RandomState
+
 rs = RandomState()
 
 SETUP = '''
@@ -19,7 +20,8 @@
 else:
     scale_64 = 2
 
-RNGS = ['mlfg_1279_861', 'mrg32k3a', 'pcg64', 'pcg32', 'mt19937', 'xorshift128', 'xorshift1024', 'random']
+RNGS = ['mlfg_1279_861', 'mrg32k3a', 'pcg64', 'pcg32', 'mt19937', 'xorshift128', 'xorshift1024',
+        'random']
 
 
 def timer(code, setup):
@@ -71,11 +73,6 @@ def timer_uniform():
 def timer_32bit():
     command = 'rs.{dist}(1000000, bits=32)'
     command_numpy = 'rs.tomaxint({scale} * 1000000)'.format(scale=scale_32)
-    print('32 bit commands')
-    print(command)
-    print(command_numpy)
-    print('Typical values')
-    print(rs.tomaxint(5))
     dist = 'random_uintegers'
     run_timer(dist, command, command_numpy, SETUP, '32-bit unsigned integers')
 
@@ -84,9 +81,6 @@ def timer_64bit():
     dist = 'random_uintegers'
     command = 'rs.{dist}(1000000, bits=64)'
     command_numpy = 'rs.tomaxint({scale} * 1000000)'.format(scale=scale_64)
-    print('64 bit commands')
-    print(command)
-    print(command_numpy)
     run_timer(dist, command, command_numpy, SETUP, '64-bit unsigned integers')
 
 
@@ -96,6 +90,7 @@ def timer_normal():
     dist = 'standard_normal'
     run_timer(dist, command, command_numpy, SETUP, 'Standard normals')
 
+
 def timer_normal_zig():
     command = 'rs.{dist}(1000000, method="zig")'
     command_numpy = 'rs.{dist}(1000000)'
@@ -109,4 +104,3 @@ def timer_normal_zig():
     timer_64bit()
     timer_normal()
     timer_normal_zig()
-

randomstate/setup-single-rng.py

@@ -1,7 +1,7 @@
+import os
 import sys
 from distutils.core import setup
 from distutils.extension import Extension
-import os
 from os import getcwd, name
 from os.path import join
 
@@ -28,12 +28,12 @@
 defs = [('XORSHIFT128_RNG', '1')]
 
 include_dirs = [pwd] + [numpy.get_include()]
-if os.name == 'nt' and sys.version_info < (3,5):
-    include_dirs += [join(pwd, 'src','common')]
+if os.name == 'nt' and sys.version_info < (3, 5):
+    include_dirs += [join(pwd, 'src', 'common')]
 include_dirs += [join(pwd, 'src', 'xorshift128')]
 
 extra_link_args = ['Advapi32.lib'] if name == 'nt' else []
-extra_compile_args= [] if name == 'nt' else ['-std=c99']
+extra_compile_args = [] if name == 'nt' else ['-std=c99']
 
 setup(ext_modules=cythonize([Extension("core_rng",
                                        sources=sources,

randomstate/src/mlfg-1279-861/mlfg-1279-861.h

@@ -10,9 +10,9 @@
 
 typedef struct s_mlfg_state
 {
-     uint64_t lags[K];
-     int pos;
-     int lag_pos;
+    uint64_t lags[K];
+    int pos;
+    int lag_pos;
 } mlfg_state;
 
 void mlfg_seed(mlfg_state* state, uint64_t seed);
@@ -30,13 +30,13 @@ void mlfg_init_state(mlfg_state *state, uint64_t seeds[K]);
 */
 inline uint64_t mlfg_next(mlfg_state* state)
 {
-   state->pos++;
-   state->lag_pos++;
-   if (state->pos >= K)
-       state->pos = 0;
-   else if (state->lag_pos >= K)
-       state->lag_pos = 0;
-   state->lags[state->pos] = state->lags[state->lag_pos] * state->lags[state->pos];
-   return state->lags[state->pos];
+    state->pos++;
+    state->lag_pos++;
+    if (state->pos >= K)
+        state->pos = 0;
+    else if (state->lag_pos >= K)
+        state->lag_pos = 0;
+    state->lags[state->pos] = state->lags[state->lag_pos] * state->lags[state->pos];
+    return state->lags[state->pos];
 }
 

randomstate/src/pcg/pcg32.c

@@ -3,14 +3,14 @@
 extern inline void pcg_setseq_64_step_r(pcg_state_setseq_64* rng);
 extern inline uint32_t pcg_output_xsl_rr_64_32(uint64_t state);
 extern inline void pcg_setseq_64_srandom_r(pcg_state_setseq_64* rng,
-                                    uint64_t initstate, uint64_t initseq);
+        uint64_t initstate, uint64_t initseq);
 extern inline uint32_t
 pcg_setseq_64_xsl_rr_32_random_r(pcg_state_setseq_64* rng);
 extern inline uint32_t
 pcg_setseq_64_xsl_rr_32_boundedrand_r(pcg_state_setseq_64* rng,
                                       uint32_t bound);
 extern inline void pcg_setseq_64_advance_r(pcg_state_setseq_64* rng,
-                                    uint64_t delta);
+        uint64_t delta);
 
 uint64_t pcg_advance_lcg_64(uint64_t state, uint64_t delta, uint64_t cur_mult,
                             uint64_t cur_plus)

randomstate/src/pcg/pcg32.h

@@ -6,7 +6,7 @@
 #endif
 
 #if __GNUC_GNU_INLINE__  &&  !defined(__cplusplus)
-    #error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.
+#error Nonstandard GNU inlining semantics. Compile with -std=c99 or better.
 #endif
 
 typedef struct {

randomstate/src/pcg64-compat/pcg64.c

@@ -27,12 +27,12 @@
 extern inline void pcg_setseq_128_step_r(pcg_state_setseq_128* rng);
 extern inline uint64_t pcg_output_xsl_rr_128_64(pcg128_t state);
 extern inline void pcg_setseq_128_srandom_r(pcg_state_setseq_128* rng,
-				     pcg128_t initstate, pcg128_t initseq);
+        pcg128_t initstate, pcg128_t initseq);
 extern inline uint64_t
 pcg_setseq_128_xsl_rr_64_random_r(pcg_state_setseq_128* rng);
 extern inline uint64_t
 pcg_setseq_128_xsl_rr_64_boundedrand_r(pcg_state_setseq_128* rng,
-				       uint64_t bound);
+                                       uint64_t bound);
 extern inline void pcg_setseq_128_advance_r(pcg_state_setseq_128* rng, pcg128_t delta);
 
 /* Multi-step advance functions (jump-ahead, jump-back)
@@ -49,41 +49,41 @@ extern inline void pcg_setseq_128_advance_r(pcg_state_setseq_128* rng, pcg128_t
 #ifndef PCG_EMULATED_128BIT_MATH
 
 pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,
-			    pcg128_t cur_plus)
+                             pcg128_t cur_plus)
 {
-   pcg128_t acc_mult = 1u;
-   pcg128_t acc_plus = 0u;
-   while (delta > 0) {
-       if (delta & 1) {
-	   acc_mult *= cur_mult;
-	   acc_plus = acc_plus * cur_mult + cur_plus;
-       }
-       cur_plus = (cur_mult + 1) * cur_plus;
-       cur_mult *= cur_mult;
-       delta /= 2;
-   }
-   return acc_mult * state + acc_plus;
+    pcg128_t acc_mult = 1u;
+    pcg128_t acc_plus = 0u;
+    while (delta > 0) {
+        if (delta & 1) {
+            acc_mult *= cur_mult;
+            acc_plus = acc_plus * cur_mult + cur_plus;
+        }
+        cur_plus = (cur_mult + 1) * cur_plus;
+        cur_mult *= cur_mult;
+        delta /= 2;
+    }
+    return acc_mult * state + acc_plus;
 }
 
 #else
 
 pcg128_t pcg_advance_lcg_128(pcg128_t state, pcg128_t delta, pcg128_t cur_mult,
-			    pcg128_t cur_plus)
+                             pcg128_t cur_plus)
 {
-   pcg128_t acc_mult = PCG_128BIT_CONSTANT(0u, 1u);
-   pcg128_t acc_plus = PCG_128BIT_CONSTANT(0u, 0u);
-   while ((delta.high > 0) || (delta.low > 0)) {
-       if (delta.low & 1) {
-	   acc_mult = _pcg128_mult(acc_mult, cur_mult);
-	   acc_plus = _pcg128_add(_pcg128_mult(acc_plus, cur_mult), cur_plus);
-       }
-       cur_plus = _pcg128_mult(_pcg128_add(cur_mult, PCG_128BIT_CONSTANT(0u, 1u)), cur_plus);
-       cur_mult = _pcg128_mult(cur_mult, cur_mult);
-       delta.low >>= 1;
-       delta.low += delta.high & 1;
-       delta.high >>= 1;
-   }
-   return _pcg128_add(_pcg128_mult(acc_mult, state), acc_plus);
+    pcg128_t acc_mult = PCG_128BIT_CONSTANT(0u, 1u);
+    pcg128_t acc_plus = PCG_128BIT_CONSTANT(0u, 0u);
+    while ((delta.high > 0) || (delta.low > 0)) {
+        if (delta.low & 1) {
+            acc_mult = _pcg128_mult(acc_mult, cur_mult);
+            acc_plus = _pcg128_add(_pcg128_mult(acc_plus, cur_mult), cur_plus);
+        }
+        cur_plus = _pcg128_mult(_pcg128_add(cur_mult, PCG_128BIT_CONSTANT(0u, 1u)), cur_plus);
+        cur_mult = _pcg128_mult(cur_mult, cur_mult);
+        delta.low >>= 1;
+        delta.low += delta.high & 1;
+        delta.high >>= 1;
+    }
+    return _pcg128_add(_pcg128_mult(acc_mult, state), acc_plus);
 }
 
 #endif