SWE/Data/FeatureVector.pm

package SWE::Data::FeatureVector;
use strict;
use warnings;

sub new ($) {
  my $self = bless {t => {}}, shift;
  return $self;
} # new

sub parse_stringref ($$) {
  my $self = shift->new;
  my $sref = $_[0] || \'';
  
  $self->{t} = { map { split /\t/, $_, 2 } split /[\x0D\x0A]+/, $$sref };
  
  return $self;
} # parse_stringref

sub set_tfidf ($$$) {
  #my ($self, $term, $tfidf) = @_;
  $_[0]->{t}->{$_[1]} = $_[2];
} # set_tfidf

sub as_key_hashref ($) {
  my $self = shift;
  return {map {$_ => 1} keys %{$self->{t}}};
} # as_key_hashref

sub clone ($) {
  my $self = shift;
  my $clone = ref ($self)->new;
  $clone->{t} = {%{$self->{t}}};
  return $clone;
} # clone

sub add ($$) {
  my $a = shift;
  my $b = shift;
  
  my $r = $a->clone;

  no warnings 'uninitialized';
  for (keys %{$b->{t}}) {
    $r->{t}->{$_} += $b->{t}->{$_};
  }
  
  return $r;
} # add

sub subtract ($$) {
  my $a = shift;
  my $b = shift;
  
  my $r = $a->clone;

  no warnings 'uninitialized';
  for (keys %{$b->{t}}) {
    $r->{t}->{$_} -= $b->{t}->{$_};
  }
  
  return $r;
} # subtract

sub multiply ($$) {
  my $a = shift;
  my $b = shift;
  
  my $r = $a->clone;
  
  no warnings 'uninitialized';
  for (keys %{$a->{t}}) { # $a, not $r
    $r->{t}->{$_} *= $b->{t}->{$_};
    delete $r->{t}->{$_} if $r->{t}->{$_} == 0;
  }

  return $r;
} # multiply

sub component_sum ($) {
  my $self = shift;
  my $r = 0;

  for (keys %{$self->{t}}) {
    $r += $self->{t}->{$_};
  }
  
  return $r;
} # component_sum

sub stringify ($) {
  my $self = shift;

  my $t = $self->{t};
  return
      join "\n",
      map { join "\t", $_, $t->{$_} }
      sort { $t->{$b} <=> $t->{$a} }
      keys %$t;
} # stringify

1;
1	wakaba	1.1	package SWE::Data::FeatureVector;
2			use strict;
3			use warnings;
4
5			sub new ($) {
6			my $self = bless {t => {}}, shift;
7			return $self;
8			} # new
9
10	wakaba	1.2	sub parse_stringref ($$) {
11	wakaba	1.1	my $self = shift->new;
12	wakaba	1.2	my $sref = $_[0] \|\| \'';
13	wakaba	1.1
14	wakaba	1.2	$self->{t} = { map { split /\t/, $_, 2 } split /[\x0D\x0A]+/, $$sref };
15	wakaba	1.1
16			return $self;
17	wakaba	1.2	} # parse_stringref
18	wakaba	1.1
19			sub set_tfidf ($$$) {
20			#my ($self, $term, $tfidf) = @_;
21			$_[0]->{t}->{$_[1]} = $_[2];
22			} # set_tfidf
23	wakaba	1.2
24			sub as_key_hashref ($) {
25			my $self = shift;
26			return {map {$_ => 1} keys %{$self->{t}}};
27			} # as_key_hashref
28
29			sub clone ($) {
30			my $self = shift;
31			my $clone = ref ($self)->new;
32			$clone->{t} = {%{$self->{t}}};
33			return $clone;
34			} # clone
35
36			sub add ($$) {
37			my $a = shift;
38			my $b = shift;
39
40			my $r = $a->clone;
41
42			no warnings 'uninitialized';
43			for (keys %{$b->{t}}) {
44			$r->{t}->{$_} += $b->{t}->{$_};
45			}
46
47			return $r;
48			} # add
49
50			sub subtract ($$) {
51			my $a = shift;
52			my $b = shift;
53
54			my $r = $a->clone;
55
56			no warnings 'uninitialized';
57			for (keys %{$b->{t}}) {
58			$r->{t}->{$_} -= $b->{t}->{$_};
59			}
60
61			return $r;
62			} # subtract
63
64			sub multiply ($$) {
65			my $a = shift;
66			my $b = shift;
67
68			my $r = $a->clone;
69
70			no warnings 'uninitialized';
71			for (keys %{$a->{t}}) { # $a, not $r
72			$r->{t}->{$_} *= $b->{t}->{$_};
73			delete $r->{t}->{$_} if $r->{t}->{$_} == 0;
74			}
75
76			return $r;
77			} # multiply
78
79			sub component_sum ($) {
80			my $self = shift;
81			my $r = 0;
82
83			for (keys %{$self->{t}}) {
84			$r += $self->{t}->{$_};
85			}
86
87			return $r;
88			} # component_sum
89	wakaba	1.1
90			sub stringify ($) {
91			my $self = shift;
92
93			my $t = $self->{t};
94			return
95			join "\n",
96			map { join "\t", $_, $t->{$_} }
97			sort { $t->{$b} <=> $t->{$a} }
98			keys %$t;
99			} # stringify
100
101			1;