// Adds sub-pixel resolution EdgeOffsets for the outline using only
// a binary image source.
// Runs a sliding window of 5 edge steps over the outline, maintaining a count
// of the number of steps in each of the 4 directions in the window, and a
// sum of the x or y position of each step (as appropriate to its direction.)
// Ignores single-count steps EXCEPT the sharp U-turn and smoothes out the
// perpendicular direction. Eg
// ___ ___ Chain code from the left:
// |___ ___ ___| 222122212223221232223000
// |___| |_| Corresponding counts of each direction:
// 0 00000000000000000123
// 1 11121111001111100000
// 2 44434443443333343321
// 3 00000001111111112111
// Count of direction at center 41434143413313143313
// Step gets used? YNYYYNYYYNYYNYNYYYyY (y= U-turn exception)
// Path redrawn showing only the used points:
// ___ ___
// ___ ___ ___|
// ___ _
// Sub-pixel edge position cannot be shown well with ASCII-art, but each
// horizontal step's y position is the mean of the y positions of the steps
// in the same direction in the sliding window, which makes a much smoother
// outline, without losing important detail.
void C_OUTLINE::ComputeBinaryOffsets() {
delete [] offsets;
offsets = new EdgeOffset[stepcount];
// Count of the number of steps in each direction in the sliding window.
int dir_counts[4];
// Sum of the positions (y for a horizontal step, x for vertical) in each
// direction in the sliding window.
int pos_totals[4];
memset(dir_counts, 0, sizeof(dir_counts));
memset(pos_totals, 0, sizeof(pos_totals));
ICOORD pos = start;
ICOORD tail_pos = pos;
// tail_pos is the trailing position, with the next point to be lost from
// the window.
tail_pos -= step(stepcount - 1);
tail_pos -= step(stepcount - 2);
// head_pos is the leading position, with the next point to be added to the
// window.
ICOORD head_pos = tail_pos;
// Set up the initial window with 4 points in [-2, 2)
for (int s = -2; s < 2; ++s) {
increment_step(s, 1, &head_pos, dir_counts, pos_totals);
}
for (int s = 0; s < stepcount; pos += step(s++)) {
// At step s, s in in the middle of [s-2, s+2].
increment_step(s + 2, 1, &head_pos, dir_counts, pos_totals);
int dir_index = chain_code(s);
ICOORD step_vec = step(s);
int best_diff = 0;
int offset = 0;
// Use only steps that have a count of >=2 OR the strong U-turn with a
// single d and 2 at d-1 and 2 at d+1 (mod 4).
if (dir_counts[dir_index] >= 2 || (dir_counts[dir_index] == 1 &&
dir_counts[Modulo(dir_index - 1, 4)] == 2 &&
dir_counts[Modulo(dir_index + 1, 4)] == 2)) {
// Valid step direction.
best_diff = dir_counts[dir_index];
int edge_pos = step_vec.x() == 0 ? pos.x() : pos.y();
// The offset proposes that the actual step should be positioned at
// the mean position of the steps in the window of the same direction.
// See ASCII art above.
offset = pos_totals[dir_index] - best_diff * edge_pos;
}
offsets[s].offset_numerator =
static_cast<inT8>(ClipToRange(offset, -MAX_INT8, MAX_INT8));
offsets[s].pixel_diff = static_cast<uinT8>(ClipToRange(best_diff, 0 ,
MAX_UINT8));
// The direction is just the vector from start to end of the window.
FCOORD direction(head_pos.x() - tail_pos.x(), head_pos.y() - tail_pos.y());
offsets[s].direction = direction.to_direction();
increment_step(s - 2, -1, &tail_pos, dir_counts, pos_totals);
}
}
void Hint (void)
{
/* The next 4 lines must be there. */
while (gtk_events_pending ())
{
gtk_main_iteration ();
}
if (ichangestuff == 0)
{
Play ("click.mp3", 0);
}
if ((((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0)) &&
(iyesno == 0)) && (((((Modulo (imoves, 2) == 0) && (iiamblack == 1)) ||
((Modulo (imoves, 2) != 0) && (iiamblack == 0))) && (inet == 1)) ||
(inet == 0))) && (imoving == 0))
{
imoving = 1;
if (Modulo (imoves, 2) == 0)
{
if (inet == 1) idohint = 1;
Computer ('b');
idohint = 0;
JudgeBoard ('w');
if (wiscomputer == 1)
{
Computer ('w');
JudgeBoard ('b');
}
}
else
{
if (inet == 1) idohint = 1;
Computer ('w');
idohint = 0;
JudgeBoard ('b');
if (biscomputer == 1)
{
Computer ('b');
JudgeBoard ('w');
}
}
imoving = 0;
}
else
{
if (inet == 1)
{
Message ("It is not your move.", 3, 0);
}
}
}
complex stb_InnerProduct(stabiliser *phi1, stabiliser *phi2)
{
affine_sp a = afp_Copy(phi1->a); //This won't work. I need to define a copy method
stabiliser stab;
stab.a = &a;
stab.q = phi1->q;
affine_sp *a1 = phi1->a, *a2 = phi2->a;
quadratic_fm *q1 = phi1->q, *q2 = phi2->q;
for (int i = a2->k +1; i < a2->n; i++){
alpha = InnerProduct(a2->h, a2->GBar[i])
res = shrink(&stab, a2->HBar[i], alpha);
if (res == EMPTY){
return (complex) 0;
}
}
short *y = (short *)calloc(a2->k, sizeof(short));
short *scratch_space = (short *)calloc(a2->n, sizeof(short));
short res = 0;
AddVectors(a2->n, scratch_space, a1->h);
AddVectors(a2->n, scratch_space, a2->h);
short **R = (short **)calloc(a2->n, sizeof(short*));
for (int i=0; i<a2->n; i++){R[i] = (short *)calloc(a2->n, sizeof(short));}
for (int i = 0; i < a2->k; i++){
y[i] = InnerProduct(scratch_space, a2->Gbar[i]);
for (int j = 0; j < a.k; j++){
R[j][i] = InnerProduct(a.G[j], a2.GBar[i]);
}
}
qfm_BasisChange(q2, R);
qfm_ShiftChange(q2, y);
for (int i = 0; i<a2->n; i++){a2->h[i] = a1->h[i];}
//Cleanup
for(int i = 0; i<q2->k; i++){free(R[i]);}
free(scratch_space);
free (R);
free(y);
//Find the final quadratic form q
q.Q = Modulo(q1->Q - q2->Q, 8);
for (int i = 0; i < q.K; i++){
q.D[i] = Modulo(q1->D[i]-q2->D[i], 8);
for (int j = 0; j<q.k; j++){
q.J[i][j] = Modulo(q1->J[i][j] - q2->J[i][j], 8);
}
}
return pow(2, -1*(a1->k - a2->k)/2)*ExponentialSum(q);
}
// Returns a pointer to the page with the given index, modulo the total
// number of pages, recaching if needed.
const ImageData* DocumentData::GetPage(int index) {
index = Modulo(index, total_pages_);
if (index < pages_offset_ || index >= pages_offset_ + pages_.size()) {
pages_offset_ = index;
if (!ReCachePages()) return NULL;
}
return pages_[index - pages_offset_];
}
EXPORT_C TUint TInteger::ModuloL(TUint aOperand) const
{
if(!aOperand)
{
User::Leave(KErrDivideByZero);
}
return Modulo(*this, aOperand);
}
void HandlePlayer(char input)
{
int tempx = player.x,
tempy = player.y;
if (input == '1')
tempx--;
else if (input == 'r')
tempx++;
else if (input == 'u')
tempy--;
else if (input == 'd')
tempy++;
player.x = Modulo(tempx, 6);
player.y = Modulo(tempy, 6);
}
void main(void)
{
char *res;
char ch1[]="12.2";
char ch2[]="25.7";
res=Modulo(ch1,ch2,'\0');
printf("Resultat :%s:\n",res);
free(res);
}
int main(int argc, char *argv[], char *env[])
{
int Nbre1 = 3;
int Nbre2 = 2;
printf("%d + %d = %d\n", Nbre1, Nbre2, Additionner(Nbre1, Nbre2));
printf("%d - %d = %d\n", Nbre1, Nbre2, Soustraire(Nbre1, Nbre2));
printf("%d * %d = %d\n", Nbre1, Nbre2, Multiplier(Nbre1, Nbre2));
printf("%d / %d = %d\n", Nbre1, Nbre2, Diviser(Nbre1, Nbre2));
printf("%d %% %d = %d\n", Nbre1, Nbre2, Modulo(Nbre1, Nbre2));
printf("%d ^ 2 = %d\n", Nbre1, Carre(Nbre1));
}
// Helper for ComputeBinaryOffsets. Increments pos, dir_counts, pos_totals
// by the step, increment, and vertical step ? x : y position * increment
// at step s Mod stepcount respectively. Used to add or subtract the
// direction and position to/from accumulators of a small neighbourhood.
void C_OUTLINE::increment_step(int s, int increment, ICOORD* pos,
int* dir_counts, int* pos_totals) const {
int step_index = Modulo(s, stepcount);
int dir_index = chain_code(step_index);
dir_counts[dir_index] += increment;
ICOORD step_vec = step(step_index);
if (step_vec.x() == 0)
pos_totals[dir_index] += pos->x() * increment;
else
pos_totals[dir_index] += pos->y() * increment;
*pos += step_vec;
}
main(){
double x[N]=
{
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0
};// Vetor de entrada, inicializado com amostragem de uma onda quadrada
double X[N]; // Vetor SaÃda
double pi_N; // Auxiliar Pi*n
unsigned int i; // Indexador de uso geral
printf("\n * Transformada Discreta de Hartley * ");
// Calculo da DHT
for (int n=0; n<N; n++){
X[n] = 0;
pi_N = 2*n*pi;
for (int k=0; k<N; k++){
X[n] += x[k]*sqrt(2)*(cos((pi_N*k)/N-pi/4));//+sin((pi_N*k)/N));
}
X[n]=2*X[n]/N;
}
// Exibe vetor de entrada
printf("\n\nEntrada:\n");
for (i=0;i<N/2;i++) printf(" %.4f ", x[i]);
printf("\n");
for (;i<N;i++) printf(" %.4f ", x[i]);
// Exibe resultado
printf("\n\nResultado DHT:\n");
for (i=0;i<N/2;i++) printf(" %.4f ", X[i]);
printf("\n");
for (;i<N;i++) printf(" %.4f ", X[i]);
// Valor absoluto
printf("\n\nEm Modulo:\n");
for (i=0;i<N/2;i++) printf(" %.4f ", Modulo(X[i]));
printf("\n");
for (;i<N;i++) printf(" %.4f ", Modulo(X[i]));
}
// Gathers outline points and their directions from start_index into dirs by
// stepping along the outline and normalizing the coordinates until the
// required feature_length has been collected or end_index is reached.
// On input pos must point to the position corresponding to start_index and on
// return pos is updated to the current raw position, and pos_normed is set to
// the normed version of pos.
// Since directions wrap-around, they need special treatment to get the mean.
// Provided the cluster of directions doesn't straddle the wrap-around point,
// the simple mean works. If they do, then, unless the directions are wildly
// varying, the cluster rotated by 180 degrees will not straddle the wrap-
// around point, so mean(dir + 180 degrees) - 180 degrees will work. Since
// LLSQ conveniently stores the mean of 2 variables, we use it to store
// dir and dir+128 (128 is 180 degrees) and then use the resulting mean
// with the least variance.
static int GatherPoints(const C_OUTLINE* outline, double feature_length,
const DENORM& denorm, const DENORM* root_denorm,
int start_index, int end_index,
ICOORD* pos, FCOORD* pos_normed,
LLSQ* points, LLSQ* dirs) {
int step_length = outline->pathlength();
ICOORD step = outline->step(start_index % step_length);
// Prev_normed is the start point of this collection and will be set on the
// first iteration, and on later iterations used to determine the length
// that has been collected.
FCOORD prev_normed;
points->clear();
dirs->clear();
int num_points = 0;
int index;
for (index = start_index; index <= end_index; ++index, *pos += step) {
step = outline->step(index % step_length);
int edge_weight = outline->edge_strength_at_index(index % step_length);
if (edge_weight == 0) {
// This point has conflicting gradient and step direction, so ignore it.
continue;
}
// Get the sub-pixel precise location and normalize.
FCOORD f_pos = outline->sub_pixel_pos_at_index(*pos, index % step_length);
denorm.NormTransform(root_denorm, f_pos, pos_normed);
if (num_points == 0) {
// The start of this segment.
prev_normed = *pos_normed;
} else {
FCOORD offset = *pos_normed - prev_normed;
float length = offset.length();
if (length > feature_length) {
// We have gone far enough from the start. We will use this point in
// the next set so return what we have so far.
return index;
}
}
points->add(pos_normed->x(), pos_normed->y(), edge_weight);
int direction = outline->direction_at_index(index % step_length);
if (direction >= 0) {
direction = NormalizeDirection(direction, f_pos, denorm, root_denorm);
// Use both the direction and direction +128 so we are not trying to
// take the mean of something straddling the wrap-around point.
dirs->add(direction, Modulo(direction + 128, 256));
}
++num_points;
}
return index;
}
int main(int argc, char** argv) {
int opcao;
float num01,num02;
do {
printf("Entre com o numero da operacao matematica:\n");
printf("1 - Adição;\n");
printf("2 - Subtração;\n");
printf("3 - Multiplicação;\n");
printf("4 - Divisao;\n");
printf("5 - Modulo;\n");
printf("6 - Sair;\n");
scanf("%d",&opcao);
printf("Entre com um numero: ");
scanf("%f",&num01);
printf("Entre com um numero: ");
scanf("%f",&num02);
if(opcao == 1){
printf("%.0f + %.0f = %.0f\n",num01,num02,Adicao(num01,num02));
}
else if(opcao == 2){
printf("%.0f - %.0f = %.0f\n",num01,num02,Substracao(num01,num02));
}
else if(opcao == 3){
printf("%.0f * %.0f = %.0f\n",num01,num02,Multiplicacao(num01,num02));
}
else if(opcao ==4){
printf("%.0f / %.0f = %.2f \n",num01,num02,Divisao(num01,num02));
}
else if(opcao == 5){
printf("%.0f %% %.0f = %.2f\n",num01,num02,Modulo(num01,num02));
}
else if( opcao != 6){
printf("Operador matematico não encontrado\n");
}
else{
printf("Saindo do sistema.");
}
}while(opcao != 6);
return (EXIT_SUCCESS);
}
// Helper returns the mean direction vector from the given stats. Use the
// mean direction from dirs if there is information available, otherwise, use
// the fit_vector from point_diffs.
static FCOORD MeanDirectionVector(const LLSQ& point_diffs, const LLSQ& dirs,
const FCOORD& start_pt,
const FCOORD& end_pt) {
FCOORD fit_vector;
if (dirs.count() > 0) {
// There were directions, so use them. To avoid wrap-around problems, we
// have 2 accumulators in dirs: x for normal directions and y for
// directions offset by 128. We will use the one with the least variance.
FCOORD mean_pt = dirs.mean_point();
double mean_dir = 0.0;
if (dirs.x_variance() <= dirs.y_variance()) {
mean_dir = mean_pt.x();
} else {
mean_dir = mean_pt.y() + 128;
}
fit_vector.from_direction(Modulo(IntCastRounded(mean_dir), 256));
} else {
// There were no directions, so we rely on the vector_fit to the points.
// Since the vector_fit is 180 degrees ambiguous, we align with the
// supplied feature_dir by making the scalar product non-negative.
FCOORD feature_dir(end_pt - start_pt);
fit_vector = point_diffs.vector_fit();
if (fit_vector.x() == 0.0f && fit_vector.y() == 0.0f) {
// There was only a single point. Use feature_dir directly.
fit_vector = feature_dir;
} else {
// Sometimes the least mean squares fit is wrong, due to the small sample
// of points and scaling. Use a 90 degree rotated vector if that matches
// feature_dir better.
FCOORD fit_vector2 = !fit_vector;
// The fit_vector is 180 degrees ambiguous, so resolve the ambiguity by
// insisting that the scalar product with the feature_dir should be +ve.
if (fit_vector % feature_dir < 0.0)
fit_vector = -fit_vector;
if (fit_vector2 % feature_dir < 0.0)
fit_vector2 = -fit_vector2;
// Even though fit_vector2 has a higher mean squared error, it might be
// a better fit, so use it if the dot product with feature_dir is bigger.
if (fit_vector2 % feature_dir > fit_vector % feature_dir)
fit_vector = fit_vector2;
}
}
return fit_vector;
}
// Helper to compute an offset index feature. In this context an offset
// feature with a dir of +/-1 is a feature of a similar direction,
// but shifted perpendicular to the direction of the feature. An offset
// feature with a dir of +/-2 is feature at the same position, but rotated
// by +/- one [compact] quantum. Returns the index of the generated offset
// feature, or -1 if it doesn't exist. Dir should be in
// [-kNumOffsetMaps, kNumOffsetMaps] to indicate the relative direction.
// A dir of 0 is an identity transformation.
// Both input and output are from the index(sparse) feature space, not
// the mapped/compact feature space, but the offset feature is the minimum
// distance moved from the input to guarantee that it maps to the next
// available quantum in the mapped/compact space.
int IntFeatureMap::ComputeOffsetFeature(int index_feature, int dir) const {
INT_FEATURE_STRUCT f = InverseIndexFeature(index_feature);
ASSERT_HOST(IndexFeature(f) == index_feature);
if (dir == 0) {
return index_feature;
} else if (dir == 1 || dir == -1) {
FCOORD feature_dir = FeatureDirection(f.Theta);
FCOORD rotation90(0.0f, 1.0f);
feature_dir.rotate(rotation90);
// Find the nearest existing feature.
for (int m = 1; m < kMaxOffsetDist; ++m) {
double x_pos = f.X + feature_dir.x() * (m * dir);
double y_pos = f.Y + feature_dir.y() * (m * dir);
int x = IntCastRounded(x_pos);
int y = IntCastRounded(y_pos);
if (x >= 0 && x <= MAX_UINT8 && y >= 0 && y <= MAX_UINT8) {
INT_FEATURE_STRUCT offset_f;
offset_f.X = x;
offset_f.Y = y;
offset_f.Theta = f.Theta;
int offset_index = IndexFeature(offset_f);
if (offset_index != index_feature && offset_index >= 0)
return offset_index; // Found one.
} else {
return -1; // Hit the edge of feature space.
}
}
} else if (dir == 2 || dir == -2) {
// Find the nearest existing index_feature.
for (int m = 1; m < kMaxOffsetDist; ++m) {
int theta = f.Theta + m * dir / 2;
INT_FEATURE_STRUCT offset_f;
offset_f.X = f.X;
offset_f.Y = f.Y;
offset_f.Theta = Modulo(theta, 256);
int offset_index = IndexFeature(offset_f);
if (offset_index != index_feature && offset_index >= 0)
return offset_index; // Found one.
}
}
return -1; // Nothing within the max distance.
}
Integer& operator%=(word t) { return *this = Modulo(t); }
Integer& operator%=(const Integer& t) { return *this = Modulo(t); }
void TInteger::PrimeRandomizeL(TUint aBits, TRandomAttribute aAttr)
{
assert(aBits > 1);
//"this" is "empty" currently. Consists of Size() words of 0's. This is just
//checking that sign flag is positive as we don't set it later.
assert(NotNegative());
//Flag for the whole function saying if we've found a prime
TBool foundProbablePrime = EFalse;
//Find 2^aBits + 1 -- any prime we find must be less than this.
RInteger max = RInteger::NewEmptyL(BitsToWords(aBits)+1);
CleanupStack::PushL(max);
max.SetBit(aBits);
assert(max.BitCount()-1 == aBits);
// aBits | approx number of odd numbers you must try to have a 50%
// chance of finding a prime
//---------------------------------------------------------
// 512 | 122
// 1024 | 245
// 2048 | 1023
//Therefore if we are generating larger than 1024 bit numbers we'll use a
//bigger bit array to have a better chance of avoiding re-generating it.
TUint sLength = aBits > 1024 ? 1024 : 512;
RInteger S = RInteger::NewEmptyL(BitsToWords(sLength));
CleanupStack::PushL(S);
while(!foundProbablePrime)
{
//Randomly choose aBits
RandomizeL(aBits, aAttr);
//If the random number chosen is less than KSmallPrimeSquared, we have a
//special set of routines.
if(SmallPrimeRandomizeL())
{
foundProbablePrime = ETrue;
}
else
{
//if it was <= KLastSmallPrimeSquared then it would have been
//handled by SmallPrimeRandomizeL()
assert(*this > KLastSmallPrimeSquared);
//Make sure any number we bother testing is at least odd
SetBit(0);
//Ensure that this + 2*sLength < max
RInteger temp = max.MinusL(*this);
CleanupStack::PushL(temp);
++temp;
temp >>=1;
if(temp < sLength)
{
//if this + 2*sLength >= max then we use a smaller sLength to
//ensure we don't find a number that is outside of our bounds
//(and bigger than our allocated memory for this)
//temp must be less than KMaxTUint as sLength is a TUint
sLength = temp.ConvertToUnsignedLong();
}
CleanupStack::PopAndDestroy(&temp);
//Start at 1 as no point in checking against 2 (all odd numbers)
for(TUint i=1; i<KPrimeTableSize; i++)
{
//no need to call ModuloL as we know KPrimeTable[i] is not 0
TUint remainder = Modulo(*this, KPrimeTable[i]);
TUint index = FindSmallestIndex(KPrimeTable[i], remainder);
EliminateComposites(S.Ptr(), KPrimeTable[i], index, sLength);
}
TInt j = FindFirstPrimeCandidate(S.Ptr(), sLength);
TInt prev = 0;
for(; j>=0; j=FindFirstPrimeCandidate(S.Ptr(), sLength))
{
ArraySetBit(S.Ptr(), j);
//should never carry as we earlier made sure that 2*j + this < max
//where max is 1 bit more than we asked for.
IncrementNoCarry(Ptr(), Size(), 2*(j-prev));
assert(*this < max);
assert(!HasSmallDivisorL(*this));
prev = j;
if( IsStrongProbablePrimeL(*this) )
{
foundProbablePrime = ETrue;
break;
}
}
//This clears the memory
S.CopyL(0, EFalse);
}
}
CleanupStack::PopAndDestroy(2, &max);
}
int CheckSides (int icsbutton, char csccolor, int csitype)
{
if ((csitype > 0) && (csitype < 4))
{
iyeah = 0;
ichecked = 0;
if (Board[icsbutton][2] != csccolor)
{
if (Board[icsbutton][2] == 'e')
{
iyeah = 1;
}
else
{
iyeah = 2;
}
sprintf (Board[icsbutton], "%c%c%c", Board[icsbutton][0],
Board[icsbutton][1], csccolor);
}
for (iclear = 1; iclear <= 361; iclear++)
{
ireturn[iclear] = 0;
Checked[iclear] = 0;
}
}
if (Checked[icsbutton] == 1)
{
return (15);
}
Checked[icsbutton] = 1;
ichecked++;
if (csccolor == 'w')
{
csnotccolor = 'b';
}
else
{
csnotccolor = 'w';
}
if ((Modulo ((icsbutton - 1), 19) == 0)
|| (Checked[icsbutton - 1] == 2)
|| ((Modulo ((icsbutton - 1), 19) != 0)
&& (Board[icsbutton - 1][2] == csnotccolor))
|| ((Modulo ((icsbutton - 1), 19) != 0)
&& (Board[icsbutton - 1][2] == csccolor)
&& (CheckSides ((icsbutton - 1), csccolor, 0) == 15)))
{
ireturn[icsbutton] += 1;
}
else
Checked[icsbutton - 1] = 2;
if ((Modulo ((icsbutton), 19) == 0)
|| (Checked[icsbutton + 1] == 2)
|| ((Modulo ((icsbutton), 19) != 0)
&& (Board[icsbutton + 1][2] == csnotccolor))
|| ((Modulo ((icsbutton), 19) != 0)
&& (Board[icsbutton + 1][2] == csccolor)
&& (CheckSides ((icsbutton + 1), csccolor, 0) == 15)))
{
ireturn[icsbutton] += 2;
}
else
Checked[icsbutton + 1] = 2;
if (((icsbutton >= 1) && (icsbutton <= 19))
|| (Checked[icsbutton - 19] == 2)
|| ((icsbutton > 19)
&& (Board[icsbutton - 19][2] == csnotccolor))
|| ((icsbutton > 19)
&& (Board[icsbutton - 19][2] == csccolor)
&& (CheckSides ((icsbutton - 19), csccolor, 0) == 15)))
{
ireturn[icsbutton] += 4;
}
else
Checked[icsbutton - 19] = 2;
if (((icsbutton >= 343) && (icsbutton <= 361))
|| (Checked[icsbutton + 19] == 2)
|| ((icsbutton < 343)
&& (Board[icsbutton + 19][2] == csnotccolor))
|| ((icsbutton < 343)
&& (Board[icsbutton + 19][2] == csccolor)
&& (CheckSides ((icsbutton + 19), csccolor, 0) == 15)))
{
ireturn[icsbutton] += 8;
}
else
Checked[icsbutton + 19] = 2;
if ((csitype == 1) || (csitype == 2))
{
if (iyeah == 1)
{
sprintf (Board[icsbutton], "%c%c%c", Board[icsbutton][0],
Board[icsbutton][1], 'e');
}
if (iyeah == 2)
{
sprintf (Board[icsbutton], "%c%c%c", Board[icsbutton][0],
Board[icsbutton][1], 's');
}
}
if (csitype == 3)
{
return (ichecked);
}
else
{
return (ireturn[icsbutton]);
}
}
// Runs backward propagation of errors on the deltas line.
// See NetworkCpp for a detailed discussion of the arguments.
bool LSTM::Backward(bool debug, const NetworkIO& fwd_deltas,
NetworkScratch* scratch,
NetworkIO* back_deltas) {
if (debug) DisplayBackward(fwd_deltas);
back_deltas->ResizeToMap(fwd_deltas.int_mode(), input_map_, ni_);
// ======Scratch space.======
// Output errors from deltas with recurrence from sourceerr.
NetworkScratch::FloatVec outputerr;
outputerr.Init(ns_, scratch);
// Recurrent error in the state/source.
NetworkScratch::FloatVec curr_stateerr, curr_sourceerr;
curr_stateerr.Init(ns_, scratch);
curr_sourceerr.Init(na_, scratch);
ZeroVector<double>(ns_, curr_stateerr);
ZeroVector<double>(na_, curr_sourceerr);
// Errors in the gates.
NetworkScratch::FloatVec gate_errors[WT_COUNT];
for (int g = 0; g < WT_COUNT; ++g) gate_errors[g].Init(ns_, scratch);
// Rotating buffers of width buf_width allow storage of the recurrent time-
// steps used only for true 2-D. Stores one full strip of the major direction.
int buf_width = Is2D() ? input_map_.Size(FD_WIDTH) : 1;
GenericVector<NetworkScratch::FloatVec> stateerr, sourceerr;
if (Is2D()) {
stateerr.init_to_size(buf_width, NetworkScratch::FloatVec());
sourceerr.init_to_size(buf_width, NetworkScratch::FloatVec());
for (int t = 0; t < buf_width; ++t) {
stateerr[t].Init(ns_, scratch);
sourceerr[t].Init(na_, scratch);
ZeroVector<double>(ns_, stateerr[t]);
ZeroVector<double>(na_, sourceerr[t]);
}
}
// Parallel-generated sourceerr from each of the gates.
NetworkScratch::FloatVec sourceerr_temps[WT_COUNT];
for (int w = 0; w < WT_COUNT; ++w)
sourceerr_temps[w].Init(na_, scratch);
int width = input_width_;
// Transposed gate errors stored over all timesteps for sum outer.
NetworkScratch::GradientStore gate_errors_t[WT_COUNT];
for (int w = 0; w < WT_COUNT; ++w) {
gate_errors_t[w].Init(ns_, width, scratch);
}
// Used only if softmax_ != NULL.
NetworkScratch::FloatVec softmax_errors;
NetworkScratch::GradientStore softmax_errors_t;
if (softmax_ != NULL) {
softmax_errors.Init(no_, scratch);
softmax_errors_t.Init(no_, width, scratch);
}
double state_clip = Is2D() ? 9.0 : 4.0;
#if DEBUG_DETAIL > 1
tprintf("fwd_deltas:%s\n", name_.string());
fwd_deltas.Print(10);
#endif
StrideMap::Index dest_index(input_map_);
dest_index.InitToLast();
// Used only by NT_LSTM_SUMMARY.
StrideMap::Index src_index(fwd_deltas.stride_map());
src_index.InitToLast();
do {
int t = dest_index.t();
bool at_last_x = dest_index.IsLast(FD_WIDTH);
// up_pos is the 2-D back step, down_pos is the 2-D fwd step, and are only
// valid if >= 0, which is true if 2d and not on the top/bottom.
int up_pos = -1;
int down_pos = -1;
if (Is2D()) {
if (dest_index.index(FD_HEIGHT) > 0) {
StrideMap::Index up_index(dest_index);
if (up_index.AddOffset(-1, FD_HEIGHT)) up_pos = up_index.t();
}
if (!dest_index.IsLast(FD_HEIGHT)) {
StrideMap::Index down_index(dest_index);
if (down_index.AddOffset(1, FD_HEIGHT)) down_pos = down_index.t();
}
}
// Index of the 2-D revolving buffers (sourceerr, stateerr).
int mod_t = Modulo(t, buf_width); // Current timestep.
// Zero the state in the major direction only at the end of every row.
if (at_last_x) {
ZeroVector<double>(na_, curr_sourceerr);
ZeroVector<double>(ns_, curr_stateerr);
}
// Setup the outputerr.
if (type_ == NT_LSTM_SUMMARY) {
if (dest_index.IsLast(FD_WIDTH)) {
fwd_deltas.ReadTimeStep(src_index.t(), outputerr);
src_index.Decrement();
} else {
ZeroVector<double>(ns_, outputerr);
}
} else if (softmax_ == NULL) {
fwd_deltas.ReadTimeStep(t, outputerr);
} else {
softmax_->BackwardTimeStep(fwd_deltas, t, softmax_errors,
softmax_errors_t.get(), outputerr);
}
if (!at_last_x)
AccumulateVector(ns_, curr_sourceerr + ni_ + nf_, outputerr);
if (down_pos >= 0)
AccumulateVector(ns_, sourceerr[mod_t] + ni_ + nf_ + ns_, outputerr);
// Apply the 1-d forget gates.
if (!at_last_x) {
const float* next_node_gf1 = node_values_[GF1].f(t + 1);
for (int i = 0; i < ns_; ++i) {
curr_stateerr[i] *= next_node_gf1[i];
}
}
if (Is2D() && t + 1 < width) {
for (int i = 0; i < ns_; ++i) {
if (which_fg_[t + 1][i] != 1) curr_stateerr[i] = 0.0;
}
if (down_pos >= 0) {
const float* right_node_gfs = node_values_[GFS].f(down_pos);
const double* right_stateerr = stateerr[mod_t];
for (int i = 0; i < ns_; ++i) {
if (which_fg_[down_pos][i] == 2) {
curr_stateerr[i] += right_stateerr[i] * right_node_gfs[i];
}
}
}
}
state_.FuncMultiply3Add<HPrime>(node_values_[GO], t, outputerr,
curr_stateerr);
// Clip stateerr_ to a sane range.
ClipVector<double>(ns_, -state_clip, state_clip, curr_stateerr);
#if DEBUG_DETAIL > 1
if (t + 10 > width) {
tprintf("t=%d, stateerr=", t);
for (int i = 0; i < ns_; ++i)
tprintf(" %g,%g,%g", curr_stateerr[i], outputerr[i],
curr_sourceerr[ni_ + nf_ + i]);
tprintf("\n");
}
#endif
// Matrix multiply to get the source errors.
PARALLEL_IF_OPENMP(GFS)
// Cell inputs.
node_values_[CI].FuncMultiply3<GPrime>(t, node_values_[GI], t,
curr_stateerr, gate_errors[CI]);
ClipVector(ns_, -kErrClip, kErrClip, gate_errors[CI].get());
gate_weights_[CI].VectorDotMatrix(gate_errors[CI], sourceerr_temps[CI]);
gate_errors_t[CI].get()->WriteStrided(t, gate_errors[CI]);
SECTION_IF_OPENMP
// Input Gates.
node_values_[GI].FuncMultiply3<FPrime>(t, node_values_[CI], t,
curr_stateerr, gate_errors[GI]);
ClipVector(ns_, -kErrClip, kErrClip, gate_errors[GI].get());
gate_weights_[GI].VectorDotMatrix(gate_errors[GI], sourceerr_temps[GI]);
gate_errors_t[GI].get()->WriteStrided(t, gate_errors[GI]);
SECTION_IF_OPENMP
// 1-D forget Gates.
if (t > 0) {
node_values_[GF1].FuncMultiply3<FPrime>(t, state_, t - 1, curr_stateerr,
gate_errors[GF1]);
ClipVector(ns_, -kErrClip, kErrClip, gate_errors[GF1].get());
gate_weights_[GF1].VectorDotMatrix(gate_errors[GF1],
sourceerr_temps[GF1]);
} else {
memset(gate_errors[GF1], 0, ns_ * sizeof(gate_errors[GF1][0]));
memset(sourceerr_temps[GF1], 0, na_ * sizeof(*sourceerr_temps[GF1]));
}
gate_errors_t[GF1].get()->WriteStrided(t, gate_errors[GF1]);
// 2-D forget Gates.
if (up_pos >= 0) {
node_values_[GFS].FuncMultiply3<FPrime>(t, state_, up_pos, curr_stateerr,
gate_errors[GFS]);
ClipVector(ns_, -kErrClip, kErrClip, gate_errors[GFS].get());
gate_weights_[GFS].VectorDotMatrix(gate_errors[GFS],
sourceerr_temps[GFS]);
} else {
memset(gate_errors[GFS], 0, ns_ * sizeof(gate_errors[GFS][0]));
memset(sourceerr_temps[GFS], 0, na_ * sizeof(*sourceerr_temps[GFS]));
}
if (Is2D()) gate_errors_t[GFS].get()->WriteStrided(t, gate_errors[GFS]);
SECTION_IF_OPENMP
// Output gates.
state_.Func2Multiply3<HFunc, FPrime>(node_values_[GO], t, outputerr,
gate_errors[GO]);
ClipVector(ns_, -kErrClip, kErrClip, gate_errors[GO].get());
gate_weights_[GO].VectorDotMatrix(gate_errors[GO], sourceerr_temps[GO]);
gate_errors_t[GO].get()->WriteStrided(t, gate_errors[GO]);
END_PARALLEL_IF_OPENMP
SumVectors(na_, sourceerr_temps[CI], sourceerr_temps[GI],
sourceerr_temps[GF1], sourceerr_temps[GO], sourceerr_temps[GFS],
curr_sourceerr);
back_deltas->WriteTimeStep(t, curr_sourceerr);
// Save states for use by the 2nd dimension only if needed.
if (Is2D()) {
CopyVector(ns_, curr_stateerr, stateerr[mod_t]);
CopyVector(na_, curr_sourceerr, sourceerr[mod_t]);
}
} while (dest_index.Decrement());
#if DEBUG_DETAIL > 2
for (int w = 0; w < WT_COUNT; ++w) {
tprintf("%s gate errors[%d]\n", name_.string(), w);
gate_errors_t[w].get()->PrintUnTransposed(10);
}
#endif
// Transposed source_ used to speed-up SumOuter.
NetworkScratch::GradientStore source_t, state_t;
source_t.Init(na_, width, scratch);
source_.Transpose(source_t.get());
state_t.Init(ns_, width, scratch);
state_.Transpose(state_t.get());
#ifdef _OPENMP
#pragma omp parallel for num_threads(GFS) if (!Is2D())
#endif
for (int w = 0; w < WT_COUNT; ++w) {
if (w == GFS && !Is2D()) continue;
gate_weights_[w].SumOuterTransposed(*gate_errors_t[w], *source_t, false);
}
if (softmax_ != NULL) {
softmax_->FinishBackward(*softmax_errors_t);
}
return needs_to_backprop_;
}
void CFootBotLightRotZOnlySensor::Update() {
/* Erase readings */
for(size_t i = 0; i < m_tReadings.size(); ++i) {
m_tReadings[i].Value = 0.0f;
}
/* Get foot-bot orientation */
CRadians cTmp1, cTmp2, cOrientationZ;
m_pcEmbodiedEntity->GetOriginAnchor().Orientation.ToEulerAngles(cOrientationZ, cTmp1, cTmp2);
/* Ray used for scanning the environment for obstacles */
CRay3 cOcclusionCheckRay;
cOcclusionCheckRay.SetStart(m_pcEmbodiedEntity->GetOriginAnchor().Position);
CVector3 cRobotToLight;
/* Buffer for the angle of the light wrt to the foot-bot */
CRadians cAngleLightWrtFootbot;
/* Buffers to contain data about the intersection */
SEmbodiedEntityIntersectionItem sIntersection;
/* List of light entities */
CSpace::TMapPerTypePerId::iterator itLights = m_cSpace.GetEntityMapPerTypePerId().find("light");
if (itLights != m_cSpace.GetEntityMapPerTypePerId().end()) {
CSpace::TMapPerType& mapLights = itLights->second;
/*
* 1. go through the list of light entities in the scene
* 2. check if a light is occluded
* 3. if it isn't, distribute the reading across the sensors
* NOTE: the readings are additive
* 4. go through the sensors and clamp their values
*/
for(CSpace::TMapPerType::iterator it = mapLights.begin();
it != mapLights.end();
++it) {
/* Get a reference to the light */
CLightEntity& cLight = *(any_cast<CLightEntity*>(it->second));
/* Consider the light only if it has non zero intensity */
if(cLight.GetIntensity() > 0.0f) {
/* Set the ray end */
cOcclusionCheckRay.SetEnd(cLight.GetPosition());
/* Check occlusion between the foot-bot and the light */
if(! GetClosestEmbodiedEntityIntersectedByRay(sIntersection,
cOcclusionCheckRay,
*m_pcEmbodiedEntity)) {
/* The light is not occluded */
if(m_bShowRays) {
m_pcControllableEntity->AddCheckedRay(false, cOcclusionCheckRay);
}
/* Get the distance between the light and the foot-bot */
cOcclusionCheckRay.ToVector(cRobotToLight);
/*
* Linearly scale the distance with the light intensity
* The greater the intensity, the smaller the distance
*/
cRobotToLight /= cLight.GetIntensity();
/* Get the angle wrt to foot-bot rotation */
cAngleLightWrtFootbot = cRobotToLight.GetZAngle();
cAngleLightWrtFootbot -= cOrientationZ;
/*
* Find closest sensor index to point at which ray hits footbot body
* Rotate whole body by half a sensor spacing (corresponding to placement of first sensor)
* Division says how many sensor spacings there are between first sensor and point at which ray hits footbot body
* Increase magnitude of result of division to ensure correct rounding
*/
Real fIdx = (cAngleLightWrtFootbot - SENSOR_HALF_SPACING) / SENSOR_SPACING;
SInt32 nReadingIdx = (fIdx > 0) ? fIdx + 0.5f : fIdx - 0.5f;
/* Set the actual readings */
Real fReading = cRobotToLight.Length();
/*
* Take 6 readings before closest sensor and 6 readings after - thus we
* process sensors that are with 180 degrees of intersection of light
* ray with robot body
*/
for(SInt32 nIndexOffset = -6; nIndexOffset < 7; ++nIndexOffset) {
UInt32 unIdx = Modulo(nReadingIdx + nIndexOffset, 24);
CRadians cAngularDistanceFromOptimalLightReceptionPoint = Abs((cAngleLightWrtFootbot - m_tReadings[unIdx].Angle).SignedNormalize());
/*
* ComputeReading gives value as if sensor was perfectly in line with
* light ray. We then linearly decrease actual reading from 1 (dist
* 0) to 0 (dist PI/2)
*/
m_tReadings[unIdx].Value += ComputeReading(fReading) * ScaleReading(cAngularDistanceFromOptimalLightReceptionPoint);
}
}
else {
/* The ray is occluded */
if(m_bShowRays) {
m_pcControllableEntity->AddCheckedRay(true, cOcclusionCheckRay);
m_pcControllableEntity->AddIntersectionPoint(cOcclusionCheckRay, sIntersection.TOnRay);
}
}
}
}
/* Apply noise to the sensors */
if(m_bAddNoise) {
for(size_t i = 0; i < 24; ++i) {
m_tReadings[i].Value += m_pcRNG->Uniform(m_cNoiseRange);
}
}
/* Trunc the reading between 0 and 1 */
for(size_t i = 0; i < 24; ++i) {
SENSOR_RANGE.TruncValue(m_tReadings[i].Value);
}
}
else {
/* There are no lights in the environment */
if(m_bAddNoise) {
/* Go through the sensors */
for(UInt32 i = 0; i < m_tReadings.size(); ++i) {
/* Apply noise to the sensor */
m_tReadings[i].Value += m_pcRNG->Uniform(m_cNoiseRange);
/* Trunc the reading between 0 and 1 */
SENSOR_RANGE.TruncValue(m_tReadings[i].Value);
}
}
}
}
void Pass (void)
{
/* The next 4 lines must be there. */
while (gtk_events_pending ())
{
gtk_main_iteration ();
}
if (ichangestuff == 0)
{
Play ("click.mp3", 0);
}
if ((((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0))
&& (iyesno == 0)) && (((((Modulo (imoves, 2) == 0) && (iiamblack == 1)) ||
((Modulo (imoves, 2) != 0) && (iiamblack == 0))) && (inet == 1)) ||
(inet == 0))) && (imoving == 0))
{
imoving = 1;
if (inet == 1)
{
SendData (1, "pass");
}
if (Modulo (imoves, 2) == 0)
{
JudgeBoard ('w');
}
else
{
JudgeBoard ('b');
}
pass[ihistory] = 1;
iscorewhite = ScoreWhite ();
iscoreblack = ScoreBlack ();
if (Modulo (imoves, 2) != 0)
{
if ((iscorewhite > iscoreblack) || (pass[ihistory - 1] == 1))
{
if (iscorewhite > iscoreblack)
{
iduh = 1;
}
EndGame ();
}
else
{
if (wiscomputer == 1)
{
Computer ('w');
JudgeBoard ('b');
}
}
}
else
{
if ((iscoreblack > iscorewhite) || (pass[ihistory - 1] == 1))
{
if (iscoreblack > iscorewhite)
{
iduh = 1;
}
EndGame ();
}
else
{
if (biscomputer == 1)
{
Computer ('b');
JudgeBoard ('w');
}
}
}
imoving = 0;
}
else
{
if (inet == 1)
{
Message ("It is not your move.", 3, 0);
}
}
}
// Converts an angle in radians (from ICOORD::angle or FCOORD::angle) to a
// standard feature direction as an unsigned angle in 256ths of a circle
// measured anticlockwise from (-1, 0).
uint8_t FCOORD::binary_angle_plus_pi(double radians) {
return Modulo(IntCastRounded((radians + M_PI) * 128.0 / M_PI), 256);
}
// Adds sub-pixel resolution EdgeOffsets for the outline if the supplied
// pix is 8-bit. Does nothing otherwise.
// Operation: Consider the following near-horizontal line:
// _________
// |________
// |________
// At *every* position along this line, the gradient direction will be close
// to vertical. Extrapoaltion/interpolation of the position of the threshold
// that was used to binarize the image gives a more precise vertical position
// for each horizontal step, and the conflict in step direction and gradient
// direction can be used to ignore the vertical steps.
void C_OUTLINE::ComputeEdgeOffsets(int threshold, Pix* pix) {
if (pixGetDepth(pix) != 8) return;
const l_uint32* data = pixGetData(pix);
int wpl = pixGetWpl(pix);
int width = pixGetWidth(pix);
int height = pixGetHeight(pix);
bool negative = flag(COUT_INVERSE);
delete [] offsets;
offsets = new EdgeOffset[stepcount];
ICOORD pos = start;
ICOORD prev_gradient;
ComputeGradient(data, wpl, pos.x(), height - pos.y(), width, height,
&prev_gradient);
for (int s = 0; s < stepcount; ++s) {
ICOORD step_vec = step(s);
TPOINT pt1(pos);
pos += step_vec;
TPOINT pt2(pos);
ICOORD next_gradient;
ComputeGradient(data, wpl, pos.x(), height - pos.y(), width, height,
&next_gradient);
// Use the sum of the prev and next as the working gradient.
ICOORD gradient = prev_gradient + next_gradient;
// best_diff will be manipulated to be always positive.
int best_diff = 0;
// offset will be the extrapolation of the location of the greyscale
// threshold from the edge with the largest difference, relative to the
// location of the binary edge.
int offset = 0;
if (pt1.y == pt2.y && abs(gradient.y()) * 2 >= abs(gradient.x())) {
// Horizontal step. diff_sign == 1 indicates black above.
int diff_sign = (pt1.x > pt2.x) == negative ? 1 : -1;
int x = MIN(pt1.x, pt2.x);
int y = height - pt1.y;
int best_sum = 0;
int best_y = y;
EvaluateVerticalDiff(data, wpl, diff_sign, x, y, height,
&best_diff, &best_sum, &best_y);
// Find the strongest edge.
int test_y = y;
do {
++test_y;
} while (EvaluateVerticalDiff(data, wpl, diff_sign, x, test_y, height,
&best_diff, &best_sum, &best_y));
test_y = y;
do {
--test_y;
} while (EvaluateVerticalDiff(data, wpl, diff_sign, x, test_y, height,
&best_diff, &best_sum, &best_y));
offset = diff_sign * (best_sum / 2 - threshold) +
(y - best_y) * best_diff;
} else if (pt1.x == pt2.x && abs(gradient.x()) * 2 >= abs(gradient.y())) {
// Vertical step. diff_sign == 1 indicates black on the left.
int diff_sign = (pt1.y > pt2.y) == negative ? 1 : -1;
int x = pt1.x;
int y = height - MAX(pt1.y, pt2.y);
const l_uint32* line = pixGetData(pix) + y * wpl;
int best_sum = 0;
int best_x = x;
EvaluateHorizontalDiff(line, diff_sign, x, width,
&best_diff, &best_sum, &best_x);
// Find the strongest edge.
int test_x = x;
do {
++test_x;
} while (EvaluateHorizontalDiff(line, diff_sign, test_x, width,
&best_diff, &best_sum, &best_x));
test_x = x;
do {
--test_x;
} while (EvaluateHorizontalDiff(line, diff_sign, test_x, width,
&best_diff, &best_sum, &best_x));
offset = diff_sign * (threshold - best_sum / 2) +
(best_x - x) * best_diff;
}
offsets[s].offset_numerator =
static_cast<inT8>(ClipToRange(offset, -MAX_INT8, MAX_INT8));
offsets[s].pixel_diff = static_cast<uinT8>(ClipToRange(best_diff, 0 ,
MAX_UINT8));
if (negative) gradient = -gradient;
// Compute gradient angle quantized to 256 directions, rotated by 64 (pi/2)
// to convert from gradient direction to edge direction.
offsets[s].direction =
Modulo(FCOORD::binary_angle_plus_pi(gradient.angle()) + 64, 256);
prev_gradient = next_gradient;
}
}
// Runs forward propagation of activations on the input line.
// See NetworkCpp for a detailed discussion of the arguments.
void LSTM::Forward(bool debug, const NetworkIO& input,
const TransposedArray* input_transpose,
NetworkScratch* scratch, NetworkIO* output) {
input_map_ = input.stride_map();
input_width_ = input.Width();
if (softmax_ != NULL)
output->ResizeFloat(input, no_);
else if (type_ == NT_LSTM_SUMMARY)
output->ResizeXTo1(input, no_);
else
output->Resize(input, no_);
ResizeForward(input);
// Temporary storage of forward computation for each gate.
NetworkScratch::FloatVec temp_lines[WT_COUNT];
for (int i = 0; i < WT_COUNT; ++i) temp_lines[i].Init(ns_, scratch);
// Single timestep buffers for the current/recurrent output and state.
NetworkScratch::FloatVec curr_state, curr_output;
curr_state.Init(ns_, scratch);
ZeroVector<double>(ns_, curr_state);
curr_output.Init(ns_, scratch);
ZeroVector<double>(ns_, curr_output);
// Rotating buffers of width buf_width allow storage of the state and output
// for the other dimension, used only when working in true 2D mode. The width
// is enough to hold an entire strip of the major direction.
int buf_width = Is2D() ? input_map_.Size(FD_WIDTH) : 1;
GenericVector<NetworkScratch::FloatVec> states, outputs;
if (Is2D()) {
states.init_to_size(buf_width, NetworkScratch::FloatVec());
outputs.init_to_size(buf_width, NetworkScratch::FloatVec());
for (int i = 0; i < buf_width; ++i) {
states[i].Init(ns_, scratch);
ZeroVector<double>(ns_, states[i]);
outputs[i].Init(ns_, scratch);
ZeroVector<double>(ns_, outputs[i]);
}
}
// Used only if a softmax LSTM.
NetworkScratch::FloatVec softmax_output;
NetworkScratch::IO int_output;
if (softmax_ != NULL) {
softmax_output.Init(no_, scratch);
ZeroVector<double>(no_, softmax_output);
int rounded_softmax_inputs = gate_weights_[CI].RoundInputs(ns_);
if (input.int_mode())
int_output.Resize2d(true, 1, rounded_softmax_inputs, scratch);
softmax_->SetupForward(input, NULL);
}
NetworkScratch::FloatVec curr_input;
curr_input.Init(na_, scratch);
StrideMap::Index src_index(input_map_);
// Used only by NT_LSTM_SUMMARY.
StrideMap::Index dest_index(output->stride_map());
do {
int t = src_index.t();
// True if there is a valid old state for the 2nd dimension.
bool valid_2d = Is2D();
if (valid_2d) {
StrideMap::Index dim_index(src_index);
if (!dim_index.AddOffset(-1, FD_HEIGHT)) valid_2d = false;
}
// Index of the 2-D revolving buffers (outputs, states).
int mod_t = Modulo(t, buf_width); // Current timestep.
// Setup the padded input in source.
source_.CopyTimeStepGeneral(t, 0, ni_, input, t, 0);
if (softmax_ != NULL) {
source_.WriteTimeStepPart(t, ni_, nf_, softmax_output);
}
source_.WriteTimeStepPart(t, ni_ + nf_, ns_, curr_output);
if (Is2D())
source_.WriteTimeStepPart(t, ni_ + nf_ + ns_, ns_, outputs[mod_t]);
if (!source_.int_mode()) source_.ReadTimeStep(t, curr_input);
// Matrix multiply the inputs with the source.
PARALLEL_IF_OPENMP(GFS)
// It looks inefficient to create the threads on each t iteration, but the
// alternative of putting the parallel outside the t loop, a single around
// the t-loop and then tasks in place of the sections is a *lot* slower.
// Cell inputs.
if (source_.int_mode())
gate_weights_[CI].MatrixDotVector(source_.i(t), temp_lines[CI]);
else
gate_weights_[CI].MatrixDotVector(curr_input, temp_lines[CI]);
FuncInplace<GFunc>(ns_, temp_lines[CI]);
SECTION_IF_OPENMP
// Input Gates.
if (source_.int_mode())
gate_weights_[GI].MatrixDotVector(source_.i(t), temp_lines[GI]);
else
gate_weights_[GI].MatrixDotVector(curr_input, temp_lines[GI]);
FuncInplace<FFunc>(ns_, temp_lines[GI]);
SECTION_IF_OPENMP
// 1-D forget gates.
if (source_.int_mode())
gate_weights_[GF1].MatrixDotVector(source_.i(t), temp_lines[GF1]);
else
gate_weights_[GF1].MatrixDotVector(curr_input, temp_lines[GF1]);
FuncInplace<FFunc>(ns_, temp_lines[GF1]);
// 2-D forget gates.
if (Is2D()) {
if (source_.int_mode())
gate_weights_[GFS].MatrixDotVector(source_.i(t), temp_lines[GFS]);
else
gate_weights_[GFS].MatrixDotVector(curr_input, temp_lines[GFS]);
FuncInplace<FFunc>(ns_, temp_lines[GFS]);
}
SECTION_IF_OPENMP
// Output gates.
if (source_.int_mode())
gate_weights_[GO].MatrixDotVector(source_.i(t), temp_lines[GO]);
else
gate_weights_[GO].MatrixDotVector(curr_input, temp_lines[GO]);
FuncInplace<FFunc>(ns_, temp_lines[GO]);
END_PARALLEL_IF_OPENMP
// Apply forget gate to state.
MultiplyVectorsInPlace(ns_, temp_lines[GF1], curr_state);
if (Is2D()) {
// Max-pool the forget gates (in 2-d) instead of blindly adding.
inT8* which_fg_col = which_fg_[t];
memset(which_fg_col, 1, ns_ * sizeof(which_fg_col[0]));
if (valid_2d) {
const double* stepped_state = states[mod_t];
for (int i = 0; i < ns_; ++i) {
if (temp_lines[GF1][i] < temp_lines[GFS][i]) {
curr_state[i] = temp_lines[GFS][i] * stepped_state[i];
which_fg_col[i] = 2;
}
}
}
}
MultiplyAccumulate(ns_, temp_lines[CI], temp_lines[GI], curr_state);
// Clip curr_state to a sane range.
ClipVector<double>(ns_, -kStateClip, kStateClip, curr_state);
if (IsTraining()) {
// Save the gate node values.
node_values_[CI].WriteTimeStep(t, temp_lines[CI]);
node_values_[GI].WriteTimeStep(t, temp_lines[GI]);
node_values_[GF1].WriteTimeStep(t, temp_lines[GF1]);
node_values_[GO].WriteTimeStep(t, temp_lines[GO]);
if (Is2D()) node_values_[GFS].WriteTimeStep(t, temp_lines[GFS]);
}
FuncMultiply<HFunc>(curr_state, temp_lines[GO], ns_, curr_output);
if (IsTraining()) state_.WriteTimeStep(t, curr_state);
if (softmax_ != NULL) {
if (input.int_mode()) {
int_output->WriteTimeStepPart(0, 0, ns_, curr_output);
softmax_->ForwardTimeStep(NULL, int_output->i(0), t, softmax_output);
} else {
softmax_->ForwardTimeStep(curr_output, NULL, t, softmax_output);
}
output->WriteTimeStep(t, softmax_output);
if (type_ == NT_LSTM_SOFTMAX_ENCODED) {
CodeInBinary(no_, nf_, softmax_output);
}
} else if (type_ == NT_LSTM_SUMMARY) {
// Output only at the end of a row.
if (src_index.IsLast(FD_WIDTH)) {
output->WriteTimeStep(dest_index.t(), curr_output);
dest_index.Increment();
}
} else {
output->WriteTimeStep(t, curr_output);
}
// Save states for use by the 2nd dimension only if needed.
if (Is2D()) {
CopyVector(ns_, curr_state, states[mod_t]);
CopyVector(ns_, curr_output, outputs[mod_t]);
}
// Always zero the states at the end of every row, but only for the major
// direction. The 2-D state remains intact.
if (src_index.IsLast(FD_WIDTH)) {
ZeroVector<double>(ns_, curr_state);
ZeroVector<double>(ns_, curr_output);
}
} while (src_index.Increment());
#if DEBUG_DETAIL > 0
tprintf("Source:%s\n", name_.string());
source_.Print(10);
tprintf("State:%s\n", name_.string());
state_.Print(10);
tprintf("Output:%s\n", name_.string());
output->Print(10);
#endif
if (debug) DisplayForward(*output);
}
Vector SDKGradientClass::Output(BaseShader *sh, ChannelData *sd)
{
Vector p=sd->p;
Real r=0.0,angle,xx,yy;
if (gdata.turbulence>0.0)
{
Vector res;
Real scl=5.0*gdata.scale,tt=sd->t*gdata.freq*0.3;
res = Vector(Turbulence(p*scl,tt,gdata.octaves,TRUE),Turbulence((p+Vector(0.34,13.0,2.43))*scl,tt,gdata.octaves,TRUE),0.0);
if (gdata.absolute)
{
p.x = Mix(p.x,res.x,gdata.turbulence);
p.y = Mix(p.y,res.y,gdata.turbulence);
}
else
{
p.x += (res.x-0.5)*gdata.turbulence;
p.y += (res.y-0.5)*gdata.turbulence;
}
}
// rotation
p.x -= 0.5;
p.y -= 0.5;
xx = gdata.ca*p.x-gdata.sa*p.y + 0.5;
yy = gdata.sa*p.x+gdata.ca*p.y + 0.5;
p.x = xx;
p.y = yy;
if (gdata.mode<=SDKGRADIENTSHADER_MODE_CORNER && gdata.cycle && (sd->texflag&TEX_TILE))
{
if (sd->texflag & TEX_MIRROR)
{
p.x = Modulo(p.x,RCO 2.0);
if (p.x>=1.0) p.x=2.0-p.x;
p.y = Modulo(p.y,RCO 2.0);
if (p.y>= 1.0) p.y=2.0-p.y;
}
else
{
p.x = Modulo(p.x, RCO 1.0);
p.y = Modulo(p.y, RCO 1.0);
}
}
switch (gdata.mode)
{
case SDKGRADIENTSHADER_MODE_U:
r = p.x;
break;
case SDKGRADIENTSHADER_MODE_V:
r = 1.0-p.y;
break;
case SDKGRADIENTSHADER_MODE_DIAGONAL:
r = (p.x+p.y)*0.5;
break;
case SDKGRADIENTSHADER_MODE_RADIAL:
p.x-=0.5;
p.y-=0.5;
if (p.x==0.0) p.x=0.00001;
angle = ATan(p.y/p.x);
if (p.x<0.0) angle+=pi;
if (angle<0.0) angle+=pi2;
r = angle/pi2;
break;
case SDKGRADIENTSHADER_MODE_CIRCULAR:
p.x-=0.5;
p.y-=0.5;
r = Sqrt(p.x*p.x+p.y*p.y)*2.0;
break;
case SDKGRADIENTSHADER_MODE_BOX:
p.x = Abs(p.x - 0.5);
p.y = Abs(p.y - 0.5);
r = FMax(p.x,p.y)*2.0;
break;
case SDKGRADIENTSHADER_MODE_STAR:
p.x = Abs(p.x - 0.5)-0.5;
p.y = Abs(p.y - 0.5)-0.5;
r = Sqrt(p.x*p.x+p.y*p.y) * 1.4142;
break;
case SDKGRADIENTSHADER_MODE_CORNER:
{
Real cx;
Vector ca,cb;
cx = FCut01(p.x);
ca = Mix(gdata.c[0],gdata.c[1],cx);
cb = Mix(gdata.c[2],gdata.c[3],cx);
return Mix(ca,cb,FCut01(p.y));
break;
}
}
return gdata.gradient->CalcGradientPixel(FCut01(r));
}
void CEPuckLightSensor::Update() {
/* Here we assume that the e-puck is rotated only wrt to the Z axis */
/* Erase readings */
for(size_t i = 0; i < m_tReadings.size(); ++i) {
m_tReadings[i].Value = 0.0f;
}
/* Get e-puck position */
const CVector3& cEPuckPosition = GetEntity().GetEmbodiedEntity().GetPosition();
/* Get e-puck orientation */
CRadians cTmp1, cTmp2, cOrientationZ;
GetEntity().GetEmbodiedEntity().GetOrientation().ToEulerAngles(cOrientationZ, cTmp1, cTmp2);
/* Buffer for calculating the light--e-puck distance */
CVector3 cLightDistance;
/* Buffer for the angle of the sensor wrt to the e-puck */
CRadians cLightAngle;
/* Initialize the occlusion check ray start to the baseline of the e-puck */
CRay cOcclusionCheckRay;
cOcclusionCheckRay.SetStart(cEPuckPosition);
/* Buffer to store the intersection data */
CSpace::SEntityIntersectionItem<CEmbodiedEntity> sIntersectionData;
/* Ignore the sensing ropuck when checking for occlusions */
TEmbodiedEntitySet tIgnoreEntities;
tIgnoreEntities.insert(&GetEntity().GetEmbodiedEntity());
/*
* 1. go through the list of light entities in the scene
* 2. check if a light is occluded
* 3. if it isn't, distribute the reading across the sensors
* NOTE: the readings are additive
* 4. go through the sensors and clamp their values
*/
try{
CSpace::TAnyEntityMap& tEntityMap = m_cSpace.GetEntitiesByType("light_entity");
for(CSpace::TAnyEntityMap::iterator it = tEntityMap.begin();
it != tEntityMap.end();
++it) {
/* Get a reference to the light */
CLightEntity& cLight = *(any_cast<CLightEntity*>(it->second));
/* Consider the light only if it has non zero intensity */
if(cLight.GetIntensity() > 0.0f) {
/* Get the light position */
const CVector3& cLightPosition = cLight.GetPosition();
/* Set the ray end */
cOcclusionCheckRay.SetEnd(cLightPosition);
/* Check occlusion between the e-puck and the light */
if(! m_cSpace.GetClosestEmbodiedEntityIntersectedByRay(sIntersectionData,
cOcclusionCheckRay,
tIgnoreEntities)) {
/* The light is not occluded */
if(m_bShowRays) GetEntity().GetControllableEntity().AddCheckedRay(false, cOcclusionCheckRay);
/* Get the distance between the light and the e-puck */
cOcclusionCheckRay.ToVector(cLightDistance);
/* Linearly scale the distance with the light intensity
The greater the intensity, the smaller the distance */
cLightDistance /= cLight.GetIntensity();
/* Get the angle wrt to e-puck rotation */
cLightAngle = cLightDistance.GetZAngle();
cLightAngle -= cOrientationZ;
/* Transform it into counter-clockwise rotation */
cLightAngle.Negate().UnsignedNormalize();
/* Find reading corresponding to the sensor */
SInt16 nMin = 0;
for(SInt16 i = 1; i < NUM_READINGS; ++i){
if((cLightAngle - m_tReadings[i].Angle).GetAbsoluteValue() < (cLightAngle - m_tReadings[nMin].Angle).GetAbsoluteValue())
nMin = i;
}
/* Set the actual readings */
Real fReading = cLightDistance.Length();
m_tReadings[Modulo((SInt16)(nMin-1), NUM_READINGS)].Value += ComputeReading(fReading * Cos(cLightAngle - m_tReadings[Modulo(nMin-1, NUM_READINGS)].Angle));
m_tReadings[ nMin ].Value += ComputeReading(fReading);
m_tReadings[Modulo((SInt16)(nMin+1), NUM_READINGS)].Value += ComputeReading(fReading * Cos(cLightAngle - m_tReadings[Modulo(nMin+1, NUM_READINGS)].Angle));
}
else {
/* The ray is occluded */
if(m_bShowRays) {
GetEntity().GetControllableEntity().AddCheckedRay(true, cOcclusionCheckRay);
GetEntity().GetControllableEntity().AddIntersectionPoint(cOcclusionCheckRay, sIntersectionData.TOnRay);
}
}
}
}
}
catch(argos::CARGoSException& e){
}
/* Now go through the sensors, add noise and clamp their values if above 1024 or under 1024 */
for(size_t i = 0; i < m_tReadings.size(); ++i) {
if(m_fNoiseLevel>0.0f)
AddNoise(i);
if(m_tReadings[i].Value > 1024.0f)
m_tReadings[i].Value = 1024.0f;
if(m_tReadings[i].Value < 0.0f)
m_tReadings[i].Value = 0.0f;
}
}
