Detailed Description

Gradual subdivision operator with a constant multiplier_.

In this class the number of subdivisions is known a priori.

Definition at line 97 of file Subdivision.h.

#include <Subdivision.h>

Inheritance diagram for BaseLib::GradualSubdivisionFixedNum:

Collaboration diagram for BaseLib::GradualSubdivisionFixedNum:

Public Member Functions
	GradualSubdivisionFixedNum (const double L, const std::size_t num_subdivisions, const double multiplier)
std::vector< double >	operator() () const override
	Returns a vector of subdivided points.
Public Member Functions inherited from BaseLib::ISubdivision
virtual	~ISubdivision ()=default

Private Attributes
const double	length_
const std::size_t	num_subdivisions_
const double	multiplier_

Constructor & Destructor Documentation

◆ GradualSubdivisionFixedNum()

BaseLib::GradualSubdivisionFixedNum::GradualSubdivisionFixedNum	(	const double	L,
		const std::size_t	num_subdivisions,
		const double	multiplier )

Constructor

Parameters

L	total length to be subdivided
num_subdivisions	number of subdivisions to generate
multiplier	multiplier to cell length

Definition at line 68 of file Subdivision.cpp.

    : length_{L}, num_subdivisions_{num_subdivisions}, multiplier_{multiplier}
{
}

References length_, multiplier_, and num_subdivisions_.

Member Function Documentation

◆ operator()()

std::vector< double > BaseLib::GradualSubdivisionFixedNum::operator() ( ) const

overridevirtual

Returns a vector of subdivided points.

Implements BaseLib::ISubdivision.

Definition at line 74 of file Subdivision.cpp.

{
    std::vector<double> subdivisions;
    subdivisions.reserve(num_subdivisions_ + 1);
    subdivisions.push_back(0.0);
    auto const q = multiplier_;
 
    if (q == 1.0)
    {
        double const dx = length_ / num_subdivisions_;
 
        for (std::size_t i = 1; i < num_subdivisions_; ++i)
        {
            subdivisions.push_back(dx * i);
        }
    }
    else
    {
        // compute initial subdivision size
        auto const a =
            length_ * (q - 1.0) / (std::pow(q, num_subdivisions_) - 1.0);
 
        double qi = q;  // q^i
        for (std::size_t i = 1; i < num_subdivisions_; ++i)
        {
            subdivisions.push_back(a * (qi - 1.0) / (q - 1.0));
            qi *= q;
        }
    }
 
    subdivisions.push_back(length_);
 
    return subdivisions;
}