Chemical calculator: Difference between revisions

Given a molecule's chemical formula, calculate the &nbsp; [https://en.wikipedia.org/wiki/Molar_mass <u>molar mass</u>].

 

;Introduction

* An atom name consists of one upper-case letter followed by zero, one or two lower-case letters.

* The number of atoms is stated behind the atom or atom group

 

 

 

;Atom masses

 

;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

 

 

:* &nbsp; Wikipedia article: &nbsp; [https://en.wikipedia.org/wiki/Molecular_mass Molecular mass]

<br><br>

 

=={{header|ALGOL W}}==

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

real procedure parseCompound ; begin

real mass, itemMass;

real procedure parseAtom ; begin

string(3) symbol;

A("Es",252 );A("Fm",257 ); % Md % %, No % % Lr %

end Actinides ;

% ---------------- first period elements ---> % A("H", 1.008);A("He", 4.002602);

% --- hypothetical eigth period elements ---> % A("Uue",315 );A("Ubn",299 );

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

end

{{out}}

<pre>

</pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

dic = NULL;

return 0;

{{out}}

<pre> H -> 1.008

C27H46O -> 386.664

Uue -> 315.000</pre>

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

{{trans|D}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre> H -> 1.008

C27H46O -> 386.664

Uue -> 315.000</pre>

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

{{trans|C#}}

#include <iostream>

#include <map>

 

return 0;

{{out}}

<pre> H -> 1.008

C27H46O -> 386.664

Uue -> 315.000</pre>

=={{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|Fōrmulæ}}==

 

 

 

 

=={{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}}

Uue -> 315.000

</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.List;

import java.util.Map;

}

}

{{out}}

<pre> H -> 1.008

C27H46O -> 386.664

Uue -> 315.000</pre>

 

=={{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

C27H46O -> 386.664

Uue -> 315.000</pre>

 

=={{header|Nim}}==

* Nim lacks runtime eval, that's the reason for so much code. (And me being a sloppy programmer)

* 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

84.162 C6H12 C6H12

186.295 C11H22O2 COOH(C(CH3)2)3CH3</pre>

=={{header|Phix}}==

A simple hand-written single-pass formula parser and evaluator in one.<br>

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.

{{out}}

<pre>

UueCl = 350.45

</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

Atomic mass C27H46O 386.664

Atomic mass Uue 315.000</pre>

=={{header|Racket}}==

 

 

(define table '([H 1.008]

(printf "~a: ~a\n"

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

 

{{out}}

Uue: 315

</pre>

=={{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

84.162 C6H12

186.295 COOH(C(CH3)2)3CH3</pre>

=={{header|REXX}}==

This REXX version has some basic error checking to catch malformed chemical formulas.

 

 

 

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

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

@.Cn=285 ; @.Hs=277 ; @.No=259 ; @.Sc= 44.955912; @.Zr= 91.224

@.Ubn=299 ; @.Uue=315

do j=1 for words($); x= word($, j) /*obtain the formula of the molecule. */

if mm<0 then iterate /*if function had an error, skip output*/

end /*j*/

exit /*stick a fork in it, we're all done. */

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>

</pre>

=={{header|Ruby}}==

{{trans|D}}

"H" => 1.008,

"He" => 4.002602,

end

 

{{out}}

<pre> H -> 1.008

C27H46O -> 386.664

Uue -> 315.000</pre>

 

=={{header|Swift}}==

 

 

struct Chem {

 

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

 

{{out}}

C27H46O => 386.664

Uue => 315.000</pre>

=={{header|VBA}}==

 

Enum ParsingStateCode

masses.Add 299, "Ubn"

masses.Add 315, "Uue"

 

{{out}}

C27H46O 386,664

Uue 315</pre>

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

{{trans|C#}}

 

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

End Sub

 

{{out}}

<pre> H -> 1.008

C27H46O -> 386.664

Uue -> 315.000</pre>

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

{{libheader|Wren-str}}

 

var atomicMass = {

for (molecule in molecules) {

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

 

{{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>

H --> 1.008

COOH(C(CH3)2)3CH3 --> 186.295

</pre>