OK I said that you conjugate the verb fully, but that’s not entirely true. As I’ve not yet learned the subjunctive system, I’m limited to the indicative present and perfect systems. I’ve also included the participles as well as the infinitives.

Might I add that linguistic and string processing with Ruby is a pleasure. Many Years (tm) ago I tried this is French with Java and it was an unholy pain.

Can anyone guess where I’m going with these last few posts?

  • Simplified macron-based entry ( ={a}, ={e}, etc.)
  • Process simplified text to UTF-8 ( the language of rails )
  • Code to process these strings into full conjugations
  • Rails as a display engine

What do you think I’m making?

BTW: This code is very much rough draft, it’s enough to handle the ideas, but needs more modularization and more refactoring, so this is not “steven at his best” level code

[code lang="ruby "]

#!/usr/bin/env ruby -Ku -rjcode
require 'rubygems'
require 'activesupport'
require 'pp'

module LatinSpelling
  @@macron_table = {"?" => 'a',"?" => 'e',"?"=>'i',"?"=>'o',"?"=>'u',
                     "\xc5\x8d"=>"o"}

  def get_last_two_chars(input)
    return [ input.chars[-2,1].to_s.chomp, input.chars[-1,1].to_s.chomp ]
  end
  
  def special_char?(x)
    return true if @@macron_table.keys.include?(x.to_s)
  end
  
  def check_macrons(input)
    # Three rules:  Long vowels are shortened when they are followed
    # 1.  by another vowel
    # 2.  by m/r/t at the end of a word
    # 3.  by nt or nd anywhere
    
    if (input.class.to_s == "Array")
      return input.map do |person|
        check_macrons(person)
      end
    end

    if (input.class.to_s == "String")
      # 1.  preceeding another macronized letter
      input = repair_double_macron(input).to_s if input =~ /[?????][?????aeiou]/
    
      # 2.  by m/r/t at the end of a word   
      if input =~ /[mrt]$/
           last_two=get_last_two_chars(input)
           if @@macron_table.keys.include?("#{last_two[0]}")
             last_two[0] = @@macron_table["#{last_two[0]}"] 
             returnString = input.chars[0..(input.jlength()-3)] + last_two.join('').to_s
             input = returnString.to_s
           end # end if @@macron_table
         end # end if input =~/[mrt]/
    
      # 3.  by nt or nd anywhere
      input = repair_nt(input).to_s if input =~ /[?????]n[td]/
    end
      
  
    return input
  end # end check_macrons

  def repair_double_macron(dmString)
    # dmString == "double macron String"
    return dmString if dmString !~ /[?????][?????aeiou]/
    
    dblPosition = dmString =~ /([?????][?????aeiou])/
    
    # puts dblPosition.to_s + dmString.chars[dblPosition..dblPosition] + $1

    base=dmString[0..dblPosition-1]
    rest=dmString.chars[dblPosition+1..99]
    firstDblMacChar=$1.chars[0..0]

    base=base+ @@macron_table[firstDblMacChar.to_s] \
      if @@macron_table.keys.include?(firstDblMacChar)
      
    return base + repair_double_macron(rest)
  end
  
  def repair_nt(ntString)
    return ntString if ntString !~ /n[td]/
    
    ntPosition = ntString =~ /(n[td])/
        
    base=ntString[0..ntPosition-1]
    testchar=base.chars[base.jlength-1..base.jlength-1]
    rest=ntString.chars[base.jlength..99]
    nSuffix=rest.chars[0..1]
    rest=rest.chars[2..99]
    base=base.chars[0..base.jlength-2]
        
    if @@macron_table.keys.include?(testchar)
      base=base + @@macron_table[testchar.to_s] 
    end
    
    return base + nSuffix + repair_nt(rest)
  end
  
  def is_char_macron_letter(c)
    if "?????" =~ /#{c}/
      puts "contains and should be set to #{c}"
      puts c
      puts "hi" + @@macron_table.keys
    end
  end

end

class Verb < Object
  include LatinSpelling
  attr_reader :firstpersonform, :infinitive, 
              :perfectstem, :passperfpart, :stem, :conjugation, :singular_string, :plural_string
  attr_writer :singular_string, :plural_string            

  def initialize(initString)
    @definition_string=initString
    (@firstpersonform, @infinitive, @perfectstem, @passperfpart)=initString.split(/,\s+/)
    pparts=initString.split(/,\s+/)
    @passive_endings = ["r", "ris", "tur", "mur", "min\xc4\xab", "ntur"]
    @personages = ["First Singular", "Second Singular", "Third Singular",
                   "First Plural", "Second Plural", "Third Plural"]
    @conjugation = evaluate_conjugation
    @singular_string= @plural_string = String.new
  end

  def active_present
    oneTwoEndings=%w(s t mus tis nt)
    thirdEndings=%w(o is it imus itis unt)
    thirdIOEndings=%w(is it imus itis iunt)

    if @conjugation == "1" or @conjugation == "2"
      return check_macrons([firstpersonform, oneTwoEndings.collect{|x| stem + x}]).flatten!
    end
    if @conjugation =="3"
      return check_macrons([thirdEndings.collect{|x| stem + x}]).flatten!
    end
    if conjugation=="3-io" or conjugation=="4"
      return check_macrons([firstpersonform, thirdIOEndings.collect{|x| stem + x}]).flatten!
    end
  end
  
  def active_imperfect   
    oneTwoEndings=%w(bam b?s bat b?mus b?tis bant)
    thirdEndings=%w(?bam ?b?s ?bat ?b?mus ?b?tis ?bant)
    if @conjugation == "1" or @conjugation == "2"
      return check_macrons([oneTwoEndings.collect{|x| stem + x}]).flatten
    end
    if @conjugation == "3"
      return check_macrons([thirdEndings.collect{|x| stem + x}]).flatten
    end
    if conjugation=="3-io" or conjugation=="4"
      base=firstpersonform.clone
      base.gsub!(/.$/,'')
      check_macrons([thirdEndings.collect{|x| base + x}]).flatten!
    end
  end

  def active_future
    oneTwoEndings=%w(b? bis bit bimus bitis bunt)
    thirdEndings=%w(am ?s et ?mus ?tis ent)
    if @conjugation == "1" or @conjugation=="2"
      return check_macrons([oneTwoEndings.collect{|x| stem + x}]).flatten
    end    
    if @conjugation == "3"
      return check_macrons([thirdEndings.collect{|x| stem + x}]).flatten
    end
    if @conjugation == "3-io" or @conjugation == "4"
      base=firstpersonform.clone
      base.gsub!(/.$/,'')      
      return check_macrons([thirdEndings.collect{|x| base + x}]).flatten
    end    
  end
  
  def evaluate_conjugation
    if @infinitive =~ /?re$/
      return "1"
    end
    
    if @infinitive =~ /?re$/
      return "2"
    end    

    if @infinitive =~ /ere$/
      if @firstpersonform =~ /i?/
        return "3-io"
      else     
        return "3"
      end
    end
    
    if @infinitive =~ /?re$/
      return "4"
    end    
    
  end
  
  def stem
    # For efficiency, if the iVar @stem is defined, don't go through this structure
    return @stem unless @stem.nil?
      
    if @infinitive =~ /?re$/
      return @stem = @infinitive.gsub(/(.*)?re$/,'\\1?')
    end
    if @infinitive =~ /?re$/
      return @stem = @infinitive.gsub(/(.*)?re$/,'\\1?')
    end    
    if @infinitive =~ /ere$/
      if firstpersonform =~ /io$/
        return @stem = @infinitive.gsub(/(.*)ere$/,'\\1')
      else
        return @stem = @infinitive.gsub(/(.*)ere$/,'\\1')
      end
    end    
    if @infinitive =~ /?re$/
      return @stem = @infinitive.gsub(/(.*)?re$/,'\\1')
    end
  end

  def to_s
    return "[#{self.firstpersonform} #{self.infinitive}" + 
             " #{self.perfectstem} #{self.passperfpart} {#{@conjugation}}]\n\n"
  end
  
  def present_passive
    if conjugation=="1" or conjugation=="2"
      local_pe=@passive_endings.clone
      return check_macrons([@firstpersonform + "r", local_pe[1..-1].map{|x| self.stem + x}].flatten!)
    end
    if conjugation=="3"
      thirdEndings=%w(r eris itur imur imin? untur)
      return check_macrons([@firstpersonform+"r", 
        thirdEndings[1..-1].map{|x| self.stem + x}].flatten!)
    end
    if @conjugation == "3-io"
      base=stem+"i"
      temp=[@firstpersonform+"r", 
        @passive_endings[1..-2].map{|x| base + x}, 
        base+"u"+@passive_endings[-1]].flatten!
      temp[1].sub!(/iris$/, 'eris')
      return check_macrons(temp)
    end
    if @conjugation=="4"
      base=stem+"i"
      temp=[@firstpersonform+"r", 
        @passive_endings[1..-2].map{|x| base + x}, 
        base+"u"+@passive_endings[-1]].flatten!
      return check_macrons(temp)
    end
  end

  def imperfect_passive
    if conjugation=="1" or conjugation=="2"
      imperfect_stem = self.stem + "b\xc4\x81"
      return check_macrons(@passive_endings.map{|x| "#{imperfect_stem}#{x}"})
    end
    if conjugation=="3" 
      ministem=self.stem + "?b?"
      return check_macrons(@passive_endings.map{|x| ministem + x})
    end
    if @conjugation == "3-io" or @conjugation=="4"
      base=stem+"i?b?"
      return check_macrons([@passive_endings.map{|x| base + x}].flatten!)
    end
  end
  
  def future_passive
    if conjugation=="1" or conjugation=="2"    
      fp_stem=self.stem+"bi"
      standards = @passive_endings[2..-1].map{|x| fp_stem + x}
      return [@stem + "b\xc5\x8d", @stem + "beris", standards].flatten!
    end
    if conjugation == "3"
      fp_stem=self.stem+"?"
      standards = @passive_endings[1..-1].map{|x| fp_stem + x}
      return [@stem + "ar", standards].flatten!      
    end
    if @conjugation == "3-io" or @conjugation=="4"
      base=stem+"i?"
      fp_stem=firstpersonform.clone
      fp_stem.sub!(/.$/,'')
      return check_macrons([fp_stem+"a"+@passive_endings[0], 
        @passive_endings[1..-1].map{|x| base + x}].flatten!)
    end    
  end
  
  def perfect_present
    substem=perfectstem.chars[0..perfectstem.jlength-2]
    endings=%w(ist? it imus istis ?runt)
    return [perfectstem, endings.collect{|x| substem+x}].flatten
  end
  
  def perfect_past
     substem=perfectstem.chars[0..perfectstem.jlength-2]
     endings=%w(eram er?s erat er?mus er?tis erant)
     return [endings.collect{|x| substem+x}].flatten     
  end
  
  def perfect_future
    substem=perfectstem.chars[0..perfectstem.jlength-2]
    endings=%w(er? eris erit erimus eritis erint)
    return [endings.collect{|x| substem+x}].flatten
  end
  
  def pass_perf_present
    endings=%w(sum es est sumus estis sunt)    
  end

  def pass_perf_past
    return %w(eram er?s erat er?mus er?tis erant)
  end

  def pass_perf_future
    return %w(er? eris erit erimus eritis erint)
  end
  
  def passive_system
    puts "Passive System"
    p_sys_hash= { :label=>@personages,
                  :present => self.present_passive,
                  :imperfect => self.imperfect_passive,
                  :future => self.future_passive}


    0.upto(5) do |index|
      printf("%-15s %-10s %-16s %s\n", 
                      p_sys_hash[:label][index],
                       p_sys_hash[:present][index],
                       p_sys_hash[:imperfect][index],
                       p_sys_hash[:future][index]
                      )
    end
    puts "\n\n"
  end
  
  def active_system
    puts "Active System"
    p_sys_hash= { :label=>@personages,
                  :present => self.active_present,
                  :imperfect => self.active_imperfect,
                  :future => self.active_future}

    0.upto(5) do |index|
      printf("%-15s %-10s %-16s %s\n", 
                      p_sys_hash[:label][index],
                       p_sys_hash[:present][index],
                       p_sys_hash[:imperfect][index],
                       p_sys_hash[:future][index]
                      )
    end
    puts "\n\n"
  end

    def perfect_system
      puts "Perfect System"
      p_sys_hash= { :label=>@personages,
                    :present => self.perfect_present,
                    :imperfect => self.perfect_past,
                    :future => self.perfect_future}

      0.upto(5) do |index|
        printf("%-15s %-10s %-16s %s\n", 
                        p_sys_hash[:label][index],
                         p_sys_hash[:present][index],
                                       p_sys_hash[:imperfect][index],
                                       p_sys_hash[:future][index]
                        )
      end
      puts "\n\n"
    end

    def pass_perfect_system
      puts "Passive Perfect System"

      
      substem=passperfpart.chars[0..passperfpart.jlength-3].to_s

      singular_endings=%w(a um)
      plural_endings=%w(? ae a)
 
      @singular_string= passperfpart + ', ' + singular_endings.collect{|x| substem + x}.join(', ')
      @plural_string=plural_endings.collect{|x| substem + x}.join(', ')

      prefixes=Array.new
      3.times{ prefixes.push(@singular_string)}
      3.times{ prefixes.push(@plural_string)}      

      p_sys_hash= { :label=>@personages,
                    :prefix=>prefixes,
                    :present => self.pass_perf_present,
                    :imperfect => self.pass_perf_past,
                    :future => self.pass_perf_future}

      0.upto(5) do |index|
        printf("%10s %10s %8s %8s %8s\n", 
                        p_sys_hash[:label][index],
                        p_sys_hash[:prefix][index],
                         p_sys_hash[:present][index],
                                       p_sys_hash[:imperfect][index],
                                       p_sys_hash[:future][index]
                        )
      end
    end
    
    def participial_stem
       if @infinitive =~ /(.*?)re$/
        return $1
      end

      if @infinitive =~ /(.*?)re$/
        return $1
      end    

      if @infinitive =~ /(.*)ere$/
        #if @firstpersonform =~ /i?/
          return $1 + "i?"
        #end
        # else     
        #   return $1 + "i?"
        # end
      end

      if @infinitive =~ /(.*)?re$/
        return $1 + "i?" 
      end
    end
    
    def present_active_participle
      endings=%w(ns ntis)
      return check_macrons(endings.collect{|x|participial_stem+x.chomp}).join(', ')
    end
    
    def future_active_participle
      mybase=@passperfpart.gsub(/us$/, "?r")
      singular_endings=%w(us a um)
      return check_macrons(singular_endings.collect{|x| mybase+"#{x}".chomp}.join(', '))
      
      return base
    end
    
    def perfect_passive_participle
      mybase=passperfpart.sub(/us$/,'')
      singular_endings=%w(us a um)
      return check_macrons(singular_endings.collect{|x| mybase+"#{x}".chomp}.join(', '))
    end
    
    def future_passive_participle
      mybase = participial_stem+"nd"
      singular_endings=%w(us a um)
      return check_macrons(singular_endings.collect{|x| mybase+"#{x}".chomp}.join(', '))
    end
    
    def gerundive
      self.future_passive_participle
    end
    
    def full_conjugation
      active_system
      perfect_system
      passive_system
      pass_perfect_system
    end
    
    def participles
      puts "\n\n"
      puts "Participles associated with: #{@definition_string} "
      puts "Present Active Participle: #{present_active_participle}"
      puts "Future Active Participle: #{future_active_participle}"
      puts "Perfect Passive Participle #{perfect_passive_participle}"
      puts "Future Passive Participle #{future_passive_participle}"
      puts "\n\n"
    end

    def present_passive_infinitive
      if @infinitive =~ /?re$/
        return  @infinitive.gsub(/(.*)?re$/,"\\1\xc4\xab")
      end
      if @infinitive =~ /?re$/
        return @infinitive.gsub(/(.*)?re$/,"\\1\xc4\xab")
      end    
      if @infinitive =~ /ere$/
        if firstpersonform =~ /io$/
          return @infinitive.gsub(/(.*)ere$/,"\\1\xc4\xab")
        else                                     
          return @infinitive.gsub(/(.*)ere$/,"\\1\xc4\xab")
        end
      end    
      if @infinitive =~ /?re$/
        return @infinitive.gsub(/(.*)?re$/,"\\1\xc4\xab")
      end      
    end
        
    def infinitives
      puts "Infinitives associated with: #{@definition_string} "
      
      puts "Present Active Infinitive: #{@infinitive}"
      puts "Perfect Active Infinitive: #{check_macrons(@perfectstem+"sse")}"      
      puts "Future Active Infinitive: #{future_active_participle.sub(/,.*/,'')} + esse"
      puts "Present Passive Infinitive #{present_passive_infinitive}"
      puts "Perfect Passive Infinitive #{perfect_passive_participle.sub(/,.*/,'')} + esse"  
      puts "\n\n"    
    end
    
end


puts x=Verb.new("laud?, laud?re, laud?v?, laudatus")
x.full_conjugation
x.participles
x.infinitives

puts y=Verb.new("mone?, mon?re, monu?, monitus")
y.full_conjugation
y.participles
y.infinitives


puts z=Verb.new("ag?, agere, ?g?, ?ctus")
z.full_conjugation
z.participles
z.infinitives


puts v1=Verb.new("capi?, capere, c?p?, captus")
v1.full_conjugation
v1.participles
v1.infinitives


puts v2=Verb.new("audi?, aud?re, aud?v?, auditus")
v2.full_conjugation
v2.participles
v2.infinitives
	
[/code]

Output:

	[laud? laud?re laud?v? laudatus {1}]

	Active System
	First Singular  laud?     laud?bam        laud?b?
	Second Singular laud?s    laud?b?s       laud?bis
	Third Singular  laudat     laud?bat        laud?bit
	First Plural    laud?mus  laud?b?mus     laud?bimus
	Second Plural   laud?tis  laud?b?tis     laud?bitis
	Third Plural    laudant    laud?bant       laud?bunt


	Perfect System
	First Singular  laud?v?  laud?veram      laud?ver?
	Second Singular laud?vist? laud?ver?s     laud?veris
	Third Singular  laud?vit  laud?verat      laud?verit
	First Plural    laud?vimus laud?ver?mus   laud?verimus
	Second Plural   laud?vistis laud?ver?tis   laud?veritis
	Third Plural    laud?v?runt laud?verant     laud?verint


	Passive System
	First Singular  laudor     laud?bar        laud?b?
	Second Singular laud?ris  laud?b?ris     laud?beris
	Third Singular  laud?tur  laud?b?tur     laud?bitur
	First Plural    laud?mur  laud?b?mur     laud?bimur
	Second Plural   laud?min? laud?b?min?   laud?bimin?
	Third Plural    laudantur  laud?bantur     laud?bintur


	Passive Perfect System
	First Singular laudatus, laudata, laudatum      sum     eram     er?
	Second Singular laudatus, laudata, laudatum       es    er?s     eris
	Third Singular laudatus, laudata, laudatum      est     erat     erit
	First Plural laudat?, laudatae, laudata    sumus  er?mus   erimus
	Second Plural laudat?, laudatae, laudata    estis  er?tis   eritis
	Third Plural laudat?, laudatae, laudata     sunt    erant    erint


	Participles associated with: laud?, laud?re, laud?v?, laudatus 
	Present Active Participle: laud?ns, laudantis
	Future Active Participle: laudat?rus, laudat?ra, laudat?rum
	Perfect Passive Participle laudatus, laudata, laudatum
	Future Passive Participle laudandus, laudanda, laudandum


	Infinitives associated with: laud?, laud?re, laud?v?, laudatus 
	Present Active Infinitive: laud?re
	Perfect Active Infinitive: laud?v?sse
	Future Active Infinitive: laudat?rus + esse
	Present Passive Infinitive laud?
	Perfect Passive Infinitive laudatus + esse


	[mone? mon?re monu? monitus {2}]

	Active System
	First Singular  mone?     mon?bam         mon?b?
	Second Singular mon?s     mon?b?s        mon?bis
	Third Singular  monet      mon?bat         mon?bit
	First Plural    mon?mus   mon?b?mus      mon?bimus
	Second Plural   mon?tis   mon?b?tis      mon?bitis
	Third Plural    monent     mon?bant        mon?bunt


	Perfect System
	First Singular  monu?     monueram         monuer?
	Second Singular monuist?  monuer?s        monueris
	Third Singular  monuit     monuerat         monuerit
	First Plural    monuimus   monuer?mus      monuerimus
	Second Plural   monuistis  monuer?tis      monueritis
	Third Plural    monu?runt monuerant        monuerint


	Passive System
	First Singular  moneor     mon?bar         mon?b?
	Second Singular mon?ris   mon?b?ris      mon?beris
	Third Singular  mon?tur   mon?b?tur      mon?bitur
	First Plural    mon?mur   mon?b?mur      mon?bimur
	Second Plural   mon?min? mon?b?min?    mon?bimin?
	Third Plural    monentur   mon?bantur      mon?bintur


	Passive Perfect System
	First Singular monitus, monita, monitum      sum     eram     er?
	Second Singular monitus, monita, monitum       es    er?s     eris
	Third Singular monitus, monita, monitum      est     erat     erit
	First Plural monit?, monitae, monita    sumus  er?mus   erimus
	Second Plural monit?, monitae, monita    estis  er?tis   eritis
	Third Plural monit?, monitae, monita     sunt    erant    erint


	Participles associated with: mone?, mon?re, monu?, monitus 
	Present Active Participle: mon?ns, monentis
	Future Active Participle: monit?rus, monit?ra, monit?rum
	Perfect Passive Participle monitus, monita, monitum
	Future Passive Participle monendus, monenda, monendum


	Infinitives associated with: mone?, mon?re, monu?, monitus 
	Present Active Infinitive: mon?re
	Perfect Active Infinitive: monu?sse
	Future Active Infinitive: monit?rus + esse
	Present Passive Infinitive mon?
	Perfect Passive Infinitive monitus + esse


	[ag? agere ?g? ?ctus {3}]

	Active System
	First Singular  ago        ag?bam          agam
	Second Singular agis       ag?b?s         ag?s
	Third Singular  agit       ag?bat          aget
	First Plural    agimus     ag?b?mus       ag?mus
	Second Plural   agitis     ag?b?tis       ag?tis
	Third Plural    agunt      ag?bant         agent


	Perfect System
	First Singular  ?g?      ?geram          ?ger?
	Second Singular ?gist?   ?ger?s         ?geris
	Third Singular  ?git      ?gerat          ?gerit
	First Plural    ?gimus    ?ger?mus       ?gerimus
	Second Plural   ?gistis   ?ger?tis       ?geritis
	Third Plural    ?g?runt  ?gerant         ?gerint


	Passive System
	First Singular  agor       ag?bar          agar
	Second Singular ageris     ag?b?ris       ag?ris
	Third Singular  agitur     ag?b?tur       ag?tur
	First Plural    agimur     ag?b?mur       ag?mur
	Second Plural   agimin?   ag?b?min?     ag?min?
	Third Plural    aguntur    ag?bantur       ag?ntur


	Passive Perfect System
	First Singular ?ctus, ?cta, ?ctum      sum     eram     er?
	Second Singular ?ctus, ?cta, ?ctum       es    er?s     eris
	Third Singular ?ctus, ?cta, ?ctum      est     erat     erit
	First Plural ?ct?, ?ctae, ?cta    sumus  er?mus   erimus
	Second Plural ?ct?, ?ctae, ?cta    estis  er?tis   eritis
	Third Plural ?ct?, ?ctae, ?cta     sunt    erant    erint


	Participles associated with: ag?, agere, ?g?, ?ctus 
	Present Active Participle: agi?ns, agientis
	Future Active Participle: ?ct?rus, ?ct?ra, ?ct?rum
	Perfect Passive Participle ?ctus, ?cta, ?ctum
	Future Passive Participle agiendus, agienda, agiendum


	Infinitives associated with: ag?, agere, ?g?, ?ctus 
	Present Active Infinitive: agere
	Perfect Active Infinitive: ?g?sse
	Future Active Infinitive: ?ct?rus + esse
	Present Passive Infinitive ag?
	Perfect Passive Infinitive ?ctus + esse


	[capi? capere c?p? captus {3-io}]

	Active System
	First Singular  capi?     capi?bam        capiam
	Second Singular capis      capi?b?s       capi?s
	Third Singular  capit      capi?bat        capiet
	First Plural    capimus    capi?b?mus     capi?mus
	Second Plural   capitis    capi?b?tis     capi?tis
	Third Plural    capiunt    capi?bant       capient


	Perfect System
	First Singular  c?p?     c?peram         c?per?
	Second Singular c?pist?  c?per?s        c?peris
	Third Singular  c?pit     c?perat         c?perit
	First Plural    c?pimus   c?per?mus      c?perimus
	Second Plural   c?pistis  c?per?tis      c?peritis
	Third Plural    c?p?runt c?perant        c?perint


	Passive System
	First Singular  capior     capi?bar        capiar
	Second Singular caperis    capi?b?ris     capi?ris
	Third Singular  capitur    capi?b?tur     capi?tur
	First Plural    capimur    capi?b?mur     capi?mur
	Second Plural   capimin?  capi?b?min?   capi?min?
	Third Plural    capiuntur  capi?bantur     capientur


	Passive Perfect System
	First Singular captus, capta, captum      sum     eram     er?
	Second Singular captus, capta, captum       es    er?s     eris
	Third Singular captus, capta, captum      est     erat     erit
	First Plural capt?, captae, capta    sumus  er?mus   erimus
	Second Plural capt?, captae, capta    estis  er?tis   eritis
	Third Plural capt?, captae, capta     sunt    erant    erint


	Participles associated with: capi?, capere, c?p?, captus 
	Present Active Participle: capi?ns, capientis
	Future Active Participle: capt?rus, capt?ra, capt?rum
	Perfect Passive Participle captus, capta, captum
	Future Passive Participle capiendus, capienda, capiendum


	Infinitives associated with: capi?, capere, c?p?, captus 
	Present Active Infinitive: capere
	Perfect Active Infinitive: c?p?sse
	Future Active Infinitive: capt?rus + esse
	Present Passive Infinitive cap?
	Perfect Passive Infinitive captus + esse


	[audi? aud?re aud?v? auditus {4}]

	Active System
	First Singular  audi?     audi?bam        audiam
	Second Singular audis      audi?b?s       audi?s
	Third Singular  audit      audi?bat        audiet
	First Plural    audimus    audi?b?mus     audi?mus
	Second Plural   auditis    audi?b?tis     audi?tis
	Third Plural    audiunt    audi?bant       audient


	Perfect System
	First Singular  aud?v?   aud?veram       aud?ver?
	Second Singular aud?vist? aud?ver?s      aud?veris
	Third Singular  aud?vit   aud?verat       aud?verit
	First Plural    aud?vimus aud?ver?mus    aud?verimus
	Second Plural   aud?vistis aud?ver?tis    aud?veritis
	Third Plural    aud?v?runt aud?verant      aud?verint


	Passive System
	First Singular  audior     audi?bar        audiar
	Second Singular audiris    audi?b?ris     audi?ris
	Third Singular  auditur    audi?b?tur     audi?tur
	First Plural    audimur    audi?b?mur     audi?mur
	Second Plural   audimin?  audi?b?min?   audi?min?
	Third Plural    audiuntur  audi?bantur     audientur


	Passive Perfect System
	First Singular auditus, audita, auditum      sum     eram     er?
	Second Singular auditus, audita, auditum       es    er?s     eris
	Third Singular auditus, audita, auditum      est     erat     erit
	First Plural audit?, auditae, audita    sumus  er?mus   erimus
	Second Plural audit?, auditae, audita    estis  er?tis   eritis
	Third Plural audit?, auditae, audita     sunt    erant    erint


	Participles associated with: audi?, aud?re, aud?v?, auditus 
	Present Active Participle: audi?ns, audientis
	Future Active Participle: audit?rus, audit?ra, audit?rum
	Perfect Passive Participle auditus, audita, auditum
	Future Passive Participle audiendus, audienda, audiendum


	Infinitives associated with: audi?, aud?re, aud?v?, auditus 
	Present Active Infinitive: aud?re
	Perfect Active Infinitive: aud?v?sse
	Future Active Infinitive: audit?rus + esse
	Present Passive Infinitive aud?
	Perfect Passive Infinitive auditus + esse