|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{refimprove|date=October 2011}}
| | I may not say which my case is going to be like everyone else's. Following all, no 2 cases are precisely the same. Hemorrhoids will vary from individual to individual and case to case. What I may say, though, is constantly which I identified an internal hemorrhoid treatment that worked for me plus that I may claim it's probably to function for you, because well. Let's not get too formal with last names and such. After all, piles aren't a disorder that anybody is pretty pleased to have or even discuss. It requirements to be debated, though. I need fellow hemorrhoid sufferers including me to understand the greatest way to escape it the way I did thus.<br><br>Then there are natural [http://hemorrhoidtreatmentfix.com/prolapsed-hemorrhoid-treatment prolapsed hemorrhoid treatment] s. Aside from making we feel relieved, it may additionally strengthen your vein walls plus boost vascular circulation. In this method you may be preventing internal plus external hemorrhoid to happen. It will furthermore stop hemorrhoid itching and bleeding. The natural hemorrhoid treatment is the greatest thing that you can utilize because it does not just do away with the pain, yet also treat the casual source of hemorrhoid. It helps you ease the symptoms of hemorrhoid like itching burning, swelling and anal discomfort.<br><br>Take a "sitz" bath with warm water. Do this 3 or 4 time a day for 15 minutes each time. This treatment is especially efficient at reducing pain and swelling and is absolutely convenient to do.<br><br>Until recent years, many people unfortunate enough to be suffering the pain, swelling, itching and bleeding of their hemorrhoid symptoms were left with no hope of ever being cured. They had no choice yet to employ the same old hemorrhoids cream, hemorrhoid ointment, gels and even suppositories. Many individuals turned to painful operation which wasn't even a permanent help.<br><br>Thankfully, there are individuals inside this world with curious minds that never accept the status quo. People that would quite get to the root of a issue rather of placing up with a temporary answer, only to have it re-appear later.<br><br>Since the largest cause of hemorrhoids is strained bowel movements and hard stools (chronic constipation), various people may discover extended term relief from hemorrhoids by acquiring a solutions which enables them to "go" more frequently and conveniently. Chronic constipation is caused inside great piece because because a society you are a quick food nation. We eat lots of processed food, plus not almost enough all-natural or fresh foods. I challenge you to take a look at the labels on the food for "dietary fiber content" when you suffer from constipation. My guess is that you'll find on many foods you eat the nutritional fiber content to be low.<br><br>You are able to apply ice packs. The application of the ice packs could lower the swelling of the affected region. You really have to re-apply after certain limited minutes. You have to do it 3 to 4 times a day. Sitz shower is regarded as the greatest treatments which you can do. You have to soak the affected region in the warm water for regarding 15 minutes about 3 to 4 instances a day too. This may aid we shrink the hemorrhoid. Complete modification with the eating habit is equally significant. We have to eat a great deal of foods that is wealthy in fibers. It may moreover assist when you are going to drink a lot of liquids. This usually aid you soften the stool plus avoid from straining throughout the bowel movement. |
| In [[computer science]], a '''set''' is an [[abstract data structure]] that can store certain values, without any particular [[sequence|order]], and no repeated values. It is a computer implementation of the [[mathematics|mathematical]] concept of a [[finite set]]. Unlike most other collection types, rather than retrieving a specific element from a set, one typically tests a value for membership in a set.
| |
| | |
| Some set data structures are designed for '''static''' or '''frozen sets''' that do not change after they are constructed. Static sets allow only query operations on their elements — such as checking whether a given value is in the set, or enumerating the values in some arbitrary order. Other variants, called '''dynamic''' or '''mutable sets''', allow also the insertion and deletion of elements from the set.
| |
| | |
| An abstract data structure is a collection, or aggregate, of data. The data may be booleans, numbers, characters, or other data structures. If one considers the structure yielded by packaging<ref>"Packaging" consists in supplying a container for an aggregation of objects in order to turn them into a single object. Consider a function call: without packaging, a function can be called to act upon a bunch only by passing each bunch element as a separate argument, which complicates the function's signature considerably (and is just not possible in some programming languages). By packaging the bunch's elements into a set, the function may now be called upon a single, elementary argument: the set object (the bunch's package).</ref> or indexing,<ref>Indexing is possible when the elements being considered are [[order theory|totally ordered]]. Being without order, the elements of a multiset (for example) do not have lesser/greater or preceding/succeeding relationships: they can only be compared in absolute terms (same/different).</ref> there are four basic data structures:<ref name="Hehner1981">{{Citation |first1=Eric C. R. |last1=Hehner |title=Bunch Theory: A Simple Set Theory for Computer Science |journal=Information Processing Letters |volume=12 |issue=1 |year=1981 |doi=10.1016/0020-0190(81)90071-5 |pages=26 }}</ref><ref name="Hehner2004">{{Citation |first1=Eric C. R. |last1=Hehner |title=A Practical Theory of Programming, second edition |year=2004 |url=http://www.cs.utoronto.ca/~hehner/aPToP/ }}</ref>
| |
| # unpackaged, unindexed: bunch
| |
| # packaged, unindexed: set
| |
| # unpackaged, indexed: string (sequence)
| |
| # packaged, indexed: list (array)
| |
| In this view, the contents of a set are a bunch, and isolated data items are elementary bunches (elements). Whereas sets ''contain'' elements, bunches ''consist of'' elements.
| |
| | |
| Further structuring may be achieved by considering the multiplicity of elements (sets become multisets, bunches become hyperbunches)<ref name="Hehner2012">{{Citation |first1=Eric C. R. |last1=Hehner |title=A Practical Theory of Programming, 2012-3-30 edition |year=2012 |url=http://www.cs.toronto.edu/~hehner/aPToP/ }}</ref> or their homogeneity (a record is a set of fields, not necessarily all of the same type).
| |
| | |
| ==Implementations==
| |
| A set can be implemented in many ways. For example, one can use a [[list (computer science)|list]], ignoring the order of the elements and taking care to avoid repeated values. Sets are often implemented using various flavors of [[tree (data structure)|trees]], [[trie]]s, or [[hash tables]].
| |
| | |
| A set can be seen, and implemented, as a (partial) [[associative array]], in which the value of each key-value pair has the [[unit type]].
| |
| | |
| ==Type theory==
| |
| In [[type theory]], sets are generally identified with their [[indicator function]] (characteristic function): accordingly, a set of values of type <math>A</math> may be denoted by <math>2^{A}</math> or <math>\mathcal{P}(A)</math>. (Subtypes and subsets may be modeled by [[refinement type]]s, and [[quotient set]]s may be replaced by [[setoid]]s.) The characteristic function <math>F</math> of a set <math>S</math> is defined as:
| |
| :<math>F(x) = \begin{cases}
| |
| 1, & \mbox{if } x \in S \\
| |
| 0, & \mbox{if } x \not \in S
| |
| \end{cases}
| |
| </math>
| |
| | |
| In theory, many other abstract data structures can be viewed as set structures with additional operations and/or additional [[axiom]]s imposed on the standard operations. For example, an abstract [[Heap data structure|heap]] can be viewed as a set structure with a <code>min(''S'')</code> operation that returns the element of smallest value.
| |
| | |
| ==Operations==
| |
| | |
| === Core set-theoretical operations ===
| |
| One may define the operations of the [[algebra of sets]]:
| |
| * <code>union(''S'',''T'')</code>: returns the [[union (set theory)|union]] of sets ''S'' and ''T''.
| |
| * <code>intersection(''S'',''T'')</code>: returns the [[intersection (set theory)|intersection]] of sets ''S'' and ''T''.
| |
| * <code>difference(''S'',''T'')</code>: returns the [[difference (set theory)|difference]] of sets ''S'' and ''T''.
| |
| * <code>subset(''S'',''T'')</code>: a predicate that tests whether the set ''S'' is a [[subset]] of set ''T''.
| |
| | |
| === Static sets ===
| |
| Typical operations that may be provided by a static set structure ''S'' are:
| |
| * <code>is_element_of(''x'',''S'')</code>: checks whether the value ''x'' is in the set ''S''.
| |
| * <code>is_empty(''S'')</code>: checks whether the set ''S'' is empty.
| |
| * <code>size(''S'')</code> or <code>[[cardinality]](''S'')</code>: returns the number of elements in ''S''.
| |
| * <code>[[iterator|iterate]](''S'')</code>: returns a function that returns one more value of ''S'' at each call, in some arbitrary order.
| |
| * <code>enumerate(''S'')</code>: returns a list containing the elements of ''S'' in some arbitrary order.
| |
| * <code>build(''x''<sub>1</sub>,''x''<sub>2</sub>,…,''x''<sub>''n''</sub>,)</code>: creates a set structure with values ''x''<sub>1</sub>,''x''<sub>2</sub>,…,''x''<sub>''n''</sub>.
| |
| * <code>create_from(''collection'')</code>: creates a new set structure containing all the elements of the given [[collection (computing)|collection]] or all the elements returned by the given [[iterator]].
| |
| | |
| === Dynamic sets ===
| |
| Dynamic set structures typically add:
| |
| * <code>create()</code>: creates a new, initially empty set structure.
| |
| ** <code>create_with_capacity(''n'')</code>: creates a new set structure, initially empty but capable of holding up to ''n'' elements.
| |
| * <code>add(''S'',''x'')</code>: adds the element ''x'' to ''S'', if it is not present already.
| |
| * <code>remove(''S'', ''x'')</code>: removes the element ''x'' from ''S'', if it is present.
| |
| * <code>capacity(''S'')</code>: returns the maximum number of values that ''S'' can hold.
| |
| | |
| Some set structures may allow only some of these operations. The cost of each operation will depend on the implementation, and possibly also on the particular values stored in the set, and the order in which they are inserted.
| |
| | |
| === Additional operations ===
| |
| There are many other operations that can (in principle) be defined in terms of the above, such as:
| |
| * <code>pop(''S'')</code>: returns an arbitrary element of ''S'', deleting it from ''S''.
| |
| * <code>[[Map (higher-order function)|map]](''F'',''S'')</code>: returns the set of distinct values resulting from applying function ''F'' to each element of ''S''.
| |
| * <code>[[Filter (higher-order function)|filter]](''P'',''S'')</code>: returns the subset containing all elements of ''S'' that satisfy a given [[predicate (mathematical logic)|predicate]] ''P''.
| |
| * <code>[[Fold (higher-order function)|fold]](''A<sub>0</sub>'',''F'',''S'')</code>: returns the value ''A''<sub>|''S''|</sub> after applying <code>''A<sub>i+1</sub>'' := ''F''(''A<sub>i</sub>'', ''e'')</code> for each element ''e'' of ''S''.
| |
| * <code>clear(''S'')</code>: delete all elements of ''S''.
| |
| * <code>equal(''S<sub>1</sub>'', ''S<sub>2</sub>'')</code>: checks whether the two given sets are equal (i.e. contain all and only the same elements).
| |
| * <code>hash(''S'')</code>: returns a [[hash value]] for the static set ''S'' such that if <code>equal(''S<sub>1</sub>'', ''S<sub>2</sub>'')</code> then <code>hash(''S<sub>1</sub>'') = hash(''S<sub>2</sub>'')</code>
| |
| | |
| Other operations can be defined for sets with elements of a special type:
| |
| * <code>sum(''S'')</code>: returns the sum of all elements of ''S'' for some definition of "sum". For example, over integers or reals, it may be defined as <code>fold(0, add, ''S'')</code>.
| |
| * <code>nearest(''S'',''x'')</code>: returns the element of ''S'' that is closest in value to ''x'' (by some [[Metric (mathematics)|metric]]).
| |
| * <code>min(''S'')</code>, <code>max(''S'')</code>: returns the minimum/maximum element of ''S''.
| |
| | |
| == Implementations ==
| |
| Sets can be implemented using various [[data structure]]s, which provide different time and space trade-offs for various operations. Some implementations are designed to improve the efficiency of very specialized operations, such as <code>nearest</code> or <code>union</code>. Implementations described as "general use" typically strive to optimize the <code>element_of</code>, <code>add</code>, and <code>delete</code> operations.
| |
| | |
| As sets can be interpreted as a kind of map (by the indicator function), sets are commonly implemented in the same way as maps (associative arrays), namely, a [[self-balancing binary search tree]] for sorted sets (which has O(log n) for most operations), or a [[hash table]] for unsorted sets (which has O(1) average-case, but O(n) worst-case, for most operations). A sorted linear hash table<ref>{{Citation |title=Sorted Linear Hash Table |first1=Thomas |last1=Wang |url=http://www.concentric.net/~Ttwang/tech/sorthash.htm |year=1997 }}</ref> may be used to provide deterministically ordered sets.
| |
| | |
| Other popular methods include [[Array data structure|arrays]]. In particular a subset of the integers 1..''n'' can be implemented efficiently as an ''n''-bit [[bit array]], which also support very efficient union and intersection operations. A [[Bloom map]] implements a set probabilistically, using a very compact representation but risking a small chance of false positives on queries.
| |
| | |
| The Boolean set operations can be implemented in terms of more elementary operations (<code>pop</code>, <code>clear</code>, and <code>add</code>), but specialized algorithms may yield lower asymptotic time bounds. If sets are implemented as sorted lists, for example, the naive algorithm for <code>union(''S'',''T'')</code> will take code proportional to the length ''m'' of ''S'' times the length ''n'' of ''T''; whereas a variant of the [[Merge algorithm|list merging algorithm]] will do the job in time proportional to ''m''+''n''. Moreover, there are specialized set data structures (such as the [[union-find algorithm|union-find data structure]]) that are optimized for one or more of these operations, at the expense of others.
| |
| | |
| == Language support ==
| |
| One of the earliest languages to support sets was [[Pascal programming language|Pascal]]; many languages now include it, whether in the core language or in a [[standard library]].
| |
| * [[Java (programming language)|Java]] offers the {{Javadoc:SE|java/util|Set}} [[Interface (computer science)|interface]] to support sets (with the {{Javadoc:SE|java/util|HashSet}} class implementing it using a hash table), and the {{Javadoc:SE|java/util|SortedSet}} sub-interface to support sorted sets (with the {{Javadoc:SE|java/util|TreeSet}} class implementing it using a binary search tree).
| |
| * [[Apple Inc.|Apple]]'s [[Foundation Kit|Foundation framework]] (part of [[Cocoa (API)|Cocoa]]) provides the [[Objective-C]] classes <code>[http://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/NSSet_Class/ NSSet]</code>, <code>[http://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/NSMutableSet_Class/ NSMutableSet]</code>, <code>[http://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/NSCountedSet_Class/ NSCountedSet]</code>, <code>[http://developer.apple.com/library/mac/#documentation/Foundation/Reference/NSOrderedSet_Class/Reference/Reference.html NSOrderedSet]</code>, and <code>[https://developer.apple.com/library/mac/#documentation/Foundation/Reference/NSMutableOrderedSet_Class/Reference/Reference.html NSMutableOrderedSet]</code>. The [[CoreFoundation]] APIs provide the [http://developer.apple.com/documentation/CoreFoundation/Reference/CFSetRef/ CFSet] and [http://developer.apple.com/documentation/CoreFoundation/Reference/CFMutableSetRef/ CFMutableSet] types for use in [[C (programming language)|C]].
| |
| * [[Python (programming language)|Python]] has built-in [http://docs.python.org/library/stdtypes.html#set-types-set-frozenset <code>set</code> and <code>frozenset</code> types] since 2.4, and since Python 3.0 and 2.7, supports non-empty set literals using a curly-bracket syntax, e.g.: <code>{x, y, z}</code>.
| |
| * The [[.NET Framework]] provides the generic <code>[http://msdn.microsoft.com/en-us/library/bb359438.aspx HashSet]</code> and <code>[http://msdn.microsoft.com/en-us/library/dd412070.aspx SortedSet]</code> classes that implement the generic <code>[http://msdn.microsoft.com/en-us/library/dd412081.aspx ISet]</code> interface.
| |
| * [[Smalltalk]]'s class library includes <code>Set</code> and <code>IdentitySet</code>, using equality and identity for inclusion test respectively. Many dialects provide variations for compressed storage (<code>NumberSet</code>, <code>CharacterSet</code>), for ordering (<code>OrderedSet</code>, <code>SortedSet</code>, etc.) or for [[weak reference]]s (<code>WeakIdentitySet</code>).
| |
| * [[Ruby (programming language)|Ruby]]'s standard library includes a <code>[http://ruby-doc.org/stdlib/libdoc/set/rdoc/index.html set]</code> module which contains <code>Set</code> and <code>SortedSet</code> classes that implement sets using hash tables, the latter allowing iteration in sorted order.
| |
| * [[OCaml]]'s standard library contains a <code>Set</code> module, which implements a functional set data structure using binary search trees.
| |
| * The [[Glasgow Haskell Compiler|GHC]] implementation of [[Haskell (programming language)|Haskell]] provides a [http://hackage.haskell.org/packages/archive/containers/0.2.0.1/doc/html/Data-Set.html <code>Data.Set</code>] module, which implements a functional set data structure using binary search trees.
| |
| * The [[Tcl]] [[Tcllib]] package provides a set module which implements a set data structure based upon TCL lists.
| |
| | |
| As noted in the previous section, in languages which do not directly support sets but do support [[associative array]]s, sets can be emulated using associative arrays, by using the elements as keys, and using a dummy value as the values, which are ignored.
| |
| | |
| === In C++ ===
| |
| {{main|set (C++)}}
| |
| In [[C++]], the [[Standard Template Library]] (STL) provides the <code>set</code> template class, which implements a sorted set using a binary search tree; [[Silicon Graphics International|SGI]]'s STL also provides the <code>hash_set</code> template class, which implements a set using a hash table.
| |
| | |
| In sets, the elements themselves are the keys, in contrast to sequenced containers, where elements are accessed using their (relative or absolute) position. Set elements must have a strict weak ordering.
| |
| | |
| ==Multiset==
| |
| A generalization of the notion of a set is that of a '''[[multiset]]''' or '''bag''', which is similar to a set but allows repeated ("equal") values (duplicates). This is used in two distinct senses: either equal values are considered ''identical,'' and are simply counted, or equal values are considered ''equivalent,'' and are stored as distinct items. For example, given a list of people (by name) and ages (in years), one could construct a multiset of ages, which simply counts the number of people of a given age. Alternatively, one can construct a multiset of people, where two people are considered equivalent if their ages are the same (but may be different people and have different names), in which case each pair (name, age) must be stored, and selecting on a given age gives all the people of a given age.
| |
| | |
| Formally, it is possible for objects in computer science to be considered "equal" under some [[equivalence relation]] but still distinct under another relation. Some types of multiset implementations will store distinct equal objects as separate items in the data structure; while others will collapse it down to one version (the first one encountered) and keep a positive integer count of the multiplicity of the element.
| |
| | |
| As with sets, multisets can naturally be implemented using hash table or trees, which yield different performance characteristics.
| |
| | |
| The set of all bags over type T is given by the expression bag T. If by multiset one considers equal items identical and simply counts them, then a multiset can be interpreted as a function from the input domain to the non-negative integers ([[natural number]]s), generalizing the identification of a set with its indicator function. In some cases a multiset in this counting sense may be generalized to allow negative values, as in Python.
| |
| | |
| * C++'s [[Standard Template Library]] implements both sorted and unsorted multisets. It provides the <code>[[Multiset (C++)|multiset]]</code> class for the sorted multiset, as a kind of [[Associative containers (C++)|associative container]], which implements this multiset using a [[self-balancing binary search tree]]. It provides the <code>unordered_multiset</code> class for the unsorted multiset, as a kind of [[Unordered associative containers (C++)|unordered associative containers]], which implements this multiset using a [[hash table]]. The unsorted multiset is standard as of [[C++11]]; previously SGI's STL provides the <code>hash_multiset</code> class, which was copied and eventually standardized.
| |
| * For [[Java (programming language)|Java]], third-party libraries provide multiset functionality:
| |
| ** [[Apache Commons]] Collections provides the <code>[http://commons.apache.org/collections/api-release/org/apache/commons/collections/Bag.html Bag]</code> and <code>SortedBag</code> interfaces, with implementing classes like <code>HashBag</code> and <code>TreeBag</code>.
| |
| ** [[Google Guava]] provides the <code>[http://google-collections.googlecode.com/svn/trunk/javadoc/com/google/common/collect/Multiset.html Multiset]</code> interface, with implementing classes like <code>HashMultiset</code> and <code>TreeMultiset</code>.
| |
| * Apple provides the <code>[http://developer.apple.com/documentation/Cocoa/Reference/Foundation/Classes/NSCountedSet_Class/ NSCountedSet]</code> class as part of [[Cocoa (API)|Cocoa]], and the <code>[http://developer.apple.com/documentation/CoreFoundation/Reference/CFBagRef/ CFBag]</code> and <code>[http://developer.apple.com/documentation/CoreFoundation/Reference/CFMutableBagRef/ CFMutableBag]</code> types as part of [[CoreFoundation]].
| |
| * [[Python (programming language)|Python's]] standard library includes <code>[http://docs.python.org/library/collections.html#collections.Counter collections.Counter]</code>, which is similar to a multiset.
| |
| * [[Smalltalk]] includes the <code>Bag</code> class, which can be instantiated to use either identity or equality as predicate for inclusion test.
| |
| | |
| Where a multiset data structure is not available, a workaround is to use a regular set, but override the equality predicate of its items to always return "not equal" on distinct objects (however, such will still not be able to store multiple occurrences of the same object) or use an [[associative array]] mapping the values to their integer multiplicities (this will not be able to distinguish between equal elements at all).
| |
| | |
| Typical operations on bags:
| |
| * <code>contains(''B'', ''x'')</code>: checks whether the element ''x'' is present (at least once) in the bag ''B''
| |
| * <code>is_sub_bag(''B<sub>1</sub>'', ''B<sub>2</sub>'')</code>: checks whether each element in the bag ''B<sub>1</sub>'' occurs in ''B<sub>1</sub>'' no more often than it occurs in the bag ''B<sub>2</sub>''; sometimes denoted as ''B<sub>1</sub>'' ⊑ ''B<sub>2</sub>''.
| |
| * <code>count(''B'', ''x'')</code>: returns the number of times that the element ''x'' occurs in the bag ''B''; sometimes denoted as ''B'' # ''x''.
| |
| * <code>scaled_by(''B'', ''n'')</code>: given a [[natural number]] ''n'', returns a bag which contains the same elements as the bag ''B'', except that every element that occurs ''m'' times in ''B'' occurs ''n'' * ''m'' times in the resulting bag; sometimes denoted as n ⊗ B.
| |
| * <code>union(''B<sub>1</sub>'', ''B<sub>2</sub>'')</code>: returns a bag that containing just those values that occur in either the bag ''B<sub>1</sub>'' or the bag ''B<sub>2</sub>'', except that the number of times a value ''x'' occurs in the resulting bag is equal to (''B<sub>1</sub>'' # x) + (''B<sub>2</sub>'' # x); sometimes denoted as ''B<sub>1</sub>'' ⊎ ''B<sub>2</sub>''.
| |
| | |
| ===Multisets in SQL===
| |
| In [[Relational database management system|relational databases]], a table can be a (mathematical) set or a multiset, depending on the presence on unicity constraints on some columns (which turns it into a candidate key).
| |
| | |
| [[SQL]] allows the selection of rows from a relational table: this operation will in general yield a multiset, unless the keyword <code>DISTINCT</code> is used to force the rows to be all different, or the selection includes the primary (or a candidate) key.
| |
| | |
| In [[Sql#Standardization|ANSI SQL]] the <code>MULTISET</code> keyword can be used to transform a subquery in a collection expression:
| |
| | |
| <source lang="sql">SELECT expression1, expression2... FROM table_name...</source>
| |
| | |
| is a general select that can be used as ''[[subquery expression]]'' of another more general query, while
| |
| | |
| <source lang="sql">MULTISET(SELECT expression1, expression2... FROM table_name...)</source>
| |
| | |
| transforms the subquery into a ''[[collection expression]]'' that can be used in another query, or in assignment to a column of appropriate collection type.
| |
| | |
| ==See also==
| |
| *[[Bloom filter]]
| |
| *[[Disjoint set (data structure)|Disjoint set]]
| |
| | |
| ==References==
| |
| {{Reflist}}
| |
| | |
| {{Data types}}
| |
| {{Data structures}}
| |
| | |
| [[Category:Data types]]
| |
| [[Category:Composite data types]]
| |
| [[Category:Abstract data types]]
| |