# File lib/linguistics/en.rb, line 705
    def pluralize_noun( word, count=nil )
        value = nil
        count ||= Linguistics::num
        count = normalize_count( count )

        return word if count == 1

        # Handle user-defined nouns
        #if value = ud_match( word, PL_sb_user_defined )
        # return value
        #end

        # Handle empty word, singular count and uninflected plurals
        case word
        when ''
            return word
        when /^(#{PL_sb_uninflected})$/i
            return word
        else
            if Linguistics::classical? &&
               /^(#{PL_sb_uninflected_herd})$/i =~ word
                return word
            end
        end

        # Handle compounds ("Governor General", "mother-in-law", "aide-de-camp", etc.)
        case word
        when /^(?:#{PL_sb_postfix_adj})$/i
            value = $2
            return pluralize_noun( $1, 2 ) + value

        when /^(?:#{PL_sb_prep_dual_compound})$/i
            value = [ $2, $3 ] 
            return pluralize_noun( $1, 2 ) + value[0] + pluralize_noun( value[1] )

        when /^(?:#{PL_sb_prep_compound})$/i
            value = $2 
            return pluralize_noun( $1, 2 ) + value

        # Handle pronouns
        when /^((?:#{PL_prep})\s+)(#{PL_pron_acc})$/i
            return $1 + PL_pron_acc_h[ $2.downcase ]

        when /^(#{PL_pron_nom})$/i
            return PL_pron_nom_h[ word.downcase ]

        when /^(#{PL_pron_acc})$/i
            return PL_pron_acc_h[ $1.downcase ]

        # Handle isolated irregular plurals 
        when /(.*)\b(#{PL_sb_irregular})$/i
            return $1 + PL_sb_irregular_h[ $2.downcase ]

        when /(#{PL_sb_U_man_mans})$/i
            return "#{$1}s"

        # Handle families of irregular plurals
        when /(.*)man$/i ;                    return "#{$1}men"
        when /(.*[ml])ouse$/i ;               return "#{$1}ice"
        when /(.*)goose$/i ;              return "#{$1}geese"
        when /(.*)tooth$/i ;              return "#{$1}teeth"
        when /(.*)foot$/i ;                   return "#{$1}feet"

        # Handle unassimilated imports
        when /(.*)ceps$/i ;                   return word
        when /(.*)zoon$/i ;                   return "#{$1}zoa"
        when /(.*[csx])is$/i ;                return "#{$1}es"
        when /(#{PL_sb_U_ex_ices})ex$/i;  return "#{$1}ices"
        when /(#{PL_sb_U_ix_ices})ix$/i;  return "#{$1}ices"
        when /(#{PL_sb_U_um_a})um$/i ;        return "#{$1}a"
        when /(#{PL_sb_U_us_i})us$/i ;        return "#{$1}i"
        when /(#{PL_sb_U_on_a})on$/i ;        return "#{$1}a"
        when /(#{PL_sb_U_a_ae})$/i ;      return "#{$1}e"
        end

        # Handle incompletely assimilated imports
        if Linguistics::classical?
            case word
            when /(.*)trix$/i ;              return "#{$1}trices"
            when /(.*)eau$/i ;               return "#{$1}eaux"
            when /(.*)ieu$/i ;               return "#{$1}ieux"
            when /(.{2,}[yia])nx$/i ;        return "#{$1}nges"
            when /(#{PL_sb_C_en_ina})en$/i; return "#{$1}ina"
            when /(#{PL_sb_C_ex_ices})ex$/i; return "#{$1}ices"
            when /(#{PL_sb_C_ix_ices})ix$/i; return "#{$1}ices"
            when /(#{PL_sb_C_um_a})um$/i ;   return "#{$1}a"
            when /(#{PL_sb_C_us_i})us$/i ;   return "#{$1}i"
            when /(#{PL_sb_C_us_us})$/i ;    return "#{$1}"
            when /(#{PL_sb_C_a_ae})$/i ; return "#{$1}e"
            when /(#{PL_sb_C_a_ata})a$/i ;   return "#{$1}ata"
            when /(#{PL_sb_C_o_i})o$/i ; return "#{$1}i"
            when /(#{PL_sb_C_on_a})on$/i ;   return "#{$1}a"
            when /#{PL_sb_C_im}$/i ;     return "#{word}im"
            when /#{PL_sb_C_i}$/i ;          return "#{word}i"
            end
        end


        # Handle singular nouns ending in ...s or other silibants
        case word
        when /^(#{PL_sb_singular_s})$/i;  return "#{$1}es"
        when /^([A-Z].*s)$/;              return "#{$1}es"
        when /(.*)([cs]h|[zx])$/i ;           return "#{$1}#{$2}es"
        # when /(.*)(us)$/i ;             return "#{$1}#{$2}es"

        # Handle ...f -> ...ves
        when /(.*[eao])lf$/i ;                return "#{$1}lves"; 
        when /(.*[^d])eaf$/i ;                return "#{$1}eaves"
        when /(.*[nlw])ife$/i ;               return "#{$1}ives"
        when /(.*)arf$/i ;                    return "#{$1}arves"

        # Handle ...y
        when /(.*[aeiou])y$/i ;               return "#{$1}ys"
        when /([A-Z].*y)$/ ;              return "#{$1}s"
        when /(.*)y$/i ;                  return "#{$1}ies"

        # Handle ...o
        when /#{PL_sb_U_o_os}$/i ;            return "#{word}s"
        when /[aeiou]o$/i ;                   return "#{word}s"
        when /o$/i ;                      return "#{word}es"

        # Otherwise just add ...s
        else
            return "#{word}s"
        end
    end