Atomic No

  1. Atomic Number: 28 Atomic Mass: 58.6934 amu Melting Point: 1453.0 °C (1726.15 K, 2647.4 °F) Boiling Point: 2732.0 °C (3005.15 K, 4949.6 °F) Number of Protons/Electrons: 28 Number of Neutrons: 31 Classification: Transition Metal Crystal Structure: Cubic Density @ 293 K: 8.902 g/cm 3 Color: white Atomic Structure.
  2. For example, the atomic number of sodium is 11. This implies that the nucleus of the sodium atom contains 11 protons and is surrounded by a total of 11 electrons. Since the atomic number of an atom is equal to the number of electrons it contains, the electronic configuration of the element can be determined just by knowing its atomic number.

Click a column header, such as Name, to sort the table by that item.
SEENotes at the bottom of the Table.

crust (%)*
Group*Electron configurationIonization
energy (eV)
36.941LithiumLi1801,3470.5318171[He] 2s15.39
49.012BerylliumBe1,2782,9701.8517972[He] 2s29.32
510.811BoronB2,3002,5502.34180813[He] 2s2 2p18.30
612.011CarbonC3,5004,8272.260.09ancient14[He] 2s2 2p211.26
714.007NitrogenN-210-1961.25177215[He] 2s2 2p314.53
815.999OxygenO-218-1831.4346.71177416[He] 2s2 2p413.62
918.998FluorineF-220-1881.700.03188617[He] 2s2 2p517.42
1020.180NeonNe-249-2460.90189818[He] 2s2 2p621.56
1122.990SodiumNa988830.972.7518071[Ne] 3s15.14
1224.305MagnesiumMg6391,0901.742.0817552[Ne] 3s27.65
1326.982AluminumAl6602,4672.708.07182513[Ne] 3s2 3p15.99
1428.086SiliconSi1,4102,3552.3327.69182414[Ne] 3s2 3p28.15
1530.974PhosphorusP442801.820.13166915[Ne] 3s2 3p310.49
1632.065SulfurS1134452.070.05ancient16[Ne] 3s2 3p410.36
1735.453ChlorineCl-101-353.210.05177417[Ne] 3s2 3p512.97
1839.948ArgonAr-189-1861.78189418[Ne] 3s2 3p615.76
1939.098PotassiumK647740.862.5818071[Ar] 4s14.34
2040.078CalciumCa8391,4841.553.6518082[Ar] 4s26.11
2144.956ScandiumSc1,5392,8322.9918793[Ar] 3d1 4s26.56
2247.867TitaniumTi1,6603,2874.540.6217914[Ar] 3d2 4s26.83
2350.942VanadiumV1,8903,3806.1118305[Ar] 3d3 4s26.75
2451.996ChromiumCr1,8572,6727.190.0417976[Ar] 3d5 4s16.77
2554.938ManganeseMn1,2451,9627.430.0917747[Ar] 3d5 4s27.43
2655.845IronFe1,5352,7507.875.05ancient8[Ar] 3d6 4s27.90
2758.933CobaltCo1,4952,8708.9017359[Ar] 3d7 4s27.88
2858.693NickelNi1,4532,7328.900.02175110[Ar] 3d8 4s27.64
2963.546CopperCu1,0832,5678.96ancient11[Ar] 3d10 4s17.73
3065.390ZincZn4209077.13ancient12[Ar] 3d10 4s29.39
3169.723GalliumGa302,4035.91187513[Ar] 3d10 4s2 4p16.00
3272.640GermaniumGe9372,8305.32188614[Ar] 3d10 4s2 4p27.90
3374.922ArsenicAs816135.72ancient15[Ar] 3d10 4s2 4p39.79
3478.960SeleniumSe2176854.79181716[Ar] 3d10 4s2 4p49.75
3579.904BromineBr-7593.12182617[Ar] 3d10 4s2 4p511.81
3683.800KryptonKr-157-1533.75189818[Ar] 3d10 4s2 4p614.00
3785.468RubidiumRb396881.6318611[Kr] 5s14.18
3887.620StrontiumSr7691,3842.5417902[Kr] 5s25.69
3988.906YttriumY1,5233,3374.4717943[Kr] 4d1 5s26.22
4091.224ZirconiumZr1,8524,3776.510.0317894[Kr] 4d2 5s26.63
4192.906NiobiumNb2,4684,9278.5718015[Kr] 4d4 5s16.76
4295.940MolybdenumMo2,6174,61210.2217816[Kr] 4d5 5s17.09
43*98.000TechnetiumTc2,2004,87711.5019377[Kr] 4d5 5s27.28
44101.070RutheniumRu2,2503,90012.3718448[Kr] 4d7 5s17.36
45102.906RhodiumRh1,9663,72712.4118039[Kr] 4d8 5s17.46
46106.420PalladiumPd1,5522,92712.02180310[Kr] 4d108.34
47107.868SilverAg9622,21210.50ancient11[Kr] 4d10 5s17.58
48112.411CadmiumCd3217658.65181712[Kr] 4d10 5s28.99
49114.818IndiumIn1572,0007.31186313[Kr] 4d10 5s2 5p15.79
50118.710TinSn2322,2707.31ancient14[Kr] 4d10 5s2 5p27.34
51121.760AntimonySb6301,7506.68ancient15[Kr] 4d10 5s2 5p38.61
52127.600TelluriumTe4499906.24178316[Kr] 4d10 5s2 5p49.01
53126.905IodineI1141844.93181117[Kr] 4d10 5s2 5p510.45
54131.293XenonXe-112-1085.90189818[Kr] 4d10 5s2 5p612.13
55132.906CesiumCs296781.8718601[Xe] 6s13.89
56137.327BariumBa7251,1403.590.0518082[Xe] 6s25.21
57138.906LanthanumLa9203,4696.1518393[Xe] 5d1 6s25.58
58140.116CeriumCe7953,2576.771803101[Xe] 4f1 5d1 6s25.54
59140.908PraseodymiumPr9353,1276.771885101[Xe] 4f3 6s25.47
60144.240NeodymiumNd1,0103,1277.011885101[Xe] 4f4 6s25.53
61*145.000PromethiumPm1,1003,0007.301945101[Xe] 4f5 6s25.58
62150.360SamariumSm1,0721,9007.521879101[Xe] 4f6 6s25.64
63151.964EuropiumEu8221,5975.241901101[Xe] 4f7 6s25.67
64157.250GadoliniumGd1,3113,2337.901880101[Xe] 4f7 5d1 6s26.15
65158.925TerbiumTb1,3603,0418.231843101[Xe] 4f9 6s25.86
66162.500DysprosiumDy1,4122,5628.551886101[Xe] 4f10 6s25.94
67164.930HolmiumHo1,4702,7208.801867101[Xe] 4f11 6s26.02
68167.259ErbiumEr1,5222,5109.071842101[Xe] 4f12 6s26.11
69168.934ThuliumTm1,5451,7279.321879101[Xe] 4f13 6s26.18
70173.040YtterbiumYb8241,4666.901878101[Xe] 4f14 6s26.25
71174.967LutetiumLu1,6563,3159.841907101[Xe] 4f14 5d1 6s25.43
72178.490HafniumHf2,1505,40013.3119234[Xe] 4f14 5d2 6s26.83
73180.948TantalumTa2,9965,42516.6518025[Xe] 4f14 5d3 6s27.55
74183.840TungstenW3,4105,66019.3517836[Xe] 4f14 5d4 6s27.86
75186.207RheniumRe3,1805,62721.0419257[Xe] 4f14 5d5 6s27.83
76190.230OsmiumOs3,0455,02722.6018038[Xe] 4f14 5d6 6s28.44
77192.217IridiumIr2,4104,52722.4018039[Xe] 4f14 5d7 6s28.97
78195.078PlatinumPt1,7723,82721.45173510[Xe] 4f14 5d9 6s18.96
79196.967GoldAu1,0642,80719.32ancient11[Xe] 4f14 5d10 6s19.23
80200.590MercuryHg-3935713.55ancient12[Xe] 4f14 5d10 6s210.44
81204.383ThalliumTl3031,45711.85186113[Xe] 4f14 5d10 6s2 6p16.11
82207.200LeadPb3271,74011.35ancient14[Xe] 4f14 5d10 6s2 6p27.42
83208.980BismuthBi2711,5609.75ancient15[Xe] 4f14 5d10 6s2 6p37.29
84*209.000PoloniumPo2549629.30189816[Xe] 4f14 5d10 6s2 6p48.42
85*210.000AstatineAt3023370.00194017[Xe] 4f14 5d10 6s2 6p59.30
86*222.000RadonRn-71-629.73190018[Xe] 4f14 5d10 6s2 6p610.75
87*223.000FranciumFr276770.0019391[Rn] 7s14.07
88*226.000RadiumRa7001,7375.5018982[Rn] 7s25.28
89*227.000ActiniumAc1,0503,20010.0718993[Rn] 6d1 7s25.17
90232.038ThoriumTh1,7504,79011.721829102[Rn] 6d2 7s26.31
91231.036ProtactiniumPa1,568015.401913102[Rn] 5f2 6d1 7s25.89
92238.029UraniumU1,1323,81818.951789102[Rn] 5f3 6d1 7s26.19
93*237.000NeptuniumNp6403,90220.201940102[Rn] 5f4 6d1 7s26.27
94*244.000PlutoniumPu6403,23519.841940102[Rn] 5f6 7s26.03
95*243.000AmericiumAm9942,60713.671944102[Rn] 5f7 7s25.97
Earth crust
Group*Electron configurationIonization
energy (eV)

Atomic number The number of protons in the nucleus of an atom. In electrically neutral atoms, this number is also equal to the number of electrons orbiting about the atom's nucleus. The atomic number of an element determines its position in the Periodic Table.

• Density of elements with boiling points below 0°C is given in g/l. In a sorted list, these elements are shown before other elements that have boiling points >0°C.
• Earth crust composition average values are from a report by F. W. Clarke and H. S. Washington, 1924. Elemental composition of crustal rocks differ between different localities (see article).
Group: There are only 18 groups in the periodic table that constitute the columns of the table. Lanthanoids and Actinoids are numbered as 101 and 102 to separate them in sorting by group.
• The elements marked with an asterisk (in the 2nd column) have no stable nuclides. For these elements the weight value shown represents the mass number of the longest-lived isotope of the element.

Abbreviations and Definitions:

No. - Atomic Number; M.P. - melting point; B.P. - boiling point

Atomic number: The number of protons in an atom. Each element is uniquely defined by its atomic number.

Atomic mass: The mass of an atom is primarily determined by the number of protons and neutrons in its nucleus. Atomic mass is measured in Atomic Mass Units (amu) which are scaled relative to carbon, 12C, that is taken as a standard element with an atomic mass of 12. This isotope of carbon has 6 protons and 6 neutrons. Thus, each proton and neutron has a mass of about 1 amu.

Isotope: Atoms of the same element with the same atomic number, but different number of neutrons. Isotope of an element is defined by the sum of the number of protons and neutrons in its nucleus. Elements have more than one isotope with varying numbers of neutrons. For example, there are two common isotopes of carbon, 12C and 13C which have 6 and 7 neutrons respectively. The abundances of different isotopes of elements vary in nature depending on the source of materials. For relative abundances of isotopes in nature see reference on Atomic Weights and Isotopic Compositions.

Atomic weight: Atomic weight values represent weighted average of the masses of all naturally occurring isotopes of an element. The values shown here are based on the IUPAC Commission determinations (Pure Appl. Chem. 73:667-683, 2001). The elements marked with an asterisk have no stable nuclides. For these elements the weight value shown represents the mass number of the longest-lived isotope of the element.

Electron configuration: See next page for explanation of electron configuration of atoms.

Ionization energy (IE): The energy required to remove the outermost electron from an atom or a positive ion in its ground level. The table lists only the first IE in eV units. To convert to kJ/mol multiply by 96.4869. Reference: NIST Reference Table on Ground states and ionization energies for the neutral atoms. IE decreases going down a column of the periodic table, and increases from left to right in a row. Thus, alkali metals have the lowest IE in a period and Rare gases have the highest.

Other resources related to the Periodic Table

  • Chemical Evolution of the Universe

Much has already been written about atomic operations on the web, usually with a focus on atomic read-modify-write (RMW) operations. However, those aren’t the only kinds of atomic operations. There are also atomic loads and stores, which are equally important. In this post, I’ll compare atomic loads and stores to their non-atomic counterparts at both the processor level and the C/C++ language level. Along the way, we’ll clarify the C++11 concept of a “data race”.

An operation acting on shared memory is atomic if it completes in a single step relative to other threads. When an atomic store is performed on a shared variable, no other thread can observe the modification half-complete. When an atomic load is performed on a shared variable, it reads the entire value as it appeared at a single moment in time. Non-atomic loads and stores do not make those guarantees.

Without those guarantees, lock-free programming would be impossible, since you could never let different threads manipulate a shared variable at the same time. We can formulate it as a rule:

Any time two threads operate on a shared variable concurrently, and one of those operations performs a write, both threads must use atomic operations.

If you violate this rule, and either thread uses a non-atomic operation, you’ll have what the C++11 standard refers to as a data race (not to be confused with Java’s concept of a data race, which is different, or the more general race condition). The C++11 standard doesn’t tell you why data races are bad; only that if you have one, “undefined behavior” will result (§1.10.21). The real reason why such data races are bad is actually quite simple: They result in torn reads and torn writes.

A memory operation can be non-atomic because it uses multiple CPU instructions, non-atomic even when using a single CPU instruction, or non-atomic because you’re writing portable code and you simply can’t make the assumption. Let’s look at a few examples.

Non-Atomic Due to Multiple CPU Instructions

Suppose you have a 64-bit global variable, initially zero.

At some point, you assign a 64-bit value to this variable.

When you compile this function for 32-bit x86 using GCC, it generates the following machine code.

As you can see, the compiler implemented the 64-bit assignment using two separate machine instructions. The first instruction sets the lower 32 bits to 0x00000002, and the second sets the upper 32 bits to 0x00000001. Clearly, this assignment operation is not atomic. If sharedValue is accessed concurrently by different threads, several things can now go wrong:

  • If a thread calling storeValue is preempted between the two machine instructions, it will leave the value of 0x0000000000000002 in memory – a torn write. At this point, if another thread reads sharedValue, it will receive this completely bogus value which nobody intended to store.
  • Even worse, if a thread is preempted between the two instructions, and another thread modifies sharedValue before the first thread resumes, it will result in a permanently torn write: the upper 32 bits from one thread, the lower 32 bits from another.
  • On multicore devices, it isn’t even necessary to preempt one of the threads to have a torn write. When a thread calls storeValue, any thread executing on a different core could read sharedValue at a moment when only half the change is visible.

Reading concurrently from sharedValue brings its own set of problems:

Here too, the compiler has implemented the load operation using two machine instructions: The first reads the lower 32 bits into eax, and the second reads the upper 32 bits into edx. In this case, if a concurrent store to sharedValue becomes visible between the two instructions, it will result in a torn read – even if the concurrent store was atomic.

These problems are not just theoretical. Mintomic’s test suite includes a test case called test_load_store_64_fail, in which one thread stores a bunch of 64-bit values to a single variable using a plain assignment operator, while another thread repeatedly performs a plain load from the same variable, validating each result. On a multicore x86, this test fails consistently, as expected.

Non-Atomic CPU Instructions

A memory operation can be non-atomic even when performed by a single CPU instruction. For example, the ARMv7 instruction set includes the strd instruction, which stores the contents of two 32-bit source registers to a single 64-bit value in memory.

On some ARMv7 processors, this instruction is not atomic. When the processor sees this instruction, it actually performs two separate 32-bit stores under the hood (§A3.5.3). Once again, another thread running on a separate core has the possibility of observing a torn write. Interestingly, a torn write is even possible on a single-core device: A system interrupt – say, for a scheduled thread context switch – can actually occur between the two internal 32-bit stores! In this case, when the thread resumes from the interrupt, it will restart the strd instruction all over again.


As another example, it’s well-known that on x86, a 32-bit mov instruction is atomic if the memory operand is naturally aligned, but non-atomic otherwise. In other words, atomicity is only guaranteed when the 32-bit integer is located at an address which is an exact multiple of 4. Mintomic comes with another test case, test_load_store_32_fail, which verifies this guarantee. As it’s written, this test always succeeds on x86, but if you modify the test to force sharedInt to certain unaligned addresses, it will fail. On my Core 2 Quad Q6600, the test fails when sharedInt crosses a cache line boundary:

Those are enough processor-specific details for now. Let’s look at atomicity at the C/C++ language level.

All C/C++ Operations Are Presumed Non-Atomic

In C and C++, every operation is presumed non-atomic unless otherwise specified by the compiler or hardware vendor – even plain 32-bit integer assignment.

The language standards have nothing to say about atomicity in this case. Maybe integer assignment is atomic, maybe it isn’t. Since non-atomic operations don’t make any guarantees, plain integer assignment in C is non-atomic by definition.

In practice, we usually know more about our target platforms than that. For example, it’s common knowledge that on all modern x86, x64, Itanium, SPARC, ARM and PowerPC processors, plain 32-bit integer assignment is atomic as long as the target variable is naturally aligned. You can verify it by consulting your processor manual and/or compiler documentation. In the games industry, I can tell you that a lot of 32-bit integer assignments rely on this particular guarantee.

Nonetheless, when writing truly portable C and C++, there’s a long-standing tradition of pretending that we don’t know anything more than what the language standards tell us. Portable C and C++ is designed to run on every possible computing device past, present and imaginary. Personally, I like to imagine a machine where memory can only be changed by mixing it up first:

On such a machine, you definitely wouldn’t want to perform a concurrent read at the same time as a plain assignment; you could end up reading a completely random value.

In C++11, there is finally a way to perform truly portable atomic loads and stores: the C++11 atomic library. Atomic loads and stores performed using the C++11 atomic library would even work on the imaginary computer above – even if it means the C++11 atomic library must secretly lock a mutex to make each operation atomic. There’s also the Mintomic library which I released last month, which doesn’t support as many platforms, but works on several older compilers, is hand-optimized and is guaranteed to be lock-free.

Relaxed Atomic Operations

Let’s return to the original sharedValue example from earlier in this post. We’ll rewrite it using Mintomic so that all operations are performed atomically on every platform Mintomic supports. First, we must declare sharedValue as one of Mintomic’s atomic data types.


The mint_atomic64_t type guarantees correct memory alignment for atomic access on each platform. This is important because, for example, the GCC 4.2 compiler for ARM bundled with Xcode 3.2.5 doesn’t guarantee that plain uint64_t will be 8-byte aligned.

In storeValue, instead of performing a plain, non-atomic assignment, we must call mint_store_64_relaxed.

Similarly, in loadValue, we call mint_load_64_relaxed.

Bad kitty camp daze pdf free download full. Using C++11’s terminology, these functions are now data race-free. When executing concurrently, there is absolutely no possibility of a torn read or write, whether the code runs on ARMv6/ARMv7 (Thumb or ARM mode), x86, x64 or PowerPC. If you’re curious how mint_load_64_relaxed and mint_store_64_relaxed actually work, both functions expand to an inline cmpxchg8b instruction on x86; for other platforms, consult Mintomic’s implementation.

Here’s the exact same thing written in C++11 instead:

You’ll notice that both the Mintomic and C++11 examples use relaxed atomics, as evidenced by the _relaxed suffix on various identifiers. The _relaxed suffix is a reminder that few guarantees are made about memory ordering.

In particular, it is still legal for the memory effects of a relaxed atomic operation to be reordered with respect to instructions which follow or precede it in program order, either due to compiler reordering or memory reordering on the processor itself. The compiler could even perform optimizations on redundant relaxed atomic operations, just as with non-atomic operations. In all cases, the operation remains atomic.

Atomic Nomad Blackeye

When manipulating shared memory concurrently, I think it’s good practice to always use Mintomic or C++11 atomic library functions, even in cases where you know that a plain load or store would already be atomic on your target platform. An atomic library function serves as a reminder that elsewhere, the variable is the target of concurrent data access.

Atomic Number Definition Chemistry

Hopefully, it’s now a bit more clear why the World’s Simplest Lock-Free Hash Table uses Mintomic library functions to manipulate shared memory concurrently from different threads.