A left join is a type of relational join operation that combines two datasets based on a common column or variable. The result of a left join includes all the rows from the left dataset and any matching rows from the right dataset.

apply for the pipeline progress report

value range of parameter x should be in numeric range [0,100] if the progress function is invoked in a parallel stack environment.

create data index for the given input data sequence

take the first n items from the given input sequence data

Value Matching

match returns a vector of the positions of (first) matches of its first argument in its second.

find the index of the elements in input sequence x in the source target sequence table

find the index of (where x in table)

https://stackoverflow.com/questions/7530765/get-the-index-of-the-values-of-one-vector-in-another

 first  = c("a", "c", "b");
 second = c("c", "b", "a");
 match(second, first);
 
 #   c b a  <-second 
 [1] 2 3 1

A vector of the same length as x. An integer vector giving the position in table of the first match if there Is a match, otherwise nomatch. If x[i] Is found To equal table[j] Then the value returned In the i-th position Of the Return value Is j, For the smallest possible j. If no match Is found, the value Is nomatch.

Bypasses a specified number of elements in a sequence and then returns the remaining elements.

An System.Collections.Generic.IEnumerable`1 that contains the elements that occur after the specified index in the input sequence.

Returns distinct elements from a sequence by using a specified IEqualityComparer to compare values.

An IEnumerable that contains distinct elements from the source sequence.

A lapply/sapply liked mapping function

Which indices are TRUE?

The which test filter, Give the TRUE indices of a logical object, allowing for array indices.

Unlike most other base R functions this does not coerce to x to logical: only arguments with typeof logical are accepted and others give an error.

an integer vector with length equal to sum(x), i.e., to the number of TRUEs in x; Basically, the result is (1:length(x))[x].

Where is the Min() or Max() or first TRUE or FALSE ?

Determines the location, i.e., index of the (first) minimum or maximum of a numeric (or logical) vector.

Missing and NaN values are discarded.

an integer Or on 64-bit platforms, if length(x) = n>= 2^31 an integer valued double of length 1 Or 0 (iff x has no non-NAs), giving the index of the first minimum Or maximum respectively of x.

If this extremum Is unique (Or empty), the results are the same As (but more efficient than) which(x == min(x, na.rm = True)) Or which(x == max(x, na.rm = True)) respectively.

Logical x – First True Or False

For a logical vector x with both FALSE And TRUE values, which.min(x) And which.max(x) return the index of the first FALSE Or TRUE, respectively, as FALSE < TRUE. However, match(FALSE, x) Or match(TRUE, x) are typically preferred, as they do indicate mismatches.

Where is the Min() or Max() or first TRUE or FALSE ?

Determines the location, i.e., index of the (first) minimum or maximum of a numeric (or logical) vector.

Missing and NaN values are discarded.

an integer Or on 64-bit platforms, if length(x) = n>= 2^31 an integer valued double of length 1 Or 0 (iff x has no non-NAs), giving the index of the first minimum Or maximum respectively of x.

If this extremum Is unique (Or empty), the results are the same As (but more efficient than) which(x == min(x, na.rm = True)) Or which(x == max(x, na.rm = True)) respectively.

Logical x – First True Or False

For a logical vector x with both FALSE And TRUE values, which.min(x) And which.max(x) return the index of the first FALSE Or TRUE, respectively, as FALSE < TRUE. However, match(FALSE, x) Or match(TRUE, x) are typically preferred, as they do indicate mismatches.

Returns the first element of a sequence.

The first element in the specified sequence. NULL value will be returned if there is no element could be found in the given seuqnece or under the given test condition.

get the last element in the sequence

group vector/list by a given evaluator or group a dataframe rows by the cell values of a specific column.

this function could also accept a numeric tolerance error as the getKey for do numeric bin grouping

get key value from the input data sequence and then populate the key with the original value elements.

element names will be returns as object reference if the given sequence** is a list. **

Sorting or Ordering Vectors

Sort (or order) a vector or factor (partially) into ascending or descending order. For ordering along more than one variable, e.g., for sorting data frames, see order.

sort is a generic function for which methods can be written, and sort.int is the internal method which is compatible with S if only the first three arguments are used. The Default sort method makes use Of order For classed objects, which In turn makes use Of the generic Function xtfrm (And can be slow unless a xtfrm method has been defined Or Is.numeric(x) Is True). Complex values are sorted first by the real part, Then the imaginary part. The "auto" method selects "radix" for short (less than 2^31 elements) numeric vectors, integer vectors, logical vectors And factors; otherwise, "shell". Except for method "radix", the sort order for character vectors will depend on the collating sequence of the locale in use: see Comparison. The sort order For factors Is the order Of their levels (which Is particularly appropriate For ordered factors). If partial Is Not NULL, it Is taken to contain indices of elements of the result which are to be placed in their correct positions in the sorted array by partial sorting. For each of the result values in a specified position, any values smaller than that one are guaranteed to have a smaller index in the sorted array And any values which are greater are guaranteed to have a bigger index in the sorted array. (This Is included for efficiency, And many of the options are Not available for partial sorting. It Is only substantially more efficient if partial has a handful of elements, And a full sort Is done (a Quicksort if possible) if there are more than 10.) Names are discarded for partial sorting. Method "shell" uses Shellsort (an O(n^{4/3}) variant from Sedgewick (1986)). If x has names a stable modification Is used, so ties are Not reordered. (This only matters if names are present.) Method "quick" uses Singleton (1969)'s implementation of Hoare's Quicksort method and is only available when x is numeric (double or integer) and partial is NULL. (For other types of x Shellsort is used, silently.) It is normally somewhat faster than Shellsort (perhaps 50% faster on vectors of length a million and twice as fast at a billion) but has poor performance in the rare worst case. (Peto's modification using a pseudo-random midpoint is used to make the worst case rarer.) This is not a stable sort, and ties may be reordered. Method "radix" relies on simple hashing to scale time linearly with the input size, i.e., its asymptotic time complexity Is O(n). The specific variant And its implementation originated from the data.table package And are due to Matt Dowle And Arun Srinivasan. For small inputs (< 200), the implementation uses an insertion sort (O(n^2)) that operates in-place to avoid the allocation overhead of the radix sort. For integer vectors of range less than 100,000, it switches to a simpler And faster linear time counting sort. In all cases, the sort Is stable; the order of ties Is preserved. It Is the default method for integer vectors And factors. The "radix" method generally outperforms the other methods, especially for character vectors And small integers. Compared to quick sort, it Is slightly faster for vectors with large integer Or real values (but unlike quick sort, radix Is stable And supports all na.last options). The implementation Is orders of magnitude faster than shell sort for character vectors, in part thanks to clever use of the internal CHARSXP table. However, there are some caveats with the radix sort If x Is a character vector, all elements must share the same encoding. Only UTF-8 (including ASCII) And Latin-1 encodings are supported. Collation always follows the "C" locale. Long vectors(with more than 2^32 elements) And complex vectors are Not supported yet.

For sort, the result depends on the S3 method which is dispatched. If x does not have a class sort.int is used and it description applies. For classed objects which do not have a specific method the default method will be used and is equivalent to x[order(x, ...)]: this depends on the class having a suitable method for [ (and also that order will work, which requires a xtfrm method). For sort.int the value Is the sorted vector unless index.return Is true, when the result Is a list with components named x And ix containing the sorted numbers And the ordering index vector. In the latter case, if method == "quick" ties may be reversed in the ordering (unlike sort.list) as quicksort Is Not stable. For method == "radix", index.return Is supported for all na.last modes. The other methods only support index.return when na.last Is NA. The index vector refers To element numbers after removal Of NAs: see order If you want the original element numbers. All attributes are removed from the Return value (see Becker et al, 1988, p.146) except names, which are sorted. (If Partial Is specified even the names are removed.) Note that this means that the returned value has no Class, except For factors And ordered factors (which are treated specially And whose result Is transformed back To the original Class).

Sorts the elements of a sequence in ascending order according to a key.

An System.Linq.IOrderedEnumerable`1 whose elements are sorted according to a key. The sort result could be situations:

1. a vector which is sort by the element evaluated value
2. a list which is sort by the specific element value
3. a dataframe which is sort its rows by a specific column value

reverse a given sequence

Are Some Values True?

Given a set of logical vectors, is at least one of the values true?

The value is a logical vector of length one.

Let x denote the concatenation of all the logical vectors in ... (after coercion), after removing NAs if requested by na.rm = TRUE.

The value returned Is True If at least one Of the values In x Is True, And False If all Of the values In x are False (including If there are no values). Otherwise the value Is NA (which can only occur If na.rm = False And ... contains no True values And at least one NA value).

Are All Values True?

Given a set of logical vectors, are all of the values true?

The value is a logical vector of length one.

Let x denote the concatenation of all the logical vectors in ... (after coercion), after removing NAs if requested by na.rm = TRUE.

The value returned Is True If all Of the values In x are True (including If there are no values), And False If at least one Of the values In x Is False. Otherwise the value Is NA (which can only occur If na.rm = False And ... contains no False values And at least one NA value).

split content sequence with a given condition as element delimiter.

the generated result is different between the vector/list:

• for vector data: split the value array directly
• for list data: split the list keys array and then break the input list data into multiple parts by keys

Keep or drop columns using their names and types

Select (and optionally rename) variables in a data frame, using a concise mini-language that makes it easy to refer to variables based on their name (e.g. a:f selects all columns from a on the left to f on the right) or type (e.g. where(is.numeric) selects all numeric columns).

An object of the same type as .data. The output has the following properties:

1. Rows are Not affected.
2. Output columns are a subset Of input columns, potentially With a different order. Columns will be renamed If new_name = old_name form Is used.
3. Data frame attributes are preserved.
4. Groups are maintained; you can't select off grouping variables.

text labeler