Home | Libraries | People | FAQ | More |
Subtraction |
intervals |
interval |
interval |
element |
element |
---|---|---|---|---|---|
|
|||||
|
|||||
|
|||||
|
|||||
|
1 |
||||
|
1 |
Functions and operators that implement Subtraction on icl objects are given in the table above.
Description of Subtraction |
|
---|---|
|
Subtraction on Sets implements set difference |
|
Subtraction on Maps implements a map
difference function similar to set
difference. If, on subtraction of an element value
pair Find more on subtractability of maps and related semantic issues following the links. |
The admissible combinations of types for subtraction functions can be summarized in the overload table below:
// overload table for T\P| e i b p T& T::subtract(const P&) ---+-------- T& subtract(T&, const P&) s | s m | m S | S S M | M M
The next table contains complexity characteristics for subtract
.
Table 1.24. Time Complexity for function subtract on icl containers
|
domain |
interval |
domain |
interval |
---|---|---|---|---|
O(log n) |
||||
O(log n) |
O(log n) |
|||
O(log n) |
amortized |
|||
O(log n) |
O(n) |
O(log n) |
O(n) |
As presented in the overload tables for operator
-=
more type combinations are provided
for subtraction than for addition.
// overload tables for element containers: interval containers: T& operator -= (T&, const P&) -= | e b s m -= | e i b p S M ---+-------- ---+------------ s | s s S | S S S m | m m m m M | M M M M M M
Subtraction provides the reverse operation of an addition for these overloads,
// Reverse addition -= | e b s m -= | e i b p S M ---+-------- ---+------------ s | s s S | S S S m | m m M | M M M
and you can erase parts of icl::maps
or interval_maps
using key values, intervals or
element or interval sets using these overloads:
// Erasure by key objects -= | e b s m -= | e i b p S M ---+-------- ---+------------ s | s s S | S S S m | m m M | M M M
On Sets both function groups fall together as set difference.
Complexity characteristics for inplace subtraction operations are given by the next tables where
n = iterative_size(y); m = iterative_size(x); //if P is a container type
Table 1.26. Time Complexity for inplace Subtraction on interval containers
|
domain |
interval |
domain |
interval |
interval |
interval |
---|---|---|---|---|---|---|
interval_sets |
O(log n) |
amortized |
O(m log(n+m)) |
|||
interval_maps |
O(log n) |
amortized |
O(log n) |
O(n) |
O(m log(n+m)) |
O(m log(n+m)) |
The admissible overloads for the infix subtraction
operator -
which is a non commutative operation is given by the next overload table.
// overload tables for - | e b s m - | e i b p S M T operator - (T, const P&) ---+-------- ---+------------ s | s s S | S S S m | m m m m M | M M M M M M
Subtraction |
Types |
Description |
---|---|---|
|
subtract right_over = left_subtract(right, left_minuend); ... d) : right ... c) : left_minuend [c d) : right_over
|
|
|
subtract left_over = right_subtract(left, right_minuend); [a ... : left [b ... : right_minuend [a b) : left_over
|
See also . . .
Back to section . . .