chemistry_paradise 1.4.2

data/lib/chemistry_paradise/toplevel_methods/periodic_table.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'chemistry_paradise/toplevel_methods/periodic_table.rb'
+# =========================================================================== #
+module ChemistryParadise
+
+  # ========================================================================= #
+  # === ChemistryParadise.periodic_table?
+  # ========================================================================= #
+  def self.periodic_table?
+    '/Users/x/DATA/SCIENCE/YAML/periodic_table.yml'
+  end
+
+end

data/lib/chemistry_paradise/toplevel_methods/remove_this_molecule_from.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'chemistry_paradise/toplevel_methods/remove_this_molecule_from.rb'
+# =========================================================================== #
+require 'chemistry_paradise/split_molecule_names.rb'
+
+module ChemistryParadise
+
+  # ========================================================================= #
+  # === ChemistryParadise.remove_this_molecule_from
+  #
+  # The first argument is the molecule that should be deducted from
+  # the formula.
+  # ========================================================================= #
+  def self.remove_this_molecule_from(
+      this_molecule = 'OH',
+      from          = 'C2H5NO2'
+    )
+    array_big_molecule  = ::ChemistryParadise.split_this_molecular_formula_into_a_hash(from)
+    array_this_molecule = ::ChemistryParadise.split_this_molecular_formula_into_a_hash(this_molecule)
+    # ======================================================================= #
+    # Next, iterate over the small molecule.
+    # ======================================================================= #
+    array_this_molecule.each {|this_compound|
+      unless this_compound =~ /\d+/
+        this_compound << '1' # Must be at the least one.
+      end
+      # ===================================================================== #
+      # Select the entry that is the correct one.
+      # ===================================================================== #
+      this_entry = array_big_molecule.find {|entry|
+        entry[0,1] == this_compound[0,1]
+      }
+      begin
+        n_times_in_the_big_molecule   = /(\d{1,3})/.match(this_entry)[1].to_i
+        n_times_in_the_small_molecule = /(\d{1,3})/.match(this_compound)[1].to_i
+        new_n_times = n_times_in_the_big_molecule - n_times_in_the_small_molecule
+        new_entry = this_compound[0,1]+new_n_times.to_s
+        # ===================================================================== #
+        # Now we have the new entry; we need to re-insert it into the big
+        # original Array.
+        # ===================================================================== #
+        proper_index = array_big_molecule.index {|entry|
+          entry[0,1] == this_compound[0,1]
+        }
+        array_big_molecule[proper_index] = new_entry
+      rescue NoMethodError => error
+        pp error
+      end
+    }
+    return array_big_molecule.join # Join it up again.
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  puts 'Deducting OH from C2H5NO2 next:'
+  puts ::ChemistryParadise.remove_this_molecule_from('OH', 'C2H5NO2')  
+  puts 'Deducting H2O from C2H5NO2 next:'
+  puts ::ChemistryParadise.remove_this_molecule_from('H2O', 'C2H5NO2')
+end

data/lib/chemistry_paradise/toplevel_methods/roebe.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'chemistry_paradise/toplevel_methods/roebe.rb' 
+# =========================================================================== #
+module ChemistryParadise
+
+  # ========================================================================= #
+  # === ChemistryParadise.is_on_roebe?
+  # ========================================================================= #
+  def self.is_on_roebe?
+    ENV['IS_ROEBE'].to_s == '1'
+  end
+
+end

data/lib/chemistry_paradise/toplevel_methods/show_electron_negativity_chart.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# require 'chemistry_paradise/toplevel_methods/show_electron_negativity_chart.rb'
+# =========================================================================== #
+require 'chemistry_paradise/constants/constants.rb'
+
+module ChemistryParadise
+
+  # ========================================================================= #
+  # === ChemistryParadise.show_electron_negativity_chart
+  # ========================================================================= #
+  def self.show_electron_negativity_chart
+    Constants::ELECTRON_NEGATIVITY_CHART.each_pair {|key, value|
+      value = value.to_f
+      value = '%.2f' % value 
+      puts key.ljust(2)+' -> '+value.to_s.rjust(2)
+    }
+  end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  ChemistryParadise.show_electron_negativity_chart
+end

data/lib/chemistry_paradise/utility_scripts/calculate_atomic_mass.rb

@@ -0,0 +1,559 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === ChemistryParadise::CalculateAtomicMass
+#
+# This class will calculate the atomic mass of a compound.
+# =========================================================================== #
+# require 'chemistry_paradise/utility_scripts/calculate_atomic_mass.rb'
+# ChemistryParadise::CalculateAtomicMass.new(ARGV)
+# =========================================================================== #
+require 'chemistry_paradise/base/base.rb'
+
+module ChemistryParadise
+
+class CalculateAtomicMass < Base # === ChemistryParadise::CalculateAtomicMass
+
+  require 'chemistry_paradise/split_molecule_names.rb'
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  # ========================================================================= #
+  # === ARRAY_HELP_OPTIONS
+  # ========================================================================= #
+  ARRAY_HELP_OPTIONS = %w(
+    HELP help --help --h -h
+  )
+
+  # ========================================================================= #
+  # === ATOMGEWICHTE
+  # ========================================================================= #
+  _ = Constants::FILE_ATOMGEWICHTE
+  if File.exist? _
+    ATOMGEWICHTE = YAML.load_file(_)
+  elsif File.exist? File.expand_path('~')+File.basename(_)
+    ATOMGEWICHTE = YAML.load_file(File.expand_path('~')+File.basename(_))
+  end
+
+  # ========================================================================= #
+  # === ChemistryParadise::CalculateAtomicMass::DEFAULT_INPUT
+  # ========================================================================= #
+  DEFAULT_INPUT = 'P2O5'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      optional_input = ARGV,
+      run_already    = true
+    )
+    reset
+    set_input(optional_input)
+    case run_already.to_s
+    when 'do_not_report'
+      @report_result = false
+      run_already = true
+    end
+    # ======================================================================= #
+    # === Handle blocks next
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :do_not_exit
+      # ===================================================================== #
+      when :do_not_exit
+        @may_we_exit = false
+      else
+        if yielded.is_a? Hash
+          _ = yielded
+          if _.has_key? :verbosity
+            @report_result = _[:verbosity]
+          end
+          if _.has_key? :may_we_exit
+            @may_we_exit =_[:may_we_exit]
+          end
+        end
+      end
+    end
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @commandline_arguments
+    # ======================================================================= #
+    @commandline_arguments = []
+    # ======================================================================= #
+    # === @show_more
+    # ======================================================================= #
+    @show_more = true
+    # ======================================================================= #
+    # === @show_the_steps
+    #
+    # If the following variable is set to true then we will display,
+    # on the commandline, what is done when. This gives the user more
+    # information about what is going on, and it may also help during
+    # debugging this class/project.
+    #
+    # Note that @show_the_steps is a bit different to @show_more, so
+    # these two variables are presently kept separate.
+    # ======================================================================= #
+    @show_the_steps = false
+    # ======================================================================= #
+    # === @individual_components
+    # ======================================================================= #
+    @individual_components = []
+    # ======================================================================= #
+    # === @output_string
+    # ======================================================================= #
+    @output_string = ''.dup
+    # ======================================================================= #
+    # === @report_result
+    # ======================================================================= #
+    @report_result = true
+    # ======================================================================= #
+    # === @may_we_exit
+    # ======================================================================= #
+    @may_we_exit = true
+    # ======================================================================= #
+    # === @molecular_formula_of_different_molecules
+    # ======================================================================= #
+    @molecular_formula_of_different_molecules = YAML.load_file(
+      FILE_MOLECULAR_FORMULA_OF_DIFFERENT_MOLECULES
+    )
+    set_input
+  end
+
+  # ========================================================================= #
+  # === set_input
+  # ========================================================================= #
+  def set_input(i = DEFAULT_INPUT)
+    if i.is_a? Array
+      @commandline_arguments = i[1..-1] # Set the remaining as commandline arguments.
+      i = i.first # And re-assign the first input.
+    end
+    i = DEFAULT_INPUT if i.nil?
+    case i.to_s
+    when 'do_not_report'
+      @report_result = false
+      i = nil
+    when 'harnstoff'
+      i = @molecular_formula_of_different_molecules['harnstoff']
+    end
+    i = ARRAY_TEST_THESE_MOLECULES if i == :test_default_molecules
+    i = i.to_s.dup
+    # if i.include? ', '
+    #   i = i.split(',').map(&:strip)
+    # end
+    # i = [i] unless i.is_a? Array
+    @input = i
+    sanitize_input
+  end
+
+  # ========================================================================= #
+  # === input?
+  # ========================================================================= #
+  def input?
+    @input
+  end
+
+  # ========================================================================= #
+  # === sanitize_input_for_element_names
+  # ========================================================================= #
+  def sanitize_input_for_element_names(array)
+    result = []
+    if array.any? {|entry| entry == entry.downcase }
+      array.each {|entry|
+        case entry
+        when *ARRAY_HELP_OPTIONS
+          show_help :then_exit
+        end
+        if entry == entry.downcase
+          result[-1] = result[-1]+entry
+        else
+          result << entry
+        end
+      }
+    else
+      result = array
+    end
+    return result
+  end
+
+  # ========================================================================= #
+  # === calculate_compound
+  #
+  # This method will attempt to calculate the given input.
+  #
+  # The input to this method will usually be something like "Pb3".
+  # ========================================================================= #
+  def calculate_compound(i)
+    result = 0
+    if i =~ /\d+/ # if input has a number
+      splitted = i.split(/(\d+)/)
+    else # else assume that the number is one.
+      splitted = [ i, 1 ]
+    end
+    if atomgewichte?.has_key? splitted[0]
+      result = splitted[1].to_i * ATOMGEWICHTE[splitted[0]]
+    end
+    gather_individual_components(i, result)
+    return result
+  end; alias ba                          calculate_compound # === ba
+       alias summenformel                calculate_compound # === summenformel
+       alias atomgewicht                 calculate_compound # === atomgewicht
+       alias molmasse                    calculate_compound # === molmasse
+       alias molare_masse                calculate_compound # === molare_masse
+       alias calculcate_molecular_weight calculate_compound # === calculcate_molecular_weight
+
+  # ========================================================================= #
+  # === atomgewichte?
+  # ========================================================================= #
+  def atomgewichte?
+    ATOMGEWICHTE
+  end
+
+  # ========================================================================= #
+  # === set_result
+  # ========================================================================= #
+  def set_result(i)
+    @result = i
+  end
+
+  # ========================================================================= #
+  # === report_result
+  # ========================================================================= #
+  def report_result
+    e @output_string
+  end
+
+  # ========================================================================= #
+  # === gather_individual_components
+  # ========================================================================= #
+  def gather_individual_components(name, weight)
+    array = [name, weight]
+    @individual_components << array
+  end
+
+  # ========================================================================= #
+  # === bold_red
+  # ========================================================================= #
+  def bold_red(i)
+    swarn(i)
+  end
+
+  # ========================================================================= #
+  # === nice_result
+  # ========================================================================= #
+  def nice_result
+    @result.to_f.round(3).to_s
+  end
+
+  # ========================================================================= #
+  # === is_included?
+  # ========================================================================= #
+  def is_included?(i = input?)
+    i = i.dup
+    # ======================================================================= #
+    # First remove all numbers from the input:
+    # ======================================================================= #
+    i.delete!('0-9')   
+    i = i[0,2] if i.size > 2 # Take only the first two characters, in the event that we have more than two characters in the supplied input.
+    atomgewichte?.has_key?(i)
+  end; alias include? is_included? # === include?
+
+  # ========================================================================= #
+  # === report_result?
+  # ========================================================================= #
+  def report_result?
+    @report_result
+  end
+
+  # ========================================================================= #
+  # === result?
+  # ========================================================================= #
+  def result?
+    @result
+  end; alias result result? # === result
+       alias masse? result? # === masse?
+
+  # ========================================================================= #
+  # === menu                                                       (menu tag)
+  #
+  # The @commandline_arguments will be checked against the internal menu. 
+  # ========================================================================= #
+  def menu(i = @commandline_arguments)
+    if i.is_a? Array
+      i.each {|entry| menu(entry) }
+    else
+      case i # case tag
+      # ===================================================================== #
+      # === molmasse C5H6N2O2 --english
+      # ===================================================================== #
+      when /^-?-?english$/
+        do_use_the_english_language
+      # ===================================================================== #
+      # === molmasse C5H6N2O2 --show-steps
+      # ===================================================================== #
+      when /^-?-?show(-|_)?steps$/
+        do_show_the_steps
+      # ===================================================================== #
+      # === molmasse C5H6N2O2 --show-details
+      # ===================================================================== #
+      when /^-?-?show(-|_)?details?$/,
+           '--detail'
+        do_show_details
+      # ===================================================================== #
+      # === molmasse --help
+      # ===================================================================== #
+      when *ARRAY_HELP_OPTIONS
+        show_help
+        exit_the_program
+      # ===================================================================== #
+      # === molmasse SUM
+      # ===================================================================== #
+      when 'SUM',
+           'SHOW',
+           'MORE'
+        do_show_details
+      end
+    end
+  end; alias check_against_menu menu # === check_against_menu
+
+  # ========================================================================= #
+  # === do_show_details
+  # ========================================================================= # 
+  def do_show_details
+    @show_more = true
+  end
+
+  # ========================================================================= #
+  # === opnn
+  # ========================================================================= #
+  def opnn
+    super(NAMESPACE)
+  end
+
+  # ========================================================================= #
+  # === determine_output_string
+  #
+  # This method will determine the String that will be shown to the
+  # user on the commandline.
+  # ========================================================================= #
+  def determine_output_string
+    _ = nice_result
+    if do_we_use_english?
+      @output_string = "#{rev}The molecular mass of #{sfancy(@input)} is "\
+                       "#{simp(_+' u (g / mol)')}."
+    else # then we probably use german
+      @output_string = "#{rev}Die molekulare Masse von #{sfancy(@input)} "\
+                       "beträgt #{simp(_+' u (g / mol)')}."
+    end
+  end
+
+  # ========================================================================= #
+  # === show_help
+  # ========================================================================= #
+  def show_help(
+      i = :then_exit
+    )
+    opn; e 'Pass -SUM to show the individual sub-steps as well.'
+    exit_the_program(i)
+  end
+
+  # ========================================================================= #
+  # === consider_modifying_the_output_string
+  # ========================================================================= #
+  def consider_modifying_the_output_string
+    if @show_more # This can modify the output string.
+      _ = ''.dup
+      Hash[@individual_components].each_pair {|key, value|
+        key = key.scan(/./).map {|entry|
+          # if entry =~ /^\d+/ # Starts with a number.
+          #   entry << 'x'
+          # end # Disabled as of July 2021. May be re-enabled at a later time.
+          entry
+        }
+        key = key.join
+        _ << key+': '+value.round(7).to_s+' | '
+      }
+      @output_string = @output_string.dup if @output_string.frozen?
+      @output_string << "#{N}#{bold_red('  (The individual components were: ').dup}#{rev}"
+      _.strip!
+      splitted = _.split('|').map {|entry|
+        Colours.kde_colour_palette_plasma_blue(entry)
+      }
+      joined = splitted.join(teal('|'))
+      @output_string << joined+
+                        bold_red(')')
+    end
+  end
+
+  # ========================================================================= #
+  # === do_show_the_steps
+  # ========================================================================= #
+  def do_show_the_steps
+    @show_the_steps = true
+  end
+
+  # ========================================================================= #
+  # === sanitize_input                                         (sanitize tag)
+  #
+  # This method will presently sanitize the input, by working on ₂ and
+  # on ₃, and replace these with the corresponding numbers. This may
+  # be useful depending on the chemical formula at hand, such as
+  # carbon dioxide (CO₂).
+  # ========================================================================= #
+  def sanitize_input
+    @input.tr!('₂','2') if @input.include? '₂'
+    @input.tr!('₃','3') if @input.include? '₃'
+    @input.tr!('₄','4') if @input.include? '₄'
+    if @input.include? '∙'
+      @input.tr!('∙','|')
+    end
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    check_against_menu
+    use_this_input = input?
+    if use_this_input.to_s.size < 3
+      unless is_included?
+        report_that_this_element_does_not_exist(use_this_input)
+      end
+    end
+    calculate_result
+    consider_modifying_the_output_string
+    report_result if report_result?
+  end
+
+  # ========================================================================= #
+  # === report_that_this_element_does_not_exist
+  # ========================================================================= #
+  def report_that_this_element_does_not_exist(
+      i, may_we_exit = @may_we_exit
+    )
+    opnn; e 'The given element at `'+sfancy(i.to_s)+'` does not exist.'
+    exit_the_program(may_we_exit)
+  end
+
+  # ========================================================================= #
+  # === exit_the_program
+  # ========================================================================= #
+  def exit_the_program(
+      may_we_exit = @may_we_exit
+    )
+    case may_we_exit
+    when :then_exit
+      may_we_exit = true
+    end
+    exit if may_we_exit
+  end
+
+  # ========================================================================= #
+  # === calculate_result
+  #
+  # Use this method to calculate the result (the molecular mass).
+  #
+  # Keep in mind that the input may be somewhat complex, such as
+  # "(NH₄)₂SO₄". This has to be expanded first.
+  # ========================================================================= #
+  def calculate_result(
+      i = input?
+    )
+    mass_number = 0 # This will become the result eventually.
+    i.squeeze!(' ')
+    # ======================================================================= #
+    # Let class SplitMoleculeNames split the components next.
+    # ======================================================================= #
+    splitted = SplitMoleculeNames.new(i).result
+    splitted = sanitize_input_for_element_names(splitted)
+    splitted.each {|entry|
+      add_this_amount = calculate_compound(entry)
+      if @show_the_steps
+        e "#{rev}Now adding #{royalblue(add_this_amount)} for the "\
+          "compound #{steelblue(entry)}."
+      end
+      mass_number += add_this_amount
+    }
+    set_result(mass_number)
+    determine_output_string
+  end; alias calculate calculate_result # === calculate
+
+  # ========================================================================= #
+  # === ChemistryParadise::CalculateAtomicMass[]
+  # ========================================================================= #
+  def self.[](i)
+    parse(i)
+  end
+
+  # ========================================================================= #
+  # === ChemistryParadise::CalculateAtomicMass.parse
+  # ========================================================================= #
+  def self.parse(i)
+    _ = new(i, false)
+    _.calculate
+    return _.nice_result
+  end
+
+end
+
+# =========================================================================== #
+# === ChemistryParadise.atomic_mass_of
+#
+# This method is a shortcut, to quickly calculate the molecular mass of
+# a compound. See the usage example that follows.
+#
+# Usage examples:
+#
+#   ChemistryParadise.atomic_mass_of 'C10H13N5O3' # => "251.245"
+#   ChemistryParadise.atomic_mass_of 'H2O'        # => "18.015"
+#
+# =========================================================================== #
+def self.atomic_mass_of(i)
+  ChemistryParadise::CalculateAtomicMass.parse(i)
+end; self.instance_eval { alias return_molmasse atomic_mass_of } # === Chemistry.return_molmasse
+     self.instance_eval { alias molmass_of?     atomic_mass_of } # === Chemistry.molmass_of?
+     self.instance_eval { alias compound_mass?  atomic_mass_of } # === Chemistry.compound_mass?
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  include ChemistryParadise
+  if ARGV.empty?
+    alias e puts
+    opn; e 'Running some tests now as no input was given to us.'
+    # ======================================================================= #
+    # === test_me
+    # ======================================================================= #
+    def test_me(i)
+      puts sprintf('  The mass number of %-4s is %3s',
+        i,
+        CalculateAtomicMass.new(i).result.to_s
+      )
+    end
+    cliner {
+      e 'Nun berechnen wir einige Atomgewichte:'
+      ARRAY_TEST_THESE_MOLECULES.each {|entry| test_me(entry) }
+    }
+    e 'Das Atomgewicht von C12H12N2 ist: '
+    e '  → '+test_me('C12H12N2').to_s
+  else
+    _ = CalculateAtomicMass.new(ARGV)
+  end
+end # mmasse T
+    # mmasse C16H12N2
+    # mmasse CH₃Cl
+    # mmasse CaCO3 --show-steps