twisty_puzzles 0.0.2 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 989d528a58cb32ca49f7502249b5e5eca71a1e46726f1a79ffa64e18381d5a86
-  data.tar.gz: 2c1bfff00d66c4b85f15592ee50fa6883e45149ae8456c7a24cc1cba60841285
+  metadata.gz: 1b7934b9679e720f3675ce3f9db174f4ab9bbc1e028654f4d29aed727a90f052
+  data.tar.gz: ab7e60a7d07dbaa3d164fb0fcd74e89871241bfb2b54b0354ab4d093b137f667
 SHA512:
-  metadata.gz: 870c957e8ba192090401e9e6092779e5f19f45fcd995d60ab1c2e52fed62b7cd25397ce06f18fb2eae6f4ac3df88e76975390f0b73ebc45a8fe2ecdc2cae41fd
-  data.tar.gz: 6140ebc4150d89e0577461b66b18158dec51c11d3527d265f028d24cd2b1e44f2299b05ae46a3264bbc040dcf0b34bda83be7ec15092884234539130a402d3ef
+  metadata.gz: 991e8297413b4a86b12b463e5ed06c489936ec988ac4816d93350603debc8280399bb7d2e98ff8e1863da7dacd6eafbd7a4d304e9d056f64ea3e477c67d53664
+  data.tar.gz: f30d251aa0aeaab5af7bf32475e01c04cede2e8a0863790eeaeb805f004acb3fcae041d71217a9a79ccd673e1777b1e324a9317b21c3b151783772bbb1c699fe

data/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.5]
+### Changed
+- Now `require 'twisty_puzzles'` also requires the native extensions.
+
+## [0.0.4]
+### Fixed
+Fixed path in extconf.
+
+## [0.0.3]
+### Fixed
+Added extension source files to gem files.
+
 ## [0.0.2]
 ### Changed
 - Now a simple `require 'twisty_puzzles'` is enough, users don't need to require files separately.
@@ -11,7 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 - Syntax error in file that wasn't included in tests previously.
 - Rubocop fixes across the codebase.
-	
+
 ## [0.0.1]
 ### Added
 - Split off core twisty puzzles functionality from cube_trainer repo into a Gem.

data/README.md

@@ -1,3 +1,8 @@
+![Ruby](https://github.com/Lykos/twisty_puzzles/workflows/Ruby/badge.svg)
+![Rubocop](https://github.com/Lykos/twisty_puzzles/workflows/Rubocop/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Gem Version](https://badge.fury.io/rb/twisty_puzzles.svg)](https://badge.fury.io/rb/twisty_puzzles)
+
 # Twisty Puzzles
 Gem for my cube_trainer rails app. Some things are better left in a separate gem with no rails, e.g. native extensions. The main purpose is to support my Rails app, but if it's useful for someone else, feel free to use it at your own risk.
 
@@ -25,7 +30,7 @@ TODO: Write usage instructions here
 
 After checking out the repo, run `bundle install` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bundle exec bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `lib/twisty_puzzles/version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 

data/ext/twisty_puzzles/native/cube_algorithm.c

@@ -0,0 +1,267 @@
+#include "cube_algorithm.h"
+
+#include "face_symbols.h"
+#include "cube_coordinate.h"
+#include "cube_state.h"
+#include "utils.h"
+
+static ID slice_id;
+static ID face_id;
+static VALUE CubeAlgorithmClass = Qnil;
+
+typedef enum {
+  SLICE,
+  FACE,
+} CubeMoveType;
+
+typedef struct {
+  CubeMoveType type;
+  face_index_t axis_face_index;
+  direction_t direction;
+  size_t slice_index;
+} CubeMove;
+
+typedef struct {
+  size_t size;
+  size_t cube_size;
+  CubeMove* moves;
+} CubeAlgorithmData;
+
+static void CubeAlgorithmData_free(void* const ptr) {
+  const CubeAlgorithmData* const data = ptr;
+  free(data->moves);
+  free(ptr);
+}
+
+static size_t CubeAlgorithmData_size(const void* const ptr) {
+  const CubeAlgorithmData* const data = ptr;
+  return sizeof(CubeAlgorithmData) + data->size * sizeof(CubeMove);
+}
+
+const rb_data_type_t CubeAlgorithmData_type = {
+  "TwistyPuzzles::Native::CubeAlgorithmData",
+  {NULL, CubeAlgorithmData_free, CubeAlgorithmData_size, NULL},
+  NULL, NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY  
+};
+
+static void check_moves(const CubeAlgorithmData* const data, const char* const name) {
+  for (size_t i = 0; i < data->size; ++i) {
+    const CubeMoveType type = data->moves[i].type;
+    if (type != SLICE && type != FACE) {
+      rb_raise(rb_eRuntimeError, "invalid move type %d in %s", type, name);
+    }
+  }
+}
+
+static CubeMove* malloc_moves(const size_t n) {
+  CubeMove* const moves = malloc(n * sizeof(CubeMove));
+  if (moves == NULL) {
+    rb_raise(rb_eNoMemError, "Allocating cube algorithm failed.");
+  }
+  return moves;
+}
+
+static VALUE CubeAlgorithm_alloc(const VALUE klass) {
+  CubeAlgorithmData* data;
+  const VALUE object = TypedData_Make_Struct(klass, CubeAlgorithmData, &CubeAlgorithmData_type, data);
+  data->size = 0;
+  data->cube_size = 0;
+  data->moves = NULL;
+  return object;
+}
+
+#define GetCubeAlgorithmData(obj, data) \
+  do { \
+    TypedData_Get_Struct((obj), CubeAlgorithmData, &CubeAlgorithmData_type, (data)); \
+  } while (0)
+
+#define GetInitializedCubeAlgorithmData(obj, data) \
+  do { \
+    GetCubeAlgorithmData((obj), (data)); \
+    if (data->cube_size == 0) { \
+      rb_raise(rb_eRuntimeError, "Cube algorithm isn't initialized."); \
+    } \
+  } while(0)
+
+static CubeMoveType extract_move_type(const VALUE move_symbol) {
+  Check_Type(move_symbol, T_SYMBOL);
+  const ID move_symbol_id = SYM2ID(move_symbol);
+  if (move_symbol_id == slice_id) {
+    return SLICE;
+  } else if (move_symbol_id == face_id) {
+    return FACE;
+  } else {
+    rb_raise(rb_eArgError, "Got invalid move symbol.");
+  }
+}
+
+static size_t components_for_move_type(const CubeMoveType type) {
+  switch (type) {
+  case SLICE:
+    return 4;
+  case FACE:
+    return 3;
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in components_for_move_type", type);
+  }
+}
+
+static VALUE CubeAlgorithm_initialize(const VALUE self, const VALUE cube_size, const VALUE moves) {
+  Check_Type(moves, T_ARRAY);
+  CubeAlgorithmData* data;
+  GetCubeAlgorithmData(self, data);
+  data->size = RARRAY_LEN(moves);
+  data->cube_size = NUM2INT(cube_size);
+  data->moves = malloc_moves(data->size);
+  for (size_t i = 0; i < RARRAY_LEN(moves); ++i) {
+    const VALUE move = rb_ary_entry(moves, i);
+    if (RARRAY_LEN(move) < 1) {
+      rb_raise(rb_eArgError, "Moves cannot be empty.");
+    }
+    const CubeMoveType type = extract_move_type(rb_ary_entry(move, 0));
+    const size_t num_components = components_for_move_type(type);
+    if (RARRAY_LEN(move) != num_components) {
+      rb_raise(rb_eArgError, "Moves with the given type need to have %ld elements. Got %ld.", num_components, RARRAY_LEN(move));
+    }
+    data->moves[i].type = type;
+    data->moves[i].axis_face_index = face_index(rb_ary_entry(move, 1));
+    data->moves[i].direction = NUM2INT(rb_ary_entry(move, 2));
+    if (type == SLICE) {
+      const size_t slice_index = NUM2INT(rb_ary_entry(move, 3));
+      if (slice_index >= data->cube_size) {
+        rb_raise(rb_eArgError, "Invalid slice index %ld for cube size %ld.", slice_index, data->cube_size);
+      }
+      data->moves[i].slice_index = slice_index;
+    }
+  }
+  return self;
+}
+
+static void apply_move_to(const CubeMove move, const CubeStateData* const cube_state) {
+  switch (move.type) {
+  case SLICE:
+    rotate_slice_for_cube(move.axis_face_index, move.slice_index, move.direction, cube_state);
+    break;
+  case FACE:
+    rotate_face_for_cube(move.axis_face_index, move.direction, cube_state);
+    break;
+  default:
+    rb_raise(rb_eRuntimeError, "invalid move type %d in apply_move_to", move.type);
+  }
+}
+
+static VALUE CubeAlgorithm_apply_to(const VALUE self, const VALUE cube_state) {
+  const CubeStateData* cube_state_data;
+  GetInitializedCubeStateData(cube_state, cube_state_data);
+  const CubeAlgorithmData* data;
+  GetInitializedCubeAlgorithmData(self, data);
+  for (size_t i = 0; i < data->size; ++i) {
+    apply_move_to(data->moves[i], cube_state_data);
+  }
+  return Qnil;
+}
+
+static CubeMove rotate_move_by(const CubeMove move, const face_index_t rotation_face_index, const direction_t rotation_direction) {
+  CubeMove result = move;
+  if (!same_axis(move.axis_face_index, rotation_face_index)) {
+    const size_t index = neighbor_index(rotation_face_index, move.axis_face_index);
+    result.axis_face_index = neighbor_face_index(rotation_face_index, index + rotation_direction);
+  }
+  return result;
+}
+
+static VALUE CubeAlgorithm_rotate_by(const VALUE self, const VALUE rotation_face_symbol, const VALUE direction) {
+  const face_index_t rotation_face_index = face_index(rotation_face_symbol);
+  const direction_t rotation_direction = NUM2INT(direction);
+  const CubeAlgorithmData* data;
+  GetInitializedCubeAlgorithmData(self, data);
+  CubeAlgorithmData* rotated_data;
+  const VALUE rotated = TypedData_Make_Struct(CubeAlgorithmClass, CubeAlgorithmData, &CubeAlgorithmData_type, rotated_data);
+  rotated_data->size = data->size;
+  rotated_data->cube_size = data->cube_size;
+  rotated_data->moves = malloc_moves(rotated_data->size);
+  for (size_t i = 0; i < data->size; ++i) {
+    rotated_data->moves[i] = rotate_move_by(data->moves[i], rotation_face_index, rotation_direction);
+  }
+  return rotated;
+}
+
+static CubeMove mirror_move(const CubeMove move, const face_index_t normal_face_index) {
+  CubeMove result = move;
+  if (same_axis(move.axis_face_index, normal_face_index)) {
+    result.axis_face_index = opposite_face_index(move.axis_face_index);
+  }
+  result.direction = invert_cube_direction(move.direction);
+  return result;
+}
+
+static VALUE CubeAlgorithm_mirror(const VALUE self, const VALUE normal_face_symbol) {
+  const face_index_t normal_face_index = face_index(normal_face_symbol);
+  const CubeAlgorithmData* data;
+  GetInitializedCubeAlgorithmData(self, data);
+  CubeAlgorithmData* mirrored_data;
+  const VALUE mirrored = TypedData_Make_Struct(CubeAlgorithmClass, CubeAlgorithmData, &CubeAlgorithmData_type, mirrored_data);
+  mirrored_data->size = data->size;
+  mirrored_data->cube_size = data->cube_size;
+  mirrored_data->moves = malloc_moves(mirrored_data->size);
+  for (size_t i = 0; i < data->size; ++i) {
+    mirrored_data->moves[i] = mirror_move(data->moves[i], normal_face_index);
+  }
+  return mirrored;
+}
+
+static CubeMove invert_move(const CubeMove move) {
+  CubeMove result = move;
+  result.direction = invert_cube_direction(result.direction);
+  return result;
+}
+
+static VALUE CubeAlgorithm_inverse(const VALUE self) {
+  const CubeAlgorithmData* data;
+  GetInitializedCubeAlgorithmData(self, data);
+  CubeAlgorithmData* inverted_data;
+  const VALUE inverted = TypedData_Make_Struct(CubeAlgorithmClass, CubeAlgorithmData, &CubeAlgorithmData_type, inverted_data);
+  inverted_data->size = data->size;
+  inverted_data->cube_size = data->cube_size;
+  inverted_data->moves = malloc_moves(inverted_data->size);
+  for (size_t i = 0; i < data->size; ++i) {
+    inverted_data->moves[i] = invert_move(data->moves[data->size - 1 - i]);
+  }
+  return inverted;
+}
+
+static VALUE CubeAlgorithm_plus(const VALUE self, const VALUE other) {
+  const CubeAlgorithmData* self_data;
+  GetInitializedCubeAlgorithmData(self, self_data);
+  const CubeAlgorithmData* other_data;
+  GetInitializedCubeAlgorithmData(other, other_data);
+  if (self_data->cube_size != other_data->cube_size) {
+    rb_raise(rb_eArgError, "Cannot concatenate algorithms for different cube sizes %ld and %ld.", self_data->cube_size, other_data->cube_size);
+  }
+  CubeAlgorithmData* sum_data;
+  const VALUE sum = TypedData_Make_Struct(CubeAlgorithmClass, CubeAlgorithmData, &CubeAlgorithmData_type, sum_data);
+  sum_data->size = self_data->size + other_data->size;
+  sum_data->cube_size = self_data->cube_size;
+  sum_data->moves = malloc_moves(sum_data->size);
+  for (size_t i = 0; i < self_data->size; ++i) {
+    sum_data->moves[i] = self_data->moves[i];
+  }
+  for (size_t i = 0; i < other_data->size; ++i) {
+    sum_data->moves[self_data->size + i] = other_data->moves[i];
+  }
+  return sum;
+}
+
+void init_cube_algorithm_class_under(const VALUE module) {
+  slice_id = rb_intern("slice");
+  face_id = rb_intern("face");
+  CubeAlgorithmClass = rb_define_class_under(module, "CubeAlgorithm", rb_cObject);
+  rb_define_alloc_func(CubeAlgorithmClass, CubeAlgorithm_alloc);
+  rb_define_method(CubeAlgorithmClass, "initialize", CubeAlgorithm_initialize, 2);
+  rb_define_method(CubeAlgorithmClass, "apply_to", CubeAlgorithm_apply_to, 1);
+  rb_define_method(CubeAlgorithmClass, "rotate_by", CubeAlgorithm_rotate_by, 2);
+  rb_define_method(CubeAlgorithmClass, "mirror", CubeAlgorithm_mirror, 1);
+  rb_define_method(CubeAlgorithmClass, "inverse", CubeAlgorithm_inverse, 0);
+  rb_define_method(CubeAlgorithmClass, "+", CubeAlgorithm_plus, 1);
+}

data/ext/twisty_puzzles/native/cube_algorithm.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <ruby.h>
+
+void init_cube_algorithm_class_under(VALUE module);

data/ext/twisty_puzzles/native/cube_average.c

@@ -0,0 +1,184 @@
+#include "cube_average.h"
+
+#include <stdlib.h>
+
+#include "utils.h"
+
+VALUE CubeAverageClass = Qnil;
+const double removed_fraction_per_side = 0.05;
+
+typedef struct {
+  size_t capacity;
+  size_t size;
+  size_t insert_index;
+  double* values;
+  double average;
+} CubeAverageData;
+
+static size_t CubeAverageData_size(const void* const ptr) {
+  return sizeof(CubeAverageData);
+}
+
+const rb_data_type_t CubeAverageData_type = {
+  "TwistyPuzzles::Native::CubeAverageData",
+  {NULL, NULL, CubeAverageData_size, NULL},
+  NULL, NULL,
+  RUBY_TYPED_FREE_IMMEDIATELY  
+};
+
+static double* malloc_values(const size_t n) {
+  double* const values = malloc(n * sizeof(double));
+  if (values == NULL) {
+    rb_raise(rb_eNoMemError, "Allocating values failed.");
+  }
+  return values;
+}
+
+#define GetCubeAverageData(obj, data) \
+  do { \
+    TypedData_Get_Struct((obj), CubeAverageData, &CubeAverageData_type, (data)); \
+  } while (0)
+#define GetInitializedCubeAverageData(obj, data) \
+  do { \
+    GetCubeAverageData((obj), (data)); \
+    if (data->values == NULL) { \
+      rb_raise(rb_eArgError, "Cube average isn't initialized."); \
+    } \
+  } while (0)
+
+static VALUE CubeAverage_alloc(const VALUE klass) {
+  CubeAverageData* data;
+  const VALUE object = TypedData_Make_Struct(klass, CubeAverageData, &CubeAverageData_type, data);
+  data->capacity = 0;
+  data->size = 0;
+  data->insert_index = 0;
+  data->values = NULL;
+  data->average = NAN;
+  return object;
+}
+
+static VALUE CubeAverage_initialize(const VALUE self, const VALUE capacity, const VALUE initial_average) {
+  Check_Type(capacity, T_FIXNUM);
+  const size_t n = FIX2INT(capacity);
+  if (n < 3) {
+    rb_raise(rb_eArgError, "The number of elements for a cube average has to be at least 3. Got %ld.", n);
+  }
+  if (n > 1000) {
+    rb_raise(rb_eArgError, "The number of elements for a cube average can be at most 1000, otherwise we need a better implementation. Got %ld.", n);
+  }
+  
+  CubeAverageData* data;
+  GetCubeAverageData(self, data);
+
+  data->capacity = n;
+  data->size = 0;
+  data->values = malloc_values(n);
+  data->average = NUM2DBL(initial_average);
+  
+  return self;
+}
+
+static VALUE CubeAverage_capacity(const VALUE self) {
+  const CubeAverageData* data;
+  GetInitializedCubeAverageData(self, data);
+  return INT2NUM(data->capacity);
+}
+
+static VALUE CubeAverage_length(const VALUE self) {
+  const CubeAverageData* data;
+  GetInitializedCubeAverageData(self, data);
+  return INT2NUM(data->size);
+}
+
+static int saturated(const CubeAverageData* const data) {
+  return data->size == data->capacity;
+}
+
+static int comp(const void* left_ptr, const void* right_ptr) {
+  const double left = *((double*)left_ptr);
+  const double right = *((double*)right_ptr);
+  if (left > right) { return  1; }
+  if (left < right) { return -1; }
+  return 0;
+}
+
+static double compute_average(const double* const values, const size_t size) {
+  double sum = 0;
+  for (size_t i = 0; i < size; ++i) {
+    sum += values[i];
+  }
+  return sum / size;
+}
+
+static double compute_cube_average(const double* const values, const size_t size) {
+  if (size <= 2) {
+    return compute_average(values, size);
+  }
+  double* const tmp = malloc_values(size);
+  memcpy(tmp, values, size * sizeof(double));
+  qsort(tmp, size, sizeof(double), comp);
+  const size_t num_removed = ceil(size * removed_fraction_per_side);
+  const double result = compute_average(tmp + num_removed, size - 2 * num_removed);
+  free(tmp);
+  return result;
+}
+
+static VALUE CubeAverage_push(const VALUE self, const VALUE new_value) {
+  CubeAverageData* data;
+  GetInitializedCubeAverageData(self, data);
+
+  data->values[data->insert_index] = NUM2DBL(new_value);
+  data->size = MIN(data->size + 1, data->capacity);
+  data->insert_index = (data->insert_index + 1) % data->capacity;
+  data->average = compute_cube_average(data->values, data->size);
+  
+  return DBL2NUM(data->average);
+}
+
+static VALUE CubeAverage_push_all(const VALUE self, const VALUE new_values) {
+  Check_Type(new_values, T_ARRAY);
+  CubeAverageData* data;
+  GetInitializedCubeAverageData(self, data);
+
+  const size_t num_values = RARRAY_LEN(new_values);
+  if (num_values == 0) {
+    return DBL2NUM(data->average);
+  }
+  const size_t insert_index = data->insert_index;
+  const size_t capacity = data->capacity;
+  const size_t start = num_values > capacity ? num_values - capacity : 0;
+  for (size_t i = start; i < RARRAY_LEN(new_values); ++i) {
+    const VALUE new_value = rb_ary_entry(new_values, i);
+    data->values[(insert_index + i) % capacity] = NUM2DBL(new_value);
+  }
+
+  data->size = MIN(data->size + num_values, capacity);
+  data->insert_index = (insert_index + num_values) % capacity;
+  data->average = compute_cube_average(data->values, data->size);
+  
+  return DBL2NUM(data->average);
+}
+
+static VALUE CubeAverage_saturated(const VALUE self) {
+  const CubeAverageData* data;
+  GetInitializedCubeAverageData(self, data);
+  return saturated(data) ? Qtrue : Qfalse;
+}
+
+static VALUE CubeAverage_average(const VALUE self) {
+  const CubeAverageData* data;
+  GetInitializedCubeAverageData(self, data);
+  return DBL2NUM(data->average);
+}
+
+void init_cube_average_class_under(const VALUE module) {
+  CubeAverageClass = rb_define_class_under(module, "CubeAverage", rb_cObject);
+  rb_define_alloc_func(CubeAverageClass, CubeAverage_alloc);
+  rb_define_method(CubeAverageClass, "initialize", CubeAverage_initialize, 2);
+  rb_define_method(CubeAverageClass, "capacity", CubeAverage_capacity, 0);
+  rb_define_method(CubeAverageClass, "length", CubeAverage_length, 0);
+  rb_define_method(CubeAverageClass, "push", CubeAverage_push, 1);
+  rb_define_method(CubeAverageClass, "push_all", CubeAverage_push_all, 1);
+  rb_define_method(CubeAverageClass, "saturated?", CubeAverage_saturated, 0);
+  rb_define_method(CubeAverageClass, "average", CubeAverage_average, 0);
+}