File Coverage

blib/lib/Quantum/Superpositions/Lazy/Superposition.pm

Criterion	Covered	Total	%
statement	85	85	100.0
branch	14	16	87.5
condition	8	8	100.0
subroutine	16	16	100.0
pod	4	4	100.0
total	127	129	98.4

package Quantum::Superpositions::Lazy::Superposition;

our $VERSION = '1.10';

use v5.24;
use warnings;
use Moo;
use Quantum::Superpositions::Lazy::State;
use Quantum::Superpositions::Lazy::Computation;
use Quantum::Superpositions::Lazy::Util qw(get_rand);
use Types::Standard qw(ArrayRef InstanceOf);
use List::Util qw(sum0);

use namespace::clean;

with "Quantum::Superpositions::Lazy::Role::Collapsible";

has "_collapsed_state" => (
	is => "ro",
	lazy => 1,
	builder => "_observe",
	clearer => "_reset",
	predicate => "_is_collapsed",
	init_arg => undef,
);

has "_states" => (
	is => "ro",
	isa => ArrayRef [
		(InstanceOf ["Quantum::Superpositions::Lazy::State"])
		->plus_coercions(
			ArrayRef->where(q{@$_ == 2}),
			q{ Quantum::Superpositions::Lazy::State->new(weight => shift @$_, value => shift @$_) },
			~InstanceOf ["Quantum::Superpositions::Lazy::State"],
			q{ Quantum::Superpositions::Lazy::State->new(value => $_) },
		)
	],
	coerce => 1,
	required => 1,
	init_arg => "states",
);

has "_weight_sum" => (
	is => "ro",
	lazy => 1,
	default => sub {
		sum0 map { $_->weight }
		shift->_states->@*;
	},
	init_arg => undef,
	clearer => 1,
);

sub collapse
{
	my ($self) = @_;

	return $self->_collapsed_state;
}

sub is_collapsed
{
	my ($self) = @_;

	return $self->_is_collapsed;
}

sub weight_sum
{
	my ($self) = @_;

	return $self->_weight_sum;
}

sub reset
{
	my ($self) = @_;

	if (!$self->{_collapsible}) {
		$self->{_collapsible} = [grep { $_->collapsible } $self->_states->@*];
	}

	foreach my $state ($self->{_collapsible}->@*) {
		$state->reset;
	}

	$self->_reset;

	return $self;
}

sub _observe
{
	my ($self) = @_;

	if (!$self->{_lookup}) {
		my @positions = $self->_states->@*;
		my $sum = $self->weight_sum;
		my @weights;
		my $current = 0;

		for my $state (@positions) {
			push @weights, $current;
			$current += $state->weight / $sum;
		}

		$self->{_lookup} = \@weights;
	}

	my $prob = get_rand;

	my @cache = $self->{_lookup}->@*;
	my $current = int(@cache / 2);
	my $step = int(@cache / 4) || 1;

	# warn "rand: $prob, all: [@cache], step: $step";
	while ($step > 1) {
		if ($cache[$current] < $prob) {
			# warn "going up: $current + $step";
			$current += $step;

			$current = @cache - 1
				if $current >= @cache;
		}

		else {
			# warn "going down $current - $step";
			$current -= $step;

			$current = 0
				if $current < 0;
		}

		$step = int($step / 2);
	}

	while ($current < $#cache && $cache[$current] < $prob) {
		$current += 1
	}

	while ($current > 0 && $cache[$current] > $prob) {
		$current -= 1
	}

	# warn "selected: $current ($cache[$current] < $prob)";

	my $state = $self->_states->[$current];

	return $state->collapsible
		? $state->value->collapse
		: $state->value;
}

sub _build_complete_states
{
	my ($self) = @_;

	my %states;
	for my $state ($self->_states->@*) {
		my @local_states;
		my $coeff = 1;

		my $value = $state->value;
		if ($state->collapsible) {

			# all values from this state must have their weights multiplied by $coeff
			# this way the weight sum will stay the same
			$coeff = $state->weight / $value->weight_sum;
			@local_states = $value->states->@*;
		}
		else {
			@local_states = $state;
		}

		foreach my $value (@local_states) {
			my $result = $value->value;
			my $copied = $value->clone_with(weight => sub { shift() * $coeff });

			if (exists $states{$result}) {
				$states{$result} = $states{$result}->merge($copied);
			}
			else {
				$states{$result} = $copied;
			}
		}
	}

	return [values %states];
}

1;

__END__