public void UpdateScreen(BitArray bitData)
{
for (int i = 0; i < pixelsObjects.Count; i++)
{
pixelsObjects[i].SetActive(bitData[i]);
}
}
static void Main()
{
BitArray bits = new BitArray(100000);
bits[99999] = 1;
Console.WriteLine(bits.ToString());
}
public static void And_EmptyArray()
{
BitArray bitArray1 = new BitArray(0);
BitArray bitArray2 = new BitArray(0);
Assert.Equal(0, bitArray1.And(bitArray2).Length);
}
private void renderCurrentState()
{
int i;
BitArray stacks = new BitArray( brain.getKnownObjects().Count );
foreach ( iThinkFact fact in brain.curState.getFactList() )
{
if ( fact.getName().Equals( "onTable" ) )
{
i = findNextFreeStack( stacks );
fact.getObj( 0 ).transform.position = new Vector3( (float)( 1.5 - i * 1.5 ), 0, 0 );
stacks.Set( i - 1, true );
}
}
foreach ( iThinkFact fact in brain.curState.getFactList() )
{
if ( fact.getName().Equals( "on" ) )
{
fact.getObj( 0 ).transform.position = fact.getObj( 1 ).transform.position;
fact.getObj( 0 ).transform.Translate( 0, (float)1.5, 0 );
}
else if ( fact.getName().Equals( "holding" ) )
{
fact.getObj( 0 ).transform.position = new Vector3( -15, 5, 0 );
}
}
}
public BitArray GenerateSubset(
int n, int k, BigInteger i, BitArray b, int offset)
{
BigInteger upperBound = Choose(n, k);
if (i>=upperBound) {
// There are only nCk possible subsets to return.
return null;
}
int zeros = 0; // Count of zeros on the front before the first 1.
BigInteger low = BigInteger.ZERO;
BigInteger high = Choose(n-1, k-1);
while (i>=high){
zeros += 1;
low = high;
high = high+Choose(n-zeros-1, k-1);
}
if (zeros + k > n) {
// Something is wrong! Not enough bits exist.
throw new Exception("Too many zeros!");
}
b[offset+zeros] = true;
if (k == 1) return b;
else return GenerateSubset(
n-zeros-1, k-1, i-low, b, offset+zeros+1);
}
public BitArray GetBitsStuffed()
{
int nstuff = 0;
bool last = false;
BitArray ba = new BitArray();
foreach (bool bit in GetBitsUnstuffed().Bits())
{
if (bit == last)
nstuff++;
else
{
nstuff = 1;
last = bit;
}
if (nstuff > 5)
{
ba.AddBit(!last);
nstuff = 1;
}
ba.AddBit(bit);
}
return ba;
}
static void Main()
{
BitArray num = new BitArray(8);
num[0] = 1;
num[7] = 1;
Console.WriteLine(num);
}
public static LinkedList<Point> GetWalkingSteps(Point start, BitArray goals, bool walkInWater = false, bool nearbyOk = false)
{
Bb.ReadBoard();
if (!goals.ToPoints().Any())
{
return null;
}
Point[] starts = { start };
var passable = Solver.GetPassable(true);
var aStarPassable = new BitArray(passable);
aStarPassable.Set(start, true);
if (nearbyOk)
{
aStarPassable.Or(goals);
}
Func<Point, Point, int> cost = (c, n) => (Bb.Water.Get(n) && !walkInWater) ? 10 : 1;
var route = Pather.AStar(starts, p => goals.Get(p), aStarPassable, cost, p => 0);
if (route == null)
{
return null;
}
var steps = new LinkedList<Point>(route);
steps.RemoveFirst();
if (steps.Count > 0 && !passable.Get(steps.Last.Value))
{
steps.RemoveLast();
}
return steps;
}
private static void TestSequentialInv(int count)
{
BitArray array = new BitArray(false, count);
for (int x = 0; x < count; x++)
{
if (array.GetBit(x))
throw new Exception("each bit should be cleared");
}
array = new BitArray(true, count);
for (int x = 0; x < count; x++)
{
if (!array.GetBit(x))
throw new Exception("each bit should be set");
}
for (int x = 0; x < count; x++)
{
array.ClearBit(x);
if (array.GetBit(x))
throw new Exception("each bit should be cleared");
array.SetBit(x);
if (!array.GetBit(x))
throw new Exception("each bit should be cleared");
array.ClearBit(x);
if (array.FindSetBit() != (x == count - 1 ? -1 : x + 1))
throw new Exception();
}
}
public static string Read()
{
String xd;
using(StreamReader reader = new StreamReader("Output.txt"))
{
xd = reader.ReadToEnd();
}
string[] c = xd.Split(' ');
List<byte> outputs = new List<byte>();
foreach(string x in c)
{
char[] d = x.ToCharArray();
BitArray Out = new BitArray(8);
if (d.Length != 8)
{
continue;
}
for(int i = 0; i < 8; i++)
{
Out[i] = d[i] == 'x';
}
outputs.Add(ConvertToByte(Out));
}
return Encoding.ASCII.GetString(outputs.ToArray());
}
// Use this for initialization
void Start () {
object[] obj = GameObject.FindSceneObjectsOfType(typeof (GameObject));
foreach (object o in obj)
{
GameObject g = (GameObject) o;
if(g.GetComponent<PhotoEye>()!=null)
{
if(g.GetComponent<PhotoEye>().IO_name_photoeye==IO_name_photoeye_trigger)
{
g.GetComponent<PhotoEye>().ConnectATR(gameObject);
}
}
}
encoding = new System.Text.ASCIIEncoding();
max_emu_to_plc_io = 1600; // 200 bytes
emu_to_plc_bits = new BitArray(max_emu_to_plc_io);
Logger.WriteLine("[INFO]","STARTUP AtrsCom on port " + ATR_PORT + " linked to photoeye " + IO_name_photoeye_trigger,"",true);
Debug.Log("STARTUP AtrsCom on port " + ATR_PORT + " linked to photoeye " + IO_name_photoeye_trigger+".\r\n");
ready = true;
listenerThread = new Thread(new ThreadStart(DoListen));
listenerThread.Start();
}
public void Load(int Index){
MemoryMappedFileSecurity CustomSecurity = new MemoryMappedFileSecurity();
CustomSecurity.AddAccessRule(new System.Security.AccessControl.AccessRule<MemoryMappedFileRights>("everyone", MemoryMappedFileRights.FullControl, System.Security.AccessControl.AccessControlType
.Allow));
using(MemoryMappedFile mmf = MemoryMappedFile.CreateOrOpen("bits", (long)Math.Ceiling(Length/8.0), MemoryMappedFileAccess.ReadWriteExecute, MemoryMappedFileOptions.None, CustomSecurity, System.IO.HandleInheritability.Inheritable)){
using (MemoryMappedViewStream stream = mmf.CreateViewStream())
{
int Amount = (int)Math.Ceiling((double)(Length/Int32.MaxValue));
int Remainder = (int)(Length%Int32.MaxValue);
int length = (int)(Amount==Index?Math.Ceiling(Remainder/8.0):Math.Ceiling(Int32.MaxValue/8.0));
byte[] buffer = BitArrayToByteArray(LoadedArray,0,LoadedArray.Length);
stream.Position=(long)Math.Ceiling((Int32.MaxValue/8.0))*LoadedArrayIndex;
BinaryWriter writer = new BinaryWriter(stream);
writer.Write(buffer);
stream.Position=0;//(long)Math.Ceiling((Int32.MaxValue/8.0))*Index;
BinaryReader reader = new BinaryReader(stream);
buffer = new byte[(int)Math.Ceiling((Int32.MaxValue/8.0))];
try{reader.Read(buffer,(int)Math.Ceiling((Int32.MaxValue/8.0))*Index,(int)Math.Ceiling((Int32.MaxValue/8.0)));} catch{LoadedArray = new BitArray((int)(length*8.0));}
}
}
//int ElementIndex = (int)Math.Floor((double)(T/Int32.MaxValue));
//int Index = (int)(T%Int32.MaxValue);
//Elements[ElementIndex][Index]=value;
//}
}
static void Main()
{
BitArray bits = new BitArray();
//Random set of bits
for (int i = 0; i < 64; i++)
{
Random random = new Random();
StringBuilder getTime = new StringBuilder();
int randomNumber = (int)DateTime.Now.Ticks;
//Трябва ми време за да се получи добър random
for (int j = 0; j < 100000; j++)
{
Math.Sqrt(j + 1);
}
//Край на губенето на време
if (randomNumber % 2 == 0)
{
bits[i] = 1;
}
}
Console.WriteLine(bits);
//Print all Bits
foreach (var item in bits)
{
Console.Write(item);
}
Console.WriteLine();
}
static void Main()
{
int maxNum = 10000000;
BitArray primeNumbers = new BitArray(maxNum, true);
for (int i = 2; i < Math.Sqrt(maxNum); i++)
{
if (primeNumbers[i] == true)
{
for (int j = i * i; j < maxNum; )
{
primeNumbers[j] = false;
j += i;
}
}
}
for (int i = 0; i < primeNumbers.Count; i++)
{
if (primeNumbers[i] == true)
{
Console.Write("{0} ",i);
}
}
}
public static string Decode (Texture2D image){
//Get the pixels for the image...
Color[] imagePixels = image.GetPixels();
//Go Through the First 32 Pixels and create a 4 byte array.
//This array should give us the message's length.
BitArray newBits = new BitArray(32);
for (int i=0;i<32;i++){
if(imagePixels[i].a == 1){
newBits[i] = true;
}
else {
newBits[i] = false;
}
}
int total = System.BitConverter.ToInt32(ToByteArray(newBits), 0);
BitArray messageBits = new BitArray(total);
for (int j=32;j<total + 32;j++){
if(imagePixels[j].a == 1){
messageBits[j-32] = true;
}
else {
messageBits[j-32] = false;
}
}
return System.Text.Encoding.ASCII.GetString(ToByteArray(messageBits));
}
// Update is called once per frame
void Update()
{
if (ListenClient.ori != null && ListenClient.ori.Length > 4)
{
//Debug.Log (ListenClient.ori);
string[] difPos = ListenClient.ori.Split('_');
Debug.Log (difPos);
string[] pos = difPos[0].Split(' ');
double accel = double.Parse(difPos[1]);
if (accel >= 7000 && !audio.isPlaying) {
audio.Play ();
}
int button = int.Parse(difPos[2]);
int trigger = int.Parse(difPos[3]);
Debug.Log (button);
b = new BitArray (new int[] { button });
bool[] bits = new bool[32];
if (button != 0) {
b.CopyTo (bits, 0);
}
Debug.Log ("button " + bits[19]);
if (bits [19]) {
globalExtended = true;
} else {
globalExtended = false;
}
if (pos.Length >= 4)
{
Quaternion q = new Quaternion(float.Parse(pos[1]), float.Parse(pos[2]), float.Parse(pos[3]), float.Parse(pos[0]));
//q = upInv * q;
//q = Quaternion.Inverse(q);
Vector3 e = q.eulerAngles;
e.x *= -1;
e.y *= -1;
pivot.transform.rotation = Quaternion.Euler(e);
//Debug.Log("transformed");
}
}
if (ListenClient.pos != null && ListenClient.pos.Length > 5)
{
string[] strPos = ListenClient.pos.Split(';');
for (int i = 0; i < strPos.Length; i++)
{
if (strPos[i].Contains("rwrist"))
{
string[] headPos = strPos[i].Split(' ');
Debug.Log("POS: " + ListenClient.pos);
Debug.Log("i: " + strPos[i]);
transform.position =
new Vector3(float.Parse(headPos[1]) * 5, float.Parse(headPos[2]) * 5, 7 - float.Parse(headPos[3]) * 2);
break;
}
}
}
}
static void Main()
{
int n = 10000000;
int m = (int)Math.Sqrt(n);
BitArray sieve = new BitArray(n);
int i = 2;
while (i <= m)
{
for (int j = 2 * i; j < n; j += i)
{
sieve[j] = true;
}
do
{
i++;
}
while (sieve[i] == true);
}
//print just the prime numbers up to 100
for (int j = 2; j < 100; j++)
{
if (sieve[j] == false)
{
Console.WriteLine(j);
}
}
}
public static void Not(int length)
{
BitArray bitArray = new BitArray(length, false);
if (length > 0)
{
bitArray[0] = true;
bitArray[1] = true;
bitArray[length - 2] = true;
bitArray[length - 1] = true;
}
BitArray bitArrayNot = bitArray.Not();
Assert.Equal(bitArray.Length, bitArrayNot.Length);
Assert.Same(bitArray, bitArrayNot);
for (int i = 0; i < bitArray.Length; i++)
{
if (i <= 1 || i >= length - 2)
{
Assert.False(bitArrayNot[i]);
}
else
{
Assert.True(bitArrayNot[i]);
}
}
}
public void loadSaveData(int id)
{
currentFlag.SetAll(false);
//load file
string filepath = string.Format("{0}/sav{1}", Application.persistentDataPath, id);
Debug.Log(filepath);
if (!File.Exists(filepath))
{
//show error
return;
}
FileStream fs = File.Open(filepath, FileMode.Open);
BinaryReader reader = new BinaryReader(fs);
currentID = reader.ReadInt32();
byte[] buf = reader.ReadBytes(10);
currentFlag = new BitArray(buf);
for (int i = (int)GameValueType.None; i < (int)GameValueType.Max; i++ )
{
values[(GameValueType)i] = reader.ReadInt32();
}
fs.Flush();
fs.Close();
startGame();
}
static void Main()
{
BitArray bits = new BitArray(8);
bits[0] = 1;
bits[7] = 1;
System.Console.WriteLine(bits);
}
public static void Main(string[] args)
{
if (args.Length == 0)
{
Bb.maxX = 5;
Bb.maxY = 5;
Point[] starts = { new Point() };
Func<Point, bool> isGoal = p => p.x == 4 && p.y == 4;
BitArray passable = new BitArray(new bool[] {
true, false, true, true, true,
true, true, true, false, true,
true, true, true, false, true,
true, false, false, false, true,
true, true, true, true, true,
});
var path = Pather.AStar(starts, isGoal, passable, (c, n) => n.x == 0 ? 1 : 0, p => 0);
foreach (Point p in path)
{
Console.WriteLine(p);
}
}
if (args.Length < 1)
{
System.Console.WriteLine("Please enter a hostname");
return;
}
IntPtr connection = Client.createConnection();
AI ai = new AI(connection);
if (Client.serverConnect(connection, args[0], "19000") == 0)
{
System.Console.WriteLine("Unable to connect to server");
return;
}
if (Client.serverLogin(connection, ai.username(), ai.password()) == 0)
return;
if (args.Length < 2)
Client.createGame(connection);
else
Client.joinGame(connection, Int32.Parse(args[1]), "player");
while (Client.networkLoop(connection) != 0)
{
if (ai.startTurn())
Client.endTurn(connection);
else
Client.getStatus(connection);
}
Client.networkLoop(connection); //Grab end game state
Client.networkLoop(connection); //Grab log
ai.end();
}
private BitArray b; // BinaryImage of the reference texture
#endregion Fields
#region Constructors
public BinaryImage(int x, int y)
{
this.x = x;
this.y = y;
b = new BitArray(x*y);
Length = b.Length;
}
public object Clone()
{
BitArray anotherArray = new BitArray();
anotherArray.bits = new BitValue[this.getLengthOfArray()];
for (int i = 0; i < this.getLengthOfArray(); ++i)
anotherArray.bits[i] = this.bits[i];
return anotherArray;
}
public static Point Decode(int index)
{
var bits = new BitArray(new[] {index});
var x = DecodeAxis(bits, 1);
var y = DecodeAxis(bits, 0);
var result = new Point(x, y);
return result;
}
public BinaryImage(int x, int y, bool b)
{
this.x = x;
this.y = y;
this.b = new BitArray(x*y, b);
Length = this.b.Length;
}
static void Main()
{
BitArray bitArray = new BitArray(4);
bitArray[1] = 1;
bitArray[8] = 1;
System.Console.WriteLine(bitArray);
}
public bool runTest()
{
Console.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver : " + s_strDtTmVer);
int iCountErrors = 0;
int iCountTestcases = 0;
String strLoc = "Loc_000oo";
BitArray bitArr1;
BitArray bitArr2;
Boolean[] bolArr1;
Int32 iNumOfElements;
Random rnd1;
try {
do
{
iNumOfElements = 10;
rnd1 = new Random();
strLoc = "Loc_742dsf!";
iCountTestcases++;
bolArr1 = new Boolean[iNumOfElements];
for(int i=0; i<iNumOfElements; i++){
if(rnd1.Next(10)>5)
bolArr1[i] = true;
else
bolArr1[i] = false;
}
bitArr1 = new BitArray(bolArr1);
bitArr2 = (BitArray)bitArr1.Clone();
for(int i=0; i<iNumOfElements; i++){
if(bitArr1[i] != bitArr2[i]){
iCountErrors++;
Console.WriteLine("Err_36tdfg_" + i + "! Wrong value returned, ");
}
}
iCountTestcases++;
for(int i=0; i<iNumOfElements; i++)
bitArr1[i] = !bitArr1[i];
for(int i=0; i<iNumOfElements; i++){
if(bitArr1[i] != !bitArr2[i]){
iCountErrors++;
Console.WriteLine("Err_394t7sg_" + i + "! Wrong value returned, ");
}
}
} while (false);
} catch (Exception exc_general ) {
++iCountErrors;
Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general==\n"+exc_general.ToString());
}
if ( iCountErrors == 0 )
{
Console.WriteLine( "paSs. "+s_strTFPath +" "+s_strTFName+" ,iCountTestcases=="+iCountTestcases);
return true;
}
else
{
Console.WriteLine("FAiL! "+s_strTFPath+" "+s_strTFName+" ,iCountErrors=="+iCountErrors+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
public static IEnumerable<Point> GetNeededTrenches(Pump pump)
{
var digworthy = GetDiggableAndUnDug();
var starts = new HashSet<Point>(pump.GetPoints());
var goals = Bb.GlaciersSet.Where(g => Bb.tileLookup[g].WaterAmount > 5);
var impassable = new BitArray(Bb.OurSpawns).Or(Bb.TheirSpawns).Or(Bb.OurPumps).Or(Bb.TheirPumps);
var path = Pather.AStar(starts, p => goals.Contains(p), impassable.Not(), (c, n) => digworthy.Get(n) ? 1 : 0, p => 0);
return path.Where(p => digworthy.Get(p));
}
static void Main()
{
BitArray bitArr = new BitArray(16);
bitArr[12] = 1;
bitArr[14] = 1;
bitArr[15] = 1;
//bitArr[16] = 1;
Console.WriteLine(bitArr.ToString());
}
public static BitArray GetOurSpawnable()
{
// (spawns + pumps-not-under-seige) - units - spawning
var spawns = Bb.OurSpawnSet.ToBitArray();
var pumps = Bb.OurPumpSet.Where(p => p.station.SiegeAmount == 0).SelectMany(p => p.GetPoints()).ToBitArray();
var units = new BitArray(Bb.OurUnits).Or(Bb.TheirUnits);
var spawning = new BitArray(Bb.IsSpawning);
return spawns.Or(pumps).And(units.Not()).And(spawning.Not());
}
public static DataParameter Create(string name, BitArray value)
{
return(new DataParameter {
DataType = DataType.BitArray, Name = name, Value = value,
});
}
private static T CreateAssociateInternal<T>(Type originalForType, Type currentForType, out Type foundForType,
string[] associateTypeSuffixes, object[] constructorParams, List<Pair<Assembly, string>> locations,
bool exactTypeMatch)
where T : class
{
if (currentForType==null) {
foundForType = null;
return null;
}
string associateTypePrefix;
Type[] genericArguments;
// Possible cases: generic type, array type, regular type
if (currentForType.IsGenericType) {
// Generic type
associateTypePrefix = currentForType.Name;
genericArguments = currentForType.GetGenericArguments();
}
else if (currentForType.IsArray) {
// Array type
Type elementType = currentForType.GetElementType();
int rank = currentForType.GetArrayRank();
if (rank==1)
associateTypePrefix = "Array`1";
else
associateTypePrefix = string.Format("Array{0}D`1", rank);
genericArguments = new Type[] {elementType};
}
else if (currentForType==typeof (Enum)) {
// Enum type
Type underlyingType = Enum.GetUnderlyingType(originalForType);
associateTypePrefix = "Enum`2";
genericArguments = new Type[] {originalForType, underlyingType};
}
else if (currentForType==typeof (Array)) {
// Untyped Array type
foundForType = null;
return null;
}
else {
// Regular type
associateTypePrefix = currentForType.Name;
genericArguments = null;
}
// Replacing 'I' at interface types
if (currentForType.IsInterface && associateTypePrefix.StartsWith("I"))
associateTypePrefix = AddSuffix(associateTypePrefix.Substring(1), "Interface");
// Search for exact associate
T result =
CreateAssociateInternal<T>(originalForType, currentForType, out foundForType, associateTypePrefix,
associateTypeSuffixes,
locations, genericArguments, constructorParams);
if (result!=null)
return result;
if (exactTypeMatch) {
foundForType = null;
return null;
}
// Nothing is found; tryng to find an associate for base type (except Object)
Type forTypeBase = currentForType.BaseType;
if (forTypeBase!=null)
while (forTypeBase!=typeof (object)) {
result = CreateAssociateInternal<T>(originalForType, forTypeBase, out foundForType,
associateTypeSuffixes, constructorParams, locations, true);
if (result!=null)
return result;
forTypeBase = forTypeBase.BaseType;
}
// Nothing is found; tryng to find an associate for implemented interface
Type[] interfaces = currentForType.GetInterfaces();
int interfaceCount = interfaces.Length;
BitArray suppressed = new BitArray(interfaceCount);
while (interfaceCount > 0) {
// Suppressing all the interfaces inherited from others
// to allow their associates to not conflict with each other
for (int i = 0; i < interfaceCount; i++) {
for (int j = 0; j < interfaceCount; j++) {
if (i==j)
continue;
if (interfaces[i].IsAssignableFrom(interfaces[j])) {
suppressed[i] = true;
break;
}
}
}
Type lastGoodInterfaceType = null;
// Scanning non-suppressed interfaces
for (int i = 0; i < interfaceCount; i++) {
if (suppressed[i])
continue;
T resultForInterface = CreateAssociateInternal<T>(originalForType, interfaces[i], out foundForType,
associateTypeSuffixes, constructorParams, locations, true);
if (resultForInterface!=null) {
if (result!=null)
throw new InvalidOperationException(string.Format(
Strings.ExMultipleAssociatesMatch,
GetShortName(currentForType),
GetShortName(result.GetType()),
GetShortName(resultForInterface.GetType())));
result = resultForInterface;
lastGoodInterfaceType = foundForType;
foundForType = null;
}
}
if (result!=null) {
foundForType = lastGoodInterfaceType;
return result;
}
// Moving suppressed interfaces to the beginning
// to scan them on the next round
int k = 0;
for (int i = 0; i < interfaceCount; i++) {
if (suppressed[i]) {
interfaces[k] = interfaces[i];
suppressed[k] = false;
k++;
}
}
interfaceCount = k;
}
// Nothing is found; tryng to find an associate for Object type
if (currentForType!=typeof (object)) {
result = CreateAssociateInternal<T>(originalForType, typeof (object), out foundForType,
"Object", associateTypeSuffixes,
locations, null, constructorParams);
if (result!=null)
return result;
}
// Nothing is found at all
foundForType = null;
return null;
}
public void OnLeaveBitArray(object obj = null)
{
BitArray bitArray = (BitArray)obj;
OnLeaveList((bitArray.Count == 0), true);
}
/// <summary> Subclasses override this to decode the portion of a barcode between the start
/// and end guard patterns.
///
/// </summary>
/// <param name="row">row of black/white values to search
/// </param>
/// <param name="startRange">start/end offset of start guard pattern
/// </param>
/// <param name="resultString">{@link StringBuffer} to append decoded chars to
/// </param>
/// <returns> horizontal offset of first pixel after the "middle" that was decoded
/// </returns>
/// <throws> ReaderException if decoding could not complete successfully </throws>
protected internal abstract int?decodeMiddle(BitArray row, int[] startRange, System.Text.StringBuilder resultString);
public override Result decodeRow(int rowNumber, BitArray row, System.Collections.Hashtable hints)
{
return(decodeRow(rowNumber, row, findStartGuardPattern(row), hints));
}
private void Button_Click(object sender, RoutedEventArgs e)
{
uint parsedValue;
if ((series_length.Text).ToString().Length == 0)
{
MessageBox.Show("Podaj długość ciągu do wygenerowania.");
return;
}
else if (!uint.TryParse(series_length.Text, out parsedValue))
{
MessageBox.Show("Długość ciągu do wygenerowania musi być dodatnią liczbą całkowitą.");
return;
}
uint parsed;
if (!uint.TryParse(lfsr1.Text, out parsed))
{
MessageBox.Show("Wartości początkowe rejestrów muszą być dodatnią liczbą całkowitą.");
return;
}
else if ((lfsr1.Text).ToString().Length == 0)
{
MessageBox.Show("Uzupełnij pola z wartościami początkowymi rejestrów.");
return;
}
var registersLength = Convert.ToInt32(RegisterLength_ComboBox.SelectedItem);
var boolArray = Convert.ToString(parsed, 2).Select(str => str.Equals('1')).Take(registersLength).ToArray();
var bitArray = new BitArray(registersLength);
for (int j = 0; j < boolArray.Length; j++)
{
bitArray[j] = boolArray[j];
}
int numOfLfsr = 1;
Lfsr[] lfsr = new Lfsr[numOfLfsr];
lfsr[0] = new Lfsr(registersLength);
TextBox tb = (TextBox)this.FindName("lfsr1");
lfsr[0].SetRegisterValues(bitArray);
wynik.Clear();
LfsrGenerator generator = new SelfShrinkingGenerator(lfsr);
if (typ.SelectedIndex == 0)
{
var gen = generator.GenerateBitsAsChars(Convert.ToInt32(series_length.Text));
wynik.Text = new string(gen);
}
else if (typ.SelectedIndex == 1)
{
var gen1 = generator.GenerateBytes(Convert.ToInt32(series_length.Text));
wynik.Text = BitConverter.ToString(gen1);
}
else if (typ.SelectedIndex == 2)
{
var gen1 = generator.GenerateIntegers(Convert.ToInt32(series_length.Text));
wynik.Text = String.Join(" ", gen1.Select(p => p.ToString()).ToArray());
}
}
static void Main(string[] args)
{
HashSet <string> U = new HashSet <string>();
HashSet <string> A = new HashSet <string>();
HashSet <string> B = new HashSet <string>();
HashSet <string> C = new HashSet <string>();
Console.Write("Введите количество множеств (2 или 3):");
int s = int.Parse(Console.ReadLine());
Console.Write("Элементы множества U: ");
string[] strU = Console.ReadLine().Split(new char[] { ' ', '\n', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);
Console.Write("Элементы множества U без дубликатов: ");
Hash(ref strU, U);
foreach (string el in U)
{
Console.Write(el + " ");
}
Console.WriteLine();
Console.Write("Элементы множества A: ");
string[] strA = Console.ReadLine().Split(new char[] { ' ', '\n', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);
Console.Write("Элементы множества A, принадлежащие универсуму: ");
Hash(ref strA, A);
Intersect(U, ref A);
Console.WriteLine();
Console.Write("Элементы множества B: ");
string[] strB = Console.ReadLine().Split(new char[] { ' ', '\n', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);
Console.Write("Элементы множества B, принадлежащие универсуму: ");
Hash(ref strB, B);
Intersect(U, ref B);
Console.WriteLine();
Array.Resize(ref strA, U.Count);
Array.Resize(ref strB, U.Count);
BitArray mybU = new BitArray(U.Count);
BitArray mybA = new BitArray(strA.Length);
BitArray mybB = new BitArray(strB.Length);
mybU.SetAll(true);
mybA.SetAll(false);
mybB.SetAll(false);
for (int i = 0; i < U.Count; i++)
{
if (strA.Contains(U.ElementAt(i)))
{
mybA[i] = true;
}
else
{
mybA[i] = false;
}
}
for (int i = 0; i < U.Count; i++)
{
if (strB.Contains(U.ElementAt(i)))
{
mybB[i] = true;
}
else
{
mybB[i] = false;
}
}
BitArray newbA = new BitArray(mybA);
BitArray newbAA = new BitArray(mybA);
BitArray newbAAa = new BitArray(mybA);
BitArray newbBB = new BitArray(mybB);
BitArray newbB = new BitArray(mybB);
BitArray mybAa = new BitArray(mybA);
BitArray forA = new BitArray(mybA);
BitArray forA1 = new BitArray(mybA);
BitArray forB = new BitArray(mybB);
BitArray forB1 = new BitArray(mybB);
Console.Write("Элементы множества А: ");
WriteBy(newbAA, U);
Console.WriteLine();
Console.Write("Элементы множества B: ");
WriteBy(mybB, U);
Console.WriteLine();
Console.Write("Пересечение множеств А и В: ");
And(ref newbAA, ref newbBB, U);
Console.Write("Объединение множеств А и В: ");
Or(ref newbA, ref newbBB, U);
Console.Write("Разность множеств А и В: ");
Xor(ref newbA, ref newbBB, U);
Console.Write("Разность множеств B и A: ");
Xor(ref newbBB, ref newbAAa, U);
Console.Write("Дополнение множества А до U: ");
Not(ref mybAa, U);
Console.Write("Дополнение множества B до U: ");
Not(ref newbB, U);
if (s == 3)
{
Console.Write("Элементы множества C: ");
string[] strC = Console.ReadLine().Split(new char[] { ' ', '\n', '\t', ',' }, StringSplitOptions.RemoveEmptyEntries);
Console.Write("Элементы множества C, принадлежащие универсуму: ");
Hash(ref strC, C);
Intersect(U, ref C);
Console.WriteLine();
Array.Resize(ref strC, U.Count);
BitArray mybC = new BitArray(strC.Length);
mybC.SetAll(false);
for (int i = 0; i < U.Count; i++)
{
if (strC.Contains(U.ElementAt(i)))
{
mybC[i] = true;
}
else
{
mybC[i] = false;
}
}
BitArray newbCa = new BitArray(mybC); BitArray myB = new BitArray(mybB); BitArray myA = new BitArray(mybA);
BitArray newbCca = new BitArray(mybC);
BitArray mybCcc = new BitArray(mybC);
BitArray newbCb = new BitArray(mybC);
BitArray newbCccb = new BitArray(mybC);
BitArray myAc = new BitArray(mybA);
BitArray myBc = new BitArray(mybB);
Console.Write("Элементы множества C: ");
WriteBy(mybC, U);
Console.WriteLine();
Console.Write("Пересечение множеств C и A: ");
And(ref newbCa, ref myAc, U);
Console.Write("Пересечение множеств C и B: ");
And(ref newbCb, ref myBc, U);
Console.Write("Объединение множеств C и A: ");
Or(ref newbCca, ref myA, U);
Console.Write("Объединение множеств C и B: ");
Or(ref newbCccb, ref myB, U);
Console.Write("Разность множеств C и A: ");
Xor(ref newbCca, ref mybA, U);
Console.Write("Разность множеств C и B: ");
Xor(ref newbCccb, ref mybB, U);
Console.Write("Разность множеств A и C: ");
BitArray newbCcc = new BitArray(mybC);
Xor(ref mybA, ref newbCcc, U);
Console.Write("Разность множеств B и C: ");
Xor(ref mybB, ref newbCcc, U);
Console.Write("Дополнение множества C до U: ");
Not(ref mybCcc, U);
BitArray forC = new BitArray(mybC);
BitArray forC1 = new BitArray(mybC);
Console.Write("Укажите номер задания(1,2 или 3):");
int q = int.Parse(Console.ReadLine());
if (q == 1)
{
SpecialOp1(ref forA, ref forA1, ref forB, ref forC, U);
}
else if (q == 2)
{
SpecialOp2(ref forB, ref forB1, ref forC, ref forC1, U);
}
else
{
SpecialOp3(ref forA, ref forA1, ref forC, ref forC1, U);
}
}
Console.ReadKey();
}
// Emulates the Java BitSet.Get() method.
// Prevents exceptions from being thrown when the index is too high.
public static bool SafeGet(this BitArray a, int loc)
{
return(loc < a.Length && a.Get(loc));
}
/// <summary>
///
/// </summary>
internal UserRights()
{
_rights = new BitArray(0);
_rightsTab = new Hashtable();
RightsHashKey = "";
}
protected override void SetStorage(object store, BitArray nullbits)
{
_values = (byte[])store;
SetNullStorage(nullbits);
}
protected override void CopyValue(int record, object store, BitArray nullbits, int storeIndex)
{
byte[] typedStore = (byte[])store;
typedStore[storeIndex] = _values[record];
nullbits.Set(storeIndex, IsNull(record));
}
/// <summary>
/// Adjust received data and build response
/// </summary>
/// <param name="send_buffer">Send buffer</param>
/// <param name="receive_buffer">Receive buffer</param>
/// <param name="flux">Object for flux gest</param>
/// <param name="unit_id">Slave id</param>
/// <param name="transaction_id">Transaction id of TCP slave</param>
void AdjAndReply(List <byte> send_buffer, List <byte> receive_buffer, object flux, byte unit_id, ushort transaction_id)
{
ushort sa, sa1, qor, qor1, bc, val, and_mask, or_mask;
int bytes;
bool cv;
bool[] ret_vals;
ModbusCodes mdbcode;
// Empting reception buffer
send_buffer.Clear();
// Adjust data
mdbcode = (ModbusCodes)receive_buffer[0];
switch (mdbcode)
{
case ModbusCodes.READ_COILS:
// Read received commands
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).Coils.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((qor >= 1) && (qor <= MAX_COILS_IN_READ_MSG)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.COIL_REGISTERS, sa, qor))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.READ_COILS);
bytes = (qor / 8) + (qor % 8 == 0 ? 0 : 1);
send_buffer.Add((byte)bytes);
ret_vals = new bool[bytes * 8];
try
{
ModbusDatabase.Single(x => x.UnitID == unit_id).Coils.ToList().GetRange(sa, qor).CopyTo(ret_vals);
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
for (int ii = 0; ii < bytes; ii++)
{
send_buffer.Add(EightBitToByte(ret_vals, ii * 8));
}
break;
case ModbusCodes.READ_DISCRETE_INPUTS:
// Read received commands
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).DiscreteInputs.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((qor >= 1) && (qor <= MAX_DISCRETE_INPUTS_IN_READ_MSG)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.DISCRETE_INPUTS_REGISTERS, sa, qor))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.READ_DISCRETE_INPUTS);
bytes = (qor / 8) + (qor % 8 == 0 ? 0 : 1);
send_buffer.Add((byte)bytes);
ret_vals = new bool[bytes * 8];
try
{
ModbusDatabase.Single(x => x.UnitID == unit_id).DiscreteInputs.ToList().GetRange(sa, qor).CopyTo(ret_vals);
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
for (int ii = 0; ii < bytes; ii++)
{
send_buffer.Add(EightBitToByte(ret_vals, ii * 8));
}
break;
case ModbusCodes.READ_HOLDING_REGISTERS:
// Read received commands
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((qor >= 1) && (qor <= MAX_HOLDING_REGISTERS_IN_READ_MSG)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.HOLDING_REGISTERS, sa, qor))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.READ_HOLDING_REGISTERS);
send_buffer.Add((byte)(2 * qor));
try
{
for (int ii = 0; ii < (qor * 2); ii += 2)
{
send_buffer.AddRange(GetBytes(ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa + (ii / 2)]));
}
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
break;
case ModbusCodes.READ_INPUT_REGISTERS:
// Read received commands
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).InputRegisters.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((qor >= 1) && (qor <= MAX_INPUT_REGISTERS_IN_READ_MSG)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.INPUT_REGISTERS, sa, qor))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.READ_INPUT_REGISTERS);
send_buffer.Add((byte)(2 * qor));
try
{
for (int ii = 0; ii < (qor * 2); ii += 2)
{
send_buffer.AddRange(GetBytes(ModbusDatabase.Single(x => x.UnitID == unit_id).InputRegisters[sa + (ii / 2)]));
}
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
break;
case ModbusCodes.WRITE_SINGLE_COIL:
// Adjusting
sa = ToUInt16(receive_buffer.ToArray(), 1);
val = ToUInt16(receive_buffer.ToArray(), 3);
switch (val)
{
case 0x0000:
cv = false;
break;
case 0xFF00:
cv = true;
break;
default:
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
cv = false; // Dummy
break;
}
if (ModbusDatabase.Single(x => x.UnitID == unit_id).Coils.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (Error == Errors.EXCEPTION_ILLEGAL_DATA_VALUE)
{
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.COIL_REGISTERS, sa, 1))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (Error == Errors.WRONG_WRITE_SINGLE_COIL_VALUE)
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_ILLEGAL_DATA_VALUE);
break;
}
try
{
ModbusDatabase.Single(x => x.UnitID == unit_id).Coils[sa] = cv;
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.WRITE_SINGLE_COIL);
send_buffer.AddRange(GetBytes(sa));
send_buffer.AddRange(GetBytes(val));
break;
case ModbusCodes.WRITE_SINGLE_REGISTER:
// Adjusting
sa = ToUInt16(receive_buffer.ToArray(), 1);
val = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((val >= 0x0000) && (val <= 0xFFFF)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.HOLDING_REGISTERS, sa, 1))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
try
{
ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa] = val;
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.WRITE_SINGLE_REGISTER);
send_buffer.AddRange(GetBytes(sa));
send_buffer.AddRange(GetBytes(val));
break;
case ModbusCodes.WRITE_MULTIPLE_COILS:
// Adjusting
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).Coils.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((qor >= 1) && (qor <= MAX_COILS_IN_WRITE_MSG)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.COIL_REGISTERS, sa, qor))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
bc = receive_buffer[5];
byte[] buffer = receive_buffer.GetRange(6, bc).ToArray();
BitArray ba = new BitArray(buffer);
try
{
ba.CopyTo(ModbusDatabase.Single(x => x.UnitID == unit_id).Coils, sa);
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.WRITE_MULTIPLE_COILS);
send_buffer.AddRange(GetBytes(sa));
send_buffer.AddRange(GetBytes(qor));
break;
case ModbusCodes.WRITE_MULTIPLE_REGISTERS:
// Adjusting
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!((qor >= 1) && (qor <= MAX_HOLDING_REGISTERS_IN_WRITE_MSG)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.HOLDING_REGISTERS, sa, qor))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
bc = receive_buffer[5];
try
{
for (int ii = 0; ii < bc; ii += 2)
{
ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa + (ii / 2)] = ToUInt16(receive_buffer.ToArray(), 6 + ii);
}
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.WRITE_MULTIPLE_REGISTERS);
send_buffer.AddRange(GetBytes(sa));
send_buffer.AddRange(GetBytes(qor));
break;
case ModbusCodes.MASK_WRITE_REGISTER:
// Adjusting
sa = ToUInt16(receive_buffer.ToArray(), 1);
and_mask = ToUInt16(receive_buffer.ToArray(), 3);
or_mask = ToUInt16(receive_buffer.ToArray(), 5);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!(((and_mask >= 0x0000) && (and_mask <= 0xFFFF)) || ((and_mask >= 0x0000) && (and_mask <= 0xFFFF))))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!IsAllRegistersPresent(unit_id, ModbusDBTables.HOLDING_REGISTERS, sa, 1))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
try
{
ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa] =
(ushort)((ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa] & and_mask) | (or_mask & (~and_mask)));
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
// Reply
send_buffer.Add((byte)ModbusCodes.MASK_WRITE_REGISTER);
send_buffer.AddRange(GetBytes(sa));
send_buffer.AddRange(GetBytes(and_mask));
send_buffer.AddRange(GetBytes(or_mask));
break;
case ModbusCodes.READ_WRITE_MULTIPLE_REGISTERS:
// Adjusting
sa = ToUInt16(receive_buffer.ToArray(), 1);
qor = ToUInt16(receive_buffer.ToArray(), 3);
sa1 = ToUInt16(receive_buffer.ToArray(), 5);
qor1 = ToUInt16(receive_buffer.ToArray(), 7);
if (ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters.Length == 0)
{
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if (!(((qor >= 1) && (qor <= MAX_HOLDING_REGISTERS_TO_READ_IN_READWRITE_MSG)) ||
((qor1 >= 1) && (qor1 <= MAX_HOLDING_REGISTERS_TO_WRITE_IN_READWRITE_MSG))))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_VALUE;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
if ((!IsAllRegistersPresent(unit_id, ModbusDBTables.HOLDING_REGISTERS, sa, qor)) ||
(!IsAllRegistersPresent(unit_id, ModbusDBTables.HOLDING_REGISTERS, sa1, qor1)))
{
Error = Errors.EXCEPTION_ILLEGAL_DATA_ADDRESS;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
bc = receive_buffer[9];
// First: Exec writing...
try
{
for (int ii = 0; ii < bc; ii += 2)
{
ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa1 + (ii / 2)] = ToUInt16(receive_buffer.ToArray(), 10 + ii);
}
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
// Second: Exec reading and prepare the reply
send_buffer.Add((byte)ModbusCodes.READ_WRITE_MULTIPLE_REGISTERS);
send_buffer.AddRange(GetBytes((ushort)(qor * 2)));
try
{
for (int ii = 0; ii < (qor * 2); ii += 2)
{
send_buffer.AddRange(GetBytes(ModbusDatabase.Single(x => x.UnitID == unit_id).HoldingRegisters[sa + (ii / 2)]));
}
}
catch
{
BuildExceptionMessage(send_buffer, mdbcode, Errors.EXCEPTION_SLAVE_DEVICE_FAILURE);
break;
}
break;
default:
Error = Errors.EXCEPTION_ILLEGAL_FUNCTION;
BuildExceptionMessage(send_buffer, mdbcode, Error);
break;
}
// Send response
SendReply(send_buffer, flux, unit_id, transaction_id);
}
public static byte[] BitArrayToByteArray(BitArray bits)
{
byte[] ret = new byte[(bits.Length - 1) / 8 + 1];
bits.CopyTo(ret, 0);
return(ret);
}
/// <summary>
/// Writes a byte of data to a specified port address
/// </summary>
public override void WritePort(ushort port, byte value)
{
if (port == 0x7ffd)
{
Last7ffd = value;
}
else if (port == 0x1ffd)
{
Last1ffd = value;
}
else if ((port & 0x01) == 0)
{
LastFe = value;
}
// get a BitArray of the port
BitArray portBits = new BitArray(BitConverter.GetBytes(port));
// get a BitArray of the value byte
BitArray bits = new BitArray(new byte[] { value });
// Check whether the low bit is reset
bool lowBitReset = !portBits[0]; // (port & 0x01) == 0;
AYDevice.WritePort(port, value);
UPDDiskDevice.WritePort(port, value);
// port 0x7ffd - hardware should only respond when bits 1 & 15 are reset and bit 14 is set
if (!portBits[1] && !portBits[15] && portBits[14])
{
if (!PagingDisabled)
{
// bits 0, 1, 2 select the RAM page
var rp = value & 0x07;
if (rp < 8)
{
RAMPaged = rp;
}
// bit 3 controls shadow screen
SHADOWPaged = bits[3];
// Bit 5 set signifies that paging is disabled until next reboot
PagingDisabled = bits[5];
// portbit 4 is the LOW BIT of the ROM selection
ROMlow = bits[4];
}
}
// port 0x1ffd - hardware should only respond when bits 1, 13, 14 & 15 are reset and bit 12 is set
if (!portBits[1] && portBits[12] && !portBits[13] && !portBits[14] && !portBits[15])
{
if (!PagingDisabled)
{
if (!bits[0])
{
// special paging is not enabled - get the ROMpage high byte
ROMhigh = bits[2];
// set the special paging mode flag
SpecialPagingMode = false;
}
else
{
// special paging is enabled
// this is decided based on combinations of bits 1 & 2
// Config 0 = Bit1-0 Bit2-0
// Config 1 = Bit1-1 Bit2-0
// Config 2 = Bit1-0 Bit2-1
// Config 3 = Bit1-1 Bit2-1
BitArray confHalfNibble = new BitArray(2);
confHalfNibble[0] = bits[1];
confHalfNibble[1] = bits[2];
// set special paging configuration
PagingConfiguration = ZXSpectrum.GetIntFromBitArray(confHalfNibble);
// set the special paging mode flag
SpecialPagingMode = true;
}
}
// bit 4 is the printer port strobe
PrinterPortStrobe = bits[4];
}
// Only even addresses address the ULA
if (lowBitReset)
{
// store the last OUT byte
LastULAOutByte = value;
/*
* Bit 7 6 5 4 3 2 1 0
+-------------------------------+
| | | | E | M | Border |
+-------------------------------+
*/
// Border - LSB 3 bits hold the border colour
if (ULADevice.BorderColor != (value & BORDER_BIT))
{
//ULADevice.RenderScreen((int)CurrentFrameCycle);
ULADevice.BorderColor = value & BORDER_BIT;
}
// Buzzer
BuzzerDevice.ProcessPulseValue((value & EAR_BIT) != 0, _renderSound);
// Tape
TapeDevice.WritePort(port, value);
// Tape
//TapeDevice.ProcessMicBit((value & MIC_BIT) != 0);
}
LastULAOutByte = value;
}
override public Result decodeRow(int rowNumber, BitArray row, Hashtable hints)
{
if (!setCounters(row))
{
return(null);
}
int startOffset = findStartPattern();
if (startOffset < 0)
{
return(null);
}
int nextStart = startOffset;
decodeRowResult.Length = 0;
do
{
int charOffset = toNarrowWidePattern(nextStart);
if (charOffset == -1)
{
return(null);
}
// Hack: We store the position in the alphabet table into a
// StringBuilder, so that we can access the decoded patterns in
// validatePattern. We'll translate to the actual characters later.
decodeRowResult.Append((char)charOffset);
nextStart += 8;
// Stop as soon as we see the end character.
if (decodeRowResult.Length > 1 &&
arrayContains(STARTEND_ENCODING, ALPHABET[charOffset]))
{
break;
}
} while (nextStart < counterLength); // no fixed end pattern so keep on reading while data is available
// Look for whitespace after pattern:
int trailingWhitespace = counters[nextStart - 1];
int lastPatternSize = 0;
for (int i = -8; i < -1; i++)
{
lastPatternSize += counters[nextStart + i];
}
// We need to see whitespace equal to 50% of the last pattern size,
// otherwise this is probably a false positive. The exception is if we are
// at the end of the row. (I.e. the barcode barely fits.)
if (nextStart < counterLength && trailingWhitespace < lastPatternSize / 2)
{
return(null);
}
if (!validatePattern(startOffset))
{
return(null);
}
// Translate character table offsets to actual characters.
for (int i = 0; i < decodeRowResult.Length; i++)
{
decodeRowResult[i] = ALPHABET[decodeRowResult[i]];
}
// Ensure a valid start and end character
char startchar = decodeRowResult[0];
if (!arrayContains(STARTEND_ENCODING, startchar))
{
return(null);
}
char endchar = decodeRowResult[decodeRowResult.Length - 1];
if (!arrayContains(STARTEND_ENCODING, endchar))
{
return(null);
}
// remove stop/start characters character and check if a long enough string is contained
if (decodeRowResult.Length <= MIN_CHARACTER_LENGTH)
{
// Almost surely a false positive ( start + stop + at least 1 character)
return(null);
}
decodeRowResult.Remove(decodeRowResult.Length - 1, 1);
decodeRowResult.Remove(0, 1);
int runningCount = 0;
for (int i = 0; i < startOffset; i++)
{
runningCount += counters[i];
}
float left = (float)runningCount;
for (int i = startOffset; i < nextStart - 1; i++)
{
runningCount += counters[i];
}
float right = (float)runningCount;
return(new Result(
decodeRowResult.ToString(),
null,
new ResultPoint[]
{
new ResultPoint(left, (float)rowNumber),
new ResultPoint(right, (float)rowNumber)
},
BarcodeFormat.CODABAR));
}
public override void UpdateImage(ImageData img) => _data = new BitArray(img.Data.ToByteArray());
/// <summary>
/// Sets all bits to false
/// </summary>
/// <param name="bits">The BitArray object.</param>
public static void Clear(this BitArray bits)
{
bits.SetAll(false);
}
public static bool[] ToBoolArray(this BitArray bitArray)
{
var boolArray = bitArray.Cast <bool>().ToArray();
return(boolArray);
}
public GenomeBinaryString(int size)
{
bits = new BitArray(size);
}
/// <summary>
/// Sets the bit at the given <paramref name="index"/> to false.
/// </summary>
/// <param name="bits">The BitArray object.</param>
/// <param name="index">The position to set to false.</param>
public static void Clear(this BitArray bits, int index)
{
bits.SafeSet(index, false);
}
static void SpecialOp1(ref BitArray forA, ref BitArray forA1, ref BitArray B, ref BitArray C, HashSet <string> U)
{
BitArray notA = forA.Not();
BitArray unionAB = forA1.Or(B);
BitArray unionNotAB = notA.Or(B);
BitArray unionNotABC = unionNotAB.Or(C); //BitArray total = unionNotABC.Xor(unionAB);
BitArray total = unionAB.Not();
Console.Write("Задание №1:");
for (int i = 0; i < U.Count; i++)
{
if (total[i] == true)
{
foreach (char el in U.ElementAt(i))
{
Console.Write(el + " ");
}
}
}
Console.WriteLine();
}
/// <summary>
/// Sets the bit at the given <paramref name="index"/> to true.
/// </summary>
/// <param name="bits">The BitArray object.</param>
/// <param name="index">The position to set to true.</param>
public static void Set(this BitArray bits, int index)
{
bits.SafeSet(index, true);
}
public BitArray GetBitArray()
{
BitArray modifiersBits = new BitArray(16);
//Difficulty
//Easy = 000
//Normal = 001
//Hard = 010
//Expert = 011
//Expert+ = 100
modifiersBits[0] = difficulty == BeatmapDifficulty.Normal || difficulty == BeatmapDifficulty.Expert; //First bit
modifiersBits[1] = difficulty == BeatmapDifficulty.Hard || difficulty == BeatmapDifficulty.Expert; //Second bit
modifiersBits[2] = difficulty == BeatmapDifficulty.ExpertPlus; //Third bit
//Song speed modifier
//Normal speed = 00
//Faster speed = 01
//Slower Speed = 10
//Reserved = 11
modifiersBits[3] = modifiers.songSpeed == GameplayModifiers.SongSpeed.Faster; //First bit
modifiersBits[4] = modifiers.songSpeed == GameplayModifiers.SongSpeed.Slower; //Second bit
//Other modifiers
modifiersBits[5] = modifiers.noFail;
modifiersBits[6] = modifiers.noObstacles;
modifiersBits[7] = modifiers.noBombs;
modifiersBits[8] = modifiers.noArrows;
modifiersBits[9] = modifiers.instaFail;
modifiersBits[10] = modifiers.batteryEnergy;
modifiersBits[11] = modifiers.disappearingArrows;
modifiersBits[12] = modifiers.ghostNotes;
//Beatmap characteristic
//Standard = 00
//No arrows = 01
//One saber = 10
//Custom = 11
switch (characteristicName)
{
case "Standard":
modifiersBits[13] = false;
modifiersBits[14] = false;
break;
case "NoArrows":
modifiersBits[13] = false;
modifiersBits[14] = true;
break;
case "OneSaber":
modifiersBits[13] = true;
modifiersBits[14] = false;
break;
default:
modifiersBits[13] = true;
modifiersBits[14] = true;
break;
}
//Reserved
modifiersBits[15] = false;
return(modifiersBits);
}
/// <summary>
/// convert total BitArray
/// </summary>
/// <param name="bitArr">source BitArray</param>
public static int ReadUInt32(BitArray bitArr)
{
return(ReadUInt32(bitArr, 0, bitArr.Length));
}
//UPGRADE_NOTE: Access modifiers of method 'decodeEnd' were changed to 'protected'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1204'"
protected internal virtual int[] decodeEnd(BitArray row, int endStart)
{
return(findGuardPattern(row, endStart, false, START_END_PATTERN));
}
/// <summary>
/// start at index 0
/// </summary>
/// <param name="bitArr">source BitArray</param>
/// <param name="length">bit count</param>
public static int ReadUInt32(BitArray bitArr, int length)
{
return(ReadUInt32(bitArr, 0, length));
}
public static string BitsToString(this BitArray a, uint start, uint end)
{
BitArray ret = Range(a, start, end);
return(ret.BitsToString());
}
public static string ToStr(this BitArray bitArray)
{
var result = string.Join("", bitArray.Cast <bool>().Select(Convert.ToInt32));
return(result);
}
internal void Init(byte ownerIdx, Note note, ADSR env, NoisePattern pattern)
{
Init(ownerIdx, note, env);
pat = (pattern == NoisePattern.Fine ? fine : rough);
}
override protected void SetStorage(object store, BitArray nullbits)
{
values = (SqlGuid[])store;
//SetNullStorage(nullbits);
}
