Pruchod graf Perl – Regulární výrazy – Fórum – Programujte.com

Potreboval bych poradit 

Potrebuji posilat signal z aktivnich uzlu -> hodnota vetsi jak >0 pro nekolik iteraci

Uzly mam A1, A2, I1, I2, T, R1, R2 atd....

napr.

                        A1      A2       I1      I2     R1     R2      T

0. iterace         1         0         0       0      0        0        0

= > posilat signal budu pouze s A1 ->  (> 0)

hodnotu signalu vypocitam = (1 * hodnota A1 / pocet vystupnich hran ^ 0.5) * 0,8

= > 1. iterace  sousedni hrany A1 jsou I1 I2 = 2 vystupni hrany             hodnota signalu je 0,56

                      A1        A2       I1      I2     R1      R2     T

1. iterace        1           0       0,56   0,56  0        0       0 

I1 ma sousedy R1 T ale take zpet A1 

I2 ma sousedy R2 T ale take zpet  A1    

     hodnota je 0,26

                     A1         A2     I1      I2      R1       R2    T

2. iterace      1, 52     0       1,13   1,13  0,26    0,26  0,52

Prosim o radu jak to nejak z automatizovat uzly a hrany mam ulozene ve strukturach. Dekuji za kazdou radu.

#use warnings;
use utf8;
use open qw( :encoding(UTF-8) :std );
use Data::Dumper;

$, = "\t";

@nodes_types = ();
%link_types = ();
%nodes = ();
@links = ();
%initial_activation = ();
%link_weights = ();
%alg_parameters = ();
                    ################### 1. NACIST DATA ################### 
open(INPUT, "<:encoding(UTF-8)", "sitparametry.txt") || die "nelze otevrit vstupni soubor!";
while (<INPUT>){
    chomp;
    my @radky = split(/\s+/);
    if (@radky) {
        if($radky[0] eq "nt"){
            my $type = $radky[1];
            push(@nodes_types,$type);
        }
        
        elsif($radky[0] eq "ltra"){
            my $type_name = $radky[1];
            my $type_of_reciprocal_link = $radky[2];
            $link_types{$type_name} = $type_of_reciprocal_link;    #link_types ( type name, type of reciprocal link )
        }
        
        elsif($radky[0] eq "n"){
            my $nodeId = $radky[1];
            my $nodeType = $radky[2];
            $nodes{$nodeId} = $nodeType;        #nodes (NodeID, NodeType)    
        }
        
        elsif($radky[0] eq "l"){
            my $initial_node = $radky[1];
            my $terminal_node = $radky[2];
            my $link_type = $radky[3];
            @vektor_link = ($initial_node, $terminal_node, $link_type);
            push(@links,[@vektor_link]);    #links (initial node, terminal node, link             type
        }
        
        elsif($radky[0] eq "ia"){
            my $nodeId = $radky[1];
            my $activation_level = $radky[2];
            $initial_activation{$nodeId} = $activation_level;        #initial activation (NodeID, Activation Level)
        }
        
        elsif($radky[0] eq "lw"){
            my $link_type = $radky[1];
            my $weight = $radky[2];
            $link_weights{$link_type} = $weight;        #link weights (link_type, weight)
        }
        
        elsif($radky[0] eq "Beta"){
            my $value = $radky[1];
            $alg_parameters{"Beta"} = $value;    #Beta value
        }
        
        elsif($radky[0] eq "IterationsNo"){
            my $value = $radky[1];        
            $alg_parameters{"IterationsNo"} = $value;                    #Iteration's value
        }
        
        elsif($radky[0] eq "Calibration"){
            my $value = $radky[1];
            $alg_parameters{"Calibration"} = $value;                    #Calibration's value
        }
        
        elsif($radky[0] eq "a"){
            my $value = $radky[1];
            $alg_parameters{"a"} = $value;
        }
        
        elsif($radky[0] eq "b"){
            my $value = $radky[1];
            $alg_parameters{"b"} = $value;                # b value
        }
        
        elsif($radky[0] eq "c"){
            my $value = $radky[1];
            $alg_parameters{"c"} = $value;                # c value
        }
        
        elsif($radky[0] eq "t"){
            my $value = $radky[1];
            $alg_parameters{"t"} = $value;                # t value
        }    
    }

}
close(INPUT);

#seznam uzlu
%list_nodes = ();
#seznam hran
@list_links = ();

foreach my $id (keys %nodes){
    my $type = $nodes{$id};
    my $value = $initial_activation{$id};
    if (!defined $value){
        $value = 0;
    }
$list_nodes{$id} = {"type",$type,"value",$value};
}
print Dumper %list_nodes;
#print Dumper %list_nodes;
#print Dumper $list_nodes{"A1"}{"value"};
#print Dumper $list_nodes{"A2"}{"value"};
#print Dumper $list_nodes{"T"}{"value"};
foreach my $i (0..$#links){
    my $initial_node = $links[$i][0];
    my $terminal_node = $links[$i][1];
    my $link_type = $links[$i][2];
    my $link_weights = $link_weights{$link_type};
    my $type_of_reciprocal_link = $link_types{$link_type};
    my %link = ("initial_node", $initial_node, "terminal_node", $terminal_node, "link_type", $link_type, "link_weights", $link_weights);
    push(@list_links, \%link);
    my $link_weights = $link_weights{$type_of_reciprocal_link};
    my %link = ("initial_node", $terminal_node, "terminal_node", $initial_node, "link_type", $type_of_reciprocal_link, "link_weights", $link_weights);
    push(@list_links, \%link);
}

print Dumper(@list_links);
print Dumper ($list_links[0]{"initial_node"});
                                            ################### OK NACTENA DATA OK ###################                     
                                    ################### OK VYTVORIT VHODNOU STRUKTURU OK ################### 
$type_calibration = $alg_parameters{"Calibration"};
$a = $alg_parameters{"a"};
$b = $alg_parameters{"b"};
$c = $alg_parameters{"c"};
$t = $alg_parameters{"t"};

@matice = ();
@vektor_hodnot = ();
# vytvoreni vektoru uzlu podle abecedy
@hlavicka_uzlu = ();
foreach my $node (sort keys %list_nodes){
    push(@hlavicka_uzlu, $node);
}
push(@matice,[@hlavicka_uzlu]);
# vytvoreni vektoru hodnot 0. iterace
for my $i (@hlavicka_uzlu){
    my $value = $list_nodes{$i}{"value"};
    push(@vektor_hodnot, $value);
}
push(@matice,[@vektor_hodnot]);
print Dumper @matice;

#1 sparky29
KIIVE nevis, jak by so to dalo prochazet ?

#2 Erik
no ja sem nejak nepochopil o co presne mu jde tak sem se zdrzel komentare...

mozna bych z toho udelal graf objektu, ale vyplnovalo by se to pak do hloubky ne do sirky jak naznacoval tim algoritmem...

ale tezko rict .. nemam chut analyzovat takhle dlouhej kod a jeste bez vstupnich dat..

#NODES_TYPES
#keyword    type  

nt        Person    
nt        Instance
nt        Resource
nt        Tag

#LINK_TYPES
#keyword    type name    type-of-reciprocal-link

ltra        A2I        I2A
ltra        I2RT        RT2I

#NODES
#Keyword     NodeID    NodeType    Importance
n        A1    Person        1.0
n        A2    Person        1.0
n        A3    Person        1.0
n        A4    Person        1.0
n        I1    Instance    1.0
n        I2    Instance    1.0
n        I3    Instance    1.0
n        I4    Instance    1.0
n        I5    Instance    1.0
n        I6    Instance    1.0
n        I7    Instance    1.0
n        I8    Instance    1.0
n        R1    Resource    1.0
n        R2    Resource    1.0
n        R3    Resource    1.0
n        R4    Resource    1.0
n        T    Tag        1.0

#LINKS
#keyword    Initial node    Terminal node    link type    Importance - is not implemented in Kosmos 1.0
l        A1        I1        A2I
l        A1        I2        A2I
l        A2        I3        A2I
l        A2        I4        A2I
l        I1        R1        I2RT
l        I1        T        I2RT
l        I2        R2        I2RT
l        I2        T        I2RT
l        I3        R1        I2RT
l        I3        T        I2RT
l        I4        R2        I2RT
l        I4        T        I2RT
l        A3        I5        A2I
l        A3        I6        A2I
l        A4        I7        A2I
l        A4        I8        A2I
l        I5        R3        I2RT
l        I5        T        I2RT
l        I6        R4        I2RT
l        I6        T        I2RT
l        I7        R3        I2RT
l        I7        T        I2RT
l        I8        R4        I2RT
l        I8        T        I2RT

# INITIAL ACTIVATION
#    The list of initially activated nodes:
#keyword    NodeID    Activation_Level

ia        A1    1

# Link Weights
# keyword    link_type    weight
lw        A2I        0.8    
lw        I2A        0.8
lw        I2RT        0.8
lw        RT2I        0.8

#SAM-ALG-PARAMETERS

Beta    0.5
    
IterationsNo    10

#Calibration   ConservationOfTotalActivation
Calibration    None
#Calibration    ConservationOfInitialActivation

a    1
b    1
c    0

t    0

Vstupni data

bez pochopeni se to dela holt blbe... maximalne sem zkusil zprehlednit ten load ...

################### 1. NACIST DATA ################### 
open(INPUT, "<:encoding(UTF-8)", "sitparametry.txt") || die "nelze otevrit vstupni soubor!";
while (<INPUT>){
    chomp;
    my @radky = split(/\s+/);
    if (@radky) {
        if ($radky[0] eq "nt") { # nt type
            push(@nodes_types,$radky[1]);
        }
        elsif ($radky[0] eq "ltra") {                      # ltra type_name type_of_reciproc_link
            $link_types{$radky[1]} = $radky[2];           #link_types ( type name, type of reciprocal link )
        }
        elsif ($radky[0] eq "n") {                         # n nodeId nodeType
            $nodes{$radky[1]} = $radky[2];    
        }
        elsif ($radky[0] eq "l") {                         # l initial_node terminal_node link_type 
            push(@links,[$radky[1],$radky[2],$radky[3]]);
        }
        elsif ($radky[0] eq "ia") {                        # ia nodeId activation_level
            $initial_activation{$radky[1]} = $radky[2];
        }
        elsif ($radky[0] eq "lw") {
            $link_weights{$radky[1]} = $radky[2];         #link weights (link_type, weight)
        }
        elsif ($radky[0] =~ /^(Beta|IterationsNo|Calibration|a|b|c|t)$/) {
            $alg_parameters{$1} = $radky[1];
        }
    }
}
close(INPUT);

ale to ti moc nepomuze :)

Diky za ochotu

Tohle ma byt vystupem : http://leteckaposta.cz/846970888

0. iterace ma hodnotu 1 pouze A1

1. iterace ma hodnotu 1 -> A1 a A1 ma dva sousedy I1, I2 a ty hodnoty se vypocitaji jako

((1 krat hodnota A1) / (pocetvystupnichhran z A1)^beta ) * hran_vaha = 0,56 pro I1 I2

2. iterace atd.. ten postup vypoctu jsem si prave vypocital z toho vystupu ktery mame dodany

ale nedokazu to z automatizovat pro N iteraci protoze to funguje i nazpatek, v dalsich iteracich I1 I2 to jde zas do A1.

#6 Sparky29
no iteraci 0 bych videl jen vyplnit dopredu a poznacit si  A1  do nejakeho listu nodu
a v iteraci si udelas kopii toho listu (puvodni smazes) a z ni budes odebirat prvky (ted tedy A1)

spocitas nejak :D a ty zmeneny nody pridavas do toho puvodniho seznamu (kde bylo pred tim A1)

chce to jen poresit to hledani hran kudy to muze jit ale mohlo by to fungovat ...

list = ['A1']; hodnoty = [1,0,0,.....];

v dalsim kole by byl vstupem:

list = ['I1','I2']; hodnoty = [1,....,000.56569,....]   (a delat si nekam kopie nebo to vypisovat rovnou na konci pocitani)

(ale treba jeste nechapu to reseni ucelene)

%nodes = ('A1'=> person, 'T' => tag, 'R1'=> resource);    takhle vypada hash nodes

%initial_activation = ('A1' =>1, 'T' =>0....);

tady si vsecny node projdu a vytvorim hash uzly....

foreach my $id (sort keys %nodes){

    my $type = $nodes{$id};
    my $value = $initial_activation{$id};
    if ($value != 1){
        $value = 0;
    };

$uzly{$id} = {"type"=>$type, "value" =>$value};
}

Ja bych potreboval upravit tuto strukturu %uzly ktera by mi ukazovala o kterou iteraci (krok) se jedna 0 , 1,  2. V kazde iteraci bude hodnota value jina.

Zkousel jsem to s anonymnim polem, ale to se mi vzdy sesype....

kazdou iteraci tu strukturu chci zvetsovat..

prosim radu jak na to                                      iter 1

                                                                        'A1'{

                                                                        type => ...

                                                                         value = >1;

                                                                         }

                                                                       iter 2

                                                                         'A2'{

                                                                          value =>1.45;

                                                                        }

kam byste tu hodnotu 0, 1 vlozily a jakym stylem do struktury?

$iter_uzly{0} = {$uzly{$id} = {"type"=>$type, "value" =>$value}};

pokusil jsem se o toto ale Dumper mi to nechce cely zobrazit

print Dumper %iter_uzly;

foreach my $id (sort keys %nodes){
    my $iter = 0;
    my $type = $nodes{$id};
    my $value = $initial_activation{$id};
    if ($value != 1){
        $value = 0;
    };
$uzly{$id} = {"type"=>$type, "value" =>$value};
$iter_uzly{$iter} = \%uzly;
}
print Dumper %iter_uzly;

Funkcni struktura prosim poradte nekdo jak bych ji tedka dokazal treba 3 krat rozsirit $iter_uzly{1} = ......

akorat tam budou vnitrni hodnoty "value" jiny.