Version 19 of Roman numbers

Updated 2006-02-22 06:53:16

Larry Smith Technically, there is no such thing. A "number" is a mathematical abstraction signifying a particular value (e.g. integers), a "numeral" is the set of glyphs used in a particular language to express a number. Hence, MDCLXVI and such consist of Roman Numerals, not "Roman numbers".

hello plz u can help me now


wdb:

 my approach

 namespace eval roman {}

 proc roman::under5 {x} {
    if {$x == 4} {
        return IV
    } else {
        string repeat I $x
    }
 }

 proc roman::under10 {x} {
    if {$x == 9} {
        return IX
    } elseif {$x >= 5} {
        set d [expr {$x - 5}]
        return V[under5 $d]
    } else {
        under5 $x
    }
 }

 proc roman::under50 {x} {
    if {$x == 49} {
        return IL
    } elseif {$x >= 40} {
        set d [expr {$x - 40}]
        return XL[under10 $d]
    } elseif {$x >= 10} {
        set d [expr {$x-10}]
        return X[under50 $d]
    } else {
        under10 $x
    }
 }

 proc roman::under100 {x} {
    if {$x == 99} {
        return IC
    } elseif {$x >= 90} {
        set d [expr {$x - 90}]
        return XC[under10 $d]
    } elseif {$x >= 50} {
        set d [expr {$x - 50}]
        return L[under50 $d]
    } else {
        under50 $x
    }
 }

 proc roman::under500 {x} {
    if {$x == 499} {
        return ID
    } elseif {$x >= 490} {
        set d [expr {$x - 490}]
        return XD[under100 $d]
    } elseif {$x >= 400} {
        set d [expr {$x - 400}]
        return CD[under100 $d]
    } elseif {$x >= 100} {
        set d [expr {$x - 100}]
        return C[under500 $d]
    } else {
        under100 $x
    }
 }

 proc roman::under1000 {x} {
    if {$x == 999} {
        return IM
    } elseif {$x >= 990} {
        set d [expr {$x - 990}]
        return XM[under10 $d]
    } elseif {$x >= 900} {
        set d [expr {$x - 900}]
        return CM[under100 $d]
    } elseif {$x >= 500} {
        set d [expr {$x - 500}]
        return D[under1000 $d]
    } else {
        under500 $x
    }
 }

 proc roman::roman {x} {
    if {$x >= 1000} {
        set d [expr {$x - 1000}]
        return M[roman $d]
    } else {
        under1000 $x
    }
 }

 namespace eval roman {namespace export roman}
 namespace import roman::roman