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 as_sorted_key_hashref ($) {
  my $self = shift;
  return {map {$_ => 1}
          sort {$self->{t}->{$b} <=> $self->{t}->{$a}}
          keys %{$self->{t}}};
} # as_sorted_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	wakaba	1.3	sub as_sorted_key_hashref ($) {
30			my $self = shift;
31			return {map {$_ => 1}
32			sort {$self->{t}->{$b} <=> $self->{t}->{$a}}
33			keys %{$self->{t}}};
34			} # as_sorted_key_hashref
35
36	wakaba	1.2	sub clone ($) {
37			my $self = shift;
38			my $clone = ref ($self)->new;
39			$clone->{t} = {%{$self->{t}}};
40			return $clone;
41			} # clone
42
43			sub add ($$) {
44			my $a = shift;
45			my $b = shift;
46
47			my $r = $a->clone;
48
49			no warnings 'uninitialized';
50			for (keys %{$b->{t}}) {
51			$r->{t}->{$_} += $b->{t}->{$_};
52			}
53
54			return $r;
55			} # add
56
57			sub subtract ($$) {
58			my $a = shift;
59			my $b = shift;
60
61			my $r = $a->clone;
62
63			no warnings 'uninitialized';
64			for (keys %{$b->{t}}) {
65			$r->{t}->{$_} -= $b->{t}->{$_};
66			}
67
68			return $r;
69			} # subtract
70
71			sub multiply ($$) {
72			my $a = shift;
73			my $b = shift;
74
75			my $r = $a->clone;
76
77			no warnings 'uninitialized';
78			for (keys %{$a->{t}}) { # $a, not $r
79			$r->{t}->{$_} *= $b->{t}->{$_};
80			delete $r->{t}->{$_} if $r->{t}->{$_} == 0;
81			}
82
83			return $r;
84			} # multiply
85
86			sub component_sum ($) {
87			my $self = shift;
88			my $r = 0;
89
90			for (keys %{$self->{t}}) {
91			$r += $self->{t}->{$_};
92			}
93
94			return $r;
95			} # component_sum
96	wakaba	1.1
97			sub stringify ($) {
98			my $self = shift;
99
100			my $t = $self->{t};
101			return
102			join "\n",
103			map { join "\t", $_, $t->{$_} }
104			sort { $t->{$b} <=> $t->{$a} }
105			keys %$t;
106			} # stringify
107
108			1;