G'day azheid,

"I have just enough coding experience to hang myself with a short rope. ... I tried to create a second similar matrix that stored the minimum distance to each node, but I am having trouble with correctly referencing the distance matrix."

I think you need some basic foundation knowledge.

In both of these lines, you're assigning an arrayref to an array:

my @distance_mat=[];
...
my @vit_dist=[ [ 0] ];
[download]

And in this line:

${$vit_dist[$i]}[$j]=min(${$vit_dist[$i-1]}[$j]+${$distance_mat[$i]}[$
+j];
[download]

you appear to be calling a min() function. You've failed to include a closing parenthesis so that leaves me guessing what is intended (and, potentially, what else has been left out or accidentally included). Perl has no min() function, Algorithm::Viterbi's documentation shows no min() function and you show no code for a min() function: I'm out of guesses.

Attempting to access a multi-dimensional array element with code like:

${${$distance_mat[$i]}[$j]}[$k]
[download]

is difficult to read and maintain: and, therefore, error-prone.

I suggest starting with "Perl references short introduction" and "Perl data structures intro".

Here's how I might have written the first piece of code you posted. I've reduced the number of elements from 10 to 2 for demonstration purposes. This should give you an idea of how you can (much simply) drill down into this sort of data structure and access individual elements.

#!/usr/bin/env perl

use strict;
use warnings;

my $max_index = 1;
my $matrix;

for my $i (0 .. $max_index) {
    for my $j (0 .. $max_index) {
        for my $k (0 .. $max_index) {
            $matrix->[$i][$j][$k] = rand 1;
        }
    }
}

use Data::Dump;
dd $matrix;
[download]

Output:

[
  [
    [0.290579816865833, 0.491432556740136],
    [0.888187692306143, 0.761365009561764],
  ],
  [
    [0.865674078359991, 0.284696276285089],
    [0.0562126863718184, 0.781856824452085],
  ],
]
[download]

You are right, your implementation of the data matrix is much cleaner. I was not aware of that notation. min() is a subroutine that I did not include. It does exactly what it sounds like, returns the minimum of two values in a list.

I will try to implement the code with this notation and see if the algorithm is easier to implement.

"min() is a subroutine that I did not include. It does exactly what it sounds like, returns the minimum of two values in a list."

I did consider that might have been something like that (e.g. similar to List::Util's min() function); however, you're only providing a single value after min( in the code you posted.

Here's an example of how ${$vit_dist[$i-1]}[$j]+${$distance_mat[$i]}[$j] might be evaluated:

$ perl -Mstrict -Mwarnings -le '
    my (@vit_dist, @distance_mat);
    $vit_dist[0][0] = 30;
    $distance_mat[1][0] = 12;
    my ($i, $j) = (1, 0);

    print ${$vit_dist[$i-1]}[$j]+${$distance_mat[$i]}[$j];
'
42
[download]

Perhaps you need a comma instead of a plus:

min(${$vit_dist[$i-1]}[$j], ${$distance_mat[$i]}[$j])
[download]

A liberalsplinklingofwhitespace may improve the readability of your code and reduce errors. :-)

-- Ken

Implement seems to be my favorite word today

for(my $i=1; $i<=$x; ++$i){
        for(my $j=0; $j<$y; ++$j){
                for(my $k=0; $k<$y; ++$j){                       
                        $distance_mat -> [$i][$j][$k] = rand 1;
                }   
        }   
}
[download]

use strict;
use warnings;
use Data::Dumper;

my $x = 4;
my $y = 5;
my $distance_mat;
####################
for(my $i=1; $i<=$x; ++$i){
        for(my $j=0; $j<$y; ++$j){
                for(my $k=0; $k<$y; ++$k){                       
                        $distance_mat -> [$i][$j][$k] = rand 1;
                }   
        }   
}
##############Start and end nodes have zero cost
for(my $i=0; $i<scalar(@{$distance_mat->[1]}); ++$i){
        $distance_mat -> [0][0][$i] = 0;
}
for(my $i=0; $i<scalar(@{$distance_mat->[-1]}); ++$i){
        $distance_mat -> [-1][0][$i] = 0;
}

print Dumper $distance_mat;
[download]

for my $i (0..$max_val)
[download]

oops, sorry. I incorrectly copied the third line of that loop. In my program, the data structure is more complicated and depends on a large file. I tried to simplify the code so that the details were easier to understand.

At this point, you are right, I should probably make a new post. I am considering asking one of my computer science colleagues to help, however in the past they have been reluctant.

No problem, this can happen, but please make sure, before opening a new thread, that at least the part of your code that produces the input data is really correct. This way, we can try to work on your Viterbi algorithm itself with good data. For the time being, the Dumper output shows for example some inner arrays with only 0 values, I am not completely sure that's really what you want to start with. Don't hesitate to use the Dumper function of the Data::Dumper module (the way I did it) to better visualize your data and be sure that it is what you wish us to work on. Also note that the two zero-cost code segments were bugged and could not compile; I fixed them so that they would at least compile and do something, but I am not completely sure that what they do now is really what you wanted them to do. Well, in brief, please provide really good input data, then, once we have that, I am sure that some gentle monks among us will be willing to go through the Viterbi algorithm with you. (If you have trouble producing really good input data, I would suggest that you ask for help here, and create a new thread only once this part of the work is completely solved.)