Paraffins: Difference between revisions

[[File:Paraffins.isopentane.png|450px600px||right]]

Enumerate, without repetitions and in order of increasing size, all possible paraffin molecules (also known as [[wp:alkane|alkane]]s).

Paraffins are built up using only carbon atoms, which has four bonds, and hydrogen, which has one bond.   All bonds for each atom must be used, so it is easiest to think of an alkane as linked carbon atoms forming the "backbone" structure, with adding hydrogen atoms linking the remaining unused bonds.

In a paraffin, one is allowed neither double bonds (two bonds between the same pair of atoms), nor cycles of linked carbons. &nbsp; So all paraffins with &nbsp; '''n''' &nbsp; carbon atoms share the empirical formula &nbsp; &nbsp; <big>C_nH_2n+2</big>

In counting isomers it should be borne in mind that the four bond positions on a given carbon atom can be freely interchanged and bonds rotated (including 3-D "out of the paper" rotations when it's being observed on a flat diagram), &nbsp; so rotations or re-orientations of parts of the molecule (without breaking bonds) do not give different isomers. &nbsp; So what seem at first to be different molecules may in fact turn out to be different orientations of the same molecule.

:::* &nbsp; a &nbsp; straight &nbsp; chain: &nbsp; &nbsp; <big>(CH₃)(CH₂)(CH₂)(CH₃)</big>

:::* &nbsp; a branched chain: &nbsp; &nbsp; &nbsp; <big>(CH₃)(CH(CH₃))(CH₃)</big>

The sequence of those results is visible in the [[oeisOEIS entry:A000602|Sloane encyclopedia]].&nbsp; The sequence is (the index starts from zero, and represents the number of carbon atoms):

<langsyntaxhighlight haskelllang="text">*Main> all_paraffins 1

[CCP H H H H]

[BCP (C H H H) (C H H H)]

[CCP H H (C H H H) (C H H H)]

[BCP (C H H (C H H H)) [BCP (C H H (C H H H)),CCP H (C H H H) (C H H H)),

[CCP H H (C H H (C H H H)) (C H H (C H H H)),CCP H (C H H H)

(C H H H) (C H CCP H (C H H H)),CCP (C H H H) (C H H H) (C H H H)),

[BCP (C H H (C H H (C H H H))) (C H H (C H H (C H H H))),BCP

BCP (C H H (C H H (C H H H))) (C H (C H H H) (C H H H)),BCP (C H

BCP (C H (C H H H) (C H H H)) (C H (C H H H) (C H H H)),CCP H (C H H H)

(C H CCP H (C H H H)) (C H H (C H H H)),CCP (C H H H) (C H H H)),

CCP (C H H H) (C H H H) (C H H H) (C H H (C H H H))]</langsyntaxhighlight>

<presyntaxhighlight lang="text"> Methane methane ethane Ethane propane Propane Isobutaneisobutane

H H H H H H H H H

| │ | | │ │ | | | │ │ │ | | | │ │ │

H -─ C -─ H H -─ C -─ C -─ H H -─ C -─ C -─ C -─ H H -─ C -─ C -─ C -─ H

| │ | | │ │ | | | │ │ │ | | | │ │ │

H H H H H H H |│ H

| │

H -─ C -─ H

| │

H</presyntaxhighlight>

* &nbsp; A paper that explains the problem and its solution in a functional language:

* &nbsp; A Haskell implementation:

* &nbsp; A Scheme implementation:

* &nbsp; A Fortress implementation: &nbsp; &nbsp; &nbsp; &nbsp; (this site has been closed)

<langsyntaxhighlight lang="c">#include <stdio.h>

}</langsyntaxhighlight>Same idea, with GMP, and done somewhat differently:<langsyntaxhighlight lang="c">#include <gmp.h>

}</langsyntaxhighlight>

<langsyntaxhighlight lang="d">import std.stdio, std.bigint;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="freebasic">' version 31-12-2016

End</langsyntaxhighlight>

<langsyntaxhighlight lang="go">package main

}</langsyntaxhighlight>

<langsyntaxhighlight lang="haskell">-- polynomial utils

main = mapM_ print $ take 200 $ zip [0 ..] a602</langsyntaxhighlight>

<langsyntaxhighlight lang="haskell">import Data.Array

main = mapM_ print $ map (\x->(x, unrooted x)) [1..max_nodes]</langsyntaxhighlight>

<langsyntaxhighlight lang="j">part3=: ;@((<@([(],.(-+/"1))],.]+i.@(]-~1+<.@-:@-))"0 i.@>:@<.@%&3))

NofParaff=: {. radGenN ((ccpGenN +:) + bcpGenN ) 2&|+<.@-:</langsyntaxhighlight>

<langsyntaxhighlight lang="j"> 6 6 $ NofParaff 36

4111846763 10660307791 27711253769 72214088660 188626236139 493782952902</langsyntaxhighlight>

<langsyntaxhighlight lang="java">import java.math.BigInteger;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="jq">def MAX_N: 500; # imprecision begins at 46

paraffins</langsyntaxhighlight>

<langsyntaxhighlight lang="jq">def paraffins:

;</langsyntaxhighlight>

<langsyntaxhighlight lang="scala">// version 1.1.4-3

}</langsyntaxhighlight>

=={{header|Mathematica}}/{{header|Wolfram Language}}==

<langsyntaxhighlight lang="mathematica">G000602s[m_, p_, n_] :=

G000598[n_] := Nest[1 + x s[3, #, n] Table[ComposeSeries[#&, x^i1 + O[x]^(n + 1)], {i, 4}n]] - ;

x s[4, #, n] - Table[ComposeSeriess[2, # - 1, x^i + O[x]^(n + 1)], {i, 2}]] +

ComposeSeries[#, x^2 + O[x]^(n + 1)] &@[G000598[n]];

Grid@Transpose@{Range[0, 200], A000602List@200}</langsyntaxhighlight>

<lang nim>import {{libheader|bigints}}

proc choose(m,: BigInt; k: int32): BigInt =

for i in 1 .. < k:

proc tree(br, n, l, sum: int32,; cnt: BigInt) =

proc bicenter(s: int32) =

echo n, ": ", unrooted[n]</langsyntaxhighlight>

<langsyntaxhighlight lang="parigp">paraffin(p) =

}</langsyntaxhighlight>

<langsyntaxhighlight lang="parigp">iso(B,n,C,S,l=n) =

}</langsyntaxhighlight>

<langsyntaxhighlight lang="pascal">Program Paraffins;

end.</langsyntaxhighlight>

<langsyntaxhighlight lang="perl">use Math::GMPz;

}</langsyntaxhighlight>

=={{header|Perl 6Phix}}==

$choices *<span style="color: @rooted[$w]#008080;">return</span>

<pre> 1: 1

21: 1

32: 1

43: 21

54: 32

65: 53

76: 95

87: 189

98: 3518

109: 7535

<langsyntaxhighlight Pikelang="pike">int MAX_N = 300;

}</langsyntaxhighlight>

<langsyntaxhighlight lang="python">try:

main()</langsyntaxhighlight>

<langsyntaxhighlight lang="python">from itertools import count, chain, tee, islice, cycle

for n,x in zip(count(0), islice(a602, 500)): print(n,x)</langsyntaxhighlight>

<langsyntaxhighlight lang="racket">

Programming note: &nbsp; the biggest concern was calculating the number of numericdecimal digits &nbsp; (so as to avoid integer overflow).

<langsyntaxhighlight lang="rexx">/*REXX programpgm enumerates (without repetition) the #number of paraffins with N carbon atoms. of carbon*/

if nodes=='' | nodes=="," then nodes=100 100 /*Not specified? Then use the default.*/

rooted. = 0; rooted.0= 1; rooted.1=1 1 /*define the base rooted numbers.*/

unrooted. = 0; unrooted.0= 1; unrooted.1=1 1 /* " " " unrooted " */

numeric digits max(9, nodes % 2) /*this program may use gihugeic numbers*/

w= length(nodes) /*W: used for aligning formatted nodes.*/

say right(0, w) unrooted.0 /*show enumerations of 0 carbon atoms*/

do C=1 for nodes; h= C %2 2 /*C: is the number of carbon atoms. */

if \(C//2==0) then unrooted.C= unrooted.C + rooted.h * (rooted.h + 1) % 2

say right(C, w) unrooted.C /*display an aligned formatted number. */

parse arg br,n,L,sum,cnt; nm= n - 1; LL=L+L; brpLL=br L +1 L

if b==4 then do b=brp to 4; sum= if LL>=sum + then leaven

if b==brp then #.br=rooted.n * cnt if sum>nodes then leave

if b==4 else #.br=#.br * (rooted.n +then bif -LL>=sum brp) % (b -then br)leave

if LL<sumb==brp then unrooted#.sumbr=unrooted rooted.sumn +* #.brcnt

if b else #.br==4 #.br * (rooted.n + b - brp) % (b then- leavebr)

rooted. if LL<sum then unrooted.sum= rootedunrooted.sum + #.br

do m=nm by -1 for nm; call treeif b, m,==4 L, sum, #.br; end then /*m*/leave

end /*b*/ rooted.sum= rooted.sum + /* ↑↑↑↑↑↑↑↑↑ recursive invocation of TREE#. */</lang>br

<langsyntaxhighlight lang="ruby">MAX_N = 500

end</langsyntaxhighlight>

<langsyntaxhighlight Scalalang="scala">object Paraffins extends App {

}</langsyntaxhighlight>

<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";

end func;</langsyntaxhighlight>

<langsyntaxhighlight lang="tcl">package require Tcl 8.5

}</langsyntaxhighlight>

<langsyntaxhighlight lang="zkl">var BN=Import("zklBigNum");

}</langsyntaxhighlight>