// nearest Basis to stored Value
public override void Evaluate(IClassicalState state)
{
int count = ReferenceBasis.CountElements;
double stateValue = state.Value;
double[] distances = new double[count];
// CALCULAR DISTANCIAS
double basisElementValue;
for (int i = 0; i < count; i++)
{
basisElementValue = ReferenceBasis.getState(i).Value;
distances[i] = System.Math.Abs(stateValue - basisElementValue);
}
// ELEJIR LA POSICION DE LA MENOR
double result = double.PositiveInfinity;
int resultPos = -1;
double value;
for (int j = 0; j < count; j++)
{
value = distances[j];
if (value < result)
{
result = value;
resultPos = j;
}
}
// DEVOLVER LA POSICION DEL LA MENOR DISTANCIA
MeasuredElement = resultPos;
}
public override void Evaluate(IClassicalState state)
{
IClassicalStateDebugger debuggerData = state.generateClassicalDebugger();
IClassicalStateDebugger debuggerElement = ReferenceBasis.getState(ReferenceElement).generateClassicalDebugger();
debuggerData.setValue(debuggerElement.getValue());
}
public override void Evaluate(IClassicalState state)
{
if (EffectiveDelayTicks != 0)
{
long startWait = System.DateTime.UtcNow.Ticks;
while (System.DateTime.UtcNow.Ticks - startWait < EffectiveDelayTicks)
{
System.Windows.Forms.Application.DoEvents();
}
}
}
public override void Evaluate(IClassicalState state)
{
if (EffectiveNoiseFactor != 0)
{
IClassicalStateDebugger debugger = state.generateClassicalDebugger();
double value = debugger.getValue();
double size = FactoryRandom.GetSingleNormalized() / EffectiveNoiseFactor;
double random = FactoryRandom.GetSingleDoubleIntervalByCenter(value, size / 2);
debugger.setValue(random);
}
}
public ClStateDebugger(IClassicalState state)
: base()
{
if (state is AbstractClassicalState)
{
_abstractState = (AbstractClassicalState)state;
}
else
{
throw new ExceptionClassicalState();
};
}
public AbstractClassicalData(int numLevels, int size, bool initialize)
: base()
{
IClassicalState[] states = new IClassicalState[size];
for (int index=0;index<size;index++)
{
states[index] = FactoryClassicalState.generateState(numLevels);
}
_internalCollection = FactoryClassicalState.generateStateCollection(states);
if (initialize) { Initialize(); }
}
public IClassicalState[] ExportAsArray()
{
int count = countObjects();
IClassicalState[] result = new IClassicalState[count];
for (int i = 0; i < count; i++)
{
result[i] = (IClassicalState)getObject(i);
}
return result;
}
protected virtual void PropagateOnClassicalReceive(IStation station, IClassicalState state)
{
_counterReceivedClassical++;
if (OnClassicalReceive != null)
{ OnClassicalReceive(this, state); };
}
private void GENE_SlaveProcessBasisData(IProtocolAgent agent, IClassicalState state)
{
int receivedPos = Slave.counterReceivedClassical - 1;
BB84Log("GENE: STEP 2: ", receivedPos, " | Slave State Receive: ", state.generateClassicalDebugger().ShortDebug);
IClassicalBit classicalBit = FactoryClassicalData.generateBit(false);
classicalBit.AssociateState(state);
bool decode = FactoryClassicalData.decodeBitByUsualBasis(classicalBit);
BB84Log("GENE: STEP 2: ", receivedPos, " | Slave conversion into Bit: ", decode.ToString());
// get element
bool usedBasis = (bool)GENE_slaveUsedBasisCollection[receivedPos];
//bool decodedBit = (bool)GENE_slaveDecodedBitCollection[receivedPos];
bool coincidence = (usedBasis == decode);
if (coincidence)
{ BB84Log("GENE: STEP 2: =========> Slave found coincidence in Basis at POS: ", receivedPos); }
// store 'coincidence' pos
GENE_slaveCoincidences.Add(coincidence);
}
private void GENE_MasterProcessCoincidencesData(IProtocolAgent agent, IClassicalState state)
{
// no hace falta comparar con las bases usadas o datos usadas
// en este caso solo se transmite si el la estación cliente detecto coincidencia
int receivedPos = Master.counterReceivedClassical - 1;
BB84Log("GENE: STEP 3: ", receivedPos, " | Master State Receive: ", state.generateClassicalDebugger().ShortDebug);
IClassicalBit classicalBit = FactoryClassicalData.generateBit(false);
classicalBit.AssociateState(state);
bool decode = FactoryClassicalData.decodeBitByUsualBasis(classicalBit);
BB84Log("GENE: STEP 3: ", receivedPos, " | Master conversion into Bit: ", decode.ToString());
if (decode)
{ BB84Log("GENE: STEP 3: =========> Master found coincidence in Basis at POS: ", receivedPos); }
GENE_masterCoincidences.Add(decode);
}
private void GENE_EavesdropperProcessCoincidencesData(IProtocolAgent agent, IClassicalState state)
{
int receivedPos = Eavesdropper.counterReceivedClassical - 1;
BB84Log("GENE: STEP 3: ", receivedPos, " | Eavesdropper State Receive: ", state.generateClassicalDebugger().ShortDebug);
IClassicalBit classicalBit = FactoryClassicalData.generateBit(false);
classicalBit.AssociateState(state);
bool decode = FactoryClassicalData.decodeBitByUsualBasis(classicalBit);
BB84Log("GENE: STEP 3: ", receivedPos, " | Eavesdropper conversion into Bit: ", decode.ToString());
if (decode)
{ BB84Log("GENE: STEP 3: =========> Eavesdropper found in Basis coincidence at POS: ", receivedPos); }
GENE_eavesdropperCoincidences.Add(decode);
}
private void GENE_EavesdropperProcessBasisData(IProtocolAgent agent, IClassicalState state)
{
//int receivedPos = Eavesdropper.counterReceivedClassical - 1;
//BB84Log(receivedPos, " | Eavesdropper State Receive: ", state.generateClassicalDebugger().ShortDebug);
//IClassicalBit classicalBit = FactoryClassicalData.generateBit(false);
//classicalBit.AssociateState(state);
//bool decode = FactoryClassicalData.decodeBitByBasis(classicalBit, FactoryRandom.GetSingleBinary());
//BB84Log(receivedPos, " | Eavesdropper conversion into Bit: ", decode.ToString());
//// get element
//bool usedBasis = (bool)GENE_eavesdropperUsedBasisCollection[receivedPos];
////bool decodedBit = (bool)GENE_eavesdropperDecodedBitCollection[receivedPos];
//bool coincidence = (usedBasis == decode);
//if (coincidence)
//{ BB84Log(" =========> Eavesdropper found coincidence at POS: ", receivedPos); }
//// store 'coincidence' pos
//GENE_eavesdropperCoincidences.Add(coincidence);
}
private void CHEC_SlaveProcessCheckValues(IProtocolAgent agent, IClassicalState state)
{
int receivedPos = Slave.counterReceivedClassical - 1;
BB84Log("CHEC: STEP 2: ", receivedPos, " | Slave State Receive: ", state.generateClassicalDebugger().ShortDebug);
IClassicalBit classicalBit = FactoryClassicalData.generateBit(false);
classicalBit.AssociateState(state);
bool decode = FactoryClassicalData.decodeBitByUsualBasis(classicalBit);
BB84Log("CHEC: STEP 2: ", receivedPos, " | Slave conversion into Bit: ", decode.ToString());
//// get index
int index = (int)CHEC_slaveComparisonIndexes[receivedPos];
BB84Log("CHEC: STEP 2: ", receivedPos, " | Slave stores for checking check POS ", index, " with VALUE ", decode);
CHEC_slaveComparisonValuesReceived.Add(decode);
}
public void AssociateState(IClassicalState state)
{
InternalCollection.setObject(state, 0);
}
public void Send(IClassicalState state)
{
Station.ClassicalTransmitSynchronous(state);
}
public ClBasicState(IClassicalState state)
: this(state.generateClassicalDebugger().getNumLevels(), state.Value)
{
}
public static IClassicalState generateState(IClassicalState state)
{
IClassicalState result = generateState(state.generateClassicalDebugger().getNumLevels());
result.Value = state.Value;
return result;
}
// EVENTS
public void transmitClassical(IProtocolAgent agent, IClassicalState state)
{
TesterLog("CLASSICAL TRANSMISSION " + agent.AgentName);
TesterLog(state.generateClassicalDebugger().FullDebug);
}
public void receiveClassical(IProtocolAgent agent, IClassicalState state)
{
TesterLog("CLASSICAL RECEPTION " + agent.AgentName);
TesterLog(state.generateClassicalDebugger().FullDebug);
}
private void CHEC_SlaveProcessCheckPositions(IProtocolAgent agent, IClassicalState state)
{
int receivedPos = Slave.counterReceivedClassical - 1;
BB84Log("CHEC: STEP 1: ", receivedPos, " | Slave State Received: ", state.generateClassicalDebugger().ShortDebug);
IClassicalBit classicalBit = FactoryClassicalData.generateBit(false);
classicalBit.AssociateState(state);
bool decode = FactoryClassicalData.decodeBitByUsualBasis(classicalBit);
BB84Log("CHEC: STEP 1: ", receivedPos, " | Slave conversion into Bit: ", decode.ToString());
// store and 'decodedBit'
CHEC_slaveComparisonSelected.Add(decode);
if (decode) //seletected
{
CHEC_slaveComparisonIndexes.Add(receivedPos);
}
}
protected virtual void PropagateOnClassicalTransmit(IStation station, IClassicalState state)
{
_counterTransmitedClassical++;
if (OnClassicalTransmit != null)
{ OnClassicalTransmit(this, state); };
}
protected override void PropagateOnClassicalReceive(IStation station, IClassicalState state)
{
IClassicalBit tempBit = FactoryClassicalData.generateBit(false);
tempBit.AssociateState(state);
ReceivedData.Add(FactoryClassicalData.decodeBitByUsualBasis(tempBit));
base.PropagateOnClassicalReceive(station,state);
}
public abstract void Evaluate(IClassicalState state);
