Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::transform_exclusive_scan

      From cppreference.com
      <cpp‎ |algorithm
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      transform_exclusive_scan
      (C++17)

      Operations on uninitialized memory
       
       
      Defined in header<numeric>
      template<class InputIt,class OutputIt,class T,

               class BinaryOp,class UnaryOp>
      OutputIt transform_exclusive_scan
         ( InputIt first, InputIt last, OutputIt d_first, T init,

            BinaryOp binary_op, UnaryOp unary_op);
      (1)(since C++17)
      (constexpr since C++20)
      template<class ExecutionPolicy,

               class ForwardIt1,class ForwardIt2,class T,
               class BinaryOp,class UnaryOp>
      ForwardIt2 transform_exclusive_scan
         ( ExecutionPolicy&& policy,
            ForwardIt1 first, ForwardIt1 last, ForwardIt2 d_first, T init,

            BinaryOp binary_op, UnaryOp unary_op);
      (2)(since C++17)
      1) Computes the exclusive prefix sum usingop.
      For each integeri in[0std::distance(first, last)), performs the following operations in order:
      1. Creates a sequence which is formed byinit followed by the values transformed from the elements of[firstiter) in order byunary_op, whereiter is the nextith iterator offirst.
      2. Computes the generalized noncommutative sum of the sequence overbinary_op.
      3. Assigns the result to*dest, wheredest is the nextith iterator ofd_first.
      2) Same as(1), but executed according topolicy.
      This overload participates in overload resolution only if all following conditions are satisfied:

      std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> istrue.

      (until C++20)

      std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> istrue.

      (since C++20)

      Thegeneralized noncommutative sum of a sequence of elements over a binary operationbinary_op is defined as follows:

      • If the sequence only has one element, the sum is the value of the element.
      • Otherwise, performs the following operations in order:
      1. Selects any two adjacent elementselem1 andelem2 from the sequence.
      2. Calculatesbinary_op(elem1, elem2) and replaces the two elements in the sequence with the result.
      3. Repeats steps 1 and 2 until there is only one element in the sequence.


      The result is non-deterministic if thebinary_op is not associative (such as floating-point addition).

      If any of the following values is not convertible toT, the program is ill-formed:

      • binary_op(init, init)
      • binary_op(init, unary_op(*first))
      • binary_op(unary_op(*first), unary_op(*first))

      If any of the following conditions is satisfied, the behavior is undefined:

      • T is notMoveConstructible.
      • unary_op orbinary_op modifies any element of[firstlast).
      • unary_op orbinary_op invalidates any iterator or subrange of[firstlast].

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to sum
      d_first - the beginning of the destination range, may be equal tofirst
      policy - theexecution policy to use
      init - the initial value
      unary_op - unaryFunctionObject that will be applied to each element of the input range. The return type must be acceptable as input tobinary_op.
      binary_op - binaryFunctionObject that will be applied in to the result ofunary_op, the results of otherbinary_op, andinit.
      Type requirements
      -
      InputIt must meet the requirements ofLegacyInputIterator.
      -
      OutputIt must meet the requirements ofLegacyOutputIterator.
      -
      ForwardIt1, ForwardIt2 must meet the requirements ofLegacyForwardIterator.

      [edit]Return value

      Iterator to the element past the last element written.

      [edit]Complexity

      Given\(\scriptsize N\)N asstd::distance(first, last):

      1,2)\(\scriptsize O(N)\)O(N) applications ofunary_op andbinary_op respectively.

      [edit]Exceptions

      The overload with a template parameter namedExecutionPolicy reports errors as follows:

      • If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
      • If the algorithm fails to allocate memory,std::bad_alloc is thrown.

      [edit]Notes

      unary_op is never applied toinit.

      [edit]Example

      Run this code
      #include <functional>#include <iostream>#include <iterator>#include <numeric>#include <vector> int main(){std::vector data{3,1,4,1,5,9,2,6}; auto times_10=[](int x){return x*10;}; std::cout<<"10 times exclusive sum: ";    std::transform_exclusive_scan(data.begin(), data.end(),std::ostream_iterator<int>(std::cout," "),0,std::plus<int>{}, times_10);std::cout<<"\n10 times inclusive sum: ";std::transform_inclusive_scan(data.begin(), data.end(),std::ostream_iterator<int>(std::cout," "),std::plus<int>{}, times_10);std::cout<<'\n';}

      Output:

      10 times exclusive sum: 0 30 40 80 90 140 230 250 10 times inclusive sum: 30 40 80 90 140 230 250 310

      [edit]See also

      computes the partial sum of a range of elements
      (function template)[edit]
      similar tostd::partial_sum, excludes theith input element from theith sum
      (function template)[edit]
      applies an invocable, then calculates inclusive scan
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/transform_exclusive_scan&oldid=180310"

      [8]ページ先頭

      ©2009-2025 Movatter.jp