Пример #1
0
 public function testIsAcyclicTrue()
 {
     $graph = new Structures_Graph();
     $node1 = new Structures_Graph_Node();
     $graph->addNode($node1);
     $node2 = new Structures_Graph_Node();
     $graph->addNode($node2);
     $node1->connectTo($node2);
     $node3 = new Structures_Graph_Node();
     $graph->addNode($node3);
     $node2->connectTo($node3);
     $this->assertTrue(Structures_Graph_Manipulator_AcyclicTest::isAcyclic($graph), 'Graph is acyclic');
 }
 public function testSort()
 {
     $graph = new Structures_Graph();
     $name1 = 'node1';
     $node1 = new Structures_Graph_Node();
     $node1->setData($name1);
     $graph->addNode($node1);
     $name11 = 'node11';
     $node11 = new Structures_Graph_Node();
     $node11->setData($name11);
     $graph->addNode($node11);
     $node1->connectTo($node11);
     $name12 = 'node12';
     $node12 = new Structures_Graph_Node();
     $node12->setData($name12);
     $graph->addNode($node12);
     $node1->connectTo($node12);
     $name121 = 'node121';
     $node121 = new Structures_Graph_Node();
     $node121->setData($name121);
     $graph->addNode($node121);
     $node12->connectTo($node121);
     $name2 = 'node2';
     $node2 = new Structures_Graph_Node();
     $node2->setData($name2);
     $graph->addNode($node2);
     $name21 = 'node21';
     $node21 = new Structures_Graph_Node();
     $node21->setData($name21);
     $graph->addNode($node21);
     $node2->connectTo($node21);
     $nodes = Structures_Graph_Manipulator_TopologicalSorter::sort($graph);
     $this->assertCount(2, $nodes[0]);
     $this->assertEquals('node1', $nodes[0][0]->getData());
     $this->assertEquals('node2', $nodes[0][1]->getData());
     $this->assertCount(3, $nodes[1]);
     $this->assertEquals('node11', $nodes[1][0]->getData());
     $this->assertEquals('node12', $nodes[1][1]->getData());
     $this->assertEquals('node21', $nodes[1][2]->getData());
     $this->assertCount(1, $nodes[2]);
     $this->assertEquals('node121', $nodes[2][0]->getData());
 }
Пример #3
0
 /**
  * Sort a list of arrays of array(downloaded packagefilename) by dependency.
  *
  * This uses the topological sort method from graph theory, and the
  * Structures_Graph package to properly sort dependencies for installation.
  * @param array an array of downloaded PEAR_Downloader_Packages
  * @return array array of array(packagefilename, package.xml contents)
  */
 function sortPackagesForInstall(&$packages)
 {
     require_once 'Structures/Graph.php';
     require_once 'Structures/Graph/Node.php';
     require_once 'Structures/Graph/Manipulator/TopologicalSorter.php';
     $depgraph = new Structures_Graph(true);
     $nodes = array();
     $reg =& $this->config->getRegistry();
     foreach ($packages as $i => $package) {
         $pname = $reg->parsedPackageNameToString(array('channel' => $package->getChannel(), 'package' => strtolower($package->getPackage())));
         $nodes[$pname] = new Structures_Graph_Node();
         $nodes[$pname]->setData($packages[$i]);
         $depgraph->addNode($nodes[$pname]);
     }
     $deplinks = array();
     foreach ($nodes as $package => $node) {
         $pf =& $node->getData();
         $pdeps = $pf->getDeps(true);
         if (!$pdeps) {
             continue;
         }
         if ($pf->getPackagexmlVersion() == '1.0') {
             foreach ($pdeps as $dep) {
                 if ($dep['type'] != 'pkg' || isset($dep['optional']) && $dep['optional'] == 'yes') {
                     continue;
                 }
                 $dname = $reg->parsedPackageNameToString(array('channel' => 'pear.php.net', 'package' => strtolower($dep['name'])));
                 if (isset($nodes[$dname])) {
                     if (!isset($deplinks[$dname])) {
                         $deplinks[$dname] = array();
                     }
                     $deplinks[$dname][$package] = 1;
                     // dependency is in installed packages
                     continue;
                 }
                 $dname = $reg->parsedPackageNameToString(array('channel' => 'pecl.php.net', 'package' => strtolower($dep['name'])));
                 if (isset($nodes[$dname])) {
                     if (!isset($deplinks[$dname])) {
                         $deplinks[$dname] = array();
                     }
                     $deplinks[$dname][$package] = 1;
                     // dependency is in installed packages
                     continue;
                 }
             }
         } else {
             // the only ordering we care about is:
             // 1) subpackages must be installed before packages that depend on them
             // 2) required deps must be installed before packages that depend on them
             if (isset($pdeps['required']['subpackage'])) {
                 $t = $pdeps['required']['subpackage'];
                 if (!isset($t[0])) {
                     $t = array($t);
                 }
                 $this->_setupGraph($t, $reg, $deplinks, $nodes, $package);
             }
             if (isset($pdeps['group'])) {
                 if (!isset($pdeps['group'][0])) {
                     $pdeps['group'] = array($pdeps['group']);
                 }
                 foreach ($pdeps['group'] as $group) {
                     if (isset($group['subpackage'])) {
                         $t = $group['subpackage'];
                         if (!isset($t[0])) {
                             $t = array($t);
                         }
                         $this->_setupGraph($t, $reg, $deplinks, $nodes, $package);
                     }
                 }
             }
             if (isset($pdeps['optional']['subpackage'])) {
                 $t = $pdeps['optional']['subpackage'];
                 if (!isset($t[0])) {
                     $t = array($t);
                 }
                 $this->_setupGraph($t, $reg, $deplinks, $nodes, $package);
             }
             if (isset($pdeps['required']['package'])) {
                 $t = $pdeps['required']['package'];
                 if (!isset($t[0])) {
                     $t = array($t);
                 }
                 $this->_setupGraph($t, $reg, $deplinks, $nodes, $package);
             }
             if (isset($pdeps['group'])) {
                 if (!isset($pdeps['group'][0])) {
                     $pdeps['group'] = array($pdeps['group']);
                 }
                 foreach ($pdeps['group'] as $group) {
                     if (isset($group['package'])) {
                         $t = $group['package'];
                         if (!isset($t[0])) {
                             $t = array($t);
                         }
                         $this->_setupGraph($t, $reg, $deplinks, $nodes, $package);
                     }
                 }
             }
         }
     }
     $this->_detectDepCycle($deplinks);
     foreach ($deplinks as $dependent => $parents) {
         foreach ($parents as $parent => $unused) {
             $nodes[$dependent]->connectTo($nodes[$parent]);
         }
     }
     $installOrder = Structures_Graph_Manipulator_TopologicalSorter::sort($depgraph);
     $ret = array();
     for ($i = 0, $count = count($installOrder); $i < $count; $i++) {
         foreach ($installOrder[$i] as $index => $sortedpackage) {
             $data =& $installOrder[$i][$index]->getData();
             $ret[] =& $nodes[$reg->parsedPackageNameToString(array('channel' => $data->getChannel(), 'package' => strtolower($data->getPackage())))]->getData();
         }
     }
     $packages = $ret;
     return;
 }
Пример #4
0
<?php

require_once 'Structures/Graph.php';
require_once 'Structures/Graph/Node.php';
$nonDirectedGraph = new Structures_Graph(false);
$nodes_names = array('a', 'b', 'c', 'd', 'e');
$nodes = array();
foreach ($nodes_names as $node) {
    /* Create a new node / vertex */
    $nodes[$node] = new Structures_Graph_Node();
    /* Add the node to the Graph structure */
    $nonDirectedGraph->addNode($nodes[$node]);
}
/**
 * Specify connections between different nodes.
 * For example in the following array, 'a-b'
 * specifies that node 'a' is connected to node 'b'.
 * Also refer to the figure above.
 */
$vertices = array('a-b', 'b-c', 'b-d', 'd-c', 'c-e', 'e-d');
foreach ($vertices as $vertex) {
    $data = preg_split("/-/", $vertex);
    $nodes[$data[0]]->connectTo($nodes[$data[1]]);
}
$test1 = array('a', 'b');
$test2 = array('c', 'd');
$test3 = array_merge($test1, $test2);
print_r($test3);
echo $nodes['b']->inDegree();
// returns 3
echo $nodes['b']->outDegree();
Пример #5
0
<?php

require_once 'Structures/Graph.php';
require_once 'Structures/Graph/Node.php';
$nonDirectedGraph = new Structures_Graph(true);
$nodes_names = array('a', 'b', 'c', 'd', 'e');
$nodes = array();
foreach ($nodes_names as $node) {
    /* Create a new node / vertex */
    $nodes[$node] = new Structures_Graph_Node();
    /* Add the node to the Graph structure */
    $nonDirectedGraph->addNode($nodes[$node]);
}
/**
 * Specify connections between different nodes.
 * For example in the following array, 'a-b'
 * specifies that node 'a' is connected to node 'b'.
 * Also refer to the figure above.
 */
$vertices = array('a-b', 'b-c', 'b-d', 'd-c', 'c-e', 'e-d');
foreach ($vertices as $vertex) {
    $data = preg_split("/-/", $vertex);
    $nodes[$data[0]]->connectTo($nodes[$data[1]]);
}
//sets the value of each node to the corresponding value, for example $nodes['a']->setData("a") so that we could know the neighbor
foreach ($nodes_names as $n) {
    $nodes[$n]->setData($n);
}
/* Get a list of all the nodes in our graph */
$array_nodes = $nonDirectedGraph->getNodes();
/* This is where will save the adj. matrix */
Пример #6
0
 /**
  * Retorna un grafo representando un conjunto de tablas y sus relaciones
  * @return Structures_Graph
  */
 static function grafo_relaciones($tablas, $relaciones)
 {
     $grafo = new Structures_Graph(true);
     // Se construyen los nodos
     $obj = array();
     $nodo = null;
     foreach ($tablas as $tabla) {
         unset($nodo);
         $nodo = new Structures_Graph_Node();
         $proveedor = isset($tabla['objeto_proveedor']) ? $tabla['objeto_proveedor'] : $tabla['objeto'];
         $obj[$proveedor] = $nodo;
         $nodo->setData($tabla);
         $grafo->addNode($obj[$proveedor]);
     }
     //Se agregan los arcos
     foreach ($relaciones as $asoc) {
         $padre = $asoc['padre_objeto'];
         $hijo = $asoc['hijo_objeto'];
         $obj[$padre]->connectTo($obj[$hijo]);
     }
     return $grafo;
 }
Пример #7
0
 function get_grafo()
 {
     $grafo = new Structures_Graph(true);
     $perfiles = toba_info_permisos::get_perfiles_funcionales($this->s__filtro['proyecto']);
     //Nodos
     $miembros = array();
     foreach ($perfiles as $perfil) {
         $nodo = new Structures_Graph_Node();
         $nodo->setData($perfil);
         $nodos[$perfil['usuario_grupo_acc']] =& $nodo;
         $grafo->addNode($nodo);
         unset($nodo);
         //Anulo el nodo, de otra manera sobre escribe todos con los valores del ultimo setData (weird)
     }
     //Relaciones
     foreach ($perfiles as $perfil) {
         //Necesita pasarle la conexion porque aun no termino la transacción
         $miembros = toba_info_permisos::get_perfiles_funcionales_miembros($perfil['proyecto'], $perfil['usuario_grupo_acc'], toba::db());
         foreach ($miembros as $miembro) {
             $nodos[$perfil['usuario_grupo_acc']]->connectTo($nodos[$miembro['usuario_grupo_acc_pertenece']]);
         }
     }
     return $grafo;
 }
Пример #8
0
$start = microtime(true);
for ($target = 1; $target < 10; $target++) {
    //Select query running and displaying using while loop in bootstrapped table
    $sql = "SELECT iduser, idtrusted FROM trust WHERE iduser = {$target}";
    $result = $conn->query($sql);
    $verti = array();
    $iduser = array();
    $idtrusted = array();
    while ($row = $result->fetch_assoc()) {
        $verti[] = $row["iduser"] . '-' . $row["idtrusted"];
        $iduser[] = $row["iduser"];
        $idtrusted[] = $row["idtrusted"];
    }
    $merged = array_merge($iduser, $idtrusted);
    $nodes_names = array_unique($merged);
    $nonDirectedGraphTest = new Structures_Graph(true);
    foreach ($nodes_names as $node) {
        /* Create a new node / vertex */
        $nodes[$node] = new Structures_Graph_Node();
        /* Add the node to the Graph structure */
        $nonDirectedGraphTest->addNode($nodes[$node]);
    }
    foreach ($verti as $vertex) {
        $data = preg_split("/-/", $vertex);
        $nodes[$data[0]]->connectTo($nodes[$data[1]]);
    }
    //sets the value of each node to the corresponding value, for example $nodes['a']->setData("a") so that we could know the neighbor
    foreach ($nodes_names as $n) {
        $nodes[$n]->setData($n);
    }
    $trustedBy = $nodes[$target]->outDegree();