Exemple #1
0
EXPORT void set_node_doubly_linked_list(
	INTERFACE	*intfc)
{
	NODE		**n;

	n = intfc->nodes;
	first_node(intfc) = *n;
	prev_node(*n) = NULL;
	for (; *(n+1); ++n) 
	{
	    next_node(*n) = *(n+1);
	    prev_node(*(n+1)) = (*n);
	}
	last_node(intfc) = *n;
	next_node(*n) = NULL;
}		/*end set_node_doubly_linked_list*/
SparseNode crm114__list_search(unsigned int c, SparseNode init, SparseElementList *l)
{
  SparseNode curr = init;

  if (!l) {
    if (CRM114__MATR_DEBUG_MODE) {
      fprintf(stderr, "crm114__list_search: null list.\n");
    }
    return make_null_node(l->compact);
  }

  if (crm114__list_is_empty(l)) {
    return make_null_node(l->compact);
  }

  if (c <= node_col(l->head)) {
    return l->head;
  }

  if (c >= node_col(l->tail)) {
    return l->tail;
  }

  while (!null_node(curr) && node_col(curr) < c) {
    curr = next_node(curr);
  }

  while (!null_node(curr) && node_col(curr) > c) {
    curr = prev_node(curr);
  }

  return curr;
}
Exemple #3
0
EXPORT	void print_linked_node_list(
	INTERFACE	*intfc)
{
	NODE		**n, *m;
	int		i, node_count;

	n = intfc->nodes;
	if (! n)
	{
	    (void) printf("NULL node list on intfc\n");
	    return;
	}

	(void) printf("\tnode list - intfc %llu\n",(long long unsigned int)interface_number(intfc));
	for (node_count = 0;  n && *n;  ++n, ++node_count)
		;

	m = first_node(intfc);
	for (i = 0;  i <= node_count + 2;  ++i) 
	{
	    if (m != NULL)
	    {
	    	(void) printf("prev %llu  m %llu  next %llu  ",
	    		      (long long unsigned int)node_number(prev_node(m)),
			      (long long unsigned int)node_number(m),
	    		      (long long unsigned int)node_number(next_node(m)));
	    	print_propagation_status(m);
	    }
	    else
	    	break;
	    m = next_node(m);
	}
}		/*end print_linked_node_list*/
Exemple #4
0
ScmDictEntry *Scm_TreeIterPrev(ScmTreeIter *iter)
{
    if (iter->at_end) return NULL;
    if (iter->e) {
        iter->e = (ScmDictEntry*)prev_node((Node*)iter->e);
    } else {
        iter->e = Scm_TreeCoreGetBound(iter->t, SCM_TREE_CORE_MAX);
    }
    if (iter->e == NULL) iter->at_end = TRUE;
    return iter->e;
}
void crm114__list_remove_elt(SparseElementList *l, SparseNode toremove) {

  if (!l) {
    if (CRM114__MATR_DEBUG_MODE) {
      fprintf(stderr, "crm114__list_remove_elt: null list.\n");
    }
    return;
  }

  if (null_node(toremove)) {
    return;
  }

  if (!null_node(prev_node(toremove))) {
    if (l->compact) {
      toremove.compact->prev->next = toremove.compact->next;
    } else {
      toremove.precise->prev->next = toremove.precise->next;
    }
  } else {
    if (l->compact) {
      l->head.compact = toremove.compact->next;
    } else {
      l->head.precise = toremove.precise->next;
    }
  }
  if (!null_node(next_node(toremove))) {
    if (l->compact) {
      toremove.compact->next->prev = toremove.compact->prev;
    } else {
      toremove.precise->next->prev = toremove.precise->prev;
    }
  } else {
    if (l->compact) {
      l->tail.compact = toremove.compact->prev;
    } else {
      l->tail.precise = toremove.precise->prev;
    }
  }

  if (l->compact) {
    if (!(l->last_addr) || (void *)toremove.compact < (void *)l ||
	(void *)toremove.compact >= l->last_addr) {
      node_free(toremove);
    }
  } else {
    if (!(l->last_addr) || (void *)toremove.precise < (void *)l ||
	(void *)toremove.precise >= l->last_addr) {
      node_free(toremove);
    }
  }
}
Exemple #6
0
static Node *delete_node(ScmTreeCore *tc, Node *n)
{
    while (n->left && n->right) {
        /* N has both children.  We swap N and its previous node.
           It would be easier just to swap key and value, but it could
           lead to a hard-to-track bug if a pointer to N is retained
           in somewhere (e.g. iterator).  So we actually swap the node. */
        swap_node(tc, n, prev_node(n));
    }

    /* we have at most one child */
    if (n->left) {
        delete_node1(tc, n, n->left);
    } else {
        delete_node1(tc, n, n->right);  /* this covers no child case */
    }
    clear_node(n);
    return n;
}
Exemple #7
0
static int
handle_input(int ch)
{
    switch (ch) 
    {
		case 'q':
			quit_mode = quit_mode ? 0 : 1;
			return 1;

		case 0x1b:
			quit_mode = 0;
			print_help = 0;
			return 1;

		case 'y':
			if (quit_mode)
				exit(0);
			break;

		case 'n':
			if (quit_mode) {
				quit_mode = 0;
				return 1;
			}
			break;

		case 'f':
			fold();
			return 1;

		case 12:
		case KEY_CLEAR:
#ifdef HAVE_REDRAWWIN
			redrawwin(stdscr);
#endif
			clear();
			return 1;

		case 'c':
			c_combined_node_list = c_combined_node_list ? 0 : 1;
			return 1;

        case 'S':
            clear();
			set_x_unit("s", 1);
            return 1;

        case 'M':
            clear();
			set_x_unit("m", 1);
            return 1;

        case 'H':
            clear();
			set_x_unit("h", 1);
            return 1;

		case 'D':
			clear();
			set_x_unit("d", 1);
			return 1;

		case 'R':
			clear();
			set_x_unit("r", 1);
			return 1;

        case '?':
            clear();
			print_help = print_help ? 0 : 1;
			return 1;

        case 'g':
			c_graphical_in_list = c_graphical_in_list ? 0 : 1;
			return 1;

		case 'd':
			c_detailed_in_list = c_detailed_in_list ? 0 : 1;
			return 1;

		case 'l':
			c_list_in_list = c_list_in_list ? 0 : 1;
			return 1;

		case KEY_LEFT:
			prev_node();
			return 1;

		case KEY_RIGHT:
			next_node();
			return 1;

		case KEY_DOWN:
			if (next_intf() == END_OF_LIST) {
				if (next_node() != END_OF_LIST)
					first_intf();
			}
			return 1;

		case KEY_UP:
			if (prev_intf() == END_OF_LIST) {
				if (prev_node() != END_OF_LIST)
					last_intf();
			}
			return 1;
		default:
			if (get_current_intf())
				if (handle_bindings(ch, get_current_intf()->i_name))
					return 1;
			break;
    }

    return 0;
}
Exemple #8
0
/* accessor */
Node *core_ref(ScmTreeCore *tc, intptr_t key, enum TreeOp op,
               Node **lo, Node **hi)
{
    Node *e = ROOT(tc), *n = NULL;

    if (e == NULL) {
        /* Tree is empty */
        if (op == TREE_CREATE) {
            n = new_node(NULL, key);
            PAINT(n, BLACK);
            SET_ROOT(tc, n);
            tc->num_entries++;
        }
        if (op == TREE_NEAR) {
            *lo = *hi = NULL;
        }
        return n;
    }

    for (;;) {
        int r = 0;
        if (tc->cmp) r = tc->cmp(tc, e->key, key);

        if (tc->cmp? (r == 0) : (e->key == key)) {
            /* Exact match */
            if (op == TREE_DELETE) {
                n = delete_node(tc, e);
                tc->num_entries--;
                return n;
            }
            if (op == TREE_NEAR) {
                *lo = prev_node(e);
                *hi = next_node(e);
            }
            return e;
        }

        if (tc->cmp? (r < 0) : (e->key < key)) {
            /* Key is larger than E */
            if (e->right) {
                e = e->right;
            } else {
                if (op == TREE_CREATE) {
                    n = new_node(e, key);
                    e->right = n;
                    balance_tree(tc, n);
                    tc->num_entries++;
                    return n;
                }
                if (op == TREE_NEAR) {
                    *lo = e;
                    *hi = next_node(e);
                }
                return NULL;
            }
        } else {
            /* Key is smaller than E */
            if (e->left) {
                e = e->left;
            } else {
                if (op == TREE_CREATE) {
                    n = new_node(e, key);
                    e->left = n;
                    balance_tree(tc, n);
                    tc->num_entries++;
                    return n;
                }
                if (op == TREE_NEAR) {
                    *hi = e;
                    *lo = prev_node(e);
                }
                return NULL;
            }
        }
    }
}
Exemple #9
0
std::vector<double> Graph::dijkstra(int source)
{
	// stores the distance from source to each node
	std::vector<double> distances(adjList.size());

	// stores which nodes have been looked at
	std::vector<bool> visited_nodes(adjList.size());

	// stores the pervious node of each node in the optimal path
	std::vector<int> prev_node(adjList.size());

	// the compare function for the priority queue, the nodes are
	// added to the queue along with there distance from the source
	// and should be sorted by that distance
	auto compare = [&] (std::pair<int, double> &n1,
			    std::pair<int, double> &n2) {
		if (n1.second == -1) {
			return false;
		}

		if (n2.second == -1) {
			return true;
		}
		
		return n1.second < n2.second;
	};

	std::vector< std::pair<int, double> > node_queue(adjList.size());

	// initialize distance to every node to infitity (-1 in this case
	// since negative edge lengths arent used in this graph.  add add every
	// node to the queue of nodes
	for (unsigned int i = 0; i < adjList.size(); i++) {
		// the distance to the source item should be 0
		if (i == source) {
			distances[i] = 0;
		} else {
			distances[i] = -1;
			prev_node[i] = -1;
		}
		
		node_queue[i] = (std::make_pair(i, distances[i]));
		visited_nodes[i] = false;
	}

	// std::priority_queue does not have the ability to decrease the priority
	// of an item, so we will use a simple array for this and just make it a heap
	std::sort(node_queue.begin(), node_queue.end(), compare);

	while (node_queue.size() != 0) {
		// get the item in node_queue with the smallest distance

		std::pair<int, double> node_pair = node_queue.front();
		node_queue.erase(node_queue.begin());
		int node1 = node_pair.first;
		double dist = node_pair.second;

		// mark this node as visited
		visited_nodes[node1] = true;

		// loop through every neighbor of this node
		for (auto &edge : neighbors(node1)) {
			int node2 = edge.dest;
			
			// only look at this neighbor if it hasnt been looked at yet
			if (visited_nodes[node2] == false) {
				double temp_dist = distances[node1] + edge.cost;

				// if this distance is smaller than our current best guess, update it
				if (temp_dist < distances[node2] || distances[node2] < 0) {
					distances[node2] = temp_dist;
					prev_node[node2] = node1;

					auto it = std::find_if(node_queue.begin(),
							       node_queue.end(),
							       [&] (const std::pair<int, double> &n) {
								       return n.first == node2;
							       });

					// update the priority for this node, this check of < 0 must
					// be done because -1 is used to represent a priority of infinity
					if (it->second < 0) {
						it->second = temp_dist;
					} else {
						it->second -= temp_dist;
					}

					// make sure the node_queue vector continues to act like a queue
					std::sort(node_queue.begin(), node_queue.end(), compare);
				}
			}
		}
	}
	
	return distances;
}
	Self &operator--(int)
	{
		Self tmp = *this;
		node = const_cast<TreeNode *>(prev_node(node));
		return tmp;
	}
	Self &operator--()
	{
		node = const_cast<TreeNode *>(prev_node(node));
		return *this;
	}
	Self operator--(int)
	{
		Self tmp = *this;
		node = prev_node(node);
		return tmp;
	}
	Self &operator--()
	{
		node = prev_node(node);
		return *this;
	}
Exemple #14
0
EXPORT NODE *reorder_node_loop(
	NODE *oldn,
	NODE *newn)
{
	INTERFACE *intfc;
	NODE	  *next, *prev;
	NODE      *next_old_node;
	
	if (oldn != NULL)
	{
	    intfc = oldn->interface;
	    next = next_node(oldn);
	    if (next == NULL) 
	    {
	        screen("ERROR in reorder_node_loop(), "
		       "next_node(oldn) == NULL\n");
	        print_node(oldn);
		(void) printf("Old interface information\n");
	        print_linked_node_list(intfc);
	        print_interface(intfc);
		if (newn != NULL)
		{
	            intfc = newn->interface;
		    (void) printf("New interface information\n");
	            print_linked_node_list(intfc);
	            print_interface(intfc);
		}
	        clean_up(ERROR);
	    }
	    prev = prev_node(oldn);
	    prev_node(next) = prev;
	    if (prev != NULL)
	        next_node(prev) = next;
	    else
	        first_node(intfc) = next;
	    next_node(last_node(intfc)) = oldn;
	    next_node(oldn) = NULL;
	    prev_node(oldn) = last_node(intfc);
	    last_node(intfc) = oldn;
	    next_old_node = next;
	}
	else
	    next_old_node = NULL;

	if (newn != NULL)
	{
	    intfc = newn->interface;
	    next = next_node(newn);
	    if (next == NULL) 
	    {
	        screen("ERROR in reorder_node_loop(), "
		       "next_node(newn) == NULL\n");
	        print_node(newn);
		if (oldn != NULL)
		{
		    (void) printf("Old interface information\n");
	            print_linked_node_list(intfc);
	            print_interface(intfc);
		}
	        intfc = newn->interface;
		(void) printf("New interface information\n");
	        print_linked_node_list(intfc);
	        print_interface(intfc);
	        clean_up(ERROR);
	    }
	    prev = prev_node(newn);
	    prev_node(next) = prev;
	    if (prev != NULL)
	        next_node(prev) = next;
	    else
	        first_node(intfc) = next;
	    next_node(last_node(intfc)) = newn;
	    next_node(newn) = NULL;
	    prev_node(newn) = last_node(intfc);
	    last_node(intfc) = newn;
	}
	return next_old_node;
}		/*end reorder_node_loop*/
Exemple #15
0
static int handle_input(int ch)
{
	switch (ch) 
	{
		case 'q':
			quit_mode = quit_mode ? 0 : 1;
			return 1;

		case 0x1b:
			quit_mode = 0;
			print_help = 0;
			return 1;

		case 'y':
			if (quit_mode)
				exit(0);
			break;

		case 'a':
			next_attr();
			return 1;

		case 'n':
			if (quit_mode)
				quit_mode = 0;
			else
				new_graph();
			return 1;

		case 'x':
			del_graph();
			return 1;

		case 'f':
			fold();
			return 1;

		case 12:
		case KEY_CLEAR:
#ifdef HAVE_REDRAWWIN
			redrawwin(stdscr);
#endif
			clear();
			return 1;

		case 'c':
			c_combined_node_list = c_combined_node_list ? 0 : 1;
			return 1;

		case 'S':
			clear();
			set_graph_unit(X_SEC);
			return 1;

		case 'M':
			clear();
			set_graph_unit(X_MIN);
			return 1;

		case 'H':
			clear();
			set_graph_unit(X_HOUR);
			return 1;

		case 'D':
			clear();
			set_graph_unit(X_DAY);
			return 1;

		case 'R':
			clear();
			set_graph_unit(X_READ);
			return 1;

			case '?':
			clear();
			print_help = print_help ? 0 : 1;
			return 1;

		case 'g':
			c_graphical_in_list = c_graphical_in_list ? 0 : 1;
			return 1;

		case 'd':
			c_detailed_in_list = c_detailed_in_list ? 0 : 1;
			return 1;

		case 'l':
			c_list_in_list = c_list_in_list ? 0 : 1;
			return 1;

		case KEY_PPAGE:
			if (print_help)
				help_page = help_page ? 0 : 1;
			else
				prev_node();
			return 1;

		case KEY_NPAGE:
			if (print_help)
				help_page = help_page ? 0 : 1;
			else
				next_node();
			return 1;

		case KEY_DOWN:
			if (next_item() == END_OF_LIST) {
				if (next_node() != END_OF_LIST)
					first_item();
			}
			return 1;

		case KEY_UP:
			if (prev_item() == END_OF_LIST) {
				if (prev_node() != END_OF_LIST)
					last_item();
			}
			return 1;

		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
			goto_item(ch - 48);
			return 1;

		case '>':
			next_graph();
			return 1;

		case '<':
			prev_graph();
			return 1;
			
		default:
			if (get_current_item())
				if (handle_bindings(ch, get_current_item()->i_name))
					return 1;
			break;
	}

	return 0;
}