Re: Unicode numeric value

[Mark H Weaver]

Hi,

Freeman Gilmore <address@hidden> writes:

> On Sun, Dec 16, 2018 at 3:15 AM Mark H Weaver <address@hidden> wrote:
>
>  Freeman Gilmore <address@hidden> writes:
>
>  > I am looking for a procedure that will read the numeric value, field 8, of
>  > an Unicode numeric character.   Has anyone written this procedure or know
>  > where I can find it?
>
>  The 'r7rs-wip' branch of the Guile git repository contains a procedure
>  that does this, with a lookup table derived from Unicode 6.3.0.
>
>    
> https://git.savannah.gnu.org/cgit/guile.git/tree/module/scheme/char.scm?h=r7rs-wip
>
>  The file is written as an R7RS library form, which won't work on current
>  releases of Guile, but for now you could simply extract the
>  'digit-value' procedure from it, provided that you preserve the
>  copyright notice.
>
>        Mark
>
> Thank you Mark:
>
> That is only half the battle, let me explain.  I do not want to read
> the standard Unicode table.  I want to directly read field 8 of a
> numeric character in the privet use area of the Unicode.
>
> This is not part of scheme.  The other half, I need to finger out how
> to put the numeric values in field 8 for the characters I want to use.

If the mapping from code points to numeric values is static, then you
could simply modify the lookup table in the code I suggested above.

If the mapping is dynamic, then you'll need a different strategy.  One
simple approach would be to use a hash table mapping from characters to
digit values:

  (define digit-value-table (make-hash-table))
  
  (define (set-digit-value! char value)
    (hashv-set! digit-value-table char value))

  (define (digit-value char)
    (hashv-ref digit-value-table char #f))

If the range of relevant code points is small enough, another approach
would be to use a vector:

  (define private-code-point-start #xE000)
  (define private-code-point-end   #xF900)

  (define (code-point-in-range? cp)
    (<= private-code-point-start
        cp
        private-code-point-end))

  (define digit-value-table
    (make-vector (- private-code-point-end
                    private-code-point-start)
                 #f))

  (define (set-digit-value! char value)
    (let ((cp (char->integer char)))
      (unless (code-point-in-range? cp)
        (error "set-digit-value!: code point out of range:" cp))
      (vector-set! digit-value-table
                   (- cp private-code-point-start)
                   value)))

  (define (digit-value char)
    (let ((cp (char->integer char)))
      (and (code-point-in-range? cp)
           (vector-ref digit-value-table
                       (- cp private-code-point-start)))))

For a more compact representation, you could use a SRFI-4 homogeneous
numeric vector instead, although you'd need to designate a special
numeric value to represent "not a digit".

    Regards,
      Mark