Chemical calculator: Difference between revisions

;Examples:

assert 2.016 == molar_mass('H2') # hydrogen gas

assert 18.015 == molar_mass('H2O') # water

assert 176.124 == molar_mass('C6H4O2(OH)4') # vitamin C

assert 386.664 == molar_mass('C27H46O') # cholesterol

Algol W has fixed length strings and no regular expressions, this parses the molecule with a simple recursive descent parser.<br>

Some error checking is included.

% calculates the molar mass of the specified molecule %

real procedure molar_mass ( string(256) value molecule ) ; begin

test( 186.29499999999996, "COOH(C(CH3)2)3CH3" ); test( 350.45, "UueCl" );

end

{{out}}

<pre>

=={{header|AutoHotkey}}==

, "Uue", "C6H4O2(O)H)4", "X2O"]

for i, str in test

}

return str " > " sum

{{out}}

<pre>H > H > 1.008000

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

dic = NULL;

return 0;

{{out}}

<pre> H -> 1.008

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre> H -> 1.008

=={{header|C++}}==

{{trans|C#}}

#include <iostream>

#include <map>

return 0;

{{out}}

<pre> H -> 1.008

=={{header|CoffeeScript}}==

===No Regular Expression===

molar_mass = (s) ->

assert 176.124, molar_mass 'C6H4O2(OH)4' # Vitamin C

assert 386.664, molar_mass 'C27H46O' # Cholesterol

===Regular Expression===

{{trans|Julia}}

mul = (match, p1, offset, string) -> '*' + p1

assert 176.124, molar_mass('C6H4O2(OH)4') # Vitamin C

assert 386.664, molar_mass('C27H46O') # Cholesterol

=={{header|D}}==

{{trans|Go}}

import std.conv;

import std.format;

}

writeln(atomicMass);

{{out}}

<pre> H -> 1.008

=={{header|Delphi}}==

{{trans|Go}}

program ChemicalCalculator;

readln;

end.

Include file with Atomic Mass Constants ('''AtomicMass.inc''').

const

ATOMIC_MASS_SIZE = 101;

226, 227, 232.0377, 231.03588, 238.02891, 237, 244, 243, 247, 247, 251, 252,

257, 315, 299);

=={{header|Factor}}==

{{works with|Factor|0.98}}

infix.private kernel math.functions math.parser multiline

peg.ebnf qw sequences splitting strings words words.constant ;

} [ molar-mass 1e-5 approx-assert= ] assoc-each ;

No assertion errors.

=={{header|Go}}==

This doesn't use regular expressions, RPN or eval (which Go doesn't have). It's just a simple molar mass evaluator written from scratch.

import (

fmt.Printf("%17s -> %7.3f\n", molecule, mass)

}

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

class ChemicalCalculator {

}

}

{{out}}

<pre> H -> 1.008

=={{header|Haskell}}==

Create a set of parsers for molecular formulae and their subparts. The parsers maintain a running total of the mass parsed so far. Use a '''Reader''' monad to store a map from atom names to their masses. The contents of the map are read from the file '''chemcalc_masses.in''', not shown here.

import Control.Monad.Reader (Reader, ask, runReader)

import Data.Bifunctor (first)

Left err -> printf "\n%s" err

Right mass -> printf " %.4f\n" mass

{{out}}

<pre>

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.List;

import java.util.Map;

}

}

{{out}}

<pre> H -> 1.008

=={{header|JavaScript}}==

const MASSES = {

C: 12.011,

for (let i = 0; i < formulae.length; i++)

console.log(`${getSubNums(formulae[i])}: ${getMolarMass(formulae[i]).toPrecision(3)}`);

{{out}}

'''The PEG grammar'''

parse("(?<e>^[A-Z][a-z]*)"); # greedy

(plus(EN) | Parenthesized | Formula)

// (plus(EN) | optional(Parenthesized))

'''Evaluation of the parsed expression'''

'''The task expressed in terms of assertions'''

def molar_mass(formula):

{remainder: formula} | Formula | .result | debug | eval;

assert( 386.664; molar_mass("C27H46O")), # cholesterol

assert( 315 ; molar_mass("Uue")) # ununennium

{{out}}

As mentioned above, a "debug" statement has been retained so that the parsed chemical formula can be seen.

=={{header|Julia}}==

Note that Julia's 64-bit floating point gets a slightly different result for one of the assertions, hence a small change in the last example. The function uses Julia's own language parser to evaluate the compound as an arithmetic expression.

const He = 4.002602

const Li = 6.94

@assert 84.162 == molar_mass("C6H12")

@assert 186.29500000000002 == molar_mass("COOH(C(CH3)2)3CH3")

No assertion errors.

=={{header|Kotlin}}==

{{trans|D}}

"H" to 1.008,

"He" to 4.002602,

println("$moleStr -> $massStr")

}

{{out}}

<pre> H -> 1.008

=={{header|Lua}}==

{{trans|C#}}

["H"] = 1.008,

["He"] = 4.002602,

local mass = evaluate(replaceParens(molecule))

print(string.format("%17s -> %7.3f", molecule, mass))

{{out}}

<pre> H -> 1.008

* Also, seqs can't contain mixed types.

import tables, strutils, sequtils, math

assert 176.124 == molar_mass "C6H4O2(OH)4" # Vitamin C

assert 386.664 == molar_mass "C27H46O" # Cholesterol

=={{header|Perl}}==

===Grammar===

use warnings;

use List::Util;

for (<H H2 H2O Na2SO4 C6H12 COOH(C(CH3)2)3CH3>) {

printf "%7.3f %s\n", $g->weight($_), $_

===Regular Expression===

use warnings;

my %atomic_weight = < H 1.008 C 12.011 O 15.999 Na 22.99 S 32.06 >;

}

{{out}}

<pre> 1.008 H1 H

Also note that initially it all worked absolutely fine with the default precision (ie "%g" instead of "%.12g"),

and that the higher precision expected value for Na2SO4 also works just fine at both printing precisions.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">elements</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">()</span> <span style="color: #000080;font-style:italic;">-- (eg "H" -&gt; 1.008)</span>

<span style="color: #000000;">molar_mass</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Uue"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Ununennium"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">315</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">molar_mass</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"UueCl"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">350.45</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Python}}==

{{trans|Julia}}

ATOMIC_MASS = {"H":1.008, "C":12.011, "O":15.999, "Na":22.98976928, "S":32.06, "Uue":315}

return print("Atomic mass {:17s} {} {:7.3f}".format(nazwa,'\t',round(eval(s),3)))

{{out}}

<pre>Atomic mass H 1.008

=={{header|Racket}}==

(define table '([H 1.008]

(printf "~a: ~a\n"

(~a test #:align 'right #:min-width 20)

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

H => 1.008 , Fe => 55.845 , Te => 127.60 , Ir => 192.217 ,

He => 4.002602 , Co => 58.933194 , I => 126.90447 , Pt => 195.084 ,

return $/.made.[0];

}

{{Out}}

<pre> 1.008 H

roentgenium (Rg), copernicium (Cn), nihoniym (Nh), flerovium (Fl), moscovium (Mc),

livermorium (Lv), tennessine (Ts), oganesson (Og)

numeric digits 30 /*ensure enough decimal digits for mass*/

/*─────────── [↓] table of known elements (+2 more) with their atomic mass ────────────*/

do i=1 until \datatype(q, 'W'); q= substr(z, k+i, 1)

if datatype(q, 'W') then n= n || q /*is a digit?*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

=={{header|Ruby}}==

{{trans|D}}

"H" => 1.008,

"He" => 4.002602,

end

{{out}}

<pre> H -> 1.008

=={{header|Swift}}==

struct Chem {

print("\(mol) => \(fmt(mass))")

{{out}}

=={{header|VBA}}==

Enum ParsingStateCode

masses.Add 299, "Ubn"

masses.Add 315, "Uue"

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Dim atomicMass As New Dictionary(Of String, Double) From {

End Sub

{{out}}

<pre> H -> 1.008

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

import "/str" for Char, Str

var mass = evaluate.call(replaceParens.call(molecule))

System.print("%(Fmt.s(17, molecule)) -> %(Fmt.f(7, mass, 3))")

{{out}}

=={{header|zkl}}==

Really bad error checking

while(span:=str.span("(",")",False)){ // get inner most () group

group:=str[span.xplode()]; // (CH3)

}

ms.reduce('+);

"Ac",227.000000, "Ag",107.868200, "Al", 26.981538, "Am",243.000000, "Ar", 39.948000,

"As", 74.921595, "At",210.000000, "Au",196.966569, "B" , 10.810000, "Ba",137.327000,

.concat("|","(",")([1-9]*)") )

: RegExp(_);

{{out}}

<pre>