Exemple #1
0
    /** Expands the cluster order while adding new neighbor points to the order.
     * @param db All data points that are to be considered by the algorithm. Changes their values.
     * @param p The point to be examined.
     * @param eps The epsilon representing the radius of the epsilon-neighborhood.
     * @param min_pts The minimum number of points to be found within an epsilon-neigborhood.
     * @param[out] o_ordered_vector The ordered vector of data points. Elements will be added to this vector.
     */
    void expand_cluster_order( DataVector& db, DataPoint* p, const real eps, const unsigned int min_pts, DataVector& o_ordered_vector) {
        assert( eps >= 0 && "eps must not be negative");
        assert( min_pts > 0 && "min_pts must be greater than 0");
        
        DataVector N_eps = get_neighbors( p, eps, db);
        p->reachability_distance( OPTICS::UNDEFINED);
        const real core_dist_p = squared_core_distance( p, min_pts, N_eps);
        p->processed( true);
        o_ordered_vector.push_back( p);
    
        if( core_dist_p == OPTICS::UNDEFINED)
            return;

        DataSet seeds;
        update_seeds( N_eps, p, core_dist_p, seeds);
        
        while( !seeds.empty()) {
            DataPoint* q = *seeds.begin();
            seeds.erase( seeds.begin()); // remove first element from seeds

            DataVector N_q = get_neighbors( q, eps, db);
            const real core_dist_q = squared_core_distance( q, min_pts, N_q);
            q->processed( true);
            o_ordered_vector.push_back( q);
            if( core_dist_q != OPTICS::UNDEFINED) {
                // *** q is a core-object ***
                update_seeds( N_q, q, core_dist_q, seeds);
            }
        }
    }
Exemple #2
0
void clique::expand_cluster(clique_block & p_block) {
    p_block.touch();

    if (p_block.get_points().size() <= m_density_threshold) {
        if (!p_block.get_points().empty()) {
            m_result_ptr->noise().insert(m_result_ptr->noise().end(), p_block.get_points().begin(), p_block.get_points().end());
        }

        return;
    }

    m_result_ptr->clusters().push_back({ });
    cluster & cur_cluster = m_result_ptr->clusters().back();
    cur_cluster.insert(cur_cluster.end(), p_block.get_points().begin(), p_block.get_points().end());

    std::list<clique_block *> neighbors;
    get_neighbors(p_block, neighbors);

    for (clique_block * neighbor : neighbors) {
        if (neighbor->get_points().size() > m_density_threshold) {
            cur_cluster.insert(cur_cluster.end(), neighbor->get_points().begin(), neighbor->get_points().end());
            get_neighbors(*neighbor, neighbors);
        }
        else if (!neighbor->get_points().empty()) {
            m_result_ptr->noise().insert(m_result_ptr->noise().end(), neighbor->get_points().begin(), neighbor->get_points().end());
        }
    }
}
Exemple #3
0
/* Split a mask into a mask with just the cycles, and another mask with the remaining dots. */
void separate_cycles(mask_t mask, mask_t *cycles, mask_t *no_cycles) {
    int i, j;

    *cycles = mask;
    *no_cycles = 0;

    for (i = j = 0; i < NUM_DOTS; j = ++i) {
        if (MASK_CONTAINS(*cycles, j)) {
            /* Repeatedly remove dots that only have less than two neighbors and add
             * them to the mask that has no cycles.
             */
            int num_neighbors;
            neighbors_t neighbors;
            get_neighbors(*cycles, j, &num_neighbors, neighbors);
            while (num_neighbors <= 1) {
                *cycles = REMOVE_FROM_MASK(*cycles, j);
                *no_cycles = ADD_TO_MASK(*no_cycles, j);
                if (num_neighbors == 0) {
                    break;
                }
                j = neighbors[0];
                get_neighbors(*cycles, j, &num_neighbors, neighbors);
            }
        }
    }
}
Exemple #4
0
std::vector<int> breadth_first_search(int root,
                                      const std::map<int,std::set<int>>& edges) {

  // Initialize data structures
  std::unordered_map<int,bool> is_visited;
  std::vector<int> sorted_nodes;
  std::queue<int> search_queue;
  search_queue.push(root);

  // Visit nodes until search queue is exhausted
  while (!search_queue.empty()) {
    const auto& node = search_queue.front();
    search_queue.pop();
    for (const auto& neighbor : get_neighbors(node, edges)) {
      if (!is_visited[neighbor]) {
        is_visited[neighbor] = true;
        sorted_nodes.push_back(neighbor);
        search_queue.push(neighbor);
      }
    }
  }

  // Return list of sorted nodes
  return sorted_nodes;

}
Exemple #5
0
std::vector<int> depth_first_search(int root,
                                    const std::map<int,std::set<int>>& edges) {

  // Initialize data structures
  std::unordered_map<int,bool> is_visited, is_sorted;
  std::vector<int> sorted_nodes;
  std::stack<int> search_stack;
  search_stack.push(root);

  // Visit nodes until search stack is exhausted
  while (!search_stack.empty()) {
    const auto& node = search_stack.top();
    search_stack.pop();
    if (!is_sorted[node]) {
      if (is_visited[node]) {
        // Add node to sorted list if we have already visited
        is_sorted[node] = true;
        sorted_nodes.push_back(node);
      } else {
        // Visit node and add neighbors to search stack
        is_visited[node] = true;
        search_stack.push(node);
        for (const auto& neighbor : get_neighbors(node, edges)) {
          if (!is_visited[neighbor] && !is_sorted[neighbor]) {
            search_stack.push(neighbor);
          }
        }
      }
    }
  }

  // Return list of sorted nodes
  return sorted_nodes;

}
Exemple #6
0
dev_info_t *
i_ddi_create_branch(dev_info_t *pdip, int nid)
{
	char *buf;
	dev_info_t *dip = NULL;

	if (pdip == NULL || nid == OBP_NONODE || nid == OBP_BADNODE)
		return (NULL);

	buf = kmem_alloc(OBP_MAXPROPNAME, KM_SLEEP);

	if (getlongprop_buf(nid, OBP_NAME, buf, OBP_MAXPROPNAME) > 0) {
		if (check_status(nid, buf, pdip) == DDI_SUCCESS)
			dip = ddi_add_child(pdip, buf, nid, -1);
	}

	kmem_free(buf, OBP_MAXPROPNAME);

	if (dip == NULL)
		return (NULL);

	/*
	 * Don't create any siblings of the branch root, just
	 * children.
	 */
	(void) get_neighbors(dip, DDI_WALK_PRUNESIB);

	di_dfs(ddi_get_child(dip), get_neighbors, 0);

	return (dip);
}
Exemple #7
0
void legion_network::neuron_states(const double t, const differ_state<double> & inputs, const differ_extra<void *> & argv, differ_state<double> & outputs) {
	unsigned int index = *(unsigned int *) argv[1];

	const double x = inputs[0];
	const double y = inputs[1];
	const double p = inputs[2];

	double potential_influence = heaviside(p + std::exp(-m_params.alpha * t) - m_params.teta);

	double stumulus = 0.0;
	if ((*m_stimulus)[index] > 0) {
		stumulus = m_params.I;
	}

	double dx = 3.0 * x - std::pow(x, 3) + 2.0 - y + stumulus * potential_influence + m_oscillators[index].m_coupling_term + m_oscillators[index].m_noise;
	double dy = m_params.eps * (m_params.gamma * (1.0 + std::tanh(x / m_params.betta)) - y);

	std::vector<unsigned int> * neighbors = get_neighbors(index);
	double potential = 0.0;

	for (std::vector<unsigned int>::const_iterator index_iterator = neighbors->begin(); index_iterator != neighbors->end(); index_iterator++) {
		unsigned int index_neighbor = *index_iterator;
		potential += m_params.T * heaviside(m_oscillators[index_neighbor].m_excitatory - m_params.teta_x);
	}

	delete neighbors;

	double dp = m_params.lamda * (1 - p) * heaviside(potential - m_params.teta_p) - m_params.mu * p;

	outputs.clear();
	outputs.push_back(dx);
	outputs.push_back(dy);
	outputs.push_back(dp);
}
Exemple #8
0
void legion_network::create_dynamic_connections(const legion_stimulus & stimulus) {
	for (size_t i = 0; i < size(); i++) {
		/* re-initialization by 0.0 */
		std::fill(m_dynamic_connections[i].begin(), m_dynamic_connections[i].end(), 0.0);

		std::vector<unsigned int> * neighbors = get_neighbors(i);

		if (neighbors->size() > 0 && stimulus[i] > 0) {
			int number_stimulated_neighbors = 0;

			for (std::vector<unsigned int>::iterator index_iterator = neighbors->begin(); index_iterator != neighbors->end(); index_iterator++) {
				if (stimulus[*index_iterator] > 0) {
					number_stimulated_neighbors++;
				}
			}

			if (number_stimulated_neighbors > 0) {
				double dynamic_weight = m_params.Wt / (double) number_stimulated_neighbors;

				for (std::vector<unsigned int>::iterator index_iterator = neighbors->begin(); index_iterator != neighbors->end(); index_iterator++) {
					m_dynamic_connections[i][*index_iterator] = dynamic_weight;
				}
			}
		}

		if (neighbors != NULL) {
			delete neighbors;
		}
	}
}
Exemple #9
0
// The strategy here is, though this is n^2, it's a very small n, just
// finely-spaced adjacent cells.
bool SpatialHash::isWithinDistanceOfAnything(PointType const& physPt,
                                             double distance) const
{
   // (save taking a lot of square roots)
   double d2 = distance * distance;

   Index idx = index_of(physPt);
   Cells nbrs;
   get_neighbors(idx, nbrs);
   // 27 <= we include the center cell itself, too.
   assert(nbrs.size() <= 27);
   for (Cells::const_iterator itCells = nbrs.begin(), endCells = nbrs.end();
        itCells != endCells; ++itCells) {
      Pts const* pts = *itCells;
      if (pts) {
         for (Pts::const_iterator itPts = pts->begin(), endPts = pts->end();
              itPts != endPts; ++itPts) {
            if (itPts->SquaredEuclideanDistanceTo<double>(physPt) < d2) {
               return true;
            }
         }
      }
   }
   return false;
}
Exemple #10
0
int find_path(AStar_t astar,int x,int y,int x1,int y1,kn_dlist *path){
	AStarNode *from = get_node(astar,x,y);
	AStarNode *to = get_node(astar,x1,y1);
	if(!from || !to || from == to || to->block)		
		return 0;
	minheap_insert(astar->open_list,&from->heap);	
	AStarNode *current_node = NULL;	
	while(1){	
		struct heapele *e = minheap_popmin(astar->open_list);
		if(!e){ 
			reset(astar);
			return 0;
		}		
		current_node = (AStarNode*)((int8_t*)e-sizeof(kn_dlist_node));
		if(current_node == to){ 
			while(current_node)
			{
				kn_dlist_remove((kn_dlist_node*)current_node);//可能在close_list中,需要删除
				if(current_node != from)//当前点无需加入到路径点中
					kn_dlist_push_front(path,(kn_dlist_node*)current_node);
				AStarNode *t = current_node;
				current_node = current_node->parent;
				t->parent = NULL;
				t->F = t->G = t->H = 0;
				t->heap.index = 0;
			}	
			reset(astar);
			return 1;
		}
		//current插入到close表
		kn_dlist_push(&astar->close_list,(kn_dlist_node*)current_node);
		//获取current的相邻节点
		kn_dlist *neighbors =  get_neighbors(astar,current_node);
		if(neighbors)
		{
			AStarNode *n;
			while((n = (AStarNode*)kn_dlist_pop(neighbors))){
				if(n->heap.index)//在openlist中
				{
					float new_G = current_node->G + cost_2_neighbor(current_node,n);
					if(new_G < n->G)
					{
						//经过当前neighbor路径更佳,更新路径
						n->G = new_G;
						n->F = n->G + n->H;
						n->parent = current_node;
						minheap_change(astar->open_list,&n->heap);
					}
					continue;
				}
				n->parent = current_node;
				n->G = current_node->G + cost_2_neighbor(current_node,n);
				n->H = cost_2_goal(n,to);
				n->F = n->G + n->H;
				minheap_insert(astar->open_list,&n->heap);
			}
			neighbors = NULL;
		}	
	}	
}
int IntAutos::automation_is_constant(int64_t start, int64_t end)
{
	Auto *current_auto, *before = 0, *after = 0;
	int result;

	result = 1;          // default to constant
	if(!last && !first) return result; // no automation at all

// quickly get autos just outside range	
	get_neighbors(start, end, &before, &after);

// autos before range
	if(before) 
		current_auto = before;   // try first auto
	else 
		current_auto = first;

// test autos in range	
	for( ; result && 
		current_auto && 
		current_auto->next && 
		current_auto->position < end; 
		current_auto = current_auto->next)
	{
// not constant
		if(((IntAuto*)current_auto->next)->value != ((IntAuto*)current_auto)->value) 
			result = 0;
	}

	return result;
}
Exemple #12
0
void Triangulation::calculate_boundaries()
{
    _VERBOSE("Triangulation::calculate_boundaries");

    get_neighbors();  // Ensure _neighbors has been created.

    // Create set of all boundary TriEdges, which are those which do not
    // have a neighbor triangle.
    typedef std::set<TriEdge> BoundaryEdges;
    BoundaryEdges boundary_edges;
    for (int tri = 0; tri < _ntri; ++tri) {
        if (!is_masked(tri)) {
            for (int edge = 0; edge < 3; ++edge) {
                if (get_neighbor(tri, edge) == -1) {
                    boundary_edges.insert(TriEdge(tri, edge));
                }
            }
        }
    }

    // Take any boundary edge and follow the boundary until return to start
    // point, removing edges from boundary_edges as they are used.  At the same
    // time, initialise the _tri_edge_to_boundary_map.
    while (!boundary_edges.empty()) {
        // Start of new boundary.
        BoundaryEdges::iterator it = boundary_edges.begin();
        int tri = it->tri;
        int edge = it->edge;
        _boundaries.push_back(Boundary());
        Boundary& boundary = _boundaries.back();

        while (true) {
            boundary.push_back(TriEdge(tri, edge));
            boundary_edges.erase(it);
            _tri_edge_to_boundary_map[TriEdge(tri, edge)] =
                BoundaryEdge(_boundaries.size()-1, boundary.size()-1);

            // Move to next edge of current triangle.
            edge = (edge+1) % 3;

            // Find start point index of boundary edge.
            int point = get_triangle_point(tri, edge);

            // Find next TriEdge by traversing neighbors until find one
            // without a neighbor.
            while (get_neighbor(tri, edge) != -1) {
                tri = get_neighbor(tri, edge);
                edge = get_edge_in_triangle(tri, point);
            }

            if (TriEdge(tri,edge) == boundary.front())
                break;  // Reached beginning of this boundary, so finished it.
            else
                it = boundary_edges.find(TriEdge(tri, edge));
        }
    }
}
Exemple #13
0
Pixel soft_dot(const Ink *inky, const SHORT x, const SHORT y)
{
Rgb3 rgb;
Pixel neighbors[9];

	average_colors(&rgb, neighbors, 
				get_neighbors(neighbors,x,y),
				vb.pencel->cmap);
	return(bclosest_col(&rgb,COLORS,inky->dither));
}
Exemple #14
0
/* Get all unique paths through a color mask with no cycles, starting from an end-point
 * (a dot with only one neighbor). This is accomplished by searching for all paths that
 * connect two end-points, and then computing all of its sub-paths. This uses a modified
 * depth-first search that "fast-forwards" through parts of paths with only one way to go.
 */
void build_paths(
        mask_t color_mask,      /* The color mask that paths are being found in. */
        visited_t visited,      /* Matrix of (start,end) pairs representing visited paths. */
        int start_index,        /* Where to start the path (or where it was started, after recursion). */
        int allow_shrinkers,    /* Whether to generate paths of length 1, which requires a power-up in-game. */
        int *num_moves,         /* Number of moves currently stored in moves. */
        move_list_t moves,      /* Array of moves being generated. */
        int current_index,      /* Current end position of the path. */
        int path_length,        /* Current path length. */
        path_t path             /* Array of indices representing the path. */
        ) {

    int num_neighbors, i;
    neighbors_t neighbors;

    /* Follow the path until the end or an intersection is reached, removing
     * dots as we go to avoid moving backwards.
     */
    get_neighbors(color_mask, current_index, &num_neighbors, neighbors);
    color_mask = REMOVE_FROM_MASK(color_mask, current_index);
    path[path_length++] = current_index;
    while (num_neighbors == 1) {
        current_index = neighbors[0];
        get_neighbors(color_mask, current_index, &num_neighbors, neighbors);
        color_mask = REMOVE_FROM_MASK(color_mask, current_index);
        path[path_length++] = current_index;
    }

    /* If there are no neighbors left (i.e. the end of the path has been reached),
     * then yield the resulting path if it hasn't been visited yet.
     */
    if (num_neighbors == 0) {
        if (!visited[start_index][current_index]) {
            get_subpaths(num_moves, moves, visited, allow_shrinkers, path_length, path);
        }
        return;
    }

    /* Recurse on the remaining branches of the intersection. */
    for (i = 0; i < num_neighbors; i++) {
        build_paths(color_mask, visited, start_index, allow_shrinkers, num_moves, moves, neighbors[i], path_length, path);
    }
}
Exemple #15
0
arma::Mat<double> RobotChasing::calculate_probabilities()
{
    calculate_states();
    arma::Mat<double> all_probabilities(state_to_ind.size() * m_possible_actions.size(),state_to_ind.size(), arma::fill::zeros);
    int it = 0;
    for(unsigned int i = 0; i <= m_max_x; i++)
    {
        for(unsigned int j = 0; j <= m_max_y; j++)
        {
            for(unsigned int k = 0; k <= m_max_x; k++)
            {
                for(unsigned int l = 0; l <= m_max_y; l++)
                {
                    for(unsigned int a = 0; a < m_possible_actions.size(); a++)
                    {
                        vector<double> s;
                        s.push_back(i);
                        s.push_back(j);
                        s.push_back(k);
                        s.push_back(l);


                        if(i == k && j == l)
                        {
                            int ind = state_to_ind[s];
                            all_probabilities(it, ind) += 1.0;
                        }
                        else
                        {
                            vector<vector<double> > neighbors = get_neighbors(s,a);
                            for(unsigned int n = 0; n < neighbors.size(); n++)
                            {
                                vector<double> neighbor = neighbors[n];

                                //                            for(unsigned int z = 0; z < neighbor.size(); z++)
                                //                            {
                                //                                cout << neighbor[z] << ",";
                                //                            }
                                //                            cout << endl;
                                int ind = state_to_ind[neighbor];

                                all_probabilities(it, ind) += 1.0/neighbors.size();
                            }
                        }
                        it++;
                    }
                }
            }
        }
    }
    //all_probabilities.print();
    //exit(1);
    return all_probabilities;
}
Exemple #16
0
bool is_closure(const std::set<int>& nodes,
                const std::map<int,std::set<int>>& edges) {
  for (const auto& node : nodes) {
    for (const auto& neighbor : get_neighbors(node, edges)) {
      if (nodes.count(neighbor) == 0) {
        return false;
      }
    }
  }
  return true;
}
Exemple #17
0
void print(const std::set<int>& nodes,
           const std::map<int,std::set<int>>& edges,
           std::ostream& os) {
  for (const auto& node : nodes) {
    os << "node " << node << " neighbors :";
    for (const auto& neighbor : get_neighbors(node, edges)) {
      os << " " << neighbor;
    }
    os << "\n";
  }
}
Exemple #18
0
std::map<int,std::set<int>> induce_subgraph(const std::set<int>& nodes,
                                            const std::map<int,std::set<int>>& edges) {
  std::map<int,std::set<int>> induced_edges;
  for (const auto& node : nodes) {
    for (const auto& neighbor : get_neighbors(node, edges)) {
      if (nodes.count(neighbor) > 0) {
        induced_edges[node].insert(neighbor);
      }
    }
  }
  return induced_edges;
}
Exemple #19
0
void pcnn::calculate_states(const pcnn_stimulus & stimulus) {
	std::vector<double> feeding(size(), 0.0);
	std::vector<double> linking(size(), 0.0);
	std::vector<double> outputs(size(), 0.0);

	for (unsigned int index = 0; index < size(); index++) {
		pcnn_oscillator & current_oscillator = m_oscillators[index];
		std::vector<unsigned int> neighbors;
		get_neighbors(index, neighbors);

		double feeding_influence = 0.0;
		double linking_influence = 0.0;

		for (std::vector<unsigned int>::const_iterator iter = neighbors.begin(); iter != neighbors.end(); iter++) {
			const double output_neighbor = m_oscillators[(*iter)].output;

			feeding_influence += output_neighbor * m_params.M;
			linking_influence += output_neighbor * m_params.W;
		}

		feeding_influence *= m_params.VF;
		linking_influence *= m_params.VL;

		feeding[index] = m_params.AF * current_oscillator.feeding + stimulus[index] + feeding_influence;
		linking[index] = m_params.AL * current_oscillator.linking + linking_influence;

		/* calculate internal activity */
		double internal_activity = feeding[index] * (1.0 + m_params.B * linking[index]);

		/* calculate output of the oscillator */
		if (internal_activity > current_oscillator.threshold) {
			outputs[index] = OUTPUT_ACTIVE_STATE;
		}
		else {
			outputs[index] = OUTPUT_INACTIVE_STATE;
		}
	}

	/* fast linking */
	if (m_params.FAST_LINKING) {
		fast_linking(feeding, linking, outputs);
	}

	/* update states of oscillators */
	for (unsigned int index = 0; index < size(); index++) {
		pcnn_oscillator & oscillator = m_oscillators[index];

		oscillator.feeding = feeding[index];
		oscillator.linking = linking[index];
		oscillator.output = outputs[index];
		oscillator.threshold = m_params.AT * oscillator.threshold + m_params.VT * outputs[index];
	}
}
Exemple #20
0
double sync_network::phase_kuramoto(const double t, const double teta, const std::vector<void *> & argv) const {
    unsigned int index = *(unsigned int *) argv[1];
	double phase = 0.0;

    std::vector<size_t> neighbors;
	get_neighbors(index, neighbors);

    for (std::vector<size_t>::const_iterator index_iterator = neighbors.cbegin(); index_iterator != neighbors.cend(); index_iterator++) {
		unsigned int index_neighbor = (*index_iterator);
		phase += std::sin(m_oscillators[index_neighbor].phase - teta);
	}

	phase = m_oscillators[index].frequency + (phase * weight / size());
	return phase;
}
Exemple #21
0
void LifeGame::update_cell(int cell, std::vector<bool> &from, std::vector<bool> &to) {
	int neighbors = get_neighbors(cell%size, cell / size);
	if (from[cell]) {
		if ((neighbors < 2) || (neighbors > 3))
			to[cell] = false;
		else
			to[cell] = true;
	}
	else {
		if (neighbors == 3)
			to[cell] = true;
		else
			to[cell] = false;
	}
}
Exemple #22
0
bool is_topologically_sorted(const std::set<int>& nodes,
                             const std::map<int,std::set<int>>& edges) {
  if (!is_closure(nodes, edges)) {
    std::stringstream err;
    err << __FILE__ << " " << __LINE__ << " :: " << "graph is not a closure";
    throw lbann_exception(err.str());
  }
  for (const auto& node : nodes) {
    const auto& neighbors = get_neighbors(node, edges);
    if (neighbors.size() > 0 && *neighbors.begin() <= node) {
      return false;
    }
  }
  return true;
}
Exemple #23
0
std::map<int,std::set<int>> transpose(const std::set<int>& nodes,
                                      const std::map<int,std::set<int>>& edges) {
  if (!is_closure(nodes, edges)) {
    std::stringstream err;
    err << __FILE__ << " " << __LINE__ << " :: " << "graph is not a closure";
    throw lbann_exception(err.str());
  }
  std::map<int,std::set<int>> transpose_edges;
  for (const auto& node : nodes) {
    for (const auto& neighbor : get_neighbors(node, edges)) {
      transpose_edges[neighbor].insert(node);
    }
  }
  return transpose_edges;
}
Exemple #24
0
/* Get all possible paths in a color mask without cycles. */
void get_paths(mask_t color_mask, int allow_shrinkers, int *num_moves, move_list_t moves) {
    int i, num_neighbors;
    neighbors_t neighbors;
    path_t path;
    visited_t visited = {{0}};

    /* Repeatedly call build_paths() from each end-point of the color mask */
    for (i = 0; i < NUM_DOTS; i++) {
        if (MASK_CONTAINS(color_mask, i)) {
            get_neighbors(color_mask, i, &num_neighbors, neighbors);
            if (num_neighbors <= 1) {
                build_paths(color_mask, visited, i, allow_shrinkers, num_moves, moves, i, 0, path);
            }
        }
    }
}
void register_pe (pos_desc *mypos, int pe_number)
{
    mypos->xpos = pe_number % x_size;
    mypos->ypos = pe_number / x_size;
    mypos->neighbor_count = get_neighbors(mypos->xpos, mypos->ypos);
    memset(mypos->neighbors, -1, MAX_NEIGHBORS * sizeof(int));

    if (have_north_neighbor(mypos->ypos))
        mypos->neighbors[NORTH] = pe_number - x_size;
    if (have_south_neighbor(mypos->ypos))
        mypos->neighbors[SOUTH] = pe_number + x_size;
    if (have_east_neighbor(mypos->xpos))
        mypos->neighbors[EAST] = pe_number + 1;
    if (have_west_neighbor(mypos->xpos)) 
        mypos->neighbors[WEST] = pe_number - 1;

    return;
}
Exemple #26
0
double FloatAutos::get_automation_constant(int64_t start, int64_t end)
{
	Auto *current_auto, *before = 0, *after = 0;
	
// quickly get autos just outside range	
	get_neighbors(start, end, &before, &after);

// no auto before range so use first
	if(before)
		current_auto = before;
	else
		current_auto = first;

// no autos at all so use default value
	if(!current_auto) current_auto = default_auto;

	return ((FloatAuto*)current_auto)->value;
}
Exemple #27
0
void pcnn::fast_linking(const std::vector<double> & feeding, std::vector<double> & linking, std::vector<double> & output) {
	std::vector<double> previous_outputs(output.cbegin(), output.cend());
	
	bool previous_output_change = true;
	bool current_output_change = false;
	
	while (previous_output_change) {
		for (unsigned int index = 0; index < size(); index++) {
			pcnn_oscillator & current_oscillator = m_oscillators[index];

			std::vector<unsigned int> neighbors;
			get_neighbors(index, neighbors);

			double linking_influence = 0.0;

			for (std::vector<unsigned int>::const_iterator iter = neighbors.begin(); iter != neighbors.end(); iter++) {
				linking_influence += previous_outputs[(*iter)] * m_params.W;
			}

			linking_influence *= m_params.VL;
			linking[index] = linking_influence;

			double internal_activity = feeding[index] * (1.0 + m_params.B * linking[index]);
			if (internal_activity > current_oscillator.threshold) {
				output[index] = OUTPUT_ACTIVE_STATE;
			}
			else {
				output[index] = OUTPUT_INACTIVE_STATE;
			}

			if (output[index] != previous_outputs[index]) {
				current_output_change = true;
			}
		}

		/* check for changes for avoiding useless operation copy */
		if (current_output_change) {
			std::copy(output.begin(), output.end(), previous_outputs.begin());
		}

		previous_output_change = current_output_change;
		current_output_change = false;
	}
}
Exemple #28
0
/* Find a path through a mask. Returns the length of the path stored in `path`. The length is 0 if no path was found. */
int _mask_to_path(mask_t mask, mask_t visited, int index, int edges[NUM_DOTS][NUM_DOTS], int path_length, path_t path) {
    int j, num_neighbors, nowhere_to_go;
    neighbors_t neighbors;

    /* All of the branches of this DFS share the same buffer for path, but that's okay because it
     * quits as soon as it finds a path that uses all of the dots.
     */
    path[path_length++] = index;
    visited = ADD_TO_MASK(visited, index);

    nowhere_to_go = 1;
    get_neighbors(mask, index, &num_neighbors, neighbors);
    for (j = 0; j < num_neighbors; j++) {
        int new_index = neighbors[j];

        /* Don't follow the same edge twice. */
        if (!edges[index][new_index]) {
            int final_path_length, new_edges[NUM_DOTS][NUM_DOTS];

            nowhere_to_go = 0;

            /* Make a copy of the edges and mark the edge about to be traversed. */
            memcpy(new_edges, edges, sizeof(new_edges));
            new_edges[index][new_index] = 1;
            new_edges[new_index][index] = 1;

            final_path_length= _mask_to_path(mask, visited, new_index, new_edges, path_length, path);
            if (final_path_length > 0) {
                return final_path_length;
            }
        }
    }

    /* End condition: all dots have been visited and there is nowhere left to go.
     * This works even for cycles where it might visit the same dot twice. */
    if (mask == visited && nowhere_to_go) {
        return path_length;
    }

    /* No path was found. */
    return 0;
}
Exemple #29
0
bool is_cyclic(const std::set<int>& nodes,
               const std::map<int,std::set<int>>& edges) {

  // Check that graph is valid
  if (!is_closure(nodes, edges)) {
    std::stringstream err;
    err << __FILE__ << " " << __LINE__ << " :: " << "graph is not a closure";
    throw lbann_exception(err.str());
  }

  // Topologically sorted graphs are not cyclic
  if (is_topologically_sorted(nodes, edges)) {
    return false;
  }

  // Perform depth-first searches to detect cycles
  std::unordered_map<int,bool> is_visited, is_sorted;
  std::stack<int> search_stack;
  for (auto&& it = nodes.rbegin(); it != nodes.rend(); ++it) {
    search_stack.push(*it);
  }
  while (!search_stack.empty()) {
    const auto& node = search_stack.top();
    search_stack.pop();
    if (!is_sorted[node]) {
      if (is_visited[node]) {
        is_sorted[node] = true;
      } else {
        is_visited[node] = true;
        search_stack.push(node);
        for (const auto& neighbor : get_neighbors(node, edges)) {
          if (is_visited[neighbor] && !is_sorted[neighbor]) {
            return true;
          }
          search_stack.push(neighbor);
        }
      }
    }
  }
  return false;
  
}
Exemple #30
0
SCM get_living_neighbors (SCM board_smob, SCM cell_smob) {
	SCM list; struct cell *cell;
	int i;
	int count;

	scm_assert_smob_type(board_tag, board_smob);
	scm_assert_smob_type(cell_tag, cell_smob);

	list = get_neighbors(board_smob, cell_smob);

	count = 0;
	for (i = 0; i < scm_to_int(scm_length(list)); i++) {
		cell = (struct cell *) SCM_SMOB_DATA(scm_list_ref(list, scm_from_int(i)));
		if (cell->status > 0) {
			count++;
		}
	}

	return scm_from_int(count);
}