public void TestTryGetValueAndRemoveKey(bool track)
{
var events = 0;
var acc = new Accumulator("test");
var dic = new TrackableDictionary <string, int>(acc, track)
{
{ "one", 1 }, { "two", 2 }
};
dic.CollectionChanged += (s, e) =>
{
events++;
Assert.AreEqual(e.Action, NotifyCollectionChangedAction.Remove);
Assert.AreEqual(e.OldItems[0], new KeyValuePair <string, int>("one", 1));
};
Assert.IsTrue(dic.TryGetValueAndRemoveKey("one", out var val));
Assert.AreEqual(1, val);
Assert.IsFalse(dic.ContainsKey("one"));
Assert.AreEqual(1, events);
if (track)
{
Assert.AreEqual(3, acc.Records.Count);
}
else
{
Assert.AreEqual(0, acc.Records.Count);
}
}
public void DeserializationTest()
{
//45 degre
var rhoIntervalCount = 4;
var conventer = new Accumulator(4, 4, rhoIntervalCount, 4);
List <int> indices = new List <int>()
{
3, 2
};
//rho
// [0] = 0 - 22,5
// [1] = 22,5 - 67,5
// [2] = 67,5 - 112,5
// [3] = 112,5 - 157,5
// [4] = 157,5 - 180
//theta
// [0] = -2.828 - -0.0707
// [1] = -0.707 - 1,414
// [2] = 1,414 - 3,535
// [3] = 3.535 - 5.656
var pointF = conventer.GetLineFromIndex(indices);
//2.35619449 rad = 135 deg - middle of 3rd range
Assert.AreEqual(2.35619449, pointF.Rho, 0.0001);
Assert.AreEqual(2.4745, pointF.Theta, 0.001);
}
static FreeTimeDebug()
{
totalTime = new Accumulator <string>();
count = new Accumulator <string>();
triggerTime = new LinkedHashMap <FreeTimeDebug.ActionTime, int>();
realTotalTime = new Accumulator <string>();
}
public Game?LoadGame()
{
if (!File.Exists("game.json"))
{
return(null);
}
var gameString = File.ReadAllText("game.json");
var gameModel = JsonSerializer.Deserialize <GameModel>(gameString);
var carModel = gameModel.Car;
var engineModel = carModel !.Engine !;
var engine = new Engine(engineModel.Durability, engineModel.BuyPrice,
engineModel.RepairPrice, engineModel.Capacity);
var accumulatorModel = carModel.Accumulator !;
var accumulator = new Accumulator(
accumulatorModel.Durability,
accumulatorModel.BuyPrice,
accumulatorModel.RepairPrice,
accumulatorModel.Capacity);
var disks = carModel.Disks
!.Select(x => new Disk(x.Durability, x.BuyPrice, x.RepairPrice, x.Capacity))
.ToArray();
var car = new Car(engine, accumulator, disks);
var playerModel = gameModel.Player;
var player = new Player(playerModel !.Money);
return(new Game(car, player));
}
public void SerializationTest()
{
//45 degre
var rhoIntervalCount = 4;
var conventer = new Accumulator(4, 4, rhoIntervalCount, 4);
var pointF = new PolarPointF()
{
Rho = 1.22173048, // 70 degre
Theta = 4
};
var indexes = conventer.GetAccumulatorIndex(pointF);
Assert.AreEqual(2, indexes[0]);
Assert.AreEqual(3, indexes[1]);
//rho
// [0] = 0 - 22,5
// [1] = 22,5 - 67,5
// [2] = 67,5 - 112,5
// [3] = 112,5 - 157,5
// [4] = 157,5 - 180
//theta
// [0] = -2.828 - -0.0707
// [1] = -0.707 - 1,141
// [2] = 1,141 - 3,535
// [3] = 3.535 - 5.656
}
public Task( long start , long end , double delta , Accumulator accumulator )
{
this.start = start ;
this.end = end ;
this.delta = delta ;
this.accumulator = accumulator ;
}
public static QueryMetrics ToQueryMetrics(Accumulator accumulator)
{
return(new QueryMetrics(
BackendMetrics.Accumulator.ToBackendMetrics(accumulator.BackendMetricsAccumulator),
IndexUtilizationInfo.Accumulator.ToIndexUtilizationInfo(accumulator.IndexUtilizationInfoAccumulator),
ClientSideMetrics.Accumulator.ToClientSideMetrics(accumulator.ClientSideMetricsAccumulator)));
}
private static void execute( int numberOfTasks )
{
const long n = 1000000000L ;
const double delta = 1.0 / n ;
long startTimeHundredsOfNanos = System.DateTime.Now.Ticks ;
long sliceSize = n / numberOfTasks ;
System.Threading.Thread[] threads = new System.Threading.Thread [ numberOfTasks ] ;
Accumulator accumulator = new Accumulator ( ) ;
for ( int i = 0 ; i < numberOfTasks ; ++i ) {
long start = 1 + i * sliceSize ;
long end = ( i + 1 ) * sliceSize ;
threads[i] = new System.Threading.Thread ( new System.Threading.ThreadStart ( delegate ( ) {
double localSum = 0.0 ;
for ( long j = start ; j <= end ; ++j ) {
double x = ( j - 0.5 ) * delta ;
localSum += 1.0 / ( 1.0 + x * x ) ;
}
accumulator.add ( localSum ) ;
}
) ) ;
}
foreach ( System.Threading.Thread t in threads ) { t.Start ( ) ; }
foreach ( System.Threading.Thread t in threads ) { t.Join ( ) ; }
double pi = 4.0 * delta * accumulator.getSum ( ) ;
double elapseTime = ( System.DateTime.Now.Ticks - startTimeHundredsOfNanos ) / 1e7 ;
System.Console.WriteLine ( "==== C# Threads Anonymous Delegate Sync Object pi = " + pi ) ;
System.Console.WriteLine ( "==== C# Threads Anonymous Delegate Sync Object iteration count = " + n ) ;
System.Console.WriteLine ( "==== C# Threads Anonymous Delegate Sync Object elapse = " + elapseTime ) ;
System.Console.WriteLine ( "==== C# Threads Anonymous Delegate Sync Object processor count = " + System.Environment.ProcessorCount ) ;
System.Console.WriteLine ( "==== C# Threads Anonymous Delegate Sync Object thread count = " + numberOfTasks ) ;
}
public MemoryMeasurementEvaluation(
FromProcessMeasurement<MemoryStruct.IMemoryMeasurement> MemoryMeasurement,
Accumulator.MemoryMeasurementAccumulator MemoryMeasurementAccu = null)
{
this.MemoryMeasurement = MemoryMeasurement?.Value;
try
{
MemoryMeasurementParsed = MemoryMeasurement?.Value?.Parse();
}
catch (Exception Exception)
{
MemoryMeasurementParseException = Exception;
}
if (null == MemoryMeasurement)
{
return;
}
try
{
MemoryMeasurementAccu = MemoryMeasurementAccu ?? new Accumulator.MemoryMeasurementAccumulator();
MemoryMeasurementAccu.Accumulate(MemoryMeasurement?.MapValue(t => MemoryMeasurementParsed));
this.MemoryMeasurementAccumulation = MemoryMeasurementAccu;
}
catch (Exception Exception)
{
MemoryMeasurementAccuException = Exception;
}
}
public void TestAccumuatorSuccess()
{
Accumulator <int> accumulator = sc.Accumulator <int>(0);
using (var s = sock.GetStream())
{
// write numUpdates
int numUpdates = 1;
SerDe.Write(s, numUpdates);
// write update
int key = 0;
int value = 100;
Tuple <int, dynamic> update = new Tuple <int, dynamic>(key, value);
var ms = new MemoryStream();
var formatter = new BinaryFormatter();
formatter.Serialize(ms, update);
byte[] sendBuffer = ms.ToArray();
SerDe.Write(s, sendBuffer.Length);
SerDe.Write(s, sendBuffer);
s.Flush();
byte[] receiveBuffer = new byte[1];
s.Read(receiveBuffer, 0, 1);
Assert.AreEqual(accumulator.Value, value);
}
}
private static void execute(int numberOfTasks) {
const long n = 1000000000L;
const double delta = 1.0 / n;
long startTimeHundredsOfNanos = System.DateTime.Now.Ticks;
long sliceSize = n / numberOfTasks;
System.Threading.Thread[] threads = new System.Threading.Thread[numberOfTasks];
Accumulator accumulator = new Accumulator();
for (int i = 0; i < numberOfTasks; ++i) {
long start = 1 + i * sliceSize;
long end = (i + 1) * sliceSize;
threads[i] = new System.Threading.Thread(new System.Threading.ThreadStart(delegate() {
double localSum = 0.0;
for (long j = start; j <= end; ++j) {
double x = (j - 0.5) * delta;
localSum += 1.0 / (1.0 + x * x);
}
accumulator.add(localSum);
}
));
}
foreach (System.Threading.Thread t in threads) { t.Start(); }
foreach (System.Threading.Thread t in threads) { t.Join(); }
double pi = 4.0 * delta * accumulator.getSum();
double elapseTime = (System.DateTime.Now.Ticks - startTimeHundredsOfNanos) / 1e7;
Output.output("Threads Anonymous Delegate Sync Object", pi, n, elapseTime, numberOfTasks);
}
/// <summary>
/// Executes the GET command.
/// </summary>
public void Execute()
{
if (!_runEnvironment.CurrentLine.LineNumber.HasValue)
{
throw new Exceptions.IllegalDirectException();
}
var variableReference = _expressionEvaluator.GetLeftValue();
var newChar = _teletypeWithPosition.ReadChar();
Accumulator newValue;
if (variableReference.IsString)
{
newValue = new Accumulator(newChar.ToString());
}
else
{
if ("+-E.\0".Contains(newChar.ToString()))
{
newChar = '0';
}
if (newChar < '0' || newChar > '9')
{
throw new Exceptions.SyntaxErrorException();
}
newValue = new Accumulator((double)(newChar - '0'));
}
variableReference.SetValue(newValue);
}
/// <include file='FactorDocs.xml' path='factor_docs/message_op_class[@name="UsesEqualDefGibbsOp2{T}"]/message_doc[@name="MarginalEstimatorInit{TDist}(TDist, int)"]/*'/>
public static BurnInAccumulator <TDist> MarginalEstimatorInit <TDist>([IgnoreDependency] TDist to_marginal, int burnIn)
where TDist : IDistribution <T>
{
Accumulator <TDist> est = (Accumulator <TDist>)ArrayEstimator.CreateEstimator <TDist, T>(to_marginal, true);
return(new BurnInAccumulator <TDist>(burnIn, 1, est));
}
/// <summary>
/// Executes a user defined function.
/// </summary>
/// <param name="parameter">new parameter value.</param>
/// <param name="runEnvironment">Run evironment.</param>
/// <param name="expressionEvaluator">Expression evaluator.</param>
/// <param name="variableRepository">Variable repository.</param>
/// <returns>Value of function.</returns>
public Accumulator Execute(
Accumulator parameter,
IRunEnvironment runEnvironment,
IExpressionEvaluator expressionEvaluator,
IVariableRepository variableRepository)
{
// Save the variable and program line.
var savedVariable = variableRepository.GetOrCreateVariable(VariableName, new short[] { }).GetValue();
var savedProgramLine = runEnvironment.CurrentLine;
// Change the variable to be our parameter.
variableRepository.GetOrCreateVariable(VariableName, new short[] { }).SetValue(parameter);
runEnvironment.CurrentLine = Line;
runEnvironment.CurrentLine.CurrentToken = LineToken;
// Evaluate the expression.
var returnValue = expressionEvaluator.GetExpression();
// Restore the variable and program line.
variableRepository.GetOrCreateVariable(VariableName, new short[] { }).SetValue(savedVariable);
runEnvironment.CurrentLine = savedProgramLine;
// return the value.
return(returnValue);
}
Tuple <T, FSharpList <TEvent> > decide_(TState state)
{
var a = new Accumulator <TEvent, TState>(FuncConvert.FromFunc(_fold), state);
var r = decide(a);
return(Tuple.Create(r, a.Accumulated));
}
/// <summary>
/// Updates the accumulator with values added to and removed from the revocation list.
/// Although unuseful, it is legal to have a value present in both the revoked and unrevoked set.
/// </summary>
/// <param name="revoked">Set of values to add to the accumulator.</param>
/// <param name="unrevoked">Set of values to remove from the accumulator (optional).</param>
public void UpdateAccumulator(HashSet <FieldZqElement> revoked, HashSet <FieldZqElement> unrevoked = null)
{
var minusDelta = PrivateKey.Negate();
var exponent = RAParameters.group.FieldZq.One;
if (revoked != null)
{
foreach (var x in revoked)
{
if (minusDelta.Equals(x)) // TODO: add unit test with -delta on revocation list
{
throw new ArgumentException("revoked set cannot contain the negation of the private key");
}
exponent *= (PrivateKey + x);
}
Accumulator = Accumulator.Exponentiate(exponent);
}
exponent = RAParameters.group.FieldZq.One;
if (unrevoked != null)
{
foreach (var x in unrevoked)
{
if (minusDelta.Equals(x)) // TODO: add unit test with -delta on revocation list
{
throw new ArgumentException("unrevoked set cannot contain the negation of the private key");
}
exponent *= (PrivateKey + x);
}
Accumulator = Accumulator.Exponentiate(exponent.Invert());
}
}
EstimateDistributionParameters(
IEnumerable <double> samples
)
{
Accumulator accumulator = new Accumulator(samples);
SetDistributionParameters(accumulator.Mean, accumulator.Sigma);
}
public void AccumulatorInitialiseToShort()
{
var sut = new Accumulator((short)-3);
Assert.AreEqual(typeof(short), sut.Type);
Assert.AreEqual((short)-3, sut.ValueAsShort());
Assert.AreEqual("-3 ", sut.ToString());
}
public void AccumulatorInitialiseToDouble()
{
var sut = new Accumulator(3.25);
Assert.AreEqual(typeof(double), sut.Type);
Assert.AreEqual(3.25, sut.ValueAsDouble());
Assert.AreEqual(" 3.25 ", sut.ToString());
}
public ConfigurationDefault(ReadonlyMemory memory, RandomAccessMemory ram, GraphicsProcessor graphicsProcessor, Accumulator accumulator, InputDevice inputDevice, Random random) : base(memory)
{
RAM = ram;
GraphicsProcessor = graphicsProcessor;
Accumulator = accumulator;
InputDevice = inputDevice;
Random = random;
}
public void AccumulatorInitialiseToString()
{
var sut = new Accumulator("HELLO");
Assert.AreEqual(typeof(string), sut.Type);
Assert.AreEqual("HELLO", sut.ValueAsString());
Assert.AreEqual("HELLO", sut.ToString());
}
public CalculatorTest()
{
// Create the validator mock.
ValidatorMock = new Mock<IValidator>();
// Create the object to test.
TestedObject = new Accumulator(ValidatorMock.Object);
}
internal IEnumerable <dynamic> Execute(int pid, IEnumerable <dynamic> iter)
{
return(iter.Select(e =>
{
accumulator += 1;
return e;
}));
}
public static IndexUtilizationInfo ToIndexUtilizationInfo(Accumulator accumulator)
{
return(new IndexUtilizationInfo(
utilizedSingleIndexes: accumulator.UtilizedSingleIndexes.ToList(),
potentialSingleIndexes: accumulator.PotentialSingleIndexes.ToList(),
utilizedCompositeIndexes: accumulator.UtilizedCompositeIndexes.ToList(),
potentialCompositeIndexes: accumulator.PotentialCompositeIndexes.ToList()));
}
public Processor(MemoryMap memory)
{
this.Memory = memory;
instructions = new InstructionSet();
extraCodeInstructions = new ExtraCodeInstructionSet();
// configure registers
// main registers?
A = memory.AddRegister <Accumulator>(0x00);
L = memory.AddRegister <ErasableMemory>(0x01);
Q = memory.AddRegister <FullRegister>(0x02);
EB = memory.AddRegister <ErasableBankRegister>(0x03);
FB = memory.AddRegister <FixedBankRegister>(0x4);
Z = memory.AddRegister <ProgramCounter>(0x05);
BB = memory.AddRegister <BothBanksRegister>(0x06);
//memory[0x7] = 0; // this is always set to 0, TODO: need to hard code?
// interrupt helper registers
ARUPT = memory.AddRegister <ErasableMemory>(0x08);
LRUPT = memory.AddRegister <ErasableMemory>(0x09);
QRUPT = memory.AddRegister <ErasableMemory>(0x0A);
// 0XB, 0XC are spares. not used?
ZRUPT = memory.AddRegister <ErasableMemory>(0x0D);
BBRUPT = memory.AddRegister <ErasableMemory>(0x0E);
BRUPT = memory.AddRegister <ErasableMemory>(0x0F);
// editing registers
CYR = memory.AddRegister <CycleRightRegister>(0x10);
SR = memory.AddRegister <ShiftRightRegister>(0x11);
CYL = memory.GetWord(0x12);
EDOP = memory.GetWord(0x13);
// time registers
TIME2 = memory.GetWord(0x14);
TIME1 = memory.GetWord(0x15);
TIME3 = memory.GetWord(0x16);
TIME4 = memory.GetWord(0x17);
TIME5 = memory.GetWord(0x18);
TIME6 = memory.GetWord(0x19);
// orientation registers
CDUX = memory.AddRegister <ErasableMemory>(0x1A);
CDUY = memory.AddRegister <ErasableMemory>(0x1B);
CDUZ = memory.AddRegister <ErasableMemory>(0x1C);
OPTY = memory.AddRegister <ErasableMemory>(0x1D);
OPTX = memory.AddRegister <ErasableMemory>(0x1E);
PIPAX = memory.AddRegister <ErasableMemory>(0x1F);
PIPAY = memory.AddRegister <ErasableMemory>(0x20);
PIPAZ = memory.AddRegister <ErasableMemory>(0x21);
// LM Only Pitch, Yaw, and Roll registers
INLINK = memory.AddRegister <ErasableMemory>(0x25);
// prime Z to start at the boot interrupt
Z.Write(new OnesCompliment(0x800));
}
public void DynamicBinaryUnidirectional()
{
dynamic x = new Accumulator(23);
dynamic y = new AddableNum(42);
dynamic r = x + y;
Assert.Equal(23 + 42, r.Value);
Assert.Throws <RuntimeBinderException>(() => y + x);
}
public static async Task InvokeActionAsyncFailure()
{
var acc = new Accumulator();
Action action = acc.IncBy1;
action += acc.Throw;
action += acc.IncBy3;
await ThrowsAsync <Exception>(async() => await action.InvokeAsync());
}
private double EvaluateInternal(ValueVector x, ValueVector y, int size)
{
Accumulator acc = CreateAccumulator();
// error handling is as if the x is fully evaluated before y
ErrorEval firstXerr = null;
ErrorEval firstYerr = null;
bool accumlatedSome = false;
double result = 0.0;
for (int i = 0; i < size; i++)
{
ValueEval vx = x.GetItem(i);
ValueEval vy = y.GetItem(i);
if (vx is ErrorEval)
{
if (firstXerr == null)
{
firstXerr = (ErrorEval)vx;
continue;
}
}
if (vy is ErrorEval)
{
if (firstYerr == null)
{
firstYerr = (ErrorEval)vy;
continue;
}
}
// only count pairs if both elements are numbers
if (vx is NumberEval && vy is NumberEval)
{
accumlatedSome = true;
NumberEval nx = (NumberEval)vx;
NumberEval ny = (NumberEval)vy;
result += acc.Accumulate(nx.NumberValue, ny.NumberValue);
}
else
{
// all other combinations of value types are silently ignored
}
}
if (firstXerr != null)
{
throw new EvaluationException(firstXerr);
}
if (firstYerr != null)
{
throw new EvaluationException(firstYerr);
}
if (!accumlatedSome)
{
throw new EvaluationException(ErrorEval.DIV_ZERO);
}
return(result);
}
public void Reset()
{
RunningAverage.Reset();
PerSecond.Reset();
Accumulator.Reset();
Snapshot.Reset();
Peak.Reset();
SnapshotDouble.Reset();
}
public void AccumulatorSetValueToShort()
{
var sut = new Accumulator(0.0);
sut.SetValue((short)-3);
Assert.AreEqual(typeof(short), sut.Type);
Assert.AreEqual((short)-3, sut.ValueAsShort());
Assert.AreEqual("-3 ", sut.ToString());
}
public void AccumulatorSetValueToString()
{
var sut = new Accumulator(0.0);
sut.SetValue("HELLO");
Assert.AreEqual(typeof(string), sut.Type);
Assert.AreEqual("HELLO", sut.ValueAsString());
Assert.AreEqual("HELLO", sut.ToString());
}
public void MulShiftTest()
{
Accumulator <Pow2.N4> v1 = new Accumulator <Pow2.N4>(Mantissa <Pow2.N4> .Full);
Accumulator <Pow2.N4> v2 = new Accumulator <Pow2.N4>(Mantissa <Pow2.N4> .One);
Accumulator <Pow2.N4> v3 = v1 * 5 / 9;
Accumulator <Pow2.N4> v11 = Accumulator <Pow2.N4> .MulShift(v1, v1);
Console.WriteLine(v11.ToHexcode());
Assert.AreEqual(5, v11.Digits);
Accumulator <Pow2.N4> v12 = Accumulator <Pow2.N4> .MulShift(v1, v2);
Console.WriteLine(v12.ToHexcode());
Assert.AreEqual(4, v12.Digits);
Assert.AreEqual(v1, v12);
Accumulator <Pow2.N4> v13 = Accumulator <Pow2.N4> .MulShift(v1, v3);
Console.WriteLine(v13.ToHexcode());
Assert.AreEqual(5, v13.Digits);
Accumulator <Pow2.N4> v21 = Accumulator <Pow2.N4> .MulShift(v2, v1);
Console.WriteLine(v21.ToHexcode());
Assert.AreEqual(4, v21.Digits);
Assert.AreEqual(v1, v21);
Accumulator <Pow2.N4> v22 = Accumulator <Pow2.N4> .MulShift(v2, v2);
Console.WriteLine(v22.ToHexcode());
Assert.AreEqual(4, v22.Digits);
Assert.AreEqual(v2, v22);
Accumulator <Pow2.N4> v23 = Accumulator <Pow2.N4> .MulShift(v2, v3);
Console.WriteLine(v23.ToHexcode());
Assert.AreEqual(4, v23.Digits);
Assert.AreEqual(v3, v23);
Accumulator <Pow2.N4> v31 = Accumulator <Pow2.N4> .MulShift(v3, v1);
Console.WriteLine(v31.ToHexcode());
Assert.AreEqual(5, v31.Digits);
Accumulator <Pow2.N4> v32 = Accumulator <Pow2.N4> .MulShift(v3, v2);
Console.WriteLine(v32.ToHexcode());
Assert.AreEqual(4, v32.Digits);
Assert.AreEqual(v3, v32);
Accumulator <Pow2.N4> v33 = Accumulator <Pow2.N4> .MulShift(v3, v3);
Console.WriteLine(v33.ToHexcode());
Assert.AreEqual(4, v33.Digits);
}
public Convolution1D(
Vector <V> v,
Accumulator <U, V> acc,
Func <int, U> factory)
{
this.v = v;
this.vc = v.Length / 2;
this.acc = acc;
this.factory = factory;
}
/// <summary>
/// Can a meld be added to the current accumulator?
/// </summary>
private bool CanAddMeld(int index, Mentsu mentsu)
{
if (index > TypesInSuit - mentsu.Stride)
{
return(false);
}
var max = TilesPerType - mentsu.Amount;
return(Accumulator.Skip(index).Take(mentsu.Stride).All(i => i <= max));
}
public Convolution2D(
Matrix <V> v,
Accumulator <U, V> acc,
Func <int, int, U> factory)
{
this.v = v;
this.vc = Vector.Build <int>().Dense(v.RowCount / 2, v.ColumnCount / 2);
this.acc = acc;
this.factory = factory;
}
public void CreateAndProcessOneMessage()
{
ManualResetEvent handle = new ManualResetEvent(false);
Accumulator accumulator = new Accumulator(1, handle);
MessageActor<int> actor = new MessageActor<int>(accumulator);
actor.Send(1);
handle.WaitOne();
Assert.AreEqual(1, accumulator.Result);
}
private Accumulator<Guid,Store> Initialize(int count)
{
_repository = new ConcurrentDictionary<Guid, Store>(
MockHelper.RandomPairs<Guid, string>(count)
.Select(k => new Store {Key = k.Item1, Name = k.Item2})
.ToDictionary(k => k.Key));
var accDict = new Accumulator<Guid, Store>(
(k,v,t)=>_repository.AddOrUpdate(k,v,(l,m)=>v),
_repository.ContainsKey,
key=>_repository[key],
k=>k.Select(Get).ToDictionary(k2=>k2.Key));
return accDict;
}
static void fill_accumulator(Accumulator acc, int x_steps, int y_steps, int z_steps, System.Func<double,double,double,int> f)
{
foreach (var x in range(x_steps))
{
foreach (var y in range(y_steps))
{
foreach (var z in range(z_steps))
{
int rgbint = f(x,y,z);
acc.Increment(rgbint);
}
}
}
}
public void TestAccumulatorInWorker()
{
StringBuilder output = new StringBuilder();
Process worker;
TcpListener CSharpRDD_SocketServer = CreateServer(output, out worker);
using (var serverSocket = CSharpRDD_SocketServer.AcceptSocket())
using (var s = new NetworkStream(serverSocket))
{
WritePayloadHeaderToWorker(s);
const int accumulatorId = 1001;
var accumulator = new Accumulator<int>(accumulatorId, 0);
byte[] command = SparkContext.BuildCommand(new CSharpWorkerFunc(new AccumulatorHelper(accumulator).Execute),
SerializedMode.String, SerializedMode.String);
SerDe.Write(s, command.Length);
SerDe.Write(s, command);
const int expectedCount = 100;
for (int i = 0; i < expectedCount; i++)
{
SerDe.Write(s, i.ToString());
}
SerDe.Write(s, (int)SpecialLengths.END_OF_DATA_SECTION);
SerDe.Write(s, (int)SpecialLengths.END_OF_STREAM);
s.Flush();
int count = 0;
foreach (var bytes in ReadDataSection(s))
{
Assert.AreEqual(count++.ToString(), Encoding.UTF8.GetString(bytes));
}
Assert.AreEqual(expectedCount, count);
// read accumulator
int accumulatorsCount = SerDe.ReadInt(s);
Assert.IsTrue(accumulatorsCount == 1);
var accumulatorFromWorker = ReadAccumulator(s, accumulatorsCount).First();
Assert.AreEqual(accumulatorId, accumulatorFromWorker.Key);
Assert.AreEqual(expectedCount, accumulatorFromWorker.Value);
SerDe.ReadInt(s);
}
AssertWorker(worker, output);
CSharpRDD_SocketServer.Stop();
}
public override IAccumulator BuildAccumulator(IEnumerable<string> variables)
{
var acc = new Accumulator(variables, SortVariables);
var variableIndexes = new int[_matchLength];
for(int i = 0 ; i < _matchLength; i++)
{
variableIndexes[i] = acc.Columns.IndexOf(SortVariables[i]);
}
if (_matchEnumerations.Count == 1)
{
return new VirtualizingAccumulator(acc.Columns, _matchEnumerations[0], variableIndexes, SortVariables);
}
bool keepGoing = true;
ulong[] toMatch = new ulong[_matchLength];
foreach (var enumerator in _matchEnumerations)
{
keepGoing &= enumerator.MoveNext();
if (CompareArrays(enumerator.Current, toMatch) > 0) toMatch = enumerator.Current;
}
while (keepGoing)
{
for(int i = 0; i < _matchEnumerations.Count; i++)
{
while(keepGoing && CompareArrays(toMatch, _matchEnumerations[i].Current) > 0)
{
keepGoing &= _matchEnumerations[i].MoveNext();
}
if (keepGoing && CompareArrays(_matchEnumerations[i].Current, toMatch) > 0)
{
toMatch = _matchEnumerations[i].Current;
}
}
if (keepGoing && _matchEnumerations.All(x=>CompareArrays(toMatch, x.Current) == 0))
{
// Bingo!
var newRow = new ulong[acc.Columns.Count];
for(int i = 0; i < _matchLength; i++)
{
newRow[variableIndexes[i]] = toMatch[i];
}
acc.AddRow(newRow);
keepGoing &= _matchEnumerations[0].MoveNext();
toMatch = _matchEnumerations[0].Current;
}
}
return acc;
}
static void Main(string[] args)
{
try {
// Compare using Accumulator and ordinary summation for a sum of large and
// small terms.
double sum = 0;
Accumulator acc = new Accumulator();
acc.Assign( 0.0 );
sum += 1e20; sum += 1; sum += 2; sum += 100; sum += 5000; sum += -1e20;
acc.Sum( 1e20 ); acc.Sum( 1 ); acc.Sum( 2 ); acc.Sum( 100 ); acc.Sum( 5000 ); acc.Sum( -1e20 );
Console.WriteLine(String.Format("{0} {1}", sum, acc.Result()));
}
catch (GeographicErr e) {
Console.WriteLine( String.Format( "Caught exception: {0}", e.Message ) );
}
}
private static void execute(int numberOfTasks) {
const long n = 1000000000L;
const double delta = 1.0 / n;
long startTimeHundredsOfNanos = System.DateTime.Now.Ticks;
long sliceSize = n / numberOfTasks;
System.Threading.Thread[] threads = new System.Threading.Thread [ numberOfTasks ];
Accumulator accumulator = new Accumulator();
for (int i = 0; i < numberOfTasks; ++i) {
Task task = new Task(1 + i * sliceSize , (i + 1) * sliceSize , delta , accumulator);
threads[i] = new System.Threading.Thread(new System.Threading.ThreadStart(task.execute));
}
foreach (System.Threading.Thread t in threads) { t.Start(); }
foreach (System.Threading.Thread t in threads) { t.Join(); }
double pi = 4.0 * delta * accumulator.getSum();
double elapseTime = (System.DateTime.Now.Ticks - startTimeHundredsOfNanos) / 1e7;
Output.output("Threads Task Class Delegate Sync Object", pi, n, elapseTime, numberOfTasks);
}
private static void Main(string[] args)
{
const int acc_size = 256 * 256 * 256;
const string hdr = "h_steps,s_steps,l_steps,notfound,found,foundmult,foundsingle,miliseconds";
string filename = "output_" + System.DateTime.Now.ToString("s").Replace(":", "-") + ".txt";
var steps_col_a = Enumerable.Range(1,10).Select(i=>i*100); // hundreds 100, 200, ... 1000
var steps_col_b = Enumerable.Range(64, 193); // 64 to 256
var steps_col_c = new int[] { 256 }; //
var steps_col = steps_col_c;
var stopwatch = new System.Diagnostics.Stopwatch();
var acc = new Accumulator(acc_size);
var fp = System.IO.File.CreateText(filename);
Console.WriteLine(hdr);
fp.WriteLine(hdr);
foreach (int numsteps in steps_col)
{
acc.Clear();
stopwatch.Reset();
stopwatch.Start();
// for each hsl value, calculate the 24bit rgb value
// and then increment the corresponding index in the accumulator
int h_steps = numsteps;
int s_steps = numsteps;
int l_steps = numsteps;
fill_accumulator(acc,h_steps, s_steps, l_steps, ColorRGBBit.HSL_To_RGBInt );
var stats = acc.GetStats();
stopwatch.Stop();
string msg = string.Format("{0},{1},{2}", h_steps, stopwatch.ElapsedMilliseconds,stats.ToCSV());
Console.WriteLine(msg);
fp.WriteLine(msg);
}
fp.Close();
}
public override IAccumulator BuildAccumulator(IEnumerable<string> variables)
{
var acc = new Accumulator(variables, SortVariables);
var variableIndexes = new int[_matchLength];
for (int i = 0; i < _matchLength; i++)
{
variableIndexes[i] = acc.Columns.IndexOf(SortVariables[i]);
}
foreach(var triple in _store.MatchAllTriples(_graphUris))
{
var newRow = new ulong[acc.Columns.Count];
for (int i = 0; i < _matchLength; i++)
{
newRow[variableIndexes[i]] = triple[i];
}
acc.AddRow(newRow);
}
return acc;
}
public void TestAccumulatingWithCache()
{
var cache =
new UpgradedCache
<Guid, TestClass, NoReferenceUpdatableElement<TestClass>>(true,
Comparer<Guid>.Default, EqualityComparer<Guid>.Default,
a => a());
var acc = new Accumulator<Guid, TestClass>(
cache.Push,
cache.HasActualValue,
k => cache.RetrieveByFunc(k, o => new TestClass {Test = k.ToString()}),
k => k.ToDictionary(k2 => k2, k2 => new TestClass {Test = k2.ToString()}));
var count = 100000;
var keys = Enumerable.Range(0, count).Select(_ => Guid.NewGuid()).ToArray();
var t1 = Get(acc, keys.Take(count/3));
var res1 = t1.ContinueWith(tt =>
{
GC.Collect(2, GCCollectionMode.Forced);
return Get2(tt.Result);
});
var t2 = t1.ContinueWith(tt2 => Get(acc, keys.Skip(count/3).Take(count/3))
.ContinueWith(t =>
{
GC.Collect
(2, GCCollectionMode.Forced);
return Get2(t.Result);
}));
var res3 = Get(acc, keys.Skip(count/3*2).ToArray())
.ContinueWith(t =>
{
GC.Collect(2, GCCollectionMode.Forced);
return Get2(t.Result);
});
Assert.AreEqual(res1.Result.Count(k => k!=null),count/3);
Assert.AreEqual(t2.Result.Result.Count(k => k != null), count/3);
Assert.AreEqual(res3.Result.Count(k => k != null), count - count / 3*2);
}
public override IAccumulator BuildAccumulator(IEnumerable<string> variables)
{
var acc = new Accumulator(variables, _triplePatterns[0].Variables.Take(1));
var varIx = acc.Columns.IndexOf(_triplePatterns[0].Variables[0]);
bool keepGoing = true;
ulong[] topItems = new ulong[_matchEnumerations.Count];
ulong toMatch = 0;
for (int i = 0; i < _matchEnumerations.Count; i++)
{
keepGoing &= _matchEnumerations[i].MoveNext();
if (!keepGoing) break;
topItems[i] = _matchEnumerations[i].Current;
if (topItems[i] > toMatch) toMatch = topItems[i];
}
while (keepGoing)
{
for(int i = 0; i < _matchEnumerations.Count; i++)
{
while (_matchEnumerations[i].Current < toMatch && keepGoing)
{
keepGoing &= _matchEnumerations[i].MoveNext();
}
if (keepGoing && _matchEnumerations[i].Current > toMatch)
{
toMatch = _matchEnumerations[i].Current;
}
}
if (keepGoing && _matchEnumerations.All(x=>x.Current.Equals(toMatch)))
{
// Bingo!
var newRow = new ulong[acc.Columns.Count];
newRow[varIx] = toMatch;
acc.AddRow(newRow);
keepGoing &= _matchEnumerations[0].MoveNext();
toMatch = _matchEnumerations[0].Current;
}
}
return acc;
}
private static void execute( int numberOfTasks )
{
const long n = 1000000000L ;
const double delta = 1.0 / n ;
long startTimeHundredsOfNanos = System.DateTime.Now.Ticks ;
long sliceSize = n / numberOfTasks ;
System.Threading.Thread[] threads = new System.Threading.Thread [ numberOfTasks ] ;
Accumulator accumulator = new Accumulator ( ) ;
for ( int i = 0 ; i < numberOfTasks ; ++i ) {
Task task = new Task ( 1 + i * sliceSize , ( i + 1 ) * sliceSize , delta , accumulator ) ;
threads[i] = new System.Threading.Thread ( new System.Threading.ThreadStart ( task.execute ) ) ;
}
foreach ( System.Threading.Thread t in threads ) { t.Start ( ) ; }
foreach ( System.Threading.Thread t in threads ) { t.Join ( ) ; }
double pi = 4.0 * delta * accumulator.getSum ( ) ;
double elapseTime = ( System.DateTime.Now.Ticks - startTimeHundredsOfNanos ) / 1e7 ;
System.Console.WriteLine ( "==== C# Threads Task Class Delegate Sync Object pi = " + pi ) ;
System.Console.WriteLine ( "==== C# Threads Task Class Delegate Sync Object iteration count = " + n ) ;
System.Console.WriteLine ( "==== C# Threads Task Class Delegate Sync Object elapse = " + elapseTime ) ;
System.Console.WriteLine ( "==== C# Threads Task Class Delegate Sync Object processor count = " + System.Environment.ProcessorCount ) ;
System.Console.WriteLine ( "==== C# Threads Task Class Delegate Sync Object thread count = " + numberOfTasks ) ;
}
internal IEnumerable<dynamic> Execute(int pid, IEnumerable<dynamic> iter)
{
return iter.Select(e =>
{
accumulator += 1;
return e;
});
}
internal AccumulatorHelper(Accumulator<int> accumulator)
{
this.accumulator = accumulator;
}
private static void ConfirmXY(Accumulator acc, double[] xarr, double[] yarr,
double expectedResult)
{
double result = 0.0;
for (int i = 0; i < xarr.Length; i++)
{
result += acc.Accumulate(xarr[i], yarr[i]);
}
Assert.AreEqual(expectedResult, result, 0.0);
}
/// <summary>
/// Estimate and set all distribution parameters based on a sample set.
/// </summary>
/// <param name="samples">Samples of this distribution.</param>
public void EstimateDistributionParameters(IEnumerable<double> samples)
{
Accumulator accumulator = new Accumulator(samples);
SetDistributionParameters(accumulator.Mean, accumulator.Sigma);
}
internal void Execute(IEnumerable<Row> iter)
{
foreach (var row in iter)
{
accumulator = accumulator + 1;
}
}
static void Main(string[] args)
{
// Project Euler Problem 280 Ant and Seeds
// Author: D.
// Date: 11/26/2014
//
// https://projecteuler.net/problem=280
// Ant and seeds
// Problem 280:
// "A laborious ant walks randomly on a 5x5 grid. The walk starts from the central square.
// At each step, the ant moves to an adjacent square at random, without leaving the grid; thus there
// are 2, 3 or 4 possible moves at each step depending on the ant's position.
// At the start of the walk, a seed is placed on each square of the lower row. When the ant
// isn't carrying a seed and reaches a square of the lower row containing a seed, it
// will start to carry the seed. The ant will drop the seed on the first empty square of
// the upper row it eventually reaches.
// What's the expected number of steps until all seeds have been dropped in the top row?
// Give your answer rounded to 6 decimal places."
// Windows .NET console application in C#.
// Created with Windows 10, .NET framework 4.6, and Visual Studio Community Edition 2015
// Solution - Brute force approach: run a set of simulations keeping track of number
// of moves required to move all the seeds to their final position.
// When all the simulations have been run, find the average number of moves
// and display on screen.
// Assumptions or inferences from the problem statement:
// "Ant can only move to adjacent square" - must mean no diagonal moves.
// Ant can only carry one seed at a time.
// Ant may only drop seed in top row.
// Ant can move to cell containing a seed, even if it already has a seed.
// The grid has 'walls' - the ant never tries to move to a cell outside the grid.
// This was an exercise in C# development.
// Solution was not checked against official number on Project Euler site.
Console.WriteLine("Project Euler Problem 280: Ant and Seeds");
const int numRows = 5; //num rows in the grid
const int numCols = 5; //num cols in the grid
//create an array to hold the count of moves from each simulation run. Array size = number of simulations to run.
const double nbrSimulationsToRun = 1000;
double nbrMoves;
// create the ant and place it in the grid on which the ant moves in the simulations
AntGrid antGrid = new AntGrid(numRows, numCols);
Accumulator sumOfMoves = new Accumulator();
for (int i = 0; i < nbrSimulationsToRun; i++)
{
// initialize and center the ant on the grid
antGrid.InitializeGrid();
//antGrid.DisplayGrid(numRows, numCols, grid, ant);
// run a simulation
nbrMoves = antGrid.RunSimulation();
sumOfMoves.AddDataValue(nbrMoves);
};
Console.WriteLine("The average number of moves in {0} simulations was: {1:f6}", nbrSimulationsToRun, sumOfMoves.Mean());
//antGrid.DisplayGrid(numRows, numCols, grid, ant);
// keep console window open until user is ready to close out.
Console.WriteLine("Complete. Press any key to exit.");
Console.ReadKey();
}
private IAccumulator Product(IAccumulator other)
{
var product = new Accumulator(Columns, BoundVariables.Union(other.BoundVariables));
/*
IEnumerable<ulong[]> outerEnumerator, innerEnumerator;
if (this.HighestBoundColumnIndex < other.HighestBoundColumnIndex)
{
outerEnumerator = this.Rows;
innerEnumerator = other.Rows;
}
else
{
// This accumulator needs to be inner, so if it is a virtual one we need to materialize it first
if (this is VirtualizingAccumulator)
{
return (this as VirtualizingAccumulator).Materialize().Product(other);
}
outerEnumerator = other.Rows;
innerEnumerator = this.Rows;
}
foreach(var outer in outerEnumerator)
{
foreach(var inner in innerEnumerator)
{
product.AddRow(RowJoin(outer, inner));
}
}
*/
IEnumerable<ulong[]> outerEnumerator = this.Rows;
IEnumerable<ulong[]> innerEnumerator = other.Rows;
foreach(var outer in outerEnumerator)
{
foreach(var inner in innerEnumerator)
{
product.AddRow(RowJoin(outer, inner));
}
}
// Update the sort order for the product
product.SortOrder = this.SortOrder;
foreach(var sortCol in other.SortOrder)
{
if(!product.SortOrder.Contains(sortCol)) product.SortOrder.Add(sortCol);
}
return product;
}
internal ForeachRowHelper(Accumulator<int> accumulator)
{
this.accumulator = accumulator;
}
private static IAccumulator JoinSorted(IAccumulator outer, IAccumulator inner)
{
var output = new Accumulator(outer, inner);
IEnumerator<ulong[]> outerEnumerator = outer.Rows.GetEnumerator();
if (inner is VirtualizingAccumulator) inner = (inner as VirtualizingAccumulator).Materialize();
var innerAcc = inner as Accumulator;
RewindableListEnumerator<ulong[]> innerEnumerator = innerAcc.RewindableEnumerator;
//IEnumerator<ulong[]> innerEnumerator = inner.Rows.GetEnumerator();
bool keepGoing = outerEnumerator.MoveNext() && innerEnumerator.MoveNext();
while (keepGoing)
{
while (keepGoing && RowMatch(outerEnumerator.Current, innerEnumerator.Current))
{
output.AddRow(RowJoin(outerEnumerator.Current, innerEnumerator.Current));
innerEnumerator.SetMark();
bool innerKeepGoing = innerEnumerator.MoveNext();
while (innerKeepGoing && RowMatch(outerEnumerator.Current, innerEnumerator.Current))
{
output.AddRow(RowJoin(outerEnumerator.Current, innerEnumerator.Current));
innerKeepGoing = innerEnumerator.MoveNext();
}
innerEnumerator.RewindToMark();
keepGoing = outerEnumerator.MoveNext();
}
if (keepGoing)
{
var cmp = RowCompare(outerEnumerator.Current, innerEnumerator.Current);
while (cmp != 0 && keepGoing)
{
keepGoing = cmp > 0 ? innerEnumerator.MoveNext() : outerEnumerator.MoveNext();
if (keepGoing) cmp = RowCompare(outerEnumerator.Current, innerEnumerator.Current);
}
}
if (!keepGoing)
{
keepGoing = outerEnumerator.MoveNext();
if (keepGoing)
{
innerEnumerator.Reset();
keepGoing &= innerEnumerator.MoveNext();
}
}
/*
while (keepGoing && RowCompare(outerEnumerator.Current, innerEnumerator.Current) < 0)
keepGoing = outerEnumerator.MoveNext();
while (keepGoing && RowCompare(outerEnumerator.Current, innerEnumerator.Current) > 0)
keepGoing = innerEnumerator.MoveNext();
*/
}
return output;
}
public void Start()
{
_accumulator = new Accumulator<ContextElement>( TimeSpan.FromSeconds( 5 ) );
_accumulator.Accumulated += Accumulator_Accumulated;
_publishSubscriberEndpoint = ConfigurationManager.AppSettings.Get( "ngsi:PublishSubscriberEndpoint" );
}
internal void Execute(Row row)
{
accumulator = accumulator + 1;
}
internal PartitionCountHelper(Accumulator<int> accumulator)
{
this.accumulator = accumulator;
}
internal void Execute(IEnumerable<Row> iter)
{
// Count only once for a partition iter
accumulator = accumulator + 1;
int i = 0;
foreach (var row in iter)
{
i++;
}
}
