remove trailing spaces

3 files changed, 61 insertions, 61 deletions

diff --git a/mrbgems/mruby-random/src/mt19937ar.c b/mrbgems/mruby-random/src/mt19937ar.c
index a27aee311..0e1279b34 100644
--- a/mrbgems/mruby-random/src/mt19937ar.c
+++ b/mrbgems/mruby-random/src/mt19937ar.c
@@ -7,8 +7,8 @@
 #include "mruby.h"
 #include "mt19937ar.h"
 
-/* Period parameters */  
-/* #define N 624 */  
+/* Period parameters */
+/* #define N 624 */
 #define M 397
 #define MATRIX_A 0x9908b0dfUL   /* constant vector a */
 #define UPPER_MASK 0x80000000UL /* most significant w-r bits */
@@ -23,8 +23,8 @@ void mrb_random_init_genrand(mt_state *t, unsigned long s)
 {
     t->mt[0]= s & 0xffffffffUL;
     for (t->mti=1; t->mti<N; t->mti++) {
-        t->mt[t->mti] = 
-	    (1812433253UL * (t->mt[t->mti-1] ^ (t->mt[t->mti-1] >> 30)) + t->mti); 
+        t->mt[t->mti] =
+	    (1812433253UL * (t->mt[t->mti-1] ^ (t->mt[t->mti-1] >> 30)) + t->mti);
         t->mt[t->mti] &= 0xffffffffUL;
     }
 }
@@ -54,7 +54,7 @@ unsigned long mrb_random_genrand_int32(mt_state *t)
 
         t->mti = 0;
     }
-  
+
     y = t->mt[t->mti++];
 
     /* Tempering */
@@ -62,7 +62,7 @@ unsigned long mrb_random_genrand_int32(mt_state *t)
     y ^= (y << 7) & 0x9d2c5680UL;
     y ^= (y << 15) & 0xefc60000UL;
     y ^= (y >> 18);
-    
+
     t->gen.int_ = y;
 
     return y;
@@ -71,9 +71,9 @@ unsigned long mrb_random_genrand_int32(mt_state *t)
 double mrb_random_genrand_real1(mt_state *t)
 {
     mrb_random_genrand_int32(t);
-    t->gen.double_ =  t->gen.int_*(1.0/4294967295.0); 
+    t->gen.double_ =  t->gen.int_*(1.0/4294967295.0);
     return t->gen.double_;
-    /* divided by 2^32-1 */ 
+    /* divided by 2^32-1 */
 }
 
 #if 0 /* dead_code */
@@ -82,8 +82,8 @@ void init_genrand(unsigned long s)
 {
     mt[0]= s & 0xffffffffUL;
     for (mti=1; mti<N; mti++) {
-        mt[mti] = 
-	    (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti); 
+        mt[mti] =
+	    (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
         /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
         /* In the previous versions, MSBs of the seed affect   */
         /* only MSBs of the array mt[].                        */
@@ -119,7 +119,7 @@ void init_by_array(unsigned long init_key[], int key_length)
         if (i>=N) { mt[0] = mt[N-1]; i=1; }
     }
 
-    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */ 
+    mt[0] = 0x80000000UL; /* MSB is 1; assuring non-zero initial array */
 }
 
 /* generates a random number on [0,0xffffffff]-interval */
@@ -148,7 +148,7 @@ unsigned long genrand_int32(void)
 
         mti = 0;
     }
-  
+
     y = mt[mti++];
 
     /* Tempering */
@@ -169,29 +169,29 @@ long genrand_int31(void)
 /* generates a random number on [0,1]-real-interval */
 double genrand_real1(void)
 {
-    return genrand_int32()*(1.0/4294967295.0); 
-    /* divided by 2^32-1 */ 
+    return genrand_int32()*(1.0/4294967295.0);
+    /* divided by 2^32-1 */
 }
 
 /* generates a random number on [0,1)-real-interval */
 double genrand_real2(void)
 {
-    return genrand_int32()*(1.0/4294967296.0); 
+    return genrand_int32()*(1.0/4294967296.0);
     /* divided by 2^32 */
 }
 
 /* generates a random number on (0,1)-real-interval */
 double genrand_real3(void)
 {
-    return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0); 
+    return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
     /* divided by 2^32 */
 }
 
 /* generates a random number on [0,1) with 53-bit resolution*/
-double genrand_res53(void) 
-{ 
-    unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6; 
-    return(a*67108864.0+b)*(1.0/9007199254740992.0); 
-} 
+double genrand_res53(void)
+{
+    unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
+    return(a*67108864.0+b)*(1.0/9007199254740992.0);
+}
 /* These real versions are due to Isaku Wada, 2002/01/09 added */
 #endif /* dead_code */
diff --git a/mrbgems/mruby-random/src/random.c b/mrbgems/mruby-random/src/random.c
index 8f983ea0f..7756bc7c9 100644
--- a/mrbgems/mruby-random/src/random.c
+++ b/mrbgems/mruby-random/src/random.c
@@ -22,27 +22,27 @@ static const struct mrb_data_type mt_state_type = {
 static mrb_value mrb_random_rand(mrb_state *mrb, mrb_value self);
 static mrb_value mrb_random_srand(mrb_state *mrb, mrb_value self);
 
-static void 
+static void
 mt_srand(mt_state *t, unsigned long seed)
 {
   mrb_random_init_genrand(t, seed);
-}  
+}
 
-static unsigned long 
+static unsigned long
 mt_rand(mt_state *t)
 {
   return mrb_random_genrand_int32(t);
-}  
+}
 
-static double 
+static double
 mt_rand_real(mt_state *t)
 {
   return mrb_random_genrand_real1(t);
-}  
+}
 
-static mrb_value 
+static mrb_value
 mrb_random_mt_srand(mrb_state *mrb, mt_state *t, mrb_value seed)
-{ 
+{
   if (mrb_nil_p(seed)) {
     seed = mrb_fixnum_value(time(NULL) + mt_rand(t));
     if (mrb_fixnum(seed) < 0) {
@@ -55,9 +55,9 @@ mrb_random_mt_srand(mrb_state *mrb, mt_state *t, mrb_value seed)
   return seed;
 }
 
-static mrb_value 
+static mrb_value
 mrb_random_mt_rand(mrb_state *mrb, mt_state *t, mrb_value max)
-{ 
+{
   mrb_value value;
 
   if (mrb_fixnum(max) == 0) {
@@ -70,7 +70,7 @@ mrb_random_mt_rand(mrb_state *mrb, mt_state *t, mrb_value max)
   return value;
 }
 
-static mrb_value 
+static mrb_value
 get_opt(mrb_state* mrb)
 {
   mrb_value arg;
@@ -104,35 +104,35 @@ get_random_state(mrb_state *mrb)
   return DATA_GET_PTR(mrb, random_val, &mt_state_type, mt_state);
 }
 
-static mrb_value 
+static mrb_value
 mrb_random_g_rand(mrb_state *mrb, mrb_value self)
 {
   mrb_value random = get_random(mrb);
   return mrb_random_rand(mrb, random);
 }
 
-static mrb_value 
+static mrb_value
 mrb_random_g_srand(mrb_state *mrb, mrb_value self)
 {
   mrb_value random = get_random(mrb);
   return mrb_random_srand(mrb, random);
 }
 
-static mrb_value 
+static mrb_value
 mrb_random_init(mrb_state *mrb, mrb_value self)
 {
   mrb_value seed;
   mt_state *t;
-  
+
   /* avoid memory leaks */
   t = (mt_state*)DATA_PTR(self);
   if (t) {
     mrb_free(mrb, t);
-  }  
+  }
 
   DATA_TYPE(self) = &mt_state_type;
   DATA_PTR(self) = NULL;
-  
+
   t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
   t->mti = N + 1;
 
@@ -146,13 +146,13 @@ mrb_random_init(mrb_state *mrb, mrb_value self)
     t->has_seed = TRUE;
     t->seed = mrb_fixnum(seed);
   }
-  
+
   DATA_PTR(self) = t;
-  
+
   return self;
 }
 
-static void 
+static void
 mrb_random_rand_seed(mrb_state *mrb, mt_state *t)
 {
   if (!t->has_seed) {
@@ -160,7 +160,7 @@ mrb_random_rand_seed(mrb_state *mrb, mt_state *t)
   }
 }
 
-static mrb_value 
+static mrb_value
 mrb_random_rand(mrb_state *mrb, mrb_value self)
 {
   mrb_value max;
@@ -171,7 +171,7 @@ mrb_random_rand(mrb_state *mrb, mrb_value self)
   return mrb_random_mt_rand(mrb, t, max);
 }
 
-static mrb_value 
+static mrb_value
 mrb_random_srand(mrb_state *mrb, mrb_value self)
 {
   mrb_value seed;
@@ -205,7 +205,7 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
 {
   mrb_int i;
   mt_state *random = NULL;
-  
+
   if (RARRAY_LEN(ary) > 1) {
     mrb_get_args(mrb, "|d", &random, &mt_state_type);
 
@@ -213,21 +213,21 @@ mrb_ary_shuffle_bang(mrb_state *mrb, mrb_value ary)
       random = get_random_state(mrb);
     }
     mrb_random_rand_seed(mrb, random);
-  
+
     mrb_ary_modify(mrb, mrb_ary_ptr(ary));
-    
+
     for (i = RARRAY_LEN(ary) - 1; i > 0; i--)  {
       mrb_int j;
       mrb_value tmp;
-      
+
       j = mrb_fixnum(mrb_random_mt_rand(mrb, random, mrb_fixnum_value(RARRAY_LEN(ary))));
-      
+
       tmp = RARRAY_PTR(ary)[i];
       RARRAY_PTR(ary)[i] = RARRAY_PTR(ary)[j];
       RARRAY_PTR(ary)[j] = tmp;
-    }    
+    }
   }
-  
+
   return ary;
 }
 
@@ -243,7 +243,7 @@ mrb_ary_shuffle(mrb_state *mrb, mrb_value ary)
 {
   mrb_value new_ary = mrb_ary_new_from_values(mrb, RARRAY_LEN(ary), RARRAY_PTR(ary));
   mrb_ary_shuffle_bang(mrb, new_ary);
-  
+
   return new_ary;
 }
 
@@ -272,7 +272,7 @@ mrb_ary_sample(mrb_state *mrb, mrb_value ary)
 
   mrb_get_args(mrb, "|i?d", &n, &given, &random, &mt_state_type);
   if (random == NULL) {
-    random = get_random_state(mrb); 
+    random = get_random_state(mrb);
   }
   mrb_random_rand_seed(mrb, random);
   mt_rand(random);
@@ -334,7 +334,7 @@ void mrb_mruby_random_gem_init(mrb_state *mrb)
   mrb_define_method(mrb, random, "initialize", mrb_random_init, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "rand", mrb_random_rand, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, random, "srand", mrb_random_srand, MRB_ARGS_OPT(1));
-  
+
   mrb_define_method(mrb, array, "shuffle", mrb_ary_shuffle, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, array, "shuffle!", mrb_ary_shuffle_bang, MRB_ARGS_OPT(1));
   mrb_define_method(mrb, array, "sample", mrb_ary_sample, MRB_ARGS_OPT(2));
diff --git a/mrbgems/mruby-random/test/random.rb b/mrbgems/mruby-random/test/random.rb
index fa31b782b..1653ae4a6 100644
--- a/mrbgems/mruby-random/test/random.rb
+++ b/mrbgems/mruby-random/test/random.rb
@@ -31,32 +31,32 @@ assert("float") do
   rand.class == Float
 end
 
-assert("Array#shuffle") do 
+assert("Array#shuffle") do
   ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   shuffled = ary.shuffle
-  
+
   ary == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and shuffled != ary and 10.times { |x| ary.include? x }
 end
 
 assert('Array#shuffle!') do
   ary = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   ary.shuffle!
-  
+
   ary != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary.include? x }
 end
 
-assert("Array#shuffle(random)") do 
+assert("Array#shuffle(random)") do
   assert_raise(TypeError) do
     # this will cause an exception due to the wrong argument
     [1, 2].shuffle "Not a Random instance"
   end
-  
+
   # verify that the same seed causes the same results
   ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   shuffle1 = ary1.shuffle Random.new 345
   ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   shuffle2 = ary2.shuffle Random.new 345
-  
+
   ary1 != shuffle1 and 10.times { |x| shuffle1.include? x } and shuffle1 == shuffle2
 end
 
@@ -65,12 +65,12 @@ assert('Array#shuffle!(random)') do
     # this will cause an exception due to the wrong argument
     [1, 2].shuffle! "Not a Random instance"
   end
-    
+
   # verify that the same seed causes the same results
   ary1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   ary1.shuffle! Random.new 345
   ary2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
   ary2.shuffle! Random.new 345
-  
+
   ary1 != [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and 10.times { |x| ary1.include? x } and ary1 == ary2
 end