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	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	sub parse_stringref ($$) {
11	my $self = shift->new;
12	my $sref = $_[0] \|\| \'';
13
14	$self->{t} = { map { split /\t/, $_, 2 } split /[\x0D\x0A]+/, $$sref };
15
16	return $self;
17	} # parse_stringref
18
19	sub set_tfidf ($$$) {
20	#my ($self, $term, $tfidf) = @_;
21	$_[0]->{t}->{$_[1]} = $_[2];
22	} # set_tfidf
23
24	sub as_key_hashref ($) {
25	my $self = shift;
26	return {map {$_ => 1} keys %{$self->{t}}};
27	} # as_key_hashref
28
29	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	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
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;