formulasearchengine - User contributions [en]

Object theory

2014-10-23T09:46:24Z

5.71.212.84: /* Models */ used prime symbol to avoid mistaken interpretation of apostrophes as markup

Plastic and Reconstructive Surgeon Rolando from Blenheim, has interests including garage saleing, new launch property singapore and snorkeling. Finished a cruise ship experience that included passing by Vallée de Mai Nature Reserve. Feel free to visit my blog post :: [http://gamerhop.com/groups/singapore-rental/ gamerhop.com]

Purely functional

2013-10-25T00:03:52Z

5.71.241.248:

[[File:Geometric dimenioning and tolerancing-hole.svg|thumb|right|Example of geometric dimensioning and tolerancing]]

'''Geometric dimensioning and tolerancing (GD&T)''' is a system for defining and communicating [[engineering tolerance]]s. It uses a symbolic language on [[engineering drawing]]s and computer-generated three-dimensional solid models that explicitly describes nominal [[geometry]] and its allowable variation. It tells the manufacturing staff and machines what degree of [[accuracy and precision]] is needed on each controlled feature of the part.
GD&T is used to define the nominal (theoretically perfect) geometry of parts and assemblies, to define the allowable variation in form and possible size of individual features, and to define the allowable variation between features.

*Dimensioning specifications define the nominal, as-modeled or as-intended geometry. One example is a basic dimension.
*Tolerancing specifications define the allowable variation for the form and possibly the size of individual features, and the allowable variation in orientation and location between features. Two examples are [[dimension|linear dimensions]] and feature control frames using a [[datum reference]] (both shown above).

There are several standards available worldwide that describe the symbols and define the rules used in GD&T. One such standard is [[American Society of Mechanical Engineers]] (ASME) Y14.5-2009. This article is based on that standard, but other standards, such as those from the [[International Organization for Standardization]] (ISO), may vary slightly. The Y14.5 standard has the advantage of providing a fairly complete set of standards for GD&T in one document. The ISO standards, in comparison, typically only address a single topic at a time. There are separate standards that provide the details for each of the major symbols and topics below (e.g. position, flatness, profile, etc.).

== Dimensioning and tolerancing philosophy ==
According to the ASME Y14.5-2009<ref>{{cite book|title=Dimensioning and Tolerancing, ASME y14.5-2009|year=2009|publisher=American Society of Mechanical Engineers|location=NY|isbn=0-7918-3192-2|authorlink=ASME}}</ref> standard, the purpose of geometric dimensioning and tolerancing (GD&T) is to describe the engineering intent of parts and assemblies. This is not a completely correct explanation of the purpose of GD&T or dimensioning and tolerancing in general.{{Citation needed|date=June 2013}}

The purpose of GD&T is more accurately defined as describing the geometric requirements for part and assembly geometry. {{Citation needed|date=June 2013}} Proper application of GD&T will ensure that the allowable part and assembly geometry defined on the drawing leads to parts that have the desired form and fit (within limits) and function as intended.

There are some fundamental rules that need to be applied (these can be found on page 7 of the 2009 edition of the standard):
*All dimensions must have a tolerance. Every feature on every manufactured part is subject to variation, therefore, the limits of allowable variation must be specified. Plus and minus tolerances may be applied directly to dimensions or applied from a general tolerance block or general note. For basic dimensions, geometric tolerances are indirectly applied in a related Feature Control Frame. The only exceptions are for dimensions marked as minimum, maximum, stock or reference.
*Dimensioning and tolerancing shall completely define the nominal geometry and allowable variation. Measurement and scaling of the drawing is not allowed except in certain cases.
*Engineering drawings define the requirements of finished (complete) parts. Every dimension and tolerance required to define the finished part shall be shown on the drawing. If additional dimensions would be helpful, but are not required, they may be marked as reference.
*Dimensions should be applied to features and arranged in such a way as to represent the function of the features. Additionally, dimensions should not be subject to more than one interpretation.
*Descriptions of manufacturing methods should be avoided. The geometry should be described without explicitly defining the method of manufacture.
*If certain sizes are required during manufacturing but are not required in the final geometry (due to shrinkage or other causes) they should be marked as non-mandatory.
*All dimensioning and tolerancing should be arranged for maximum readability and should be applied to visible lines in true profiles.
*When geometry is normally controlled by gage sizes or by code (e.g. stock materials), the dimension(s) shall be included with the gage or code number in parentheses following or below the dimension.
*Angles of 90° are assumed when lines (including center lines) are shown at right angles, but no angular dimension is explicitly shown. (This also applies to other orthogonal angles of 0°, 180°, 270°, etc.)
*Dimensions and tolerances are valid at 20 °C / 101.3 kPa unless stated otherwise.
*Unless explicitly stated, all dimensions and tolerances are only valid when the item is in a free state.
*Dimensions and tolerances apply to the full length, width, and depth of a feature including form variation.
*Dimensions and tolerances only apply at the level of the drawing where they are specified. It is not mandatory that they apply at other drawing levels, unless the specifications are repeated on the higher level drawing(s).

(Note: The rules above are not the exact rules stated in the ASME Y14.5-2009 standard.)

== Symbols ==
Tolerances: Type of Tolerances; 1) Unilateral 2) Bi- Lateral type
{| class="wikitable sortable"
|+Geometric tolerancing reference chart Per ASME Y14.5 M-1982
|-
! Type of tolerance
! Geometric characteristics
! Symbol
! Character ([[Unicode]])
! Can be applied to a surface?
! Can be applied to a feature of size?
! Can affect virtual condition?
! Datum reference used?
! Can use<center>[[Image:Gd&t maximummaterialcondition.png]]</center>modifier?
! Can use<center>[[Image:Gd&t regardlessoffeaturesize.png]]</center>modifier?
! Can be affected by a bonus tolerance?
! Can be affected by a shift tolerance?
|-
| Form
! [[Straightness]]
| <center>[[Image:Gd&t straightness.png]]</center>
| <center><big>[[⏤]]</big> [[Unicode|U]]+23E4</center>
| Yes
| Yes
| Yes (note 1)
| style="background:silver" | No
| Yes (note 1)
| style="background:silver" | No (note 5)
| Yes (note 4)
| style="background:silver" | No
|-
| Form
! Planarity ([[Flatness (mathematics)|flatness]])
| <center>[[Image:Gd&t flatness.png]]</center>
| <center><big>[[⏥]]</big> [[Unicode|U]]+23E5</center>
| Yes
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| style="background:silver" | No
|-
| Form
! [[Roundness (object)|Circularity]]
| <center>[[Image:Gd&t circularity.png]]</center>
| <center><big>[[○]]</big> [[Unicode|U]]+25CB</center>
| Yes
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| style="background:silver" | No
|-
| Form
! [[Cylindricity]]
| <center>[[Image:Gd&t cylindricity.png]]</center>
| <center><big>[[⌭]]</big> [[Unicode|U]]+232D</center>
| Yes
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| style="background:silver" | No
|-
| Profile
! Profile of a [[Line (geometry)|line]]
| <center>[[Image:Gd&t line profile.png]]</center>
| <center><big>[[⌒]]</big> [[Unicode|U]]+2312</center>
| Yes
| style="background:silver" | No
| style="background:silver" | No
| Yes (note 2)
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| Yes (note 3)
|-
| Profile
! Profile of a [[surface]]
| <center>[[Image:Gd&t profile.png]]</center>
| <center><big>[[⌓]]</big> [[Unicode|U]]+2313</center>
| Yes
| style="background:silver" | No
| style="background:silver" | No
| Yes (note 2)
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| Yes (note 3)
|-
| Orientation
! [[Perpendicular]]ity
| <center>[[Image:Gd&t perpendicularity.png]]</center>
| <center><big>[[⟂]]</big> [[Unicode|U]]+27C2</center>
| Yes
| Yes
| Yes (note 1)
| Yes
| Yes (note 1)
| style="background:silver" | No (note 5)
| Yes (note 4)
| Yes (note 3)
|-
| Orientation
! [[Angle|Angularity]]
| <center>[[Image:Gd&t angularity.png]]</center>
| <center><big>[[∠]]</big> [[Unicode|U]]+2220</center>
| Yes
| Yes
| Yes (note 1)
| Yes
| Yes (note 1)
| style="background:silver" | No (note 5)
| Yes (note 4)
| Yes (note 3)
|-
| Orientation
! [[Parallel (geometry)|Parallelism]]
| <center>[[Image:Gd&t parallelism.png]]</center>
| <center><big>[[∥]]</big> [[Unicode|U]]+2225</center>
| Yes
| Yes
| Yes (note 1)
| Yes
| Yes (note 1)
| style="background:silver" | No (note 5)
| Yes (note 4)
| Yes (note 3)
|-
| Location
! [[Symmetry]]
| <center>[[Image:Gd&t symmetry.png]]</center>
| <center><big>[[⌯]]</big> [[Unicode|U]]+232F</center>
| ? (note 6)
| ? (note 6)
| ? (note 6)
| ? (note 6)
| ? (note 6)
| ? (note 6)
| ? (note 6)
| ? (note 6)
|-
| Location
! [[Position tolerance|Positional Tolerance]]
| <center>[[Image:Gd&t position.png]]</center>
| <center><big>[[⌖]]</big> [[Unicode|U]]+2316</center>
| style="background:silver" | No
| Yes
| Yes
| Yes
| Yes
| Yes
| Yes (note 4)
| Yes (note 3)
|-
| Location
! [[Concentric]]ity
| <center>[[Image:Gd&t concentricity.png]]</center>
| <center><big>[[◎]]</big> [[Unicode|U]]+25CE</center>
| style="background:silver" | No
| Yes
| Yes
| Yes
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| style="background:silver" | No
|-
| [[Run-out]]
! Circular run-out
| <center>[[Image:Gd&t runout.png]]</center>
| <center><big>[[↗]]</big> [[Unicode|U]]+2197</center>
| Yes
| Yes
| Yes (note 1)
| Yes
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| style="background:silver" | No
|-
| [[Run-out]]
! Total run-out
| <center>[[Image:Gd&t totalrunout.png]]</center>
| <center><big>[[⌰]]</big> [[Unicode|U]]+2330</center>
| Yes
| Yes
| Yes (note 1)
| Yes
| style="background:silver" | No
| style="background:silver" | No (note 5)
| style="background:silver" | No
| style="background:silver" | No
|}

Notes:
# When applied to a feature-of-size.
# Can also be used as a form control without a datum reference.
# When a datum feature-of-size is referenced with the MMC modifier.
# When an MMC modifier is used.
# Automatic per rule #3.
# The symmetry symbol's characteristics were not included in the version of the chart that this chart is derived from. The symmetry symbol was dropped from the Y14.5M standard around 1982 and re-added around 1994.

{| class="wikitable sortable"
|+ Symbols used in a "feature control frame" to specify a feature's description, tolerance, modifier and [[datum references]]
|-
! Symbol !! Modifier !! Notes
|-
| [[File:Gd&t freestate.png|center]] || Free state ||
|-
| [[File:Gd&t leastmaterialcondition.png|center]] || Least material condition (LMC) ||
|-
| [[File:Gd&t maximummaterialcondition.png|center]] || Maximum material condition (MMC) ||
|-
| [[File:Gd&t projectedtolerancezone.png|center]] || Projected tolerance zone ||
|-
| [[File:Gd&t regardlessoffeaturesize.png|center]] || Regardless of feature size (RFS) || Not part of the 1994 version. See para. A5, bullet 3. Also para. D3. Also, Figure 3-8.
|-
| [[File:Gd&t tangentplane.png|center]] || Tangent plane ||
|-
| [[File:Gd&t unilateral.png|center]] || Unilateral || Appears in the 2009 version of the standard, and refers to unequal profile distribution.
|}

=== Datums and datum references ===

A '''[[datum (geodesy)|datum]]''' is a virtual ideal plane, line, point, or axis. A '''datum feature''' is a physical feature of a part identified by a '''datum feature symbol''' and corresponding '''datum feature triangle''', e.g.,

:<math>{\displaystyle\Box}\!\!\!\!{\scriptstyle\mathsf{A}}\!-\!\!\!-\!\!\!\blacktriangleleft\!\!\!|</math>

These are then referred to by one or more '''[[datum reference]]s ''' which indicate measurements that should be made with respect to the corresponding datum feature.

== GD&T data exchange ==
Exchange of geometric dimensioning and tolerancing (GD&T) information between [[CAD]] systems is available on different levels of fidelity for different purposes:
* In the early days of CAD exchange only lines, texts and symbols were written into the exchange file. A receiving system could display them on the screen or print them out, but only a human could interpret them.
* ''GD&T presentation'': On a next higher level the presentation information is enhanced by grouping them together into ''callouts'' for a particular purpose, e.g. a ''datum feature callout'' and a ''datum reference frame''. And there is also the information which of the curves in the exchange file are leader, projection or dimension curves and which are used to form the shape of a product.
* ''GD&T representation'': Unlike GD&T presentation, the GD&T representation does not deal with how the information is presented to the user but only deal with which element of a shape of a product has which GD&T characteristic. A system supporting GD&T representation may display the GD&T information in some tree and other dialogs and allow the user to directly select and highlight the corresponding feature on the shape of the product, 2D and 3D.
* Ideally both GD&T presentation and representation are available in the exchange file and are associated with each other. Then a receiving system can allow a user to select a GD&T callout and get the corresponding feature highlighted on the shape of the product.
* An enhancement of GD&T representation is defining a formal language for GD&T (similar to a programming language) which also has built-in rules and restrictions for the proper GD&T usage. This is still a research area (see below reference to McCaleb and ISO 10303-1666).
* ''GD&T validation'': Based on GD&T representation data (but not on GD&T presentation) and the shape of a product in some useful format (e.g. a [[boundary representation]]), it is possible to validate the completeness and consistency of the GD&T information. The software tool FBTol from the [[Kansas City Plant]] is probably the first one in this area.
* GD&T representation information can also be used for the software assisted manufacturing planning and cost calculation of parts. See ISO 10303-224 and 238 below.

== GD&T ==

=== ISO TC 10 ''Technical product documentation'' ===
* ISO 128 ''Technical drawings – Indication of dimensions and tolerances''
* ISO 7083 ''Symbols for geometrical tolerancing – Proportions and dimensions''
* ISO 13715 ''Technical drawings – Edges of undefined shape – Vocabulary and indications''
* ISO 15786 ''Simplified representation and dimensioning of holes''
* ISO 16792:2006 ''Technical product documentation—Digital product definition data practices'' (Note: ISO 16792:2006 was derived from ASME Y14.41-2003 by permission of ASME)
* ISO 2010
* ISO

=== {{anchor|ISO/TC 213}} ISO/TC 213 ''Dimensional and geometrical product specifications and verification'' ===
In ISO/TR 14638 ''GPS – Masterplan'' the distinction between fundamental, global, general and complementary GPS standards is made.

* Fundamental GPS standards
** ISO 8015 ''Concepts, principles and rules''

* Global GPS standards
** ISO 14660-1 ''Geometrical features''
** ISO/TS 17, orientation and location
** ISO 1101 ''Geometrical tolerancing – Tolerances of form, orientation, location and run-out''
*** Amendment 1 ''Representation of specifications in the form of a 3D model''
** ISO 1119 ''Series of conical tapers and taper angles''
** ISO 2692 ''Geometrical tolerancing – Maximum material requirement (MMR), least material requirement (LMR) and reciprocity requirement (RPR)''
** ISO 3040 ''Dimensioning and tolerancing – Cones''
** ISO 5458 ''Geometrical tolerancing – Positional tolerancing''
** ISO 5459 ''Geometrical tolerancing – Datums and datum systems''
** ISO 10578 ''Tolerancing of orientation and location – Projected tolerance zone''
** ISO 10579 ''Dimensioning and tolerancing – Non-rigid parts''
** ISO 14406 ''Extraction''
** ISO 22432 ''Features utilized in specification and verification''

* General GPS standards: '''Areal and profile surface texture'''
** ISO 1302 ''Indication of surface texture in technical product documentation''
** ISO 3274 ''Surface texture: Profile method – Nominal characteristics of contact (stylus) instruments''
** ISO 4287 ''Surface texture: Profile method – Terms, definitions and surface texture parameters''
** ISO 4288 ''Surface texture: Profile method – Rules and procedures for the assessment of surface texture''
** ISO 8785 ''Surface imperfections – Terms, definitions and parameters''
** Form of a surface independent of a datum or datum system. Each of them has a part 1 for the ''Vocabulary and parameters'' and a part 2 for the ''Specification operators'':
*** ISO 12180 ''Cylindricity''
*** ISO 12181 ''Roundness''
*** ISO 12780 ''Straightness''
*** ISO 12781 ''Flatness''
** ISO 25178 ''Surface texture: Areal''

* General GPS standards: '''Extraction and filtration techniques'''
** ISO/TS 1661 ''Filtration''
** ISO 11562 ''Surface texture: Profile method – Metrological characteristics of phase correct filters''
** ISO 12085 ''Surface texture: Profile method – Motif parameters''
** ISO 13565 ''Profile method; Surfaces having stratified functional properties''

=== ASME standards ''American Society of Mechanical Engineers'' ===
* [[ASME Y14.41-2003]] Digital Product Definition Data Practices
* ASME Y14.5 - 2009 Dimensioning and Tolerancing
* ASME Y14.5M-1994 Dimensioning and Tolerancing
* ASME Y14.5.1M-1994 Mathematical Definition of Dimensioning and Tolerancing Principles

ASME Y14.5.1M-2

=== GD&T standards for data exchange and integration ===
* [[ISO 10303]] ''Industrial automation systems and integration — Product data representation and exchange''
** ISO 10303-47 ''Integrated generic resource: Shape variation tolerances''
** ISO/TS 10303-1130 ''Application module: Derived shape element''
** ISO/TS 10303-1050 ''Application module: Dimension tolerance''
** ISO/TS 10303-1051 ''Application module: Geometric tolerance''
** ISO/TS 10303-1052 ''Application module: Default tolerance''
** ISO/TS 10303-1666 ''Application module: Extended geometric tolerance''
** ISO 10303-203 ''Application protocol: Configuration controlled 3D design of mechanical parts and assemblies''
** ISO 10303-210 ''Application protocol: Electronic assembly, interconnection, and packaging design''
** ISO 10303-214 ''Application protocol: Core data for automotive mechanical design processes''
** ISO 10303-224 ''Application protocol: Mechanical product definition for process planning using machining features''
** [[STEP-NC|ISO 10303-238 ''Application protocol: Application interpreted model for computerized numerical controllers'' (STEP-NC)]]

== See also ==
* [[Surface_finish#Specification|Specification of surface finish]]

== References ==
{{More footnotes|date=April 2010}}
{{reflist}}

== Further reading ==
{{ISBN|date=October 2011}}
*{{cite journal |first1=Michael R. |last1=McCale |title=A Conceptual Data Model of Datum Systems |url=http://nvl.nist.gov/pub/nistpubs/jres/104/4/j44mac.pdf |journal=Journal of Research of the National Institute of Standards and Technology |volume=104 |issue=4 |pages=349–400 |year=1999 |doi=10.6028/jres.104.024}}
* HENZOLD, Georg. Geometrical Dimensioning and Tolerancing for Design, Manufacturing and Inspection. 2nd Edition, Elsevier, Oxford, UK, 2006.
*{{cite journal |doi=10.1016/j.cad.2007.06.006 |title=Standardizing the specification, verification, and exchange of product geometry: Research, status and trends |year=2008 |last1=Srinivasan |first1=Vijay |journal=Computer-Aided Design |volume=40 |issue=7 |pages=738–49}}
* DRAKE JR, Paul J. Dimensioning and Tolerancing Handbook. McGraw-Hill, New York, 1999
* Neumann, Scott and Al Neumann. GeoTol Pro: A Practical Guide to Geometric Tolerancing per ASME Y14.5-2009. Society of Manufacturing Engineers, Dearborn, MI, 2009. ISBN # 978-0-8726-3865-5
* Bramble, Kelly L. Geometric Boundaries II, Practical Guide to Interpretation and Application ASME Y14.5-2009, Engineers Edge, 2009
* {{cite book
|title=Design Dimensioning and Tolerancing
|last1=Wilson |first1=Bruce A. |authorlink1=
|coauthors=
|editor1-last= |editor1-first= |editor1-link=
|year= 2005
|publisher=Goodheart-Wilcox
|location=US
|isbn=9781590703281
|url=
|page=
|pages=275
|ref=
}}

== External links ==
{{Commons category|Geometric dimensioning and tolerancing}}
*[http://www.gwp-ag.at/media/www.gwp-ag.at/org/med_646/811_general_tolerances.pdf General tolerances for linear and angular dimensions according to ISO 2768]
*[http://www.gd-t.com/map-of-gdt/ Interactive map of GD&T.] jj
*[http://www.engineersedge.com/training_engineering/What_Is_GD&T.htm What is GD&T]
*[http://www.tdcofarizona.com/importance_of_gdt_a/267.htm The importance of GD&T]
*[http://www.etinews.com/gdt_glossary.html GD&T Glossary of Terms and Definitions]
*[http://www.tec-ease.com/gdt-tips.htm Free GD&T Help and Tips]
*[http://www.advanceddimensionalmanagement.com/gdt_justification.php Justification for GD&T]
*[http://www.efunda.com/designstandards/gdt/introduction.cfm GDT: Introduction]
*[http://www.asme.org/Codes/CertifAccred/Personnel/Levels_Certification_2.cfm ASME Certification]
*[http://www.tdcofarizona.com/changes_and_additions_to_asme_y14-5_a/272.htm Changes and Additions to ASME Y14.5M]

[[Category:Technical drawing]]

Credit valuation adjustment

2013-10-17T16:24:50Z

5.71.118.66:

{{Infobox Algorithm
|class=[[Sorting algorithm]]
|image=[[File:Bubblesort-edited.png|Static visualization of bubblesort]]
|data=[[Array data structure|Array]]
|best-time= <math>O(n)</math>
|average-time= <math>O(n^2)</math>
|time=<math>O(n^2)</math>
|space=<math>O(1)</math> auxiliary
|optimal=No
}}
'''Bubble sort''', sometimes incorrectly referred to as '''sinking sort''', is a simple [[sorting algorithm]] that works by repeatedly stepping through the list to be sorted, comparing each pair of adjacent items and [[Swap (computer science)|swap]]ping them if they are in the wrong order. The pass through the list is repeated until no swaps are needed, which indicates that the list is sorted. The algorithm gets its name from the way smaller elements "bubble" to the top of the list. Because it only uses comparisons to operate on elements, it is a [[comparison sort]]. Although the algorithm is simple, most of the other sorting algorithms are more efficient for large lists.
==Analysis==
[[File:Bubble-sort-example-300px.gif|300px|thumb|right|An example of bubble sort. Starting from the beginning of the list, compare every adjacent pair, swap their position if they are not in the right order (the latter one is smaller than the former one). After each iteration, one less element (the last one) is needed to be compared until there are no more elements left to be compared.]]

=== Performance ===
Bubble sort has worst-case and average complexity both ''[[big o notation|О]]''(''n''2), where ''n'' is the number of items being sorted. There exist many sorting algorithms with substantially better worst-case or average complexity of ''O''(''n'' log ''n''). Even other ''О''(''n''2) sorting algorithms, such as [[insertion sort]], tend to have better performance than bubble sort. Therefore, bubble sort is not a practical sorting algorithm when ''n'' is large.

The only significant advantage that bubble sort has over most other implementations, even [[quicksort]], but not [[insertion sort]], is that the ability to detect that the list is sorted is efficiently built into the algorithm. Performance of bubble sort over an already-sorted list (best-case) is ''O''(''n''). By contrast, most other algorithms, even those with better [[average-case complexity]], perform their entire sorting process on the set and thus are more complex. However, not only does [[insertion sort]] have this mechanism too, but it also performs better on a list that is substantially sorted (having a small number of [[inversion (discrete mathematics)|inversions]]).

Bubble sort should be avoided in case of large collections. It will not be efficient in case of reverse ordered collection.

===Rabbits and turtles===
The positions of the elements in bubble sort will play a large part in determining its performance. Large elements at the beginning of the list do not pose a problem, as they are quickly swapped. Small elements towards the end, however, move to the beginning extremely slowly. This has led to these types of elements being named rabbits and turtles, respectively.

Various efforts have been made to eliminate turtles to improve upon the speed of bubble sort. [[Cocktail sort]] is a bi-directional bubble sort that goes from beginning to end, and then reverses itself, going end to beginning. It can move turtles fairly well, but it retains ''[[Big O notation|O(n2)]]'' worst-case complexity. [[Comb sort]] compares elements separated by large gaps, and can move turtles extremely quickly before proceeding to smaller and smaller gaps to smooth out the list. Its average speed is comparable to faster algorithms like [[quicksort]].

===Step-by-step example ===

Let us take the array of numbers "5 1 4 2 8", and sort the array from lowest number to greatest number using bubble sort. In each step, elements written in '''bold''' are being compared.
Three passes will be required.

'''First Pass:''' 
( '''5''' '''1''' 4 2 8 ) <math>\to</math> ( '''1''' '''5''' 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1. 
( 1 '''5''' '''4''' 2 8 ) <math>\to</math> ( 1 '''4''' '''5''' 2 8 ), Swap since 5 > 4 
( 1 4 '''5''' '''2''' 8 ) <math>\to</math> ( 1 4 '''2''' '''5''' 8 ), Swap since 5 > 2 
( 1 4 2 '''5''' '''8''' ) <math>\to</math> ( 1 4 2 '''5''' '''8''' ), Now, since these elements are already in order (8 > 5), algorithm does not swap them. 
'''Second Pass:''' 
( '''1''' '''4''' 2 5 8 ) <math>\to</math> ( '''1''' '''4''' 2 5 8 ) 
( 1 '''4''' '''2''' 5 8 ) <math>\to</math> ( 1 '''2''' '''4''' 5 8 ), Swap since 4 > 2 
( 1 2 '''4''' '''5''' 8 ) <math>\to</math> ( 1 2 '''4''' '''5''' 8 ) 
( 1 2 4 '''5''' '''8''' ) <math>\to</math> ( 1 2 4 '''5''' '''8''' ) 
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one '''whole''' pass without '''any''' swap to know it is sorted. 
'''Third Pass:''' 
( '''1''' '''2''' 4 5 8 ) <math>\to</math> ( '''1''' '''2''' 4 5 8 ) 
( 1 '''2''' '''4''' 5 8 ) <math>\to</math> ( 1 '''2''' '''4''' 5 8 ) 
( 1 2 '''4''' '''5''' 8 ) <math>\to</math> ( 1 2 '''4''' '''5''' 8 ) 
( 1 2 4 '''5''' '''8''' ) <math>\to</math> ( 1 2 4 '''5''' '''8''' ) 

== Implementation ==
=== Pseudocode implementation ===
The algorithm can be expressed as (0-based array):
<source lang="pli">
procedure bubbleSort( A : list of sortable items )
repeat
swapped = false
for i = 1 to length(A) - 1 inclusive do:
/* if this pair is out of order */
if A[i-1] > A[i] then
/* swap them and remember something changed */
swap( A[i-1], A[i] )
swapped = true
end if
end for
until not swapped
end procedure
</source>

=== Optimizing bubble sort ===
The bubble sort algorithm can be easily optimized by observing that the n-th pass finds the n-th largest element and puts it into its final place. So, the inner loop can avoid looking at the last n-1 items when running for the n-th time:

<source lang="pli">
procedure bubbleSort( A : list of sortable items )
n = length(A)
repeat
swapped = false
for i = 1 to n-1 inclusive do
if A[i-1] > A[i] then
swap(A[i-1], A[i])
swapped = true
end if
end for
n = n - 1
until not swapped
end procedure
</source>

More generally, it can happen that more than one element is placed in their final position on a single pass. In particular, after every pass, all elements after the last swap are sorted, and do not need to be checked again. This allows us to skip over a lot of the elements, resulting in about a worst case 50% improvement in comparison count (though no improvement in swap counts), and adds very little complexity because the new code subsumes the "swapped" variable:

To accomplish this in [[pseudocode]] we write the following:
<source lang="pli">
procedure bubbleSort( A : list of sortable items )
n = length(A)
repeat
newn = 0
for i = 1 to n-1 inclusive do
if A[i-1] > A[i] then
swap(A[i-1], A[i])
newn = i
end if
end for
n = newn
until n = 0
end procedure
</source>

Alternate modifications, such as the [[cocktail shaker sort]] attempt to improve on the bubble sort performance while keeping the same idea of repeatedly comparing and swapping adjacent items.

==In practice==
[[File:Bubble sort animation.gif|thumb|right|280px|A bubble sort, a sorting algorithm that continuously steps through a list, [[Swap (computer science)|swapping]] items until they appear in the correct order. The list was plotted in a Cartesian coordinate system, with each point (x,y) indicating that the value y is stored at index x. Then the list would be sorted by Bubble sort according to every pixel's value. Note that the largest end gets sorted first, with smaller elements taking longer to move to their correct positions.]]
Although bubble sort is one of the simplest sorting algorithms to understand and implement, its ''[[Big O notation|O(n2)]]'' complexity means that its efficiency decreases dramatically on lists of more than a small number of elements. Even among simple ''O(n2)'' sorting algorithms, algorithms like [[insertion sort]] are usually considerably more efficient.

Due to its simplicity, bubble sort is often used to introduce the concept of an algorithm, or a sorting algorithm, to introductory [[computer science]] students. However, some researchers such as [[Owen Astrachan]] have gone to great lengths to disparage bubble sort and its continued popularity in computer science education, recommending that it no longer even be taught.<ref name="Astrachan2003" />

The [[Jargon file]], which famously calls [[bogosort]] "the archetypical [sic] perversely awful algorithm", also calls bubble sort "the generic '''bad''' algorithm".<ref>http://www.jargon.net/jargonfile/b/bogo-sort.html</ref> [[Donald Knuth]], in his famous book ''[[The Art of Computer Programming]]'', concluded that "the bubble sort seems to have nothing to recommend it, except a catchy name and the fact that it leads to some interesting theoretical problems", some of which he then discusses.<ref name="Knuth">[[Donald Knuth]]. ''[[The Art of Computer Programming]]'', Volume 3: ''Sorting and Searching'', Second Edition. Addison-Wesley, 1998. ISBN 0-201-89685-0. Pages 106–110 of section 5.2.2: Sorting by Exchanging.</ref>

Bubble sort is [[Asymptotic notation|asymptotically]] equivalent in running time to [[insertion sort]] in the worst case, but the two algorithms differ greatly in the number of swaps necessary. Experimental results such as those of Astrachan have also shown that [[insertion sort]] performs considerably better even on random lists. For these reasons many modern algorithm textbooks avoid using the bubble sort algorithm in favor of insertion sort.

Bubble sort also interacts poorly with modern CPU hardware. It requires at least twice as many writes as insertion sort, twice as many cache misses, and asymptotically more [[branch prediction|branch mispredictions]]. Experiments by Astrachan sorting strings in Java show bubble sort to be roughly 5 times slower than [[insertion sort]] and 40% slower than [[selection sort]].<ref name="Astrachan2003">Owen Astrachan. Bubble Sort: An Archaeological Algorithmic Analysis. SIGCSE 2003 Hannan Akhtar . [http://www.cs.duke.edu/~ola/papers/bubble.pdf (pdf)]</ref>

In computer graphics it is popular for its capability to detect a very small error (like swap of just two elements) in almost-sorted arrays and fix it with just linear complexity (2n). For example, it is used in a polygon filling algorithm, where bounding lines are sorted by their x coordinate at a specific scan line (a line parallel to x axis) and with incrementing y their order changes (two elements are swapped) only at intersections of two lines.

== Variations ==
*[[Odd-even sort]] is a parallel version of bubble sort, for message passing systems.
*[[Cocktail sort]] is another parallel version of the bubble sort
*In some cases, the sort works from right to left (the opposite direction), which is more appropriate for partially sorted lists, or lists with unsorted items added to the end.

===Alone bubble sort===
''Alone bubble sort'' is a 1992 modification{{cn|date=September 2013}} of the simple bubble sorting algorithm. Unlike the normal bubble sort where the loop resets after every performed swap of elements, in the alone bubble sort, the loop index only returns back by one step thus allowing the swapping to continue until a smaller value element in the array is reached. The following is the alone bubble realization (the algorithm only) in Pascal:

<source lang="Pascal">
f:=false;
for x:=1 to max-1 do
if a[x]>a[x+1] then
begin
if f=false then d:=x;
f:=true;
t:=a[x];
a[x]:=a[x+1];
a[x+1]:=t;
if x>1 then dec(x,2) else x:=0;
end
else
if f=true then
begin
x:=d;
f:=false;
end;
</source>

== Debate Over Name ==

Bubble sort has occasionally been referred to as a "sinking sort," including by the National Institute of Standards and Technology. [http://xlinux.nist.gov/dads/HTML/bubblesort.html]

However, in Donald Knuth's ''The Art of Computer Programming'', Volume 3: ''Sorting and Searching'' he states in section 5.2.1 'Sorting by Insertion', that [the value] "settles to its proper level" this method of sorting has often been called the ''sifting'' or ''sinking'' technique. Furthermore the ''larger'' values might be regarded as ''heavier'' and therefore be seen to progressively ''sink'' to the ''bottom'' of the list.

== Notes ==
<references />

== References ==
* [[Donald Knuth]]. ''The Art of Computer Programming'', Volume 3: ''Sorting and Searching'', Third Edition. Addison-Wesley, 1997. ISBN 0-201-89685-0. Pages 106–110 of section 5.2.2: Sorting by Exchanging.
* [[Thomas H. Cormen]], [[Charles E. Leiserson]], [[Ronald L. Rivest]], and [[Clifford Stein]]. ''[[Introduction to Algorithms]]'', Second Edition. MIT Press and McGraw-Hill, 2001. ISBN 0-262-03293-7. Problem 2-2, pg.38.
* [https://www.cs.tcd.ie/publications/tech-reports/reports.05/TCD-CS-2005-57.pdf Sorting in the Presence of Branch Prediction and Caches]
*Fundamentals of Data Structures by Ellis Horowitz, [[Sartaj Sahni]] and Susan Anderson-Freed ISBN 81-7371-605-6

== External links==
{{wikibooks|Algorithm implementation|Sorting/Bubble_sort|Bubble sort}}
{{commons category|Bubble sort}}
{{wikiversity|Bubble sort}}
* {{cite web | url=http://codecodex.com/wiki/Bubble_sort | title= Bubble Sort implemented in 34 languages}}
* {{cite web | url=http://www.sorting-algorithms.com/bubble-sort |title = Animated Sorting Algorithms: Bubble Sort | author= David R. Martin}} – graphical demonstration and discussion of bubble sort
* {{cite web | url= http://lecture.ecc.u-tokyo.ac.jp/~ueda/JavaApplet/BubbleSort.html |title= Lafore's Bubble Sort}} (Java applet animation)
* {{OEIS|A008302}} Table (statistics) of the number of permutations of [n] that need k pair-swaps during the sorting.

{{sorting}}

[[Category:Articles with example pseudocode]]
[[Category:Sorting algorithms]]
[[Category:Comparison sorts]]
[[Category:Stable sorts]]

[[no:Sorteringsalgoritme#Boblesortering]]