public static void VerifyGroupActionAssociaty() { for (int caseIdx = 0; caseIdx < 100; caseIdx++) { CubeAction a = CubeAction.Random(Utils.GlobalRandom.Next(1, 20)); CubeAction b = CubeAction.Random(Utils.GlobalRandom.Next(1, 15)); CubeAction c = CubeAction.Random(Utils.GlobalRandom.Next(1, 10)); CubeAction ab = a.Mul(b); CubeAction bc = b.Mul(c); CubeState origState = CubeAction.RandomCube(Utils.GlobalRandom.Next(1, 20)); CubeState a_b_c_state = new CubeState(origState); c.Act(a_b_c_state); b.Act(a_b_c_state); a.Act(a_b_c_state); CubeState ab_c_state = new CubeState(origState); c.Act(ab_c_state); ab.Act(ab_c_state); CubeState a_bc_state = new CubeState(origState); bc.Act(a_bc_state); a.Act(a_bc_state); Utils.DebugAssert(a_b_c_state.Equals(ab_c_state)); Utils.DebugAssert(a_b_c_state.Equals(a_bc_state)); } }
protected void DetermineNotChangedAndDeltas( Context context, Context.ConnectionData connectionData, ushort currentSequence, int numCubes, ref int[] cubeIds, ref bool[] notChanged, ref bool[] hasDelta, ref ushort[] baselineSequence, ref CubeState[] cubeState, ref CubeDelta[] cubeDelta ) { Profiler.BeginSample( "DeterminedNotChangedAndDeltas" ); #if !DISABLE_DELTA_COMPRESSION CubeState baselineCubeState = CubeState.defaults; #endif // #if !DISABLE_DELTA_COMPRESSION for ( int i = 0; i < numCubes; ++i ) { notChanged[i] = false; hasDelta[i] = false; #if !DISABLE_DELTA_COMPRESSION #if DEBUG_DELTA_COMPRESSION cubeDelta[i].absolute_position_x = cubeState[i].position_x; cubeDelta[i].absolute_position_y = cubeState[i].position_y; cubeDelta[i].absolute_position_z = cubeState[i].position_z; #endif // #if DEBUG_DELTA_COMPRESSION if ( context.GetMostRecentAckedState( connectionData, cubeIds[i], ref baselineSequence[i], context.GetResetSequence(), ref baselineCubeState ) ) { if ( Network.Util.BaselineDifference( currentSequence, baselineSequence[i] ) > Constants.MaxBaselineDifference ) { // baseline is too far behind => send the cube state absolute. continue; } if ( baselineCubeState.Equals( cubeState[i] ) ) { notChanged[i] = true; } else { hasDelta[i] = true; cubeDelta[i].position_delta_x = cubeState[i].position_x - baselineCubeState.position_x; cubeDelta[i].position_delta_y = cubeState[i].position_y - baselineCubeState.position_y; cubeDelta[i].position_delta_z = cubeState[i].position_z - baselineCubeState.position_z; cubeDelta[i].linear_velocity_delta_x = cubeState[i].linear_velocity_x - baselineCubeState.linear_velocity_x; cubeDelta[i].linear_velocity_delta_y = cubeState[i].linear_velocity_y - baselineCubeState.linear_velocity_y; cubeDelta[i].linear_velocity_delta_z = cubeState[i].linear_velocity_z - baselineCubeState.linear_velocity_z; cubeDelta[i].angular_velocity_delta_x = cubeState[i].angular_velocity_x - baselineCubeState.angular_velocity_x; cubeDelta[i].angular_velocity_delta_y = cubeState[i].angular_velocity_y - baselineCubeState.angular_velocity_y; cubeDelta[i].angular_velocity_delta_z = cubeState[i].angular_velocity_z - baselineCubeState.angular_velocity_z; } } #endif // #if !DISABLE_DELTA_COMPRESSION } Profiler.EndSample(); }
public List <Tuple <CubeAction, CubeState> > SolveCube(CubeState puzzleState) { if (SolvingMap.Count <= 0) { throw new ArgumentException(); } var originalPuzzleState = new CubeState(puzzleState); var ret = new List <Tuple <CubeAction, CubeState> >(); ret.Add(new Tuple <CubeAction, CubeState>(new CubeAction(), new CubeState(puzzleState))); for (int gIdx = 0; gIdx < SolvingMap.Count; gIdx++) { var g = SolvingMap[gIdx]; if (null == g.OrbitToCoset) { for (int gIdx_inner = gIdx + 1; gIdx_inner < SolvingMap.Count; gIdx_inner++) { Utils.DebugAssert(null == SolvingMap[gIdx_inner].OrbitToCoset); } continue; } var observed = new BlockSet(puzzleState, g.ToStablize.Indexes); if (!g.OrbitToCoset.ContainsKey(observed)) { throw new ArgumentException(); } var cosetRepresentative = g.OrbitToCoset[observed]; var rCosetRepr = cosetRepresentative.Reverse(); rCosetRepr.Act(observed.State); puzzleState = observed.State; Utils.DebugAssert(g.OrbitToCoset.ContainsKey(observed)); Utils.DebugAssert(g.OrbitToCoset[observed].Equals(new CubeAction())); ret.Add(new Tuple <CubeAction, CubeState>(rCosetRepr, new CubeState(observed.State))); } { var trialState = new CubeState(originalPuzzleState); foreach (var pair in ret) { var action = pair.Item1; action.Act(trialState); } Utils.DebugAssert(trialState.Equals(new CubeState())); } return(ret); }
private bool EqualAct(CubeAction obj) { var stateThis = new CubeState(); var stateObj = new CubeState(); this.Act(stateThis); obj.Act(stateObj); bool actEqual = stateThis.Equals(stateObj); return(actEqual); }
private bool EqualOps(CubeAction obj) { var stateThis = new CubeState(); var stateObj = new CubeState(); this.ActOps(stateThis); obj.ActOps(stateObj); bool opsEqual = stateThis.Equals(stateObj); return(opsEqual); }
public static void VerifyCubeTurnAround() { for (int caseIdx = 0; caseIdx < 100; caseIdx++) { CubeState cubeState = CubeAction.RandomCube(Utils.GlobalRandom.Next(1, 30)); foreach (CubeOp.Type op in Enum.GetValues(typeof(CubeOp.Type))) { var action = new CubeAction(new int[] { (int)op }); CubeState newCubeState = new CubeState(cubeState); for (int i = 0; i < CubeState.TurnAround; i++) { action.Act(newCubeState); } Utils.DebugAssert(newCubeState.Equals(cubeState)); } } for (int caseIdx = 0; caseIdx < 100; caseIdx++) { CubeState cubeState = CubeAction.RandomCube(Utils.GlobalRandom.Next(1, 30)); foreach (CubeOp.Type op in Enum.GetValues(typeof(CubeOp.Type))) { var action = new CubeAction(new int[] { (int)op, (int)op, (int)op }); CubeState newCubeState = new CubeState(cubeState); for (int i = 0; i < CubeState.TurnAround; i++) { action.Act(newCubeState); } Utils.DebugAssert(newCubeState.Equals(cubeState)); } } for (int caseIdx = 0; caseIdx < 100; caseIdx++) { CubeState cubeState = CubeAction.RandomCube(Utils.GlobalRandom.Next(1, 30)); foreach (CubeOp.Type op in Enum.GetValues(typeof(CubeOp.Type))) { var action = new CubeAction(new int[] { (int)op, (int)op }); CubeState newCubeState = new CubeState(cubeState); for (int i = 0; i < CubeState.TurnAround / 2; i++) { action.Act(newCubeState); } Utils.DebugAssert(newCubeState.Equals(cubeState)); } } }
private void VerifyAccelerationMap() { if (!Utils.ShouldVerify()) { return; } var actionCubeState = new CubeState(); ActOps(actionCubeState); var mapCubeState = new CubeState(); AccelerationMap.Act(mapCubeState); Utils.DebugAssert(mapCubeState.Equals(actionCubeState)); }
private static void LazyInitActionShrink() { if (ActionShrinkDict != null) { return; } // Bigger than 5 may OOM on my desktop const int DICT_SCAN_ROUNDS = 5; // To aoivd OOM, exclude reflect and inverse ops after certain rounds const int DICT_SCAN_REDUCED_ROUND = 4; ActionShrinkDict = new Dictionary <CubeState, CubeAction>() { { new CubeState(), new CubeAction() } }; var fullyWalkedStates = new HashSet <CubeState>(); for (int round = 0; round < DICT_SCAN_ROUNDS; round++) { var needWalkStates = new HashSet <CubeState>(ActionShrinkDict.Keys); needWalkStates.RemoveWhere(x => fullyWalkedStates.Contains(x)); int foundCount = 0; int walkedCount = 0; foreach (var state in needWalkStates) { foreach (CubeOp.Type op in Enum.GetValues(typeof(CubeOp.Type))) { var action = ActionShrinkDict[state]; int sameOpCount = 0; for (int i = action.Ops.Count - 1; i >= 0; i--) { if (action.Ops[i] == op) { sameOpCount++; } else { break; } } var newStateBase = new CubeState(state); int turnCount = CubeState.TurnAround - sameOpCount - 1; if (round >= DICT_SCAN_REDUCED_ROUND) { turnCount = 1; } // Scanning while including the reflect and reverse operations for (int turn = 1; turn <= turnCount; turn++) { CubeOp.Op(newStateBase, op); if (!ActionShrinkDict.ContainsKey(newStateBase)) { var newState = new CubeState(newStateBase); var newAction = new CubeAction(action); newAction.Ops.InsertRange(0, Enumerable.Repeat(op, turn)); ActionShrinkDict.Add(newState, newAction); foundCount++; } } } walkedCount++; } fullyWalkedStates.UnionWith(needWalkStates); Console.WriteLine( $"LazyInitActionShrink: round={round} foundCount={foundCount} " + $"total={ActionShrinkDict.Count}"); } // // Verifying // foreach (var kv in ActionShrinkDict) { var state = new CubeState(); kv.Value.ActOps(state); Utils.DebugAssert(state.Equals(kv.Key)); Utils.DebugAssert(!kv.Value.RefMode); } }