示例#1
0
 public static bool[] ByteArrayToBoolArray(byte[] data)
 {
     ConversionBinary conversions = new ConversionBinary(data);
     bool[] result = conversions.ToBoolArray();
     return result;
 }
示例#2
0
        //EXECUTION
        protected override void InternalExecution()
        {
            IQuantumBit quantumbitA = FactoryQuantumData.generateBit();
            TesterLog("QuantumBit Integrity Test:");
            TesterLog("Store FALSE...");
            quantumbitA.setBit(false);
            TesterLog("\tInternal state => " + quantumbitA.generateQuantumDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t"+quantumbitA.getBit());
            TesterLog("\tInternal state => " + quantumbitA.generateQuantumDebugger().ShortDebug);
            TesterLog("Store TRUE...");
            quantumbitA.setBit(true);
            TesterLog("\tInternal state => " + quantumbitA.generateQuantumDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t"+quantumbitA.getBit());
            TesterLog("\tInternal state => " + quantumbitA.generateQuantumDebugger().ShortDebug);

            TesterLog("");

            short sizeA=8;
            short dataA=42; //Numero mágico
            IQuantumBitArray quantumbitarrayA = FactoryQuantumData.generateBitArray(sizeA);
            ConversionBinary conversionA = new ConversionBinary(dataA, sizeA);
            bool[] dataarrayA = conversionA.ToBoolArray();

            TesterLog("QuantumBitArray Integrity Test:");
            TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayA) + "... ");
            quantumbitarrayA.setBitArray(dataarrayA);
            TesterLog("\tInternal state => " + quantumbitarrayA.generateQuantumDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t" + ArrayTools.BoolArrayToString(quantumbitarrayA.getBitArray()));
            TesterLog("\tInternal state => " + quantumbitarrayA.generateQuantumDebugger().ShortDebug);

            TesterLog("");

            short sizeB = 8;
            short dataB = (short)(FactoryRandom.GetSingleIntenger());
            IQuantumBitArray quantumbitarrayB = FactoryQuantumData.generateBitArray(sizeB);
            ConversionBinary conversionB = new ConversionBinary(dataB, sizeB);
            bool[] dataarrayB = conversionB.ToBoolArray();

            TesterLog("RANDOM QuantumBitArray Integrity Test:");
            TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayB) + "... ");
            TesterLog("\tInternal state => " + quantumbitarrayB.generateQuantumDebugger().ShortDebug);
            quantumbitarrayB.setBitArray(dataarrayB);
            TesterLog("Read Data:");
            TesterLog("\t" + ArrayTools.BoolArrayToString(quantumbitarrayB.getBitArray()));
            TesterLog("\tInternal state => " + quantumbitarrayB.generateQuantumDebugger().ShortDebug);

            TesterLog("");

            short sizeC = 8;
            short dataC = 42; //Numero mágico
            IQuantumBitArray quantumbitarrayC;
            ConversionBinary conversionC = new ConversionBinary(dataC, sizeC);
            bool[] dataarrayC = conversionC.ToBoolArray();
            bool[] basisboolC = FactoryRandom.GetManyBinary(sizeC);
            bool[] errorboolC = FactoryRandom.GetManyBinary(sizeC);

            TesterLog("QuantumBitArray RANDOM CODING:");
            TesterLog("Random basis: " + ArrayTools.BoolArrayToString(basisboolC));
            TesterLog("Erroneus basis: " + ArrayTools.BoolArrayToString(errorboolC));
            TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayC) + "... ");
            quantumbitarrayC = FactoryQuantumData.encodeArrayByBasis(dataarrayC, basisboolC);
            TesterLog("\tInternal state" + quantumbitarrayC.generateQuantumDebugger().ShortDebug);
            TesterLog("CORRECT Read Data:");
              bool[] decodedokC = FactoryQuantumData.decodeArrayByBasis(quantumbitarrayC, basisboolC);
              TesterLog("\t" + ArrayTools.BoolArrayToString(decodedokC));
              TesterLog("\tInternal state => " + quantumbitarrayC.generateQuantumDebugger().ShortDebug);
            TesterLog("ERRONEOUS Read Data:");
              bool[] decodederroneusC = FactoryQuantumData.decodeArrayByBasis(quantumbitarrayC, errorboolC);
              TesterLog("\t" + ArrayTools.BoolArrayToString(decodederroneusC));
              TesterLog("\tInternal state => " + quantumbitarrayC.generateQuantumDebugger().ShortDebug);
            TesterLog("AGAIN CORRECT Read Data:");
              bool[] decodedagainC = FactoryQuantumData.decodeArrayByBasis(quantumbitarrayC, basisboolC);
              TesterLog("\t" + ArrayTools.BoolArrayToString(decodedagainC));
              TesterLog("\tInternal state => " + quantumbitarrayC.generateQuantumDebugger().ShortDebug);
        }
示例#3
0
        //EXECUTION
        protected override void InternalExecution()
        {
            IClassicalBit classicalbitA = FactoryClassicalData.generateBit();
            TesterLog("ClassicalBit Integrity Test:");
            TesterLog("Store FALSE...");
            classicalbitA.setBit(false);
            TesterLog("\tInternal state => " + classicalbitA.generateClassicalDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t" + classicalbitA.getBit());
            TesterLog("\tInternal state => " + classicalbitA.generateClassicalDebugger().ShortDebug);
            TesterLog("Store TRUE...");
            classicalbitA.setBit(true);
            TesterLog("\tInternal state => " + classicalbitA.generateClassicalDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t" + classicalbitA.getBit());
            TesterLog("\tInternal state => " + classicalbitA.generateClassicalDebugger().ShortDebug);

            TesterLog("");

            short sizeA = 8;
            short dataA = 42; //Numero mágico
            IClassicalBitArray classicalbitarrayA = FactoryClassicalData.generateBitArray(sizeA);
            ConversionBinary conversionA = new ConversionBinary(dataA, sizeA);
            bool[] dataarrayA = conversionA.ToBoolArray();

            TesterLog("ClassicalBitArray Integrity Test:");
            TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayA) + "... ");
            classicalbitarrayA.setBitArray(dataarrayA);
            TesterLog("\tInternal state => " + classicalbitarrayA.generateClassicalDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t" + ArrayTools.BoolArrayToString(classicalbitarrayA.getBitArray()));
            TesterLog("\tInternal state => " + classicalbitarrayA.generateClassicalDebugger().ShortDebug);

            TesterLog("");

            short sizeB = 8;
            short dataB = (short)(FactoryRandom.GetSingleIntenger());
            IClassicalBitArray classicalbitarrayB = FactoryClassicalData.generateBitArray(sizeB);
            ConversionBinary conversionB = new ConversionBinary(dataB, sizeB);
            bool[] dataarrayB = conversionB.ToBoolArray();

            TesterLog("RANDOM ClassicalBitArray Integrity Test:");
            TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayB) + "... ");
            classicalbitarrayB.setBitArray(dataarrayB);
            TesterLog("\tInternal state => " + classicalbitarrayB.generateClassicalDebugger().ShortDebug);
            TesterLog("Read Data:");
            TesterLog("\t" + ArrayTools.BoolArrayToString(classicalbitarrayB.getBitArray()));
            TesterLog("\tInternal state => " + classicalbitarrayB.generateClassicalDebugger().ShortDebug);

            TesterLog("");

            //short sizeC = 8;
            //short dataC = 42; //Numero mágico
            //IClassicalBitArray classicalbitarrayC;
            //ConversionBinary conversionC = new ConversionBinary(dataC, sizeC);
            //bool[] dataarrayC = conversionC.ToBoolArray();
            //bool[] basisboolC = FactoryRandom.GetManyBinary(sizeC);
            //bool[] errorboolC = FactoryRandom.GetManyBinary(sizeC);
            //TesterLog("ClassicalBitArray RANDOM CODING:");
            //TesterLog("Random basis: " + ArrayTools.BoolArrayToString(basisboolC));
            //TesterLog("Erroneus basis: " + ArrayTools.BoolArrayToString(errorboolC));
            //TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayC) + "... ");
            //classicalbitarrayC = FactoryClassicalData.encodeArrayByBasis(dataarrayC, basisboolC);
            //TesterLog("CORRECT Read Data:");
            //bool[] decodedokC = FactoryClassicalData.decodeArrayByBasis(classicalbitarrayC, basisboolC);
            //TesterLog("\t" + ArrayTools.BoolArrayToString(decodedokC));
            //TesterLog("ERRONEOUS Read Data:");
            //bool[] decodederroneusC = FactoryClassicalData.decodeArrayByBasis(classicalbitarrayC, errorboolC);
            //TesterLog("\t" + ArrayTools.BoolArrayToString(decodederroneusC));
            //TesterLog("AGAIN CORRECT Read Data:");
            //bool[] decodedagainC = FactoryClassicalData.decodeArrayByBasis(classicalbitarrayC, basisboolC);
            //TesterLog("\t" + ArrayTools.BoolArrayToString(decodedagainC));
            //TesterLog("");

            short sizeD = 8;
            bool[] dataarrayD = FactoryRandom.GetManyBinary(sizeD);
            TesterLog("Antoher ClassicalBitArray RANDOM CODING:");
            TesterLog("Store " + ArrayTools.BoolArrayToString(dataarrayD) + "... ");
            IClassicalBitArray classicalbitarrayD = FactoryClassicalData.generateBitArrayByUsualBasis(dataarrayD);
            TesterLog("\tInternal state => " + classicalbitarrayD.generateClassicalDebugger().ShortDebug);
            TesterLog("Read Data:");
            bool[] decodedD = classicalbitarrayD.getBitArray();
            TesterLog("\t" + ArrayTools.BoolArrayToString(decodedD));
            TesterLog("\tInternal state => " + classicalbitarrayD.generateClassicalDebugger().ShortDebug);
        }
        public bool[] GetManyBinary(int numberQuantity)
        {
            bool[] result = new bool[numberQuantity];

            int remainder;
            int quotient = System.Math.DivRem(numberQuantity, sizeof(short) * 8, out remainder);

            int[] tempInt = GetManyIntenger(quotient);
            ConversionBinary conversion;
            int temp;
            for (int i = 0; i < quotient; i++)
            {
                temp = tempInt[i];
                conversion = new ConversionBinary(temp, sizeof(short) * 8);
                conversion.ToBoolArray().CopyTo(result, sizeof(short) * 8 * i);
            }

            conversion = new ConversionBinary(GetSingleIntenger(), remainder);
            conversion.ToBoolArray().CopyTo(result, sizeof(short) * 8 * quotient);

            return result;
        }