distributions.hpp

Go to the documentation of this file.

#ifndef GENESIS_PLACEMENT_SIMULATOR_DISTRIBUTIONS_H_
#define GENESIS_PLACEMENT_SIMULATOR_DISTRIBUTIONS_H_

/*
    Genesis - A toolkit for working with phylogenetic data.
    Copyright (C) 2014-2017 Lucas Czech

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Contact:
    Lucas Czech <lucas.czech@h-its.org>
    Exelixis Lab, Heidelberg Institute for Theoretical Studies
    Schloss-Wolfsbrunnenweg 35, D-69118 Heidelberg, Germany
*/

#include "genesis/placement/sample.hpp"
#include "genesis/utils/core/options.hpp"

#include <random>
#include <stdexcept>
#include <string>
#include <vector>

namespace genesis {
namespace placement {

// =================================================================================================
//     Placement Simulator Edge Distribution
// =================================================================================================

class SimulatorEdgeDistribution
{
public:

    // -------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------

    SimulatorEdgeDistribution()  = default;
    ~SimulatorEdgeDistribution() = default;

    SimulatorEdgeDistribution( SimulatorEdgeDistribution const& ) = default;
    SimulatorEdgeDistribution( SimulatorEdgeDistribution&& )      = default;

    SimulatorEdgeDistribution& operator= ( SimulatorEdgeDistribution const& ) = default;
    SimulatorEdgeDistribution& operator= ( SimulatorEdgeDistribution&& )      = default;

    // -------------------------------------------------
    //     Generate Random Edges
    // -------------------------------------------------

    void prepare( Sample const& sample )
    {
        // If nothing was set, initialize to uniform distrib.
        if( edge_weights.size() == 0 ) {
            edge_weights = std::vector<double>( sample.tree().edge_count(), 1.0 );
        }

        // Check size.
        if( edge_weights.size() != sample.tree().edge_count() ) {
            throw std::runtime_error(
                "Incorrect number of edge weights for SimulatorEdgeDistribution."
            );
        }

        // Prepare the actual distrib.
        distrib_ = std::discrete_distribution<size_t>( edge_weights.begin(), edge_weights.end() );
    }

    size_t generate()
    {
        return distrib_( utils::Options::get().random_engine() );
    }

    // -------------------------------------------------
    //     Data Members
    // -------------------------------------------------

public:

    std::vector<double> edge_weights;

private:

    std::discrete_distribution<size_t> distrib_;
};

// =================================================================================================
//     Placement Simulator Extra Placement Distribution
// =================================================================================================

class SimulatorExtraPlacementDistribution
{
public:

    // -----------------------------------------------------
    //     Typedefs and Structs
    // -----------------------------------------------------

    struct EdgeProximity
    {
        using EdgeCandidates = std::vector<size_t>;
        std::vector<EdgeCandidates> candidates_per_level;
        size_t total_candidates = 0;
    };

    // -----------------------------------------------------
    //     Constructor and Rule of Five
    // -----------------------------------------------------

    SimulatorExtraPlacementDistribution()  = default;
    ~SimulatorExtraPlacementDistribution() = default;

    SimulatorExtraPlacementDistribution( SimulatorExtraPlacementDistribution const& ) = default;
    SimulatorExtraPlacementDistribution( SimulatorExtraPlacementDistribution&& )      = default;

    SimulatorExtraPlacementDistribution& operator= ( SimulatorExtraPlacementDistribution const& ) = default;
    SimulatorExtraPlacementDistribution& operator= ( SimulatorExtraPlacementDistribution&& )      = default;

    // -----------------------------------------------------
    //     Generate Random Positions
    // -----------------------------------------------------

    void prepare( Sample const& sample );
    std::vector<size_t> generate( PlacementTreeEdge const& edge );

    std::string         dump_edge_proximities() const;
    std::vector<size_t> edge_proximity_maxima() const;

    // -----------------------------------------------------
    //     Data Members
    // -----------------------------------------------------

public:

    std::vector<double> placement_number_weights;
    std::vector<double> placement_path_length_weights;

private:

    std::discrete_distribution<size_t> placement_number_distrib_;
    std::discrete_distribution<size_t> placement_path_length_distrib_;

    std::vector<EdgeProximity> edge_proximities_;
};

// =================================================================================================
//     Placement Simulator Like Weight Ratio Distribution
// =================================================================================================

class SimulatorLikeWeightRatioDistribution
{
public:

    // -------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------

    SimulatorLikeWeightRatioDistribution()  = default;
    ~SimulatorLikeWeightRatioDistribution() = default;

    SimulatorLikeWeightRatioDistribution( SimulatorLikeWeightRatioDistribution const& ) = default;
    SimulatorLikeWeightRatioDistribution( SimulatorLikeWeightRatioDistribution&& )      = default;

    SimulatorLikeWeightRatioDistribution& operator= ( SimulatorLikeWeightRatioDistribution const& ) = default;
    SimulatorLikeWeightRatioDistribution& operator= ( SimulatorLikeWeightRatioDistribution&& )      = default;

    // -----------------------------------------------------
    //     Generate Random Ratios
    // -----------------------------------------------------

    void prepare( Sample const& sample );

    double generate()
    {
        return distrib_( utils::Options::get().random_engine() );
    }

    // -----------------------------------------------------
    //     Data Members
    // -----------------------------------------------------

public:

    std::vector<double> intervals;
    std::vector<double> weights;

private:

    std::piecewise_linear_distribution<double> distrib_;
};

// =================================================================================================
//     Placement Simulator Pendant Length Distribution
// =================================================================================================

class SimulatorPendantLengthDistribution
{
public:

    // -------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------

    SimulatorPendantLengthDistribution()  = default;
    ~SimulatorPendantLengthDistribution() = default;

    SimulatorPendantLengthDistribution( SimulatorPendantLengthDistribution const& ) = default;
    SimulatorPendantLengthDistribution( SimulatorPendantLengthDistribution&& )      = default;

    SimulatorPendantLengthDistribution& operator= ( SimulatorPendantLengthDistribution const& ) = default;
    SimulatorPendantLengthDistribution& operator= ( SimulatorPendantLengthDistribution&& )      = default;

    // -----------------------------------------------------
    //     Generate Random Length
    // -----------------------------------------------------

    void prepare( Sample const& sample )
    {
        (void) sample;
        distrib_ = std::uniform_real_distribution<double>(min, max);
    }

    double generate( PlacementTreeEdge const& edge )
    {
        // We don't use the edge in the default distribution.
        (void) edge;

        return distrib_( utils::Options::get().random_engine() );
    }

    // -----------------------------------------------------
    //     Data Members
    // -----------------------------------------------------

public:

    double min = 0.0;
    double max = 1.0;

private:

    std::uniform_real_distribution<double> distrib_;
};

// =================================================================================================
//     Placement Simulator Proximal Length Distribution
// =================================================================================================

class SimulatorProximalLengthDistribution
{
public:

    // -------------------------------------------------
    //     Constructor and Rule of Five
    // -------------------------------------------------

    SimulatorProximalLengthDistribution()  = default;
    ~SimulatorProximalLengthDistribution() = default;

    SimulatorProximalLengthDistribution( SimulatorProximalLengthDistribution const& ) = default;
    SimulatorProximalLengthDistribution( SimulatorProximalLengthDistribution&& )      = default;

    SimulatorProximalLengthDistribution& operator= ( SimulatorProximalLengthDistribution const& ) = default;
    SimulatorProximalLengthDistribution& operator= ( SimulatorProximalLengthDistribution&& )      = default;

    // -----------------------------------------------------
    //     Generate Random Positions
    // -----------------------------------------------------

    void prepare( Sample const& sample )
    {
        (void) sample;
        distrib_ = std::uniform_real_distribution<double>( 0.0, 1.0 );
    }

    double generate( PlacementTreeEdge const& edge )
    {
        // We do a multiplication with the branch length here, because this allows for a single
        // distribution instance instead of one per different length.
        auto branch_length = edge.data<PlacementEdgeData>().branch_length;
        return distrib_( utils::Options::get().random_engine() ) * branch_length;
    }

    // -----------------------------------------------------
    //     Data Members
    // -----------------------------------------------------

private:

    std::uniform_real_distribution<double> distrib_;
};

} // namespace placement
} // namespace genesis

#endif // include guard