commit 1cecea625ed405c7203d1977e687da36d835fc9a
parent 0b1930307f41db3ea7552d6b2f4666b33c64d26a
Author: Sebastiano Tronto <sebastiano@tronto.net>
Date: Sun, 9 Jun 2024 20:23:58 +0200
Cleanup cube.h
Diffstat:
4 files changed, 11 insertions(+), 128 deletions(-)
diff --git a/TODO.txt b/TODO.txt
@@ -1,7 +1,5 @@
Refactoring: remove cube_fast_t and add b32 format
- - cleanup cube.h
- remove some documentation, move to new file
- create src/cube_pulic.h for implementations of cube.h stuff
+ - see TODO comments in cube.h
- switch to b32 by default (part 1)
add tests for b32 (write at some by hand)
- fix utility code in utils/*.c
diff --git a/src/cube.h b/old/cube_h_with_format_documentation
diff --git a/src/cube.h b/src/cube.h
@@ -1,139 +1,27 @@
-/******************************************************************************
-Cube type definition
-
-Each piece is represented by an (unsigned) 8-bit integer. The 4
-least-significant bits determine which piece it is, the other 4 determine
-the orientation.
-
-Edges are numbered as follows (see also cube.c):
-UF=0 UB=1 DB=2 DF=3 UR=4 UL=5 DL=6 DR=7 FR=8 FL=9 BL=10 BR=11
-
-Corners are numbered as follows:
-UFR=0 UBL=1 DFL=2 DBR=3 UFL=4 UBR=5 DFR=6 DBL=7
-
-The orientation of the edges is with respect to F/B, the orientation of
-corners is with respect to U/D.
-
-The permutation of the center pieces is not stored. This means that the
-cube is assumed to be in a fixed orientation.
-
-TODO: define EO and CO better, explain how to use them
-TODO: encode centers?
-
-The exact cube type structure depends on your system's configuration. If
-you operate on the cube only via the functions provided below, you don't
-need to worry about this.
-******************************************************************************/
-
-/* Apply the second cube on the first as a move sequence */
-cube_t compose(cube_t, cube_t);
-
-/* Invert the cube */
-cube_t inverse(cube_t);
-
-/* Check if a cube represent a valid state (possibly unsolvable) */
-
-/* TODO comment on these and the format for moves and trans */
-/* For trans, only one trans is supported */
+/* TODO: change cube to const char [static 22], or const char * */
+/* TODO: return error code */
+/* TODO: implement all of this, or move the implementation to cube_public.h */
+/* TODO: document in a separate file, possibly leave here 1-line comments */
+
+cube_t compose(cube_t cube, cube_t perm);
+cube_t inverse(cube_t cube);
+cube_t solvedcube(void);
cube_t applymoves(cube_t, const char *);
cube_t applytrans(cube_t, const char *);
-
-/******************************************************************************
-Read / write utilities
-
-Reading and writing is not done directly via stdin / stdout, but via an
-array of char (called buf in the prototypes below).
-
-Multiple representations of the cube as text are supported:
-
-- H48: a human-readable format.
- Each edge is represented by two letters denoting the sides it
- belongs to and one number denoting its orientation (0 oriented, 1
- mis-oriented). Similarly, each corner is represented by three letters and
- a number (0 oriented, 1 twisted clockwise, 2 twisted counter-clockwise).
-
- The solved cube looks like this:
-
- UF0 UB0 DB0 DF0 UR0 UL0 DL0 DR0 FR0 FL0 BL0 BR0
- UFR0 UBL0 DFL0 DBR0 UFL0 UBR0 DFR0 DBL0
-
- The cube after the moves R'U'F looks like this:
-
- FL1 BR0 DB0 UR1 UF0 UB0 DL0 FR0 UL1 DF1 BL0 DR0
- UBL1 DBR1 UFR2 DFR2 DFL2 UBL2 UFL2 DBL0
-
- Whitespace (including newlines) between pieces is ignored when reading the
- cube. A single whitespace character is added between pieces when writing.
-
-- SRC: format used to generate code for internal use.
- If OUT is the output in SRC format, one can use `cube_t cube = OUT` to
- declare a new cube object.
-
-- LST: a format for internal use and generating code.
- The cube is printed as a comma-separated list of 20 integers, as they appear
- in cube_t. Corners come first, followed by edge (unlike H48).
-******************************************************************************/
-
cube_t readcube(const char *format, const char *buf);
void writecube(const char *format, cube_t cube, char *buf);
-
-/******************************************************************************
-Solvers
-
-The solutions are returned as a newline-separated list of characters. Moves
-are separated by single spaces.
-
-Unless specified otherwise, all the solutions are not trivially simplifiable.
-This means that sequences like U U2 or R L R will not appear in any solution.
-Moreover, two consecutive parallel moves are always going to be sorted in
-increasing order. For example, L R2 may never appear in a solution, but R2 L
-could.
-******************************************************************************/
-
int64_t solve(
- /* The cube to solve. Must be solvable. */
cube_t cube,
-
- /* Supported solvers:
- * "optimal" - currently the same as "simple"
- * "simple" - a simple, slow solver without tables
- */
const char *solver,
-
- /* Some solvers accept extra options,like "!filter". */
const char *options,
-
- /* Can be "normal", "inverse", "mixed" or "linear". */
const char *nisstype,
-
- /* The minimum number of moves. Must be >= 0. */
int8_t minmoves,
-
- /* The maximum number of moves. If negative, the maximum length
- * is unlimited.
- */
int8_t maxmoves,
-
- /* The maximum number of solutions. */
int64_t maxsols,
-
- /* All solutions at most "optimal" moves from the shortest solution
- * (respecting minmoves) are found. If negative, it is ignored.
- */
int8_t optimal,
-
- /* Some solvers require extra data to function properly (for example,
- * pruning tables). This data can be generated with gendata().
- */
const void *data,
-
- /* The solutions (return parameter) */
char *solutions
);
-
-/* Solving n cubes optimally, one solutions per cube. Options are similar
- * to solve().
- */
void multisolve(
int n,
cube_t *cube,
@@ -141,7 +29,4 @@ void multisolve(
const void *data,
char *sols
);
-
-/* Returns the number of bytes written to data, -1 in case of error.
- * TODO: write down how much memory every solver requires. */
int64_t gendata(const char *solver, const char *options, void *data);
diff --git a/src/cube_generic.h b/src/cube_generic.h
@@ -1,7 +1,7 @@
#define _move(M, c) compose(c, _move_cube_ ## M)
#define _premove(M, c) compose(_move_cube_ ## M, c)
-_static cube_t solvedcube();
+_static cube_t solvedcube(void);
_static bool isconsistent(cube_t);
_static bool issolvable(cube_t);
_static bool issolved(cube_t);
@@ -16,7 +16,7 @@ _static cube_t transform_corners(cube_t, uint8_t);
_static cube_t transform(cube_t, uint8_t);
_static cube_t
-solvedcube()
+solvedcube(void)
{
return solved;
}
