<numeric> işlevleri

yığmak

Ardışık kısmi toplamları hesaplayarak belirli bir aralıktaki bazı başlangıç değerleri dahil tüm öğelerin toplamını hesaplar. Veya belirtilen ikili işlemin ardışık kısmi sonuçlarını hesaplar.

template <class InputIterator, class Type>
Type accumulate(
    InputIterator first,
    InputIterator last,
    Type init);

template <class InputIterator, class Type, class BinaryOperation>
Type accumulate(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op);

Parametreler

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

Dönüş değeri

İlk şablon işlevi için belirtilen aralıktaki tüm öğelerin toplamı veya ikinci şablon işlevi için ikili işlemin toplam işlemi yerine (*PartialResult, in_iter) binary_op uygulanması sonucu elde edilir; burada PartialResult işlemin önceki uygulamalarının sonucudur ve in_iter aralıktaki sonraki öğeye işaret eden bir yineleyicidir.

Açıklamalar

İlk değer, aralık boş olduğunda iyi tanımlanmış bir sonuç olmasını sağlar ve bu durumda init döndürülür. İkili işlemin ilişkilendirilebilir veya karşılıklı olması gerekmez. Sonuç ilk değer girişine başlatılır ve ardından sonuç = binary_op(sonuç, in_iter) aralık üzerinden yinelemeli olarak hesaplanır; burada in_iter aralıktaki ardışık öğelerin her birine işaret eden bir yineleyicidir. Aralık geçerli olmalıdır ve karmaşıklık aralığın boyutuyla doğrusaldır. İkili işlecin dönüş türü, yineleme sırasında kapatılmasını sağlamak için Tür'e dönüştürülebilir olmalıdır.

Örnek

// numeric_accum.cpp
// compile with: /EHsc
#include <vector>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector <int> v1, v2(20);
   vector <int>::iterator iter1, iter2;

   int i;
   for (i = 1; i < 21; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   // The first member function for the accumulated sum
   int total;
   total = accumulate(v1.begin(), v1.end(), 0);

   cout << "The sum of the integers from 1 to 20 is: "
        << total << "." << endl;

   // Constructing a vector of partial sums
   int j = 0, partotal;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      partotal = accumulate(v1.begin(), iter1 + 1, 0);
      v2[j] = partotal;
      j++;
   }

   cout << "The vector of partial sums is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function for the accumulated product
   vector <int> v3, v4(10);
   vector <int>::iterator iter3, iter4;

   int s;
   for (s = 1; s < 11; s++)
   {
      v3.push_back(s);
   }

   cout << "The original vector v3 is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl;

   int ptotal;
   ptotal = accumulate(v3.begin(), v3.end(), 1, multiplies<int>());

   cout << "The product of the integers from 1 to 10 is: "
        << ptotal << "." << endl;

   // Constructing a vector of partial products
   int k = 0, ppartotal;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++) {
      ppartotal = accumulate(v3.begin(), iter3 + 1, 1, multiplies<int>());
      v4[k] = ppartotal;
      k++;
   }

   cout << "The vector of partial products is:\n ( " ;
   for (iter4 = v4.begin(); iter4 != v4.end(); iter4++)
      cout << *iter4 << " ";
   cout << ")." << endl;
}

The original vector v1 is:
( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ).
The sum of the integers from 1 to 20 is: 210.
The vector of partial sums is:
( 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 ).

The original vector v3 is:
( 1 2 3 4 5 6 7 8 9 10 ).
The product of the integers from 1 to 10 is: 3628800.
The vector of partial products is:
( 1 2 6 24 120 720 5040 40320 362880 3628800 ).

adjacent_difference

Giriş aralığındaki her öğe ile öncül arasındaki ardışık farkları hesaplar. Sonuçları bir hedef aralığa verir. Alternatif olarak, fark işleminin belirtilen başka bir ikili işlemle değiştirildiği genelleştirilmiş bir yordamın sonucunu hesaplar.

template <class InputIterator, class OutIterator>
OutputIterator adjacent_difference(
    InputIterator first,
    InputIterator last,
    OutputIterator result);

template <class InputIterator, class OutIterator, class BinaryOperation>
OutputIterator adjacent_difference(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 adjacent_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

template <class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation>
ForwardIterator2 adjacent_difference(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op);

Parametreler

Exec
Yürütme ilkesi.

birinci
Öğeleri karşılık gelen öncelleriyle fark kaydı yapılacak olan giriş aralığındaki ilk öğeyi ele alan veya değer çiftinin başka bir belirtilen ikili işlemde çalıştırılacağı bir giriş yineleyici.

son
Öğeleri karşılık gelen öncelleriyle fark kaydı yapılacak olan giriş aralığındaki son öğeyi ele alan veya değer çiftinin başka bir belirtilen ikili işlemde çalıştırılacağı bir giriş yineleyici.

sonuç
Fark dizilerinin veya belirtilen işlemin sonuçlarının depolanacağı hedef aralıktaki ilk öğeyi ele alan çıkış yineleyici.

binary_op
Genelleştirilmiş işlemde uygulanacak ikili işlem, fark kayıt yordamındaki çıkarma işleminin yerini alır.

Dönüş değeri

Hedef aralığın sonunu ele alan bir çıkış yineleyicisi: result + ( - lastfirst).

Açıklamalar

Çıkış yineleyici sonucunun, değerlerin yerinde hesaplanması için önce adjacent_differencegiriş yineleyicisi ile aynı yineleyici olması sağlanır.

Giriş aralığındaki 1, 2, 3 değerlerinin dizisi için, ilk şablon işlevi hedef aralıkta 1, 2 - 1, a3 - 2 ardışık adjacent_difference değerleri depolar.

Giriş aralığında 1, 2, 3 değerleri dizisi için ikinci şablon işlevi, hedef aralıkta 1, 2 binary_op 1, 3 binary_op 2 değerlerini depolar.adjacent_difference

uygulanan işlemlerin sırası belirtildiğinden, ikili işlem binary_op ilişkilendirilebilir veya commutative olması gerekmez.

Örnek

// numeric_adj_diff.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;

   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend, LIterend2;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t * t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the adjacent_differences of
   // elements in a list output to a vector
   VIterend = adjacent_difference ( L1.begin ( ) , L1.end ( ) ,
      V1.begin ( ) );

   cout << "Output vector containing adjacent_differences is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the adjacent products of the elements in a list
   VIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) ,
      multiplies<int>( ) );

   cout << "The output vector with the adjacent products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of adjacent_differences in place
   LIterend2 = adjacent_difference ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "In place output adjacent_differences in list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend2 ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

exclusive_scan

İlk değer verilip verilmediği için bir aralık üzerinde belirtilen ikili işleci veya birini kullanarak std::plus<>() bir özel ön ek toplama işlemini hesaplar. Sonuçları belirtilen hedefte başlayan aralığa yazar. Özel ön ek toplamı, n. giriş öğesinin n. toplama dahil olmadığı anlamına gelir. Yürütme ilkesi bağımsız değişkeni içeren aşırı yüklemeler belirtilen ilkeye göre yürütülür.

template<class InputIterator, class OutputIterator, class Type>
OutputIterator exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init);

template<class InputIterator, class OutputIterator, class Type, class BinaryOperation>
OutputIterator exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init,
    BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
ForwardIterator2 exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation>
ForwardIterator2 exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init,
    BinaryOperation binary_op);

Parametreler

Exec
Yürütme ilkesi.

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

sonuç
İlk öğeyi, belirtilen işlemin toplamlarının veya sonuçlarının depolandığı hedef aralığı ele alan bir çıkış yineleyicisi.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

Dönüş değeri

Hedef aralığın sonunu ele alan bir çıkış yineleyicisi: result + (son - ilk).

obeb

m ve n tamsayılarının en büyük ortak böleni hesaplar.

template <class M, class N>
constexpr common_type_t<M,N> gcd(M m, N n);

Parametreler

m, n
İntegral türü değerleri.

Dönüş değeri

m ve n mutlak değerlerinin en büyük ortak böleni veya hem m hem de n sıfır ise sıfır değerini döndürür. m veya n mutlak değerleri türündeki common_type_t<M,N>değerler olarak gösterilemiyorsa sonuçlar tanımlanmamıştır.

inclusive_scan

İlk değer verilip verilmediği bir aralık üzerinde belirtilen ikili işleci veya birini kullanarak std::plus<>() kapsayıcı bir ön ek toplamı işlemi hesaplar. Sonuçları belirtilen hedefte başlayan aralığa yazar. Kapsayıcı ön ek toplamı, n. giriş öğesinin n. toplama dahil olduğu anlamına gelir. Yürütme ilkesi bağımsız değişkeni içeren aşırı yüklemeler belirtilen ilkeye göre yürütülür.

template<class InputIterator, class OutputIterator>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result);

template<class InputIterator, class OutputIterator, class BinaryOperation>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

template<class InputIterator, class OutputIterator, class BinaryOperation, class Type>
OutputIterator inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
class BinaryOperation, class Type>
ForwardIterator2 inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    Type init);

Parametreler

Exec
Yürütme ilkesi.

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

sonuç
İlk öğeyi, belirtilen işlemin toplamlarının veya sonuçlarının depolandığı hedef aralığı ele alan bir çıkış yineleyicisi.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

Dönüş değeri

Hedef aralığın sonunu ele alan bir çıkış yineleyicisi: result + (son - ilk).

inner_product

İki aralığın öğe açısından çarpımının toplamını hesaplar ve bunu belirtilen bir başlangıç değerine ekler veya toplam ve ürün ikili işlemlerinin diğer belirtilen ikili işlemlerle değiştirildiği genelleştirilmiş bir yordamın sonucunu hesaplar.

template <class InputIterator1, class InputIterator2, class Type>
Type inner_product(
    InputIterator1   first1,
    InputIterator1   last1,
    InputIterator2   first2,
    Type             init);

template <class InputIterator1, class InputIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type inner_product(
    InputIterator1   first1,
    InputIterator1   last1,
    InputIterator2   first2,
    Type             init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

Parametreler

ilk1
İç ürünü veya ikinci aralıkla genelleştirilmiş iç ürünü hesaplanacak ilk aralıktaki ilk öğeyi ele alan bir giriş yineleyicisi.

son1
İç ürünü veya ikinci aralıkla genelleştirilmiş iç ürünü hesaplanacak olan ilk aralıktaki son öğeyi ele alan bir giriş yineleyicisi.

ilk2
İkinci aralıktaki ilk öğeyi ele alan, iç ürünü veya ilk aralıkla genelleştirilmiş iç ürünü hesaplanacak bir giriş yineleyicisi.

init
Aralıklar arasında iç ürünün veya genelleştirilmiş iç ürünün eklendiği bir başlangıç değeri.

binary_op1
İç ürünün genelleştirilmesinde öğeye göre ürünlere uygulanan toplamın iç ürün işleminin yerini alan ikili işlem.

binary_op2
İç ürünün genelleştirilmesinde çarpmanın iç ürün öğesi açısından çalışmasının yerini alan ikili işlem.

Dönüş değeri

İlk üye işlevi, öğeye göre ürünlerin toplamını döndürür ve belirtilen başlangıç değerini ekler. Bu nedenle, ive bi değerlerinin aralıkları için şunu döndürür:

init + (a1 * b1) + (a2 * b2) + ... + (an * bn)

init yerine init + (ai * bi) yazın.

İkinci üye işlevi şunu döndürür:

init binary_op1 (a1 binary_op2 b1) binary_op1 (2 binary_op2 b2) binary_op1 ... binary_op1 (n binary_op2 bn)

init'i init binary_op1 (ai binary_op2 bi) ile yinelemeli olarak değiştirerek.

Açıklamalar

İlk değer, aralık boş olduğunda iyi tanımlanmış bir sonuç olmasını sağlar. Bu durumda, init döndürülür. İkili işlemlerin ilişkilendirilebilir veya karşılıklı olması gerekmez. Aralık geçerli olmalıdır ve karmaşıklık aralığın boyutuyla doğrusaldır. İkili işlecin dönüş türü, yineleme sırasında kapatılmasını sağlamak için Tür'e dönüştürülebilir olmalıdır.

Örnek

// numeric_inner_prod.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main()
{
   using namespace std;

   vector <int> v1, v2(7), v3(7);
   vector <int>::iterator iter1, iter2, iter3;

   int i;
   for (i = 1; i <= 7; i++)
   {
      v1.push_back(i);
   }

   cout << "The original vector v1 is:\n ( " ;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
      cout << *iter1 << " ";
   cout << ")." << endl;

   list <int> l1, l2(7);
   list <int>::iterator lIter1, lIter2;

   int t;
   for (t = 1; t <= 7; t++)
   {
      l1.push_back(t);
   }

   cout << "The original list l1 is:\n ( " ;
   for (lIter1 = l1.begin(); lIter1 != l1.end(); lIter1++)
      cout << *lIter1 << " ";
   cout << ")." << endl;

   // The first member function for the inner product
   int inprod;
   inprod = inner_product(v1.begin(), v1.end(), l1.begin(), 0);

   cout << "The inner_product of the vector v1 and the list l1 is: "
        << inprod << "." << endl;

   // Constructing a vector of partial inner_products between v1 & l1
   int j = 0, parinprod;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++) {
      parinprod = inner_product(v1.begin(), iter1 + 1, l1.begin(), 0);
      v2[j] = parinprod;
      j++;
   }

   cout << "Vector of partial inner_products between v1 & l1 is:\n ( " ;
   for (iter2 = v2.begin(); iter2 != v2.end(); iter2++)
      cout << *iter2 << " ";
   cout << ")." << endl << endl;

   // The second member function used to compute
   // the product of the element-wise sums
   int inprod2;
   inprod2 = inner_product (v1.begin(), v1.end(),
      l1.begin(), 1, multiplies<int>(), plus<int>());

   cout << "The sum of the element-wise products of v1 and l1 is: "
        << inprod2 << "." << endl;

   // Constructing a vector of partial sums of element-wise products
   int k = 0, parinprod2;
   for (iter1 = v1.begin(); iter1 != v1.end(); iter1++)
   {
      parinprod2 =
         inner_product(v1.begin(), iter1 + 1, l1.begin(), 1,
         multiplies<int>(), plus<int>());
      v3[k] = parinprod2;
      k++;
   }

   cout << "Vector of partial sums of element-wise products is:\n ( " ;
   for (iter3 = v3.begin(); iter3 != v3.end(); iter3++)
      cout << *iter3 << " ";
   cout << ")." << endl << endl;
}

zerre

İlk öğeden başlayarak ve aralıktaki [first, last)öğelerin her birinde bu değerin (value++) art arda artışlarıyla dolduran bir başlangıç değeri depolar.

template <class ForwardIterator, class Type>
void iota(ForwardIterator first, ForwardIterator last, Type value);

Parametreler

birinci
Doldurulacak aralıktaki ilk öğeyi ele alan bir giriş yineleyicisi.

son
Doldurulacak aralıktaki son öğeyi ele alan bir giriş yineleyicisi.

value
İlk öğede depolamak ve sonraki öğeler için art arda artırmak için başlangıç değeri.

Örnek

Aşağıdaki örnek, bir tamsayı listesini doldurarak ve ardından random_shuffle işlevinin kullanılabilmesi için iota bir vektör list doldurarak işlevin bazı kullanımlarını gösterir.

// compile by using: cl /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <numeric>
#include <list>
#include <vector>
#include <iostream>

using namespace std;

int main(void)
{
    list <int> intList(10);
    vector <list<int>::iterator> intVec(intList.size());

    // Fill the list
    iota(intList.begin(), intList.end(), 0);

    // Fill the vector with the list so we can shuffle it
    iota(intVec.begin(), intVec.end(), intList.begin());

    random_shuffle(intVec.begin(), intVec.end());

    // Output results
    cout << "Contents of the integer list: " << endl;
    for (auto i: intList) {
        cout << i << ' ';
    }
    cout << endl << endl;

    cout << "Contents of the integer list, shuffled by using a vector: " << endl;
    for (auto i: intVec) {
        cout << *i << ' ';
    }
    cout << endl;
}

Lcm

template <class M, class N>
constexpr common_type_t<M,N> lcm(M m, N n);

partial_sum

İlk öğeden n. öğeye kadar bir giriş aralığındaki bir dizi toplamı hesaplar ve bu tür her toplamın sonucunu hedef aralığın n. öğesinde depolar. Veya toplama işleminin belirtilen başka bir ikili işlemle değiştirildiği genelleştirilmiş bir yordamın sonucunu hesaplar.

template <class InputIterator, class OutIt>
OutputIterator partial_sum(
    InputIterator first,
    InputIterator last,
    OutputIterator result);

template <class InputIterator, class OutIt, class Fn2>
OutputIterator partial_sum(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op);

Parametreler

birinci
Belirtilen bir ikili işleme göre kısmen toplanan veya birleştirilen aralıktaki ilk öğeyi ele alan giriş yineleyici.

son
Yineleyen birikime dahil son öğenin ötesinde konumlanmış belirtilen bir ikili işleme göre kısmen toplanan veya birleştirilen aralıktaki son öğeyi ele alan giriş yineleyici.

sonuç
Kısmi toplamlar serisini veya belirtilen ikili işlemin ardışık sonuçlarını depolamak için hedef aralığın ilk öğesini ele alan bir çıkış yineleyicisi.

binary_op
Genelleştirilmiş işlemde uygulanacak ikili işlem, kısmi toplam yordamındaki toplam işleminin yerini alır.

Dönüş değeri

Hedef aralığın sonunu ele alan bir çıkış yineleyicisi: result + (son - ilk).

Açıklamalar

Kısmi toplamların hesaplanması için çıkış yineleyici sonucunun önce giriş yineleyicisi ile aynı yineleyici olması sağlanır.

Bir değer dizisi için 1, 2, ... ax, bir giriş aralığında, ilk şablon işlevi hedef aralıkta ardışık kısmi toplamları depolar. n. öğe tarafından verilir (a1 + a2 + a3 + ... + an).

Giriş aralığındaki 1, 2, 3 değerlerinin dizisi için ikinci şablon işlevi, hedef aralıkta ardışık kısmi sonuçları depolar. n. öğe ((... ((a1 binary_op a2) binary_op a3) binary_op ... ) binary_op n).

uygulanan işlemlerin sırası belirtildiğinden, ikili işlem binary_op ilişkilendirilebilir veya commutative olması gerekmez.

Örnek

// numeric_partial_sum.cpp
// compile with: /EHsc
#include <vector>
#include <list>
#include <numeric>
#include <functional>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> V1( 10 ), V2( 10 );
   vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;

   list <int> L1;
   list <int>::iterator LIter1, LIterend;

   int t;
   for ( t = 1 ; t <= 10 ; t++ )
   {
      L1.push_back( t );
   }

   cout << "The input list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != L1.end( ) ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;

   // The first member function for the partial sums of
   // elements in a list output to a vector
   VIterend = partial_sum ( L1.begin ( ) , L1.end ( ) ,
      V1.begin ( ) );

   cout << "The output vector containing the partial sums is:\n ( " ;
   for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
      cout << *VIter1 << " ";
   cout << ")." << endl;

   // The second member function used to compute
   // the partial product of the elements in a list
   VIterend2 = partial_sum ( L1.begin ( ) , L1.end ( ) , V2.begin ( ) ,
      multiplies<int>( ) );

   cout << "The output vector with the partial products is:\n ( " ;
   for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
      cout << *VIter2 << " ";
   cout << ")." << endl;

   // Computation of partial sums in place
   LIterend = partial_sum ( L1.begin ( ) , L1.end ( ) , L1.begin ( ) );
   cout << "The in place output partial_sum list L1 is:\n ( " ;
   for ( LIter1 = L1.begin( ) ; LIter1 != LIterend ; LIter1++ )
      cout << *LIter1 << " ";
   cout << ")." << endl;
}

azaltmak

Toplamları rastgele ve muhtemelen permütasyonlu bir sırada hesaplayarak, belirli bir aralıktaki tüm öğeleri (büyük olasılıkla bazı başlangıç değerleri dahil) azaltır. Veya belirtilen ikili işlemin sonuçlarını hesaplayarak azaltır. Yürütme ilkesi bağımsız değişkeni içeren aşırı yüklemeler belirtilen ilkeye göre yürütülür.

template<class InputIterator>
typename iterator_traits<InputIterator>::value_type reduce(
    InputIterator first,
    InputIterator last);

template<class InputIterator, class Type>
Type reduce(
    InputIterator first,
    InputIterator last,
    Type init);

template<class InputIterator, class Type, class BinaryOperation>
Type reduce(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op);

template<class ExecutionPolicy, class ForwardIterator>
typename iterator_traits<ForwardIterator>::value_type reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last);

template<class ExecutionPolicy, class ForwardIterator, class Type>
Type reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init);

template<class ExecutionPolicy, class ForwardIterator, class Type, class BinaryOperation>
Type reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init,
    BinaryOperation binary_op);

Parametreler

Exec
Yürütme ilkesi.

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

sonuç
İlk öğeyi, belirtilen işlemin toplamlarının veya sonuçlarının depolandığı hedef aralığı ele alan bir çıkış yineleyicisi.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

Dönüş değeri

binary_op veya init'e ve belirtilen aralıktaki tüm öğelerin (*PartialResult, in_iter) uygulanmasının sonucudur; burada PartialResult işlemin önceki uygulamalarının sonucudur ve in_iter aralıktaki bazı öğelere işaret eden bir yineleyicidirstd::plus<>(). Init belirtmeyen aşırı yüklemelerde, kullanılan init değeri ile typename iterator_traits<InputIterator>::value_type{}eşdeğerdir.

Açıklamalar

reducebinary_op ilişkilendirici ve karşılıklı olmadığı sürece davranış belirleyici değildir. binary_op herhangi bir öğeyi değiştirirse veya [ilk, son] (dahil) aralığındaki herhangi bir yineleyiciyi geçersiz hale getirirse davranış tanımlanmamıştır.

transform_exclusive_scan

Bir aralığın öğelerini belirtilen birli işleçle dönüştürür, ardından ilk değer verilip aralık üzerinde belirtilen ikili işleçlerden birini std::plus<>() kullanarak bir özel ön ek toplamı işlemi hesaplar. Sonuçları belirtilen hedefte başlayan aralığa yazar. Özel ön ek toplamı, n. giriş öğesinin n. toplama dahil olmadığı anlamına gelir. Yürütme ilkesi bağımsız değişkeni içeren aşırı yüklemeler belirtilen ilkeye göre yürütülür. Toplama rastgele bir sırada gerçekleştirilebilir.

template<class InputIterator, class OutputIterator, class Type, class BinaryOperation, class UnaryOperation>
OutputIterator transform_exclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation, class UnaryOperation>
ForwardIterator2 transform_exclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

Parametreler

Exec
Yürütme ilkesi.

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

sonuç
İlk öğeyi, belirtilen işlemin toplamlarının veya sonuçlarının depolandığı hedef aralığı ele alan bir çıkış yineleyicisi.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

unary_op
Belirtilen aralıktaki her öğeye uygulanacak birli işlem.

transform_inclusive_scan

Bir aralığın öğelerini belirtilen birli işleçle dönüştürür, ardından ilk değer verilip aralık üzerinde belirtilen ikili işleçlerden birini std::plus<>() kullanarak kapsayıcı bir ön ek toplamı işlemi hesaplar. Sonuçları belirtilen hedefte başlayan aralığa yazar. Kapsayıcı ön ek toplamı, n. giriş öğesinin n. toplama dahil olduğu anlamına gelir. Yürütme ilkesi bağımsız değişkeni içeren aşırı yüklemeler belirtilen ilkeye göre yürütülür. Toplama rastgele bir sırada gerçekleştirilebilir.

template<class InputIterator, class OutputIterator, class BinaryOperation, class UnaryOperation>
OutputIterator transform_inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class InputIterator, class OutputIterator, class BinaryOperation, class UnaryOperation, class Type>
OutputIterator transform_inclusive_scan(
    InputIterator first,
    InputIterator last,
    OutputIterator result,
    BinaryOperation binary_op,
    UnaryOperation unary_op,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class UnaryOperation>
ForwardIterator2 transform_inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class BinaryOperation, class UnaryOperation, class Type>
ForwardIterator2 transform_inclusive_scan(
    ExecutionPolicy&& exec,
    ForwardIterator1 first,
    ForwardIterator1 last,
    ForwardIterator2 result,
    BinaryOperation binary_op,
    UnaryOperation unary_op,
    Type init);

Parametreler

Exec
Yürütme ilkesi.

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

sonuç
İlk öğeyi, belirtilen işlemin toplamlarının veya sonuçlarının depolandığı hedef aralığı ele alan bir çıkış yineleyicisi.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

unary_op
Belirtilen aralıktaki her öğeye uygulanacak birli işlem.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

transform_reduce

Bir dizi öğeyi dönüştürür, ardından dönüştürülen öğeleri rastgele sırada azaltan bir functor uygular. Etkili bir şekilde, ardından bir transform reduce.

template<class InputIterator1, class InputIterator2, class Type>
Type transform_reduce(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    Type init);

template<class InputIterator1, class InputIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type transform_reduce(
    InputIterator1 first1,
    InputIterator1 last1,
    InputIterator2 first2,
    Type init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

template<class InputIterator, class Type, class BinaryOperation, class UnaryOperation>
Type transform_reduce(
    InputIterator first,
    InputIterator last,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    Type init);

template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2, class Type, class BinaryOperation1, class BinaryOperation2>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator1 first1,
    ForwardIterator1 last1,
    ForwardIterator2 first2,
    Type init,
    BinaryOperation1 binary_op1,
    BinaryOperation2 binary_op2);

template<class ExecutionPolicy, class ForwardIterator, class Type, class BinaryOperation, class UnaryOperation>
Type transform_reduce(
    ExecutionPolicy&& exec,
    ForwardIterator first,
    ForwardIterator last,
    Type init,
    BinaryOperation binary_op,
    UnaryOperation unary_op);

Parametreler

Exec
Yürütme ilkesi.

birinci
binary_op kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

ilk1
binary_op1 kullanarak toplama veya birleştirme için aralıktaki ilk öğeyi adresleyen bir giriş yineleyicisi.

son
Binary_op kullanarak toplama veya birleştirme için aralıktaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

son1
Binary_op1 kullanarak toplama veya birleştirme aralığındaki son öğeyi ele alan bir giriş yineleyicisi, yinelenen birikmeye dahil edilen son öğenin ötesindeki bir konumdur.

sonuç
İlk öğeyi, belirtilen işlemin toplamlarının veya sonuçlarının depolandığı hedef aralığı ele alan bir çıkış yineleyicisi.

init
Her öğenin sırayla eklendiği veya binary_op kullanılarak birleştirildiği bir başlangıç değeri.

binary_op
Belirtilen aralıktaki her öğeye uygulanacak ikili işlem ve önceki uygulamalarının sonucu.

unary_op
Belirtilen aralıktaki her öğeye uygulanacak birli işlem.

Dönüş değeri

Dönüştürülen sonuç daha sonra azaltıldı.