Cell *Cell::getNeighborWithImage(char anImage) { Cell *neighbors[4]; unsigned count = 0; if (north()->getImage() == anImage) neighbors[count++] = north(); if (south()->getImage() == anImage) neighbors[count++] = south(); if (east()->getImage() == anImage) neighbors[count++] = east(); if (west()->getImage() == anImage) neighbors[count++] = west(); if (!count) return this; else return neighbors[Ocean1->random->nextIntBetween(0,count-1)]; }
GeoDataCoordinates GeoDataLatLonAltBox::center() const { if ( isEmpty() ) return GeoDataCoordinates(); if( crossesDateLine() ) return GeoDataCoordinates( GeoDataCoordinates::normalizeLon(east() + 2 * M_PI - (east() + 2 * M_PI - west()) / 2), north() - (north() - south()) / 2, d->m_maxAltitude - (d->m_maxAltitude - d->m_minAltitude) / 2); else return GeoDataCoordinates( east() - (east() - west()) / 2, north() - (north() - south()) / 2, d->m_maxAltitude - (d->m_maxAltitude - d->m_minAltitude) / 2); }
std::vector< Ellipsoid_rasterizer::EuclideanVector >& Ellipsoid_rasterizer::rasterize() { GsTLInt center_id = cursor_.node_id( center_[0], center_[1], center_[2] ); appli_assert( center_id >= 0 && center_id < int(already_visited_.size()) ); already_visited_[ center_id ] = true; s_.push( center_id ); EuclideanVector west(-1,0,0); EuclideanVector east(1,0,0); EuclideanVector south(0,-1,0); EuclideanVector north(0,1,0); EuclideanVector down(0,0,-1); EuclideanVector up(0,0,1); // move away from center, until we reach the border of the ellipsoid while( ! s_.empty() ) { GsTLInt id = s_.top(); s_.pop(); GsTLGridNode loc; cursor_.coords( id, loc[0], loc[1], loc[2] ); check_node( loc+west ); check_node( loc+east ); check_node( loc+north ); check_node( loc+south ); check_node( loc+up ); check_node( loc+down ); } return ellipsoid_nodes_; }
int main() { FILE *in = fopen( "bee.in", "r" ); int field; currentStep = 1; posX = 0; posY = -1; south( 2 ); for( int schale = 1; currentStep < 10000; schale ++ ) { northWest( schale ); north( schale ); northEast( schale ); southEast( schale ); south( schale + 1 ); southWest( schale ); } while( fscanf( in, "%d", &field )==1 ) { printf( "%d %d\n", fieldX[field], fieldY[field] ); } return 0; }
void ModelExporter::processLight(const scene::INodePtr& node) { // Export lights as small polyhedron static const double EXTENTS = 8.0; std::vector<model::ModelPolygon> polys; Vertex3f up(0, 0, EXTENTS); Vertex3f down(0, 0, -EXTENTS); Vertex3f north(0, EXTENTS, 0); Vertex3f south(0, -EXTENTS, 0); Vertex3f east(EXTENTS, 0, 0); Vertex3f west(-EXTENTS, 0, 0); // Upper semi-diamond polys.push_back(createPolyCCW(up, south, east)); polys.push_back(createPolyCCW(up, east, north)); polys.push_back(createPolyCCW(up, north, west)); polys.push_back(createPolyCCW(up, west, south)); // Lower semi-diamond polys.push_back(createPolyCCW(down, south, west)); polys.push_back(createPolyCCW(down, west, north)); polys.push_back(createPolyCCW(down, north, east)); polys.push_back(createPolyCCW(down, east, south)); Matrix4 exportTransform = node->localToWorld().getPremultipliedBy(_centerTransform); _exporter->addPolygons("lights/default", polys, exportTransform); }
void flood_fill(int new_room) { int visited_num, i, j; do { visited_num = 0; for (i = 0; i < N; i++) { /* for each module */ for (j = 0; j < M; j++) { if (room[i][j] == visited) { // printf("[%d %d] ", i, j); visited_num++; room[i][j] = new_room; if (!west(module[i][j])) if (room[i][j-1] == nil) room[i][j-1] = visited; if (!north(module[i][j])) if (room[i-1][j] == nil) room[i-1][j] = visited; if (!east(module[i][j])) if (room[i][j+1] == nil) room[i][j+1] = visited; if (!south(module[i][j])) if (room[i+1][j] == nil) room[i+1][j] = visited; } } } size[new_room] += visited_num; } while (visited_num); }
//'@rdname neighbours //'@export // [[Rcpp::export]] DataFrame gh_neighbours(CharacterVector hashes){ unsigned int input_size = hashes.size(); CharacterVector north(input_size); CharacterVector ne(input_size); CharacterVector east(input_size); CharacterVector se(input_size); CharacterVector south(input_size); CharacterVector sw(input_size); CharacterVector west(input_size); CharacterVector nw(input_size); std::vector < std::string > holding(8); for(unsigned int i = 0; i < input_size; i++){ if((i % 10000) == 0){ Rcpp::checkUserInterrupt(); } if(CharacterVector::is_na(hashes[i])){ north[i] = NA_REAL; ne[i] = NA_REAL; east[i] = NA_REAL; se[i] = NA_REAL; south[i] = NA_REAL; sw[i] = NA_REAL; west[i] = NA_REAL; nw[i] = NA_REAL; } else { holding = cgeohash::all_neighbours(Rcpp::as<std::string>(hashes[i])); north[i] = holding[0]; ne[i] = holding[1]; east[i] = holding[2]; se[i] = holding[3]; south[i] = holding[4]; sw[i] = holding[5]; west[i] = holding[6]; nw[i] = holding[7]; } } return DataFrame::create(_["north"] = north, _["northeast"] = ne, _["east"] = east, _["southeast"] = se, _["south"] = south, _["southwest"] = sw, _["west"] = west, _["northwest"] = nw, _["stringsAsFactors"] = false); }
QString GeoDataLatLonAltBox::toString( GeoDataCoordinates::Unit unit ) const { switch( unit ){ case GeoDataCoordinates::Radian: return QString( "North: %1; West: %2 MaxAlt: %3\n South: %4; East: %5 MinAlt: %6" ) .arg( north() ).arg( west() ) .arg( d->m_maxAltitude ).arg( south() ) .arg( east() ).arg( d->m_minAltitude ); break; case GeoDataCoordinates::Degree: return QString( "North: %1; West: %2 MaxAlt: %3\n South: %4; East: %5 MinAlt: %6" ) .arg( north() * RAD2DEG ).arg( west() * RAD2DEG ) .arg( d->m_maxAltitude ).arg( south() * RAD2DEG ) .arg( east() * RAD2DEG ).arg( d->m_minAltitude ); break; } return QString( "GeoDataLatLonAltBox::text(): Error in unit: %1\n" ) .arg( unit ); }
double LatLonConvert::rightGreenich() { if (isGu()) { return northGreenich.eastDegree(180); }else { double d = pixelToDegree((int)scrDaegak()); NorthGreenichPoint p1, p2; p1.set(north(), greenich()); p1.moveEast(d); p1.moveNorth(d); p2.set(north(), greenich()); p2.moveEast(d); p2.moveSouth(d); double gp = qMax(p1.greenich(), p2.greenich()); gp = northGreenich.eastDegree(d); double dy = mppToDegree(); double max = baseWJ(gp, dy) + dy + dy; return max; } }
void do_op(char C) { switch(C) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': push(C-'0'); break; case '+': addition(); break; case '-': subtraction(); break; case '*': multiplication(); break; case '/': division(); break; case '%': modulo(); break; case '^': north(); break; case '>': east(); break; case 'V': case 'v': south(); break; case '<': west(); break; case '?': spin(); break; case '!': lnot(); break; case '`': gt(); break; case '_': hif(); break; case '|': vif(); break; case '"': tsm(); break; case ':': dup(); break; case '\\': swap(); break; case '$': chomp(); break; case '#': jump(); break; case 'p': put(); break; case 'g': get(); break; case 'H': gate(); break; case '.': print_i(); break; case ',': print_c(); break; case '&': input_i(); break; case '~': input_c(); break; case '@': hacf(); break; case '{': left_b(); break; case '}': right_b(); break; case '[': carry_l(); break; case ']': carry_r(); break; case ';': empty(); break; case 'O': portal_o(); break; case 'B': portal_b(); break; default: /* DO NOTHING! */ break; } }
void _set_wind (const Planet& planet, const Climate_parameters&, Climate_generation_season& season) { for (auto& t : tiles(planet)) { season.tiles[id(t)].wind = _default_wind(planet, id(t), season.tropical_equator); season.tiles[id(t)].wind.direction += north(planet, &t); } for (auto& t : tiles(planet)) { //tile shape in 2d, rotated according to wind direction std::vector<Vector2> corners = rotation_matrix(north(planet, &t) - season.tiles[id(t)].wind.direction) * polygon(&t, rotation_to_default(planet)); int e = edge_count(t); for (int k=0; k<e; k++) { int direction = sign(nth_edge(t, k), &t); if (corners[k].x + corners[(k+1)%e].x < 0) direction *= -1; season.edges[id(nth_edge(t, k))].wind_velocity -= 0.5 * direction * season.tiles[id(t)].wind.speed * std::abs(corners[k].y - corners[(k+1)%e].y) / length(corners[k] - corners[(k+1)%e]); } } }
double LatLonConvert::leftGreenich() { if (isGu()) { return northGreenich.westDegree(180); }else { double d = pixelToDegree((int)scrDaegak()); NorthGreenichPoint p1, p2; p1.set(north(), greenich()); p1.moveNorth(d); p1.moveWest(d); p2.set(north(), greenich()); p2.moveSouth(d); p2.moveWest(d); double gp = qMin(p1.greenich(), p2.greenich()); gp = northGreenich.westDegree(d); double dy = mppToDegree(); double min = baseWJ(gp, dy) - dy; return min; } }
void menu()// NORTH AND SOUTH BOUND ROUTE { system("cls"); p("\n\n\n\t\t\t= Cavite Bus Transit =\n\n"); p("\n\t\t\t Ticket Transaction\n "); p("\n\n\tChoose Destination: "); p("[ 1 ] NORTH BOUND [ 2 ] SOUTH BOUND "); p("\n\n\tRoute: "); s("%d", &y); if (y == 1) north(); else if ( y == 2) south(); else {p("INVALID CHOICE!"); getch(); system("cls"); menu(); getch(); } }
void ViewEvaluator::outputView(GeoPoint* view, string filename) { readyFeatures(); oc->volActor->GetProperty()->SetAmbient(0.3); oc->volActor->GetProperty()->SetDiffuse(0.7); //SetShading(0); oc->volActor->GetProperty()->SetSpecular(0.7); //SetShading(0); oc->volActor->GetProperty()->SetInterpolationToPhong(); oc->volActor->SetVisibility(1); vtkSmartPointer<vtkWindowToImageFilter> windowToImageFilter = vtkSmartPointer<vtkWindowToImageFilter>::New(); windowToImageFilter->SetInput(renderWindow); vtkSmartPointer<vtkPNGWriter> writer = vtkSmartPointer<vtkPNGWriter>::New(); writer->SetInput(windowToImageFilter->GetOutput()); float viewRange = 3; vnl_vector<float> pos(3); double* upV = new double[3](); pos[0] = viewRange * view->getx(); pos[1] = viewRange * view->gety(); pos[2] = viewRange * view->getz(); camera->SetPosition(pos[0], pos[1], pos[2]); if (!upSet) { upSet = true; upV = camera->GetViewUp(); } //upV[0]=0;upV[1]=1;upV[2]=0; camera->SetViewUp(upV); vnl_vector<float> northPole(3); northPole[0] = 0.0001; northPole[1] = 1; northPole[2] = 0; vnl_vector<float> north(3); vnl_vector<float> here(3); here[0] = pos[0]; here[1] = pos[1]; here[2] = pos[2]; north = northPole - here; camera->OrthogonalizeViewUp(); upV = camera->GetViewUp(); cout << " up is " << upV[0] << " " << upV[1] << " " << upV[2] << endl; cout << " view is " << pos[0] << " " << pos[1] << " " << pos[2] << endl; renderWindow->Render(); windowToImageFilter->Update(); filename = *(oc->resultsPath) + filename; cout << "OUTPUTTING PNG to " << filename << endl; writer->SetFileName(filename.c_str()); writer->Write(); renderWindow->Render(); climbDownFeatures(); }
int main() { int n; char s[6]; while (scanf("%d",&n),n) { init(); while (n--) { scanf("%s",s); if (strcmp(s,"north")==0) north(); else if (strcmp(s,"south")==0) south(); else if (strcmp(s,"east")==0) east(); else if (strcmp(s,"west")==0) west(); } printf("%d\n",dice[0]); } }
zz::map::location zz::map::location::adjacent( zz::map::direction direction ) const { switch( direction ) { case zz::map::north : return north( ); case zz::map::east : return east( ); case zz::map::south : return south( ); case zz::map::west : return west( ); } fprintf( stderr, "invalid direction provided to map::location::adjacent\n" ); fflush( stderr ); exit( EXIT_FAILURE ); }
virtual void operator()(osg::Node* node, osg::NodeVisitor* nv) { if( nv->getVisitorType() == osg::NodeVisitor::CULL_VISITOR ) { osgUtil::CullVisitor* cv = static_cast<osgUtil::CullVisitor*>(nv); osg::Vec3 eye,center,up; cv->getCurrentCamera()->getViewMatrixAsLookAt(eye,center,up); osg::Vec3 look = center - eye; look.z() = 0; look.normalize(); osg::Vec3 north(0,1,0); osg::Matrix mat = osg::Matrix::rotate(look,north); g_pNorthArrowStateSet->getUniform("matBearing")->set(mat); } traverse(node,nv); }
TEST_F(VecTest, ArithmeticFunc) { vec3 east(1, 0, 0); vec3 north(0, 1, 0); vec3 up( cross(east, north) ); EXPECT_EQ(up, vec3(0,0,1)); EXPECT_EQ(dot(east, north), 0); EXPECT_EQ(length(east), 1); EXPECT_EQ(distance(east, north), sqrtf(2)); vec3 v0(1,2,3); vec3 vn(normalize(v0)); EXPECT_FLOAT_EQ(1, length(vn)); EXPECT_FLOAT_EQ(length(v0), dot(v0, vn)); tvec3<double> vd(east); EXPECT_EQ(length(vd), 1); }
void DrawPoint( const Vector2& point, float size ) { size *= 0.5f; Vector2 north(point + Vector2::UnitY * size ); Vector2 south(point - Vector2::UnitY * size ); Vector2 east(point + Vector2::UnitX * size ); Vector2 west(point - Vector2::UnitX * size ); float points[] = { north.X, north.Y, east.X, east.Y, south.X, south.Y, west.X, west.Y, }; glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 0, points); glDrawArrays(GL_LINE_LOOP, 0, 4); }
void LandscapeRenderer::BuildNormArray() { if (m_verts.Size() <= 0) return; int nextNormId = 0; // Go through all the strips... for (int i = 0; i < m_strips.Size(); ++i) { LandTriangleStrip *strip = m_strips[i]; m_verts[nextNormId++].m_norm = g_upVector; m_verts[nextNormId++].m_norm = g_upVector; int const maxJ = strip->m_numVerts - 2; // For each vertex in strip for (int j = 0; j < maxJ; j += 2) { Vector3 const &v1 = m_verts[strip->m_firstVertIndex + j].m_pos; Vector3 const &v2 = m_verts[strip->m_firstVertIndex + j + 1].m_pos; Vector3 const &v3 = m_verts[strip->m_firstVertIndex + j + 2].m_pos; Vector3 const &v4 = m_verts[strip->m_firstVertIndex + j + 3].m_pos; Vector3 north(v1 - v2); Vector3 northEast(v3 - v2); Vector3 east(v4 - v2); Vector3 norm1(northEast ^ north); norm1.Normalise(); Vector3 norm2(east ^ northEast); norm2.Normalise(); m_verts[nextNormId++].m_norm = norm1; m_verts[nextNormId++].m_norm = norm2; int vertIndex = strip->m_firstVertIndex + j + 2; AppDebugAssert(nextNormId - 2 == vertIndex); } } int vertIndex = m_verts.NumUsed(); AppDebugAssert(nextNormId == vertIndex); }
int main () { int i,n,result; char roll[6]; while (1) { scanf("%d", &n); if (n==0) return 0; dice[kTOP] = 1; dice[kBOTTOM] = 6; dice[kNORTH] = 5; dice[kSOUTH] = 2; dice[kEAST] = 3; dice[kWEST] = 4; result = 1; for (i=0;i<n;i++) { scanf("%s", roll); switch (roll[0]) { case 'N': north(); break; case 'E': east(); break; case 'W': west(); break; case 'S': south(); break; case 'R': right(); break; case 'L': left(); break; } result += dice[kTOP]; } printf("%d\n", result); } }
int main() { WFMath::Vector<3> east(1,0,0), north(0,1,0), west(-1,0,0); WFMath::Vector<3> up(0,0,1), down(0,0,-1); Quaternion rotation; // Normal 90 degree rotation rotation = quaternionFromTo(east, north); // No rotation to cover special case rotation = quaternionFromTo(east, east); // Exact 180 to cover special case rotation = quaternionFromTo(east, west); // Exact 180 to cover other part of same case rotation = quaternionFromTo(up, down); return 0; }
static void make_see(int levelplayer, t_players *player, int fd, t_env *e) { int count; count = 0; dprintf(fd, "{"); while (count < levelplayer + 1) { if (player->orientation == O) west(count, fd, e, player); else if (player->orientation == N) north(count, fd, e, player); else if (player->orientation == E) east(count, fd, e, player); else if (player->orientation == S) south(count, fd, e, player); count = count + 1; if (count < levelplayer + 1 || count == 0) dprintf(fd, ","); } dprintf(fd, "}\n"); }
bool BoardEvaluator::IsFinished(Board &board, Colour *winningColour) { for (unsigned int i = 0; i < WIDTH; i++) { for (unsigned int j = 0; j < HEIGHT; j++) { Counter *counter = board.Space(i, j); if (counter != NULL) { // creating the dirctions to be searched in. North north(i, j); South south(i, j); East east(i, j); West west(i, j); NorthEast northEast(i, j); NorthWest northWest(i, j); SouthEast southEast(i, j); SouthWest southWest(i, j); bool retVal = false; Colour retCol = NULL_COLOUR; unsigned int conLength = CONNECT_LENGTH; Colour colour = (Colour)counter->GetColour(); if (RecursiveSearch(colour, &north, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &south, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &east, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &west, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &northEast, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &northWest, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &southEast, conLength - 1, board)) { retCol = colour; retVal = true; } if (RecursiveSearch(colour, &southWest, conLength - 1, board)) { retCol = colour; retVal = true; } if (retVal) { *winningColour = retCol; return true; } } } } return false; }
void MobileVRInterface::set_position_from_sensors() { _THREAD_SAFE_METHOD_ // this is a helper function that attempts to adjust our transform using our 9dof sensors // 9dof is a misleading marketing term coming from 3 accelerometer axis + 3 gyro axis + 3 magnetometer axis = 9 axis // but in reality this only offers 3 dof (yaw, pitch, roll) orientation uint64_t ticks = OS::get_singleton()->get_ticks_usec(); uint64_t ticks_elapsed = ticks - last_ticks; float delta_time = (double)ticks_elapsed / 1000000.0; // few things we need Input *input = Input::get_singleton(); Vector3 down(0.0, -1.0, 0.0); // Down is Y negative Vector3 north(0.0, 0.0, 1.0); // North is Z positive // make copies of our inputs bool has_grav = false; Vector3 acc = input->get_accelerometer(); Vector3 gyro = input->get_gyroscope(); Vector3 grav = input->get_gravity(); Vector3 magneto = scale_magneto(input->get_magnetometer()); // this may be overkill on iOS because we're already getting a calibrated magnetometer reading if (sensor_first) { sensor_first = false; } else { acc = scrub(acc, last_accerometer_data, 2, 0.2); magneto = scrub(magneto, last_magnetometer_data, 3, 0.3); }; last_accerometer_data = acc; last_magnetometer_data = magneto; if (grav.length() < 0.1) { // not ideal but use our accelerometer, this will contain shakey shakey user behaviour // maybe look into some math but I'm guessing that if this isn't available, its because we lack the gyro sensor to actually work out // what a stable gravity vector is grav = acc; if (grav.length() > 0.1) { has_grav = true; }; } else { has_grav = true; }; bool has_magneto = magneto.length() > 0.1; if (gyro.length() > 0.1) { /* this can return to 0.0 if the user doesn't move the phone, so once on, it's on */ has_gyro = true; }; if (has_gyro) { // start with applying our gyro (do NOT smooth our gyro!) Basis rotate; rotate.rotate(orientation.get_axis(0), gyro.x * delta_time); rotate.rotate(orientation.get_axis(1), gyro.y * delta_time); rotate.rotate(orientation.get_axis(2), gyro.z * delta_time); orientation = rotate * orientation; tracking_state = ARVRInterface::ARVR_NORMAL_TRACKING; }; ///@TODO improve this, the magnetometer is very fidgity sometimes flipping the axis for no apparent reason (probably a bug on my part) // if you have a gyro + accelerometer that combo tends to be better then combining all three but without a gyro you need the magnetometer.. if (has_magneto && has_grav && !has_gyro) { // convert to quaternions, easier to smooth those out Quat transform_quat(orientation); Quat acc_mag_quat(combine_acc_mag(grav, magneto)); transform_quat = transform_quat.slerp(acc_mag_quat, 0.1); orientation = Basis(transform_quat); tracking_state = ARVRInterface::ARVR_NORMAL_TRACKING; } else if (has_grav) { // use gravity vector to make sure down is down... // transform gravity into our world space grav.normalize(); Vector3 grav_adj = orientation.xform(grav); float dot = grav_adj.dot(down); if ((dot > -1.0) && (dot < 1.0)) { // axis around which we have this rotation Vector3 axis = grav_adj.cross(down); axis.normalize(); Basis drift_compensation(axis, acos(dot) * delta_time * 10); orientation = drift_compensation * orientation; }; }; // JIC orientation.orthonormalize(); last_ticks = ticks; };
main () { FILE *fin = fopen ("castle.in", "r"); FILE *fout = fopen ("castle.out", "w"); int i, j; unsigned int type; fscanf (fin, "%d %d", &M, &N); for (i = 0; i < N; i++) { for (j = 0; j < M; j++) { fscanf (fin, "%u", &type); module[i][j] = ( unsigned char ) type; room[i][j] = nil; //printf ("%d ", (unsigned char) type); } } for (i = 0; i < 2500; i++) size[i] = 0; max_size = 0; find_room(); fprintf(fout, "%d\n", room_num+1); for (i = 0; i <= room_num; i++) if (size[i] > max_size) max_size = size[i]; fprintf(fout, "%d\n", max_size); int new_size; for (i = 0; i < N; i++) { for (j = 0; j < M; j++) { if (north(module[i][j]) && i > 0 && room[i][j] != room[i-1][j]) { new_size = size[room[i][j]] + size[room[i-1][j]]; if (new_size > new_room_size) { x = i; y = j; direction = 'N'; new_room_size = new_size; } else if (new_size == new_room_size) { if (j<y || (j==y && i>x) ) { x = i; y = j; direction = 'N'; } } } else if (east(module[i][j]) && j < M-1 && room[i][j] != room[i][j+1]) { new_size = size[room[i][j]] + size[room[i][j+1]]; if (new_size > new_room_size) { x = i; y = j; direction = 'E'; new_room_size = new_size; } else if (new_size == new_room_size) { if (j<y || (j==y && i>x) ) { x = i; y = j; direction = 'E'; } } } } } fprintf(fout, "%d\n", new_room_size); fprintf(fout, "%d %d %c\n", x+1, y+1, direction); exit (0); }
/** * \brief The work function * * This function does the actual work of activating the guide port outputs * for a given amount of time. */ void AsiGuidePort::run() { std::unique_lock<std::mutex> lock(_mutex); // we keep running until the _running variable becomes false // we are sure not to miss this event, because we carefully lock // the private data of the class all the time while (_running) { // find the time when the next action should finish int duration = 0; // first check for any right ascension movement if (0 != _ra) { if (_ra > 0) { west(); duration = _ra; } else { east(); duration = -_ra; } } else { rastop(); } // check whether any declination movement is needed if (0 != _dec) { if (_dec > 0) { north(); if (_dec < duration) { duration = _dec; } } else { south(); if (-_dec < duration) { duration = -_dec; } } } else { decstop(); } // so we are done, and wait for new information if (0 == duration) { // just wait for new information _condition.wait(lock); } else { // wait for the condition variable for the duration // in milliseconds. std::cv_status status = _condition.wait_for(lock, std::chrono::milliseconds(duration)); // if this times out, then we have waited for the // duration, so we change the _ra und _dec variables // accordingly if (status == std::cv_status::timeout) { if (_ra > 0) { _ra -= duration; } if (_ra < 0) { _ra += duration; } if (_dec > 0) { _dec -= duration; } if (_dec < 0) { _dec += duration; } } // in other cases, i.e. if it does not time out, // then new settings for _ra and _dec must have become // available, so we just loop around, and pick up the // new values } } }
LatLng northwest() const { return LatLng(north(), west()); }
AZ_MATRIX *user_Ke_build(struct user_partition *Edge_Partition) { double dcenter, doff, sigma = .0001; int ii,jj, horv, i, nx, global_id, nz_ptr, Nlocal_edges; /* Aztec matrix and temp variables */ int *Ke_bindx, *Ke_data_org = NULL; double *Ke_val; AZ_MATRIX *Ke_mat; int proc_config[AZ_PROC_SIZE], *cpntr = NULL; int *reordered_glob_edges = NULL, *reordered_edge_externs = NULL; Nlocal_edges = Edge_Partition->Nlocal; nx = (int) sqrt( ((double) Edge_Partition->Nglobal/2) + .00001); Ke_bindx = (int *) malloc((7*Nlocal_edges+1)*sizeof(int)); Ke_val = (double *) malloc((7*Nlocal_edges+1)*sizeof(double)); Ke_bindx[0] = Nlocal_edges+1; dcenter = 2 + 2.*sigma/((double) ( 3 * nx * nx)); doff = -1 + sigma/((double) ( 6 * nx * nx)); for (i = 0; i < Nlocal_edges; i++) { global_id = (Edge_Partition->my_global_ids)[i]; invindex(global_id, &ii, &jj, nx, &horv); nz_ptr = Ke_bindx[i]; Ke_val[i] = dcenter; if (horv == HORIZONTAL) { if (jj != 0) { Ke_bindx[nz_ptr] = north(ii,jj,nx); Ke_val[nz_ptr++] = doff; Ke_bindx[nz_ptr] = east(ii,jj,nx); Ke_val[nz_ptr++] = -1.; if (ii != 0) {Ke_bindx[nz_ptr]=west(ii,jj,nx); Ke_val[nz_ptr++]= 1.;} jj--; } else { Ke_val[i] = 1. + 2.*sigma/((double) ( 3 * nx * nx)); jj = nx-1; } Ke_bindx[nz_ptr] = east(ii,jj,nx); Ke_val[nz_ptr++] = 1.; if (ii != 0){ Ke_bindx[nz_ptr]=west(ii,jj,nx); Ke_val[nz_ptr++]=-1.;} if (jj != 0){ Ke_bindx[nz_ptr]=south(ii,jj,nx); Ke_val[nz_ptr++]=doff;} } else { if (ii != 0) { Ke_bindx[nz_ptr] = north(ii,jj,nx); Ke_val[nz_ptr++] = -1.; Ke_bindx[nz_ptr] = east(ii,jj,nx); Ke_val[nz_ptr++] = doff; if (jj != 0) {Ke_bindx[nz_ptr]=south(ii,jj,nx); Ke_val[nz_ptr++]=1.;} ii--; } else { Ke_val[i] = 1 + 2.*sigma/((double) ( 3 * nx * nx)); ii = nx-1; } Ke_bindx[nz_ptr] = north(ii,jj,nx); Ke_val[nz_ptr++] = 1.; if (ii != 0) {Ke_bindx[nz_ptr]=west(ii,jj,nx); Ke_val[nz_ptr++]=doff;} if (jj != 0) {Ke_bindx[nz_ptr]=south(ii,jj,nx); Ke_val[nz_ptr++]=-1.;} } Ke_bindx[i+1] = nz_ptr; } AZ_set_proc_config(proc_config, COMMUNICATOR); AZ_transform_norowreordering(proc_config, &(Edge_Partition->needed_external_ids), Ke_bindx, Ke_val, Edge_Partition->my_global_ids, &reordered_glob_edges, &reordered_edge_externs, &Ke_data_org, Nlocal_edges, 0, 0, 0, &cpntr, AZ_MSR_MATRIX); AZ_free(reordered_glob_edges); AZ_free(reordered_edge_externs); Edge_Partition->Nghost = Ke_data_org[AZ_N_external]; Ke_mat = AZ_matrix_create( Nlocal_edges ); AZ_set_MSR(Ke_mat, Ke_bindx, Ke_val, Ke_data_org, 0, NULL, AZ_LOCAL); return(Ke_mat); }