twisty_puzzles 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 989d528a58cb32ca49f7502249b5e5eca71a1e46726f1a79ffa64e18381d5a86
-  data.tar.gz: 2c1bfff00d66c4b85f15592ee50fa6883e45149ae8456c7a24cc1cba60841285
+  metadata.gz: 2ade419b71ffb378baf9543f4971d2ebf303f309c7b22281c24448725c7066e4
+  data.tar.gz: 06b797f7652f9138983cb750ddb1dfedddfe1e9fd793f6912b005445ec099687
 SHA512:
-  metadata.gz: 870c957e8ba192090401e9e6092779e5f19f45fcd995d60ab1c2e52fed62b7cd25397ce06f18fb2eae6f4ac3df88e76975390f0b73ebc45a8fe2ecdc2cae41fd
-  data.tar.gz: 6140ebc4150d89e0577461b66b18158dec51c11d3527d265f028d24cd2b1e44f2299b05ae46a3264bbc040dcf0b34bda83be7ec15092884234539130a402d3ef
+  metadata.gz: b10baf651145e999a998938806a3e07a10e84f0c060924ca93a898b936b3299d00330f106bc658596c6df50c30a3db4c82c7b80254f535d69d3dc40e3e593424
+  data.tar.gz: 262a1c10e10096be3a5f6376679436e8e76cc695ae98a4093a8eadaa2a23aa541c3608c3ace56d231204516880a7f306fced862eb4b179ec608d8eebd02a8201

data/CHANGELOG.md

@@ -4,6 +4,10 @@ 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.2]
+### Fixed
+Added extension source files to files.
+
 ## [0.0.2]
 ### Changed
 - Now a simple `require 'twisty_puzzles'` is enough, users don't need to require files separately.
@@ -11,7 +15,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/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);
+}