void CEpisodeHistory::getStep(int index, CStep *step)
{
assert(index < getNumSteps());
// struct timeval t1;
// struct timeval t2;
// struct timeval t3;
int lnum = index;
int i = 0;
CEpisode *episode;
// gettimeofday(&t1, NULL);
if (stepToEpisodeMap)
{
episode = (*stepToEpisodeMap)[index];
lnum = lnum - (*episodeOffsetMap)[episode];
}
else
{
while (lnum >= (episode = getEpisode(i))->getNumSteps())
{
lnum -= episode->getNumSteps();
i ++;
}
}
// gettimeofday(&t2, NULL);
episode->getStep(lnum, step);
// gettimeofday(&t3, NULL);
//
// static int count = 0;
// static double dur1 = 0;
// static double dur2 = 0;
//
// dur1 += (t2.tv_sec - t1.tv_sec) * 1000 + t2.tv_usec - t1.tv_usec;
// dur2 += (t3.tv_sec - t1.tv_sec) * 1000 + t3.tv_usec - t1.tv_usec;
// count ++;
// if (count % 100 == 0)
// {
// printf("Time for step retrieval: %f %f\n", dur1, dur2);
// dur1 = 0;
// dur2 = 0;
// }
}
/*
Moves the stepper to the specified angle relative to the origin.
Moves at the specified motor speed.
*/
void Stepper::setAngle(float new_angle)
{
new_angle = fmod(new_angle, 360.0); // so 0 <= new_angle <= 360
int steps;
float diff_angle;
float deg;
diff_angle = new_angle - this->angle;
deg = abs(diff_angle);
if(deg == 180) {
diff_angle = 180;
} else if(deg > 180) {
if(diff_angle > 0) diff_angle -= 360;
else diff_angle += 360;
}
steps = getNumSteps(diff_angle);
step(steps);
}
// Takes in the desired angle it wants the rotation stage set to and
// figures out the quickest direction to go and the appropriate number of steps
void rotationStage::setPosition(float angle){
float oldPosition = this->position;
//this->position = angle;
direction directionToTurn = getRotationDirection(oldPosition, angle);
int numSteps = getNumSteps(oldPosition, angle);
std::cout << "Rotating to " << angle << " degrees in the direction: "
<< directionToTurn << "Which will take " << numSteps << " number of steps" << std::endl;
if(directionToTurn==clockwise){
this->rotationStepper->stepForward(numSteps, stepper::SLOW);
}
else if (directionToTurn==counterClockwise){
this->rotationStepper->stepBackward(numSteps, stepper::SLOW);
}
else
throw std::invalid_argument("I don't know what direction to turn!");
this->rotationStepper->brake(1500000);
std::cout << "Current position: " << std::setprecision(3)<< this->position << std::endl;
updatePosition(numSteps, directionToTurn);
std::cout << "New position: " << std::setprecision(3)<< this->position << std::endl;
};
int main()
{
int i, j, k = 0;
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
for (k = 0; k < 8; k++) {
allTrans (&trans[i][j][k], i, j, k);
}
}
}
assert(trans[5][5][0].x == 6 && trans[5][5][0].y == 7);
assert(trans[5][5][1].x == 7 && trans[5][5][1].y == 6);
assert(trans[5][5][2].x == 7 && trans[5][5][2].y == 4);
assert(trans[5][5][3].x == 6 && trans[5][5][3].y == 3);
assert(trans[5][5][4].x == 4 && trans[5][5][4].y == 3);
assert(trans[5][5][5].x == 3 && trans[5][5][5].y == 4);
assert(trans[5][5][6].x == 3 && trans[5][5][6].y == 6);
assert(trans[5][5][7].x == 4 && trans[5][5][7].y == 7);
for (i = 0; i < 8; i++) {
for (j = 0; j < 8; j++) {
for (k = 0; k < 8; k++) {
int x = trans[i][j][k].x;
int y = trans[i][j][k].y;
if(x < 0 || y < 0 || x >= 8 || y >= 8) continue;
int nk = (k + 4) % 8;
assert(trans[x][y][nk].x == i && trans[x][y][nk].y == j);
}
}
}
assert(getNumSteps(0,0,0,0) == 0);
assert(getNumSteps(1,0,1,0) == 0);
assert(getNumSteps(7,0,7,0) == 0);
assert(getNumSteps(5,5,6,7) == 1);
assert(getNumSteps(5,5,7,6) == 1);
assert(getNumSteps(5,5,7,4) == 1);
assert(getNumSteps(5,5,6,3) == 1);
assert(getNumSteps(5,5,4,3) == 1);
assert(getNumSteps(5,5,3,4) == 1);
assert(getNumSteps(5,5,3,6) == 1);
assert(getNumSteps(5,5,4,7) == 1);
char a,b,c,d;
while(scanf("%c%c %c%c\n", &a, &b, &c, &d) != EOF) {
int origx = a-'a';
int origy = b-'1';
int finx = c-'a';
int finy = d-'1';
printf("To get from %c%c to %c%c " , a, b, c, d);
printf("takes %d knight moves.\n", getNumSteps(origx, origy, finx, finy));
}
return 0;
}
/*
Moves the stepper to the specified angle relative to the current
angle. Moves at the specified motor speed.
*/
void Stepper::rotate(float relative_angle)
{
int steps = getNumSteps(relative_angle);
step(steps);
}
void AsyncProfiler::calculateAverage()
{
if (trials.size() == 0) return;
//std::cout << "########################################################################" << std::endl;
std::cout << "Calculating Average" << std::endl;
size_t numSteps = getNumSteps();
average.resize(numSteps);
average.trialName = "average";
average.aggregateStep.setName("aggregate");
Trial total(numSteps), count(numSteps);
// sum step attributes
trialsAveraged = 0;
size_t firstTrial = (trials.size()>numThrowAwayTrials) ? numThrowAwayTrials : 0;
size_t totalTime = 0;
size_t totalMemory = 0;
size_t totalFlops = 0;
for (size_t t = firstTrial; t < trials.size(); t++)
{
trialsAveraged++;
for (size_t s = 0; s < trials[t].size(); s++)
{
// time
size_t oTime = get(t, s, time);
size_t uTime = total.get(s, time) + oTime;
total.set(s, time, uTime );
count.set(s, time, count.get(s, time)+1 );
totalTime += oTime;
// flops
size_t oFlops= get(t, s, flops);
size_t uFlops = total.get(s, flops) + oFlops;
total.set(s, flops, uFlops );
count.set(s, flops, count.get(s, flops)+1 );
totalFlops += oFlops;
// memory
size_t oMemory = get(t, s, memory);
size_t uMemory = total.get(s, memory) + oMemory;
total.set(s, memory, uMemory );
count.set(s, memory, count.get(s, memory)+1 );
totalMemory += oMemory;
}
}
// assign average trial attributes
average.aggregateStep.set(time, totalTime / trialsAveraged);
average.aggregateStep.set(flops, totalFlops / trialsAveraged);
average.aggregateStep.set(memory, totalMemory / trialsAveraged);
average.aggregateStep.set(flops_s, static_cast<size_t>(1000000000.0 * totalFlops / totalTime) );
average.aggregateStep.set(bandwidth, static_cast<size_t>(1000000000.0 * totalMemory / totalTime) );
//std::cout
// << "bandwidth:" << average.attributeValues[bandwidth] << " = "
// << "memory:" << totalMemory << " / "
// << "time:" << totalTime << " x1000000000" << std::endl;
// assign average step attributes
for (size_t s = 0; s < total.size(); s++)
{
average.setStepName( s, trials[0].getStepName( s ) );
for (size_t a = 0; a < NUM_ATTRIBUTES; a++)
{
size_t n = count.get(s, a);
if (n > 0)
{
size_t tot = total.get(s, a);
average.set(s, a, tot / n);
}
}
}
//std::cout << "########################################################################" << std::endl;
//std::cout << "Calculating Derived" << std::endl;
average.computeStepsDerived();
// accumulate for standard deviation
for (size_t t = firstTrial; t < trials.size(); t++)
{
// accumulate for trial
size_t dTime = trials[t].attributeValues[time] - average.aggregateStep.get(time);
average.aggregateStep.stdDev[time] += dTime * dTime;
size_t dBandwidth = trials[t].attributeValues[bandwidth] - average.aggregateStep.get(bandwidth);
average.aggregateStep.stdDev[bandwidth] += dBandwidth * dBandwidth;
size_t dFlops_s = trials[t].attributeValues[flops_s] - average.aggregateStep.get(flops_s);
average.aggregateStep.stdDev[flops_s] += dFlops_s * dFlops_s;
// accumulate for steps
for (size_t s = 0; s < trials[t].size(); s++)
{
// time
size_t sTime = get(t, s, time);
size_t avgTime = average.get(s, time);
size_t diffTime = sTime - avgTime;
average[s].stdDev[time] += diffTime*diffTime;
// flops_s
size_t sFlops_s = get(t, s, flops_s);
size_t avgFlops_s = average.get(s, flops_s);
size_t diffFlops_s = sFlops_s - avgFlops_s;
average[s].stdDev[flops_s] += diffFlops_s*diffFlops_s;
// bandwidth
size_t sBandwidth = get(t, s, bandwidth);
size_t avgBandwidth = average.get(s, bandwidth);
size_t diffBandwidth = sBandwidth - avgBandwidth;
average[s].stdDev[bandwidth] += diffBandwidth*diffBandwidth;
}
}
// final divide for trial stddev
// time
average.aggregateStep.stdDev[time] = static_cast<size_t>(sqrt(average.aggregateStep.stdDev[time]/(trialsAveraged-1.0) ));
// flops_s
average.aggregateStep.stdDev[flops_s] = static_cast<size_t>(sqrt(average.aggregateStep.stdDev[flops_s]/(trialsAveraged-1.0) ));
// bandwidth
average.aggregateStep.stdDev[bandwidth] = static_cast<size_t>(sqrt(average.aggregateStep.stdDev[bandwidth]/(trialsAveraged-1.0) ));
//std::cout << "Size of Average Trials: " << average.size() << std::endl;
// final divide for steps stddev
for (size_t s = 0; s < average.size(); s++)
{
// time
average[s].stdDev[time] = static_cast<size_t>(sqrt(average[s].stdDev[time]/(count.get(s,time)-1.0) ));
// flops_s
average[s].stdDev[flops_s] = static_cast<size_t>(sqrt(average[s].stdDev[flops_s]/(count.get(s,flops)-1.0) ));
// bandwidth
average[s].stdDev[bandwidth] = static_cast<size_t>(sqrt(average[s].stdDev[bandwidth]/(count.get(s,memory)-1.0) ));
}
// Print basic info to stdout
printf("Avg Agg Time: %7.3f ms\n", average.aggregateStep.get( time ) /1000000.f );
}
