public void SendOutputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
foreach (ForwardGate successor in _successors)
{
successor.ReceiveInputValue(value, evaluator, evaluationState, circuitContext);
}
}
public T[] Evaluate <T>(IBatchCircuitEvaluator <T> evaluator, T[] input)
{
if (input.Length != InputGates.Length)
{
throw new ArgumentException("Number of provided inputs does not match the number of input gates in the circuit.", nameof(input));
}
ForwardEvaluationState <T> evaluationState = new ForwardEvaluationState <T>(Context.NumberOfOutputGates);
for (int i = 0; i < InputGates.Length; ++i)
{
InputGates[i].ReceiveInputValue(input[i], evaluator, evaluationState);
}
GateEvaluation <T>[] delayedAndGateEvaluations;
while ((delayedAndGateEvaluations = evaluationState.GetDelayedAndGateEvaluations()).Length > 0)
{
GateEvaluationInput <T>[] evaluationInputs = delayedAndGateEvaluations.Select(evaluation => evaluation.Input).ToArray();
T[] evaluationOutputs = evaluator.EvaluateAndGateBatch(evaluationInputs);
if (evaluationOutputs.Length != evaluationInputs.Length)
{
throw new ArgumentException("Batch circuit evaluator must provide exactly one output value for each gate evaluation.", nameof(evaluator));
}
for (int i = 0; i < delayedAndGateEvaluations.Length; ++i)
{
delayedAndGateEvaluations[i].Gate.SendOutputValue(evaluationOutputs[i], evaluator, evaluationState);
}
}
return(evaluationState.Output);
}
public override void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState)
{
Optional <T> cachedInputValue = evaluationState.ReadInputValueFromCache(this);
if (cachedInputValue.IsPresent)
{
ReceiveInputValues(cachedInputValue.Value, value, evaluator, evaluationState);
}
else
{
evaluationState.WriteInputValueToCache(this, value);
}
}
protected abstract void ReceiveInputValues <T>(T leftValue, T rightValue, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState);
public override void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
evaluationState.SetOutput(_outputIndex, value);
}
public abstract void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext);
protected override void ReceiveInputValues <T>(T leftValue, T rightValue, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState)
{
T outputValue = evaluator.EvaluateXorGate(leftValue, rightValue);
SendOutputValue(outputValue, evaluator, evaluationState);
}
public override void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState)
{
SendOutputValue(value, evaluator, evaluationState);
}
protected override void ReceiveInputValues <T>(T leftValue, T rightValue, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState)
{
GateEvaluationInput <T> evaluationInput = new GateEvaluationInput <T>(leftValue, rightValue);
evaluationState.DelayAndGateEvaluation(new GateEvaluation <T>(this, evaluationInput));
}
public override void ReceiveInputValue <T>(T value, IBatchCircuitEvaluator <T> evaluator, ForwardEvaluationState <T> evaluationState, CircuitContext circuitContext)
{
T outputValue = evaluator.EvaluateNotGate(value, _context, circuitContext);
SendOutputValue(outputValue, evaluator, evaluationState, circuitContext);
}
public ReportingBatchCircuitEvaluator(IBatchCircuitEvaluator <T> innerEvaluator)
{
_innerEvaluator = innerEvaluator;
_batchSizes = new List <int>();
}
