R: Mathematical Fuzzy Tuple

FuzzyTuple {set6} | R Documentation

## Mathematical Fuzzy Tuple

### Description

A general FuzzyTuple object for mathematical fuzzy tuples, inheriting from `FuzzySet`.

### Details

Fuzzy tuples generalise standard mathematical tuples to allow for fuzzy relationships. Whereas a standard, or crisp, tuple assumes that an element is either in a tuple or not, a fuzzy tuple allows an element to be in a tuple to a particular degree, known as the membership function, which quantifies the inclusion of an element by a number in [0, 1]. Thus a (crisp) tuple is a fuzzy tuple where all elements have a membership equal to 1. Similarly to Tuples, elements do not need to be unique and the ordering does matter, FuzzySets are special cases where the ordering does not matter and elements must be unique.

### Super classes

`set6::Set` -> `set6::FuzzySet` -> `FuzzyTuple`

### Methods

#### Public methods

- `FuzzyTuple$equals()`

- `FuzzyTuple$isSubset()`

- `FuzzyTuple$alphaCut()`

- `FuzzyTuple$clone()`

Inherited methods

- `set6::Set$add()`

- `set6::Set$contains()`

- `set6::Set$multiplicity()`

- `set6::Set$print()`

- `set6::Set$remove()`

- `set6::Set$summary()`

- `set6::FuzzySet$core()`

- `set6::FuzzySet$inclusion()`

- `set6::FuzzySet$initialize()`

- `set6::FuzzySet$membership()`

- `set6::FuzzySet$strprint()`

- `set6::FuzzySet$support()`

#### Method `equals()`

Tests if two sets are equal.

##### Usage

    FuzzyTuple$equals(x, all = FALSE)

##### Arguments

`x`

  Set or vector of Sets.

`all`

  logical. If `FALSE` tests each `x` separately. Otherwise returns `TRUE` only if all `x` pass test.

##### Details

Two fuzzy sets are equal if they contain the same elements with the same memberships and in the same order. Infix operators can be used for:

Equal | `==`
Not equal | `!=`

##### Returns

If `all` is `TRUE` then returns `TRUE` if all `x` are equal to the Set, otherwise `FALSE`. If `all` is `FALSE` then returns a vector of logicals corresponding to each individual element of `x`.

#### Method `isSubset()`

Test if one set is a (proper) subset of another

##### Usage

    FuzzyTuple$isSubset(x, proper = FALSE, all = FALSE)

##### Arguments

`x`

  any. Object or vector of objects to test.

`proper`

  logical. If `TRUE` tests for proper subsets.

`all`

  logical. If `FALSE` tests each `x` separately. Otherwise returns `TRUE` only if all `x` pass test.

##### Details

If using the method directly, and not via one of the operators then the additional boolean argument `proper` can be used to specify testing of subsets or proper subsets. A Set is a proper subset of another if it is fully contained by the other Set (i.e. not equal to) whereas a Set is a (non-proper) subset if it is fully contained by, or equal to, the other Set.

Infix operators can be used for:

Subset | `<`
Proper Subset | `<=`
Superset | `>`
Proper Superset | `>=`

##### Returns

If `all` is `TRUE` then returns `TRUE` if all `x` are subsets of the Set, otherwise `FALSE`. If `all` is `FALSE` then returns a vector of logicals corresponding to each individual element of `x`.

#### Method `alphaCut()`

The alpha-cut of a fuzzy set is defined as the set

A_α = {x ε F | m ≥ α}

where x is an element in the fuzzy set, F, and m is the corresponding membership.

##### Usage

    FuzzyTuple$alphaCut(alpha, strong = FALSE, create = FALSE)

##### Arguments

`alpha`

  numeric in [0, 1] to determine which elements to return

`strong`

  logical, if `FALSE` (default) then includes elements greater than or equal to alpha, otherwise only strictly greater than

`create`

  logical, if `FALSE` (default) returns the elements in the alpha cut, otherwise returns a crisp set of the elements

##### Returns

Elements in FuzzyTuple or a Set of the elements.

#### Method `clone()`

The objects of this class are cloneable with this method.

##### Usage

    FuzzyTuple$clone(deep = FALSE)

##### Arguments

`deep`

  Whether to make a deep clone.

### See Also

Other sets: `ConditionalSet`, `FuzzyMultiset`, `FuzzySet`, `Interval`, `Multiset`, `Set`, `Tuple`

### Examples

    # Different constructors
    FuzzyTuple$new(1, 0.5, 2, 1, 3, 0)
    FuzzyTuple$new(elements = 1:3, membership = c(0.5, 1, 0))

    # Crisp sets are a special case FuzzyTuple
    # Note membership defaults to full membership
    FuzzyTuple$new(elements = 1:5) == Tuple$new(1:5)

    f <- FuzzyTuple$new(1, 0.2, 2, 1, 3, 0)
    f$membership()
    f$alphaCut(0.3)
    f$core()
    f$inclusion(0)
    f$membership(0)
    f$membership(1)

    # Elements can be duplicated, and with different memberships,
    #  although this is not necessarily sensible.
    FuzzyTuple$new(1, 0.1, 1, 1)

    # More important is ordering.
    FuzzyTuple$new(1, 0.1, 2, 0.2) != FuzzyTuple$new(2, 0.2, 1, 0.1)
    FuzzySet$new(1, 0.1, 2, 0.2) == FuzzySet$new(2, 0.2, 1, 0.1)

[Package set6 version 0.2.3 Index]