public AstarSerializer(AstarPath script)
{
active = script;
astarData = script.astarData;
mask = -1;
mask -= SMask.SaveNodes;
}
public Task Start(IDictionary <string, List <string> > args)
{
try
{
var bm = new BitMask(156);
var bm3 = new BitMask(56);
bm[3] = true;
bm[34] = true;
bm[134] = true;
bm3[2] = true;
var T = bm.GetTiles();
var s1 = bm.ToBinaryString();
var s2 = bm.ToUintString();
var s3 = bm.ToString();
var s4 = bm3.ToString();
var bm2 = new BitMask(T, bm.Count);
bm.Or(bm2);
Passed = true;
IsComplete = true;
}
catch (Exception ex)
{
Passed = false;
FailureMessage = ex.Message;
}
return(Task.CompletedTask);
}
public void CanHasTrue()
{
var bitMask = new BitMask(new[] { 1, 2, 3, 4, 10, 16, 17, 20, 30, 31, 63, 72, 112 });
var bitMask2 = new BitMask(new[] { 2, 4, 16, 17, 30, 63, 112 });
Assert.True(bitMask.Has(bitMask2));
}
// Toggles the bit specified in intBit in the byte given in bytByte
public void ToggleBit(ref object bytByte, object intBit)
{
double BitMask;
BitMask = Math.Pow(2, (int.Parse(intBit.ToString()) - 1));
bytByte = int.Parse(bytByte.ToString()) ^ int.Parse(BitMask.ToString());
}
/// <summary>
/// Returns the plugins that are meant to be run at the specified stage
/// </summary>
/// <param name="plugins">All plugins loaded</param>
/// <param name="type">The plugin type</param>
/// <param name="stage">the process stage</param>
/// <returns></returns>
public static List <AbstractPlugin> GetPluginsForStage(List <AbstractPlugin> plugins, PluginType type,
ProcessStage stage)
{
return(plugins.Where(
x => BitMask.IsContainedInMask((int)x.PluginTypeToggle, (int)type, true) &&
BitMask.IsContainedInMask((int)x.ProcessStages, (int)stage, true)).ToList());
}
public TickAttribBidAsk(int value)
{
var mask = new BitMask(value);
BidPastLow = mask[0];
AskPastHigh = mask[1];
}
public void CanEqualsFalse()
{
var bitMask = new BitMask(new[] { 1, 2, 3, 4, 10, 16, 17, 20, 30, 31, 63, 72, 112 });
var bitMask2 = new BitMask(new[] { 1, 2, 4, 21, 29, 30, 72, 118 });
Assert.False(bitMask == bitMask2);
}
private static IEnumerable <BitMask[]> ExplodeMaskPart2(BitMask[] mask)
{
var index = -1;
for (var i = 0; i < mask.Length; i++)
{
if (mask[i] == BitMask.Any)
{
index = i;
break;
}
}
if (index == -1)
{
return(new[] { mask });
}
var copy1 = new BitMask[mask.Length];
var copy2 = new BitMask[mask.Length];
Array.Copy(mask, copy1, mask.Length);
Array.Copy(mask, copy2, mask.Length);
copy1[index] = BitMask.Zero;
copy2[index] = BitMask.One;
return(new[] { copy1, copy2 }.SelectMany(ExplodeMaskPart2));
}
public TickAttribLast(int value)
{
var mask = new BitMask(value);
PastLimit = mask[0];
Unreported = mask[1];
}
public UtilityTest()
{
mask = new BitMask();
//
// TODO: Add constructor logic here
//
}
public Computer Decode(string[] instructions)
{
foreach (var instruction in instructions)
{
var splitData = instruction.Split(new char[] { '[', ']', '=', ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (instruction.StartsWith("mask"))
{
Mask = BitMask.Parse(splitData[1]);
}
else if (instruction.StartsWith("mem"))
{
var address = Mask.SetBits(long.Parse(splitData[1]));
var value = long.Parse(splitData[2]);
for (int floatNr = 0; floatNr < Math.Pow(2, Mask.Float.Count); floatNr++)
{
var tempAddress = address;
for (int bitIndex = 0; bitIndex < Mask.Float.Count; bitIndex++)
{
var bitValue = ((floatNr >> bitIndex) & 0x1);
tempAddress = UpdateBit(tempAddress, Mask.Float[bitIndex], bitValue);
}
SaveToRegister(tempAddress, value);
}
}
}
return(this);
}
public bool ProcessControlWordLabel() //Processes a control word label and adds it to the list of control word labels
{
String name = GetWordToken();
long bank = GetIntToken();
if (!Enumerator.HasToken())
{
throw new MicroassemblerParseException(Enumerator.Current, "Number or Number:Number pair expected");
}
int msb, lsb;
if (Enumerator.Current.TokenType == TokenType.Pair)
{
Object[] arr = (Object[])Enumerator.Current.Value;
if (!(arr[0] is long) || !(arr[1] is long))
{
throw new MicroassemblerParseException("Number:Number pair expected");
}
msb = Convert.ToInt32(arr[0]);
lsb = Convert.ToInt32(arr[1]);
Enumerator.Advance();
}
else
{
msb = (int)GetIntToken();
lsb = msb;
}
BitMask mask = new BitMask(msb, lsb);
Microprogram.ControlWordLabels.Add(name, new ControlWordLabel {
Bank = Convert.ToInt32(bank), Name = name, Mask = mask
});
Console.WriteLine($"Added new control word label '{name}' on bank {bank} at {mask}");
return(true);
}
public override string Solve_1()
{
var reMask = new Regex(@"mask = (?<mask>\w+)");
var reMem = new Regex(@"mem\[(?<address>\d+)+\] = (?<value>\d+)");
BitMask mask = new BitMask("0");
var memory = new Dictionary <int, long>();
_input.ForEach(line =>
{
var m = reMem.Match(line);
if (m.Success)
{
var k = int.Parse(m.Groups["address"].Value);
var v = int.Parse(m.Groups["value"].Value);
memory[k] = mask.Apply(v);
}
else
{
m = reMask.Match(line);
mask = new BitMask(m.Groups["mask"].Value);
}
});
return($"{memory.Values.ToList().Sum()}");
}
public void CanHasFalse()
{
var bitMask = new BitMask(new[] { 1, 2, 3, 4, 10, 16, 17, 20, 30, 31 });
var bitMask2 = new BitMask(new[] { 1, 2, 3, 4, 9, 10, 16, 17, 20, 30, 31, 72 });
Assert.False(bitMask.Has(bitMask2));
}
public void WritesAllMasksCorrectly()
{
// we can't use [range] args because we have to skip cases where end is over 64
int count = 0;
for (int start = 0; start < 64; start++)
{
for (int bits = 0; bits < 64; bits++)
{
int end = start + bits;
if (end > 64)
{
continue;
}
ulong expected = SlowMask(start, end);
ulong actual = BitMask.OuterMask(start, end);
count++;
if (expected != actual)
{
Assert.Fail($"Failed, start:{start} bits:{bits}");
}
}
}
//UnityEngine.Debug.Log($"{count} masks tested");
}
// Returns true if the bit specified in intBit is true, false if not.
public bool ExamineBit(byte bytToCheck, int intBit)
{
double BitMask;
BitMask = Math.Pow(2, (intBit - 1));
return((bytToCheck & byte.Parse(BitMask.ToString())) > 0);
}
private static List <BitMask> CalculateFloatingBitMasks(BitMask bitmask)
{
var result = new List <BitMask>();
for (int i = 0; i < 36; i++)
{
if (bitmask[i] == null)
{
var falseMask = bitmask.Clone();
var trueMask = bitmask.Clone();
falseMask[i] = false;
trueMask[i] = true;
result.AddRange(CalculateFloatingBitMasks(falseMask));
result.AddRange(CalculateFloatingBitMasks(trueMask));
break;
}
if (i == 35)
{
result.Add(bitmask);
}
}
return(result);
}
public void MaskValueIsCorrect([Range(0, 64)] int bits)
{
var mask = BitMask.Mask(bits);
var expected = slowMask(bits);
Assert.That(mask, Is.EqualTo(expected), $" mask:{mask:X}\nexpected:{expected:X}");
}
public static IEnumerable <MemoryAddress> Decode(BitMask mask, MemoryAddress memoryAddress)
{
var floatingAddress = mask.Overwrite(memoryAddress);
var decodingAddress = new List <string>
{
string.Empty
};
foreach (var bit in floatingAddress)
{
var assignBit = bit == 'X' ? '0' : bit;
for (var i = 0; i < decodingAddress.Count; i++)
{
decodingAddress[i] += assignBit;
}
if (bit != 'X')
{
continue;
}
foreach (var decodingResult in decodingAddress.ToList())
{
decodingAddress.Add(decodingResult[..^ 1] + '1');
int ReserveTransient(Entity entity, Resolutions resolution, BitMask mask = null)
{
var index = _slots.count++;
_slots.Ensure();
ref var slot = ref _slots.items[index];
private static void PartTwo()
{
var memoryMap = new Dictionary <long, long>();
BitMask memoryMask = null;
using (var inputFile = File.OpenRead("input.txt"))
{
using (var reader = new StreamReader(inputFile))
{
while (!reader.EndOfStream)
{
var currentLine = reader.ReadLine();
var lineParts = currentLine.Split('=');
if (lineParts.First().StartsWith("mask"))
{
memoryMask = new BitMask(lineParts.Last().Trim());
}
else if (lineParts.First().StartsWith("mem"))
{
var address = int.Parse(Regex.Match(lineParts.First().Trim(), "mem\\[([0-9]+)\\]").Groups[1].Value);
var decimalValue = long.Parse(lineParts.Last().Trim());
var addressMask = new BitMask(address);
for (int i = 0; i < 36; i++)
{
if (memoryMask[i].HasValue)
{
if (memoryMask[i].Value == true)
{
addressMask[i] = true;
}
}
else
{
addressMask[i] = null;
}
}
var floatingAddresses = CalculateFloatingBitMasks(addressMask);
foreach (var finalAddress in floatingAddresses)
{
memoryMap[finalAddress.ToLong()] = decimalValue;
}
}
}
}
}
var result = 0L;
foreach (var entry in memoryMap)
{
result += entry.Value;
}
Console.WriteLine(result);
}
public void Test_Constructors()
{
var bm = new BitMask(2, 8, 16);
var bm1 = new BitMask(2 | 8 | 16);
Assert.AreEqual((int)bm, (int)bm1);
}
public void Test_RemoveAllPrefixes()
{
var bm = new BitMask(2 | 8);
Debug.AddPrefixForMask(bm, "HELLO");
Debug.RemoveAllPrefixes();
Assert.IsTrue(Debug.GetAllPrefixes().Count == 0);
}
public void CanAnd()
{
var bitMask = new BitMask(new[] { 1, 2, 3, 4, 10, 16, 17, 20, 30, 31, 63, 72, 112 });
var bitMask2 = new BitMask(new[] { 1, 2, 3, 4, 10, 17, 20, 30, 31, 63, 112 });
var expectedResult = new BitMask(new[] { 1, 2, 3, 4, 10, 17, 20, 30, 31, 63, 112 });
Assert.Equal(expectedResult, bitMask & bitMask2);
}
public BitMask( BitMask mask )
{
_bytes = new uint[mask._bytes.Length];
for( var i = 0; i < mask._bytes.Length; i++ )
{
_bytes[i] = mask._bytes[i];
}
}
public void UnsetBitRange_SecondShortUnset()
{
nint value = (nint)nuint.MaxValue;
value = BitMask.UnsetBitRange(value, 16, 16);
Assert.IsTrue((ulong)value == 0b_1111_1111_1111_1111_1111_1111_1111_1111_0000_0000_0000_0000_1111_1111_1111_1111);
}
public void triggerMask(BitMask mask)
{
msclPINVOKE.EventTriggerOptions_triggerMask__SWIG_1(swigCPtr, BitMask.getCPtr(mask));
if (msclPINVOKE.SWIGPendingException.Pending)
{
throw msclPINVOKE.SWIGPendingException.Retrieve();
}
}
public void SetBitRange_SecondShortSet()
{
nint value = 0;
value = BitMask.SetBitRange(value, 16, 16);
Assert.IsTrue((ulong)value == 0b_0000_0000_0000_0000_0000_0000_0000_0000_1111_1111_1111_1111_0000_0000_0000_0000);
}
public void ADL_Mask_Constructors_Test()
{
BitMask bm = new BitMask(2, 8, 16);
BitMask bm1 = new BitMask(2 | 8 | 16);
Assert.AreEqual((int)bm, (int)bm1);
}
public void ADL_Mask_RemoveFlags_Test()
{
BitMask <char> bm1 = new BitMask <char>(2 | 8 | 16);
BitMask <char> ret = BitMask.RemoveFlags(bm1, 2);
Assert.False(BitMask.IsContainedInMask(ret, 2, true));
Assert.True(BitMask.IsContainedInMask(bm1, 2, true));
}
public void ADL_Mask_IsUniqueMask_Test()
{
BitMask <char> bm = new BitMask <char>(2 | 4);
BitMask <char> bm1 = new BitMask <char>(8);
Assert.True(BitMask.IsUniqueMask(bm1));
Assert.False(BitMask.IsUniqueMask(bm));
}
public BitMask And( BitMask mask )
{
Debug.Assert( _bytes.Length == mask._bytes.Length, "BitMasks must be the same size" );
for( var i = 0; i < mask._bytes.Length; i++ )
{
_bytes[i] = _bytes[i] & mask._bytes[i];
}
return this;
}
public AstarSerializer(AstarPath script)
{
active = script;
astarData = script.astarData;
mask = -1;
mask -= SMask.SaveNodes;
}
private static bool _isEqual( BitMask m1, BitMask m2 )
{
// BitMasks need to be the same size
if( m1._bytes.Length != m2._bytes.Length ) return false;
// Compare all elements in each BitMask's _byte array
for( int i = 0; i < m1._bytes.Length; i++ )
{
if( m1._bytes[i] != m2._bytes[i] )
{
return false;
}
}
return true;
}
private byte RegisterRead(Register register, BitMask mask)
{
var regval = RawReadRegister((byte) register);
regval &= (byte) mask;
if (mask != 0x0)
{
regval >>= (GetShiftCount((byte) mask) - 1);
}
return regval;
}
private void RegisterWrite(Register register, BitMask mask, byte data)
{
var regval = RawReadRegister((byte) register);
regval &= (byte) ~(mask);
if (mask != 0x0)
{
regval |= (byte) (data << (GetShiftCount((byte) mask) - 1));
}
else
{
regval |= data;
}
try
{
spi.Write((byte) ((byte) register & 0x3F), regval);
}
catch (Exception e)
{
Debug.Print(e.Message);
}
}
