stevengharms.com

Sententiae viri ex temporibus duobus

[Rails] [LaTeX] [Latin] Conjugate Verbs Fully* in Latin With Ruby

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

Comments