wcscpy metodu

Örnek
Elimizde şöyle bir bellek olsun

wchar_t menuText[MAXTEXTLEN];

Şöyle yaparız

wcscpy(menuText, L"&Sample Text");

std::uniform_real_distribution Sınıfı

Giriş
Dağılım [a-b) arasında yarı açık bir dağılımdır. Açıklaması şöyle

Produces random floating-point values i, uniformly distributed on the interval [a, b)

uniform_int_distribution, normal_distribution sınıfları ile kardeştir.

Diğer daha az kullanılan dağılım sınıfları şöyle.

std::weibull_distribution<double>
std::exponential_distribution<double>
std::lognormal_distribution<double>;
std::chi_squared_distribution<double>

Diğer Kısıtlar
Açıklaması şöyle

explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
Requires: a ≤ b and b − a ≤ numeric_limits<RealType>::max().
Effects: Constructs a uniform_real_distribution object; a and b correspond to
the respective parameters of the distribution.

Döndürdüğü Tip

Bu dağılımın default template tipi double olduğu için tip vermek zorunda değiliz.

template <class RealType = double>
class uniform_real_distribution;

Yani şöyle kullanabiliyoruz.

std::uniform_real_distribution<> randomizer(0, 100);

1. Yarı Açık Kullanım

Örnek
Şöyle yaparız. [0 - 1) arasında değer döndürür.

#include <random>
#include <iostream>

std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<> dis(0, 1);
double uniformOn01 = dis(gen);

2. Kapalı Kullanım
Eğer kapalı bir dağılım istersek std::nextafter ile bir sonraki sayısı almamız gerekir.
Örnek
Şöyle yaparız. [0,1] arasında değer döndürür. std::nextafter()'a verilen parametre 1'den 2 yönüne doğru giderken 1'den sonraki gelen ilk sayıyı ver anlamına gelir.

std::uniform_real_distribution<float> dist(0.f, std::nextafter(1.f, 2.f))

Örnek
Şöyle yaparız. [0,M_PI] arasında değer döndürür. 2 * M_PI ile de hangi yöndeki bir sonraki sayıyı istediğimizi belirtiriz.

#include <iostream>
#include <random>

std::random_device rd;
std::default_random_engine gen(rd());
std::uniform_real_distribution<double> dis{0.0, std::nextafter(M_PI, 2.*M_PI)};
std::cout << dis (gen) << std::endl;

Max Kullanım
Şöyle yaparız.

std::random_device rd;
std::mt19937 gen(rd());
std::uniform_real_distribution<double> dis(
                                std::numeric_limits<double>::min(), 
                                std::numeric_limits<double>::max());

double test = dis (gen);

std::reduce - Paralel Çalışabilir

Giriş
C++14 ile geldi. Şu satır dahil edilir.

#include <numeric>

Paralel çalışabildiği için std::accumulate metoduna tercih edilebilir

Binary işlem associative ve commutative olmalıdır. Açıklaması şöyle

The behavior is non-deterministic if binary_op is not associative or not commutative.

Associative (Birleşme Özelliği) Nedir
Birleşme Özelliği 3 tane elemanın işlem sırasının değiştirilebilmesi ve sonucun etkilenmemesidir. Yani

(a + b) + c ile a + (b + c)

işlemlerinin aynı sonucu vermesidir.
Commutative (Değişme Özelliği)  Nedir
Değişme Özelliği ikili bir işlemde değerlerin yer değiştirebilmesi ve sonucun etkilenmemesidir. Yani

a + b = b + a

olabilmesidir.

Matematiksel olarak Değişme Özelliğini bozan bir kaç sayı olması genel özelliği bozmaz. Açıklaması şöyle. Ancak bu durum kodlama açısından kabul edilebilir değil.

An operation is commutative if for any aa and bb, we have ab=ba. Finding one pair a,ba,b such that ab=baab=ba doesn't prove the operation is commutative; this has to hold for every pair.

İmzası
İmzası şöyle.

template<class InputIt, class T>
T reduce(InputIt first, InputIt last, T init);

İmzası şöyle.

template<class ExecutionPolicy, class ForwardIt, class T, class BinaryOp>
T reduce(ExecutionPolicy&& policy,
         ForwardIt first, ForwardIt last, T init, BinaryOp binary_op);

Örnek
Şöyle yaparız.

double algorithm_polynomials(const vector<double> & coeffs, double x) {
  return reduce(execution::seq, cbegin(coeffs), end(coeffs), 0, ...);
}

std::par ile kullanımı
Şu satır dahil edilir.

#include <execution_policy>

std::par'ın açıklaması şöyle

Any such invocations executing in the same thread are indeterminately sequenced with respect to each other.

Şöyle yapılır

std::vector<double> v(10'000'007, 0.5);
double result = std::reduce(std::par, v.begin(), v.end());