ruby-fizzbuzz 0.0.2

data/ext/fizzbuzz/fizzbuzz.h

@@ -0,0 +1,233 @@
+/* :enddoc: */
+
+/*
+ * fizzbuzz.h
+ *
+ * Copyright 2012-2013 Krzysztof Wilczynski
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if !defined(_FIZZBUZZ_H)
+#define _FIZZBUZZ_H 1
+
+#include "common.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define ZERO  INT2FIX(0)
+#define ONE   INT2FIX(1)
+#define THREE INT2FIX(3)
+#define FIVE  INT2FIX(5)
+
+#define PLUS(a, b)  fizzbuzz_plus((a), (b))
+#define MINUS(a, b) fizzbuzz_minus((a), (b))
+#define MOD(a, b)   fizzbuzz_modulo((a), (b))
+
+#define GREATER(a, b)       fizzbuzz_greater((a), (b))
+#define GREATER_EQUAL(a, b) fizzbuzz_greater_equal((a), (b))
+#define LESS_EQUAL(a, b)    fizzbuzz_less_equal((a), (b))
+
+#define INTEGER_P(x) (TYPE(x) == T_FIXNUM || TYPE(x) == T_BIGNUM)
+
+#define ZERO_P(x) \
+    (FIXNUM_P(x) ? (NUM2TYPE(x) == 0) : fizzbuzz_equal((x), ZERO))
+
+#define INCREASE(x) PLUS((x),  ONE)
+#define DECREASE(x) MINUS((x), ONE)
+
+#define COMPUTE_MOD_3(x) ZERO_P(MOD((x), THREE))
+#define COMPUTE_MOD_5(x) ZERO_P(MOD((x), FIVE))
+
+#define SCORE_FIXNUM(x) (uint8_t)(!((x) % 3) + 2 * !((x) % 5))
+#define SCORE_BIGNUM(x) (uint8_t)(COMPUTE_MOD_3(x) + 2 * COMPUTE_MOD_5(x))
+
+#define SCORE_VALUE(x) \
+    (FIXNUM_P(x) ? SCORE_FIXNUM(NUM2TYPE(x)) : SCORE_BIGNUM(x))
+
+#define IS_FIZZ(x)     (!ZERO_P(x) && (SCORE_VALUE(x) == 1))
+#define IS_BUZZ(x)     (!ZERO_P(x) && (SCORE_VALUE(x) == 2))
+#define IS_FIZZBUZZ(x) (!ZERO_P(x) && (SCORE_VALUE(x) == 3))
+
+#define WANT_ARRAY(x) ((x) == R_TYPE_ARRAY)
+
+#define LOOP_FORWARD(x) ((x) == D_LOOP_FORWARD)
+#define LOOP_REVERSE(x) ((x) == D_LOOP_REVERSE)
+
+#define CHECK_TYPE(x, m)                        \
+    do {                                        \
+        if (!INTEGER_P(x))                      \
+            rb_raise(rb_eTypeError, "%s", (m)); \
+    } while (0)
+
+#define CHECK_BOUNDARY(a, b, m)                 \
+    do {                                        \
+        if (GREATER((a), (b)))                  \
+            rb_raise(rb_eArgError, "%s", (m));  \
+    } while (0)
+
+enum error {
+    E_INVALID_TYPE = 0,
+    E_INVALID_START_TYPE,
+    E_INVALID_STOP_TYPE,
+    E_BAD_VALUE_START,
+    E_BAD_VALUE_STOP
+};
+
+enum return_type {
+    R_TYPE_ARRAY = 0,
+    R_TYPE_ENUMERATOR
+};
+
+enum direction {
+    D_LOOP_FORWARD = 0,
+    D_LOOP_REVERSE
+};
+
+typedef enum error error_t;
+typedef enum return_type return_type_t;
+typedef enum direction direction_t;
+
+static const char *errors[] = {
+    "must be an integer value",
+    "must be an integer value for start",
+    "must be an integer value for stop",
+    "start value is higher than stop value",
+    "stop value is lower than start value",
+    NULL
+};
+
+static const char *words[] = {
+    "Fizz", "Buzz",
+    "FizzBuzz", NULL
+};
+
+inline static VALUE
+fizzbuzz_plus(VALUE a, VALUE b)
+{
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        return TYPE2NUM(NUM2TYPE(a) + NUM2TYPE(b));
+    }
+
+    return rb_funcall(a, rb_intern("+"), 1, b);
+}
+
+inline static VALUE
+fizzbuzz_minus(VALUE a, VALUE b)
+{
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        return TYPE2NUM(NUM2TYPE(a) - NUM2TYPE(b));
+    }
+
+    return rb_funcall(a, rb_intern("-"), 1, b);
+}
+
+inline static VALUE
+fizzbuzz_modulo(VALUE a, VALUE b)
+{
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        return TYPE2NUM(NUM2TYPE(a) % NUM2TYPE(b));
+    }
+
+    return rb_funcall(a, rb_intern("%"), 1, b);
+}
+
+inline static VALUE
+fizzbuzz_equal(VALUE a, VALUE b)
+{
+    VALUE result;
+
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        result = (NUM2TYPE(a) == NUM2TYPE(b));
+    }
+    else {
+        result = rb_funcall(a, rb_intern("=="), 1, b);
+    }
+
+    return RVAL2CBOOL(result);
+}
+
+inline static VALUE
+fizzbuzz_greater(VALUE a, VALUE b)
+{
+    VALUE result;
+
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        result = (NUM2TYPE(a) > NUM2TYPE(b));
+    }
+    else {
+        result = rb_funcall(a, rb_intern(">"), 1, b);
+    }
+
+    return RVAL2CBOOL(result);
+}
+
+inline static VALUE
+fizzbuzz_greater_equal(VALUE a, VALUE b)
+{
+    VALUE result;
+
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        result = (NUM2TYPE(a) >= NUM2TYPE(b));
+    }
+    else {
+        result = rb_funcall(a, rb_intern(">="), 1, b);
+    }
+
+    return RVAL2CBOOL(result);
+}
+
+inline static VALUE
+fizzbuzz_less_equal(VALUE a, VALUE b)
+{
+    VALUE result;
+
+    if (FIXNUM_P(a) && FIXNUM_P(b)) {
+        result = (NUM2TYPE(a) <= NUM2TYPE(b));
+    }
+    else {
+        result = rb_funcall(a, rb_intern("<="), 1, b);
+    }
+
+    return RVAL2CBOOL(result);
+}
+
+RUBY_EXTERN ID id_at_start, id_at_stop;
+RUBY_EXTERN VALUE rb_cFizzBuzz;
+
+RUBY_EXTERN VALUE rb_fb_initialize(int argc, VALUE *argv, VALUE object);
+
+RUBY_EXTERN VALUE rb_fb_get_start(VALUE object);
+RUBY_EXTERN VALUE rb_fb_set_start(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_fb_get_stop(VALUE object);
+RUBY_EXTERN VALUE rb_fb_set_stop(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_fb_array(VALUE object);
+RUBY_EXTERN VALUE rb_fb_enumerator(VALUE object);
+RUBY_EXTERN VALUE rb_fb_reverse_enumerator(VALUE object);
+
+RUBY_EXTERN VALUE rb_fb_is_fizz(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_fb_is_buzz(VALUE object, VALUE value);
+RUBY_EXTERN VALUE rb_fb_is_fizzbuzz(VALUE object, VALUE value);
+
+RUBY_EXTERN VALUE rb_fb_square(VALUE object, VALUE value);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* _FIZZBUZZ_H */
+
+/* vim: set ts=8 sw=4 sts=2 et : */

data/lib/fizzbuzz.rb

@@ -0,0 +1,94 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# fizzbuzz.rb
+#
+# Copyright 2012-2013 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# :startdoc:
+
+require 'fizzbuzz/fizzbuzz'
+require 'fizzbuzz/version'
+require 'fizzbuzz/integer'
+require 'fizzbuzz/bignum'
+
+#
+# Yet another _FizzBuzz_ in Ruby.
+#
+# Provides simple and fast solution to a popular _FizzBuzz_ problem for Ruby.
+#
+class FizzBuzz
+  #
+  # call-seq:
+  #   FizzBuzz.fizzbuzz( start, stop, reverse )                  -> array
+  #   FizzBuzz.fizzbuzz( start, stop, reverse ) {|value| block } -> self
+  #
+  # Returns either an array or accepts a block if such is given. When a block is given
+  # then it will call the block once for each subsequent value for a given range from
+  # +start+ to +stop+, passing the value as a parameter to the block.
+  #
+  # Additionally, if the value of +reverse+ is set to be +true+ then the results will
+  # be given in an <em>reverse order</em> whether in a resulting array or when passing
+  # values to a block given.
+  #
+  # Example:
+  #
+  #   FizzBuzz.fizzbuzz(1, 15)          #=> [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz"]
+  #   FizzBuzz.fizzbuzz(1, 15, true)    #=> ["FizzBuzz", 14, 13, "Fizz", 11, "Buzz", "Fizz", 8, 7, "Fizz", "Buzz", 4, "Fizz", 2, 1]
+  #
+  # Example:
+  #
+  #   FizzBuzz.fizzbuzz(1, 15) {|value| puts "Got #{value}" }
+  #
+  # Produces:
+  #
+  #   Got 1
+  #   Got 2
+  #   Got Fizz
+  #   Got 4
+  #   Got Buzz
+  #   Got Fizz
+  #   Got 7
+  #   Got 8
+  #   Got Fizz
+  #   Got Buzz
+  #   Got 11
+  #   Got Fizz
+  #   Got 13
+  #   Got 14
+  #   Got FizzBuzz
+  #
+  # See also: FizzBuzz::[], FizzBuzz::new, FizzBuzz#to_a, FizzBuzz#each and FizzBuzz#reverse_each
+  #
+  def self.fizzbuzz(start, stop, reverse = false)
+    fb = FizzBuzz.new(start, stop)
+
+    if block_given?
+      fb.send(reverse ? :reverse_each : :each) {|i| yield i }
+    else
+      reverse ? fb.to_a.reverse : fb.to_a
+    end
+  end
+end
+
+# :enddoc:
+
+FB = FizzBuzz
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/fizzbuzz/bignum.rb

@@ -0,0 +1,90 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# bignum.rb
+#
+# Copyright 2012-2013 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# :startdoc:
+
+#
+# Provides a convenient integration of _FizzBuzz_ with _Bignum_ class.
+#
+class Bignum
+  #
+  # call-seq:
+  #   Bignum.fizz? -> true or false
+  #
+  # Returns +true+ if a given integer value is divisible by *three* (given
+  # value is a _Fizz_), or +false+ otherwise.
+  #
+  # Example:
+  #
+  #   1000000000000.fizz?    #=> false
+  #   1000000000002.fizz?    #=> true
+  #   1000000000005.fizz?    #=> false
+  #
+  # See also: FizzBuzz::[] and FizzBuzz::is_fizz?
+  #
+  def fizz?
+    FizzBuzz.is_fizz?(self)
+  end
+
+  #
+  # call-seq:
+  #   Bignum.buzz? -> true or false
+  #
+  # Returns +true+ if a given integer value is divisible by *five* (given
+  # value is a _Buzz_), or +false+ otherwise.
+  #
+  # Example:
+  #
+  #   1000000000000.buzz?    #=> true
+  #   1000000000002.buzz?    #=> false
+  #   1000000000005.buzz?    #=> false
+  #
+  # See also: FizzBuzz::[] and FizzBuzz::is_buzz?
+  #
+  def buzz?
+    FizzBuzz.is_buzz?(self)
+  end
+
+  #
+  # call-seq:
+  #   Bignum.fizzbuzz? -> true or false
+  #
+  # Returns +true+ if a given integer value is divisible by both *three*
+  # and *five* (given value is a _FizzBuzz_), or +false+ otherwise.
+  #
+  # Example:
+  #
+  #   1000000000000.fizzbuzz?    #=> false
+  #   1000000000002.fizzbuzz?    #=> false
+  #   1000000000005.fizzbuzz?    #=> true
+  #
+  # See also: FizzBuzz::[] and FizzBuzz::is_fizzbuzz?
+  #
+  def fizzbuzz?
+    FizzBuzz.is_fizzbuzz?(self)
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/fizzbuzz/integer.rb

@@ -0,0 +1,90 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# integer.rb
+#
+# Copyright 2012 Krzysztof Wilczynski
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# :startdoc:
+
+#
+# Provides a convenient integration of _FizzBuzz_ with _Integer_ class.
+#
+class Integer
+  #
+  # call-seq:
+  #   Integer.fizz? -> true or false
+  #
+  # Returns +true+ if a given integer value is divisible by *three* (given
+  # value is a _Fizz_), or +false+ otherwise.
+  #
+  # Example:
+  #
+  #    3.fizz?    #=> true
+  #    5.fizz?    #=> false
+  #   15.fizz?    #=> false
+  #
+  # See also: FizzBuzz::[] and FizzBuzz::is_fizz?
+  #
+  def fizz?
+    FizzBuzz.is_fizz?(self)
+  end
+
+  #
+  # call-seq:
+  #   Integer.buzz? -> true or false
+  #
+  # Returns +true+ if a given integer value is divisible by *five* (given
+  # value is a _Buzz_), or +false+ otherwise.
+  #
+  # Example:
+  #
+  #    3.buzz?    #=> false
+  #    5.buzz?    #=> true
+  #   15.buzz?    #=> false
+  #
+  # See also: FizzBuzz::[] and FizzBuzz::is_buzz?
+  #
+  def buzz?
+    FizzBuzz.is_buzz?(self)
+  end
+
+  #
+  # call-seq:
+  #   Integer.fizzbuzz? -> true or false
+  #
+  # Returns +true+ if a given integer value is divisible by both *three*
+  # and *five* (given value is a _FizzBuzz_), or +false+ otherwise.
+  #
+  # Example:
+  #
+  #    3.fizzbuzz?    #=> false
+  #    5.fizzbuzz?    #=> false
+  #   15.fizzbuzz?    #=> true
+  #
+  # See also: FizzBuzz::[] and FizzBuzz::is_fizzbuzz?
+  #
+  def fizzbuzz?
+    FizzBuzz.is_fizzbuzz?(self)
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8