Urbit Docs
  • What is Urbit?
  • Get on Urbit
  • Build on Urbit
    • Contents
    • Environment Setup
    • Hoon School
      • 1. Hoon Syntax
      • 2. Azimuth (Urbit ID)
      • 3. Gates (Functions)
      • 4. Molds (Types)
      • 5. Cores
      • 6. Trees and Addressing
      • 7. Libraries
      • 8. Testing Code
      • 9. Text Processing I
      • 10. Cores and Doors
      • 11. Data Structures
      • 12. Type Checking
      • 13. Conditional Logic
      • 14. Subject-Oriented Programming
      • 15. Text Processing II
      • 16. Functional Programming
      • 17. Text Processing III
      • 18. Generic and Variant Cores
      • 19. Mathematics
    • App School I
      • 1. Arvo
      • 2. The Agent Core
      • 3. Imports and Aliases
      • 4. Lifecycle
      • 5. Cards
      • 6. Pokes
      • 7. Structures and Marks
      • 8. Subscriptions
      • 9. Vanes
      • 10. Scries
      • 11. Failure
      • 12. Next Steps
      • Appendix: Types
    • App School II (Full-Stack)
      • 1. Types
      • 2. Agent
      • 3. JSON
      • 4. Marks
      • 5. Eyre
      • 6. React app setup
      • 7. React app logic
      • 8. Desk and glob
      • 9. Summary
    • Core Academy
      • 1. Evaluating Nock
      • 2. Building Hoon
      • 3. The Core Stack
      • 4. Arvo I: The Main Sequence
      • 5. Arvo II: The Boot Sequence
      • 6. Vere I: u3 and the Serf
      • 7. Vere II: The Loom
      • 8. Vanes I: Behn, Dill, Kahn, Lick
      • 9. Vanes II: Ames
      • 10. Vanes III: Eyre, Iris
      • 11. Vanes IV: Clay
      • 12. Vanes V: Gall and Userspace
      • 13. Vanes VI: Khan, Lick
      • 14. Vanes VII: Jael, Azimuth
    • Runtime
      • U3
      • Conn.c Guide
      • How to Write a Jet
      • API Overview by Prefix
      • C in Urbit
      • Cryptography
      • Land of Nouns
    • Tools
      • Useful Links
      • JS Libraries
        • HTTP API
      • Docs App
        • File Format
        • Index File
        • Suggested Structure
    • Userspace
      • Command-Line App Tutorial
      • Remote Scry
      • Unit Tests
      • Software Distribution
        • Software Distribution Guide
        • Docket File
        • Glob
      • Examples
        • Building a CLI App
        • Debugging Wrapper
        • Host a Website
        • Serving a JS Game
        • Ship Monitoring
        • Styled Text
  • Urbit ID
    • What is Urbit ID?
    • Azimuth Data Flow
    • Life and Rift
    • Urbit HD Wallet
    • Advanced Azimuth Tools
    • Custom Roller Tutorial
    • Azimuth.eth Reference
    • Ecliptic.eth Reference
    • Layer 2
      • L2 Actions
      • L2 Rollers
      • L2 Roller HTTP RPC-API
      • L2 Transaction Format
  • Urbit OS
    • What is Urbit OS?
    • Base
      • Hood
      • Threads
        • Basics Tutorial
          • Bind
          • Fundamentals
          • Input
          • Output
          • Summary
        • HTTP API Guide
        • Spider API Reference
        • Strandio Reference
        • Examples
          • Child Thread
          • Fetch JSON
          • Gall
            • Poke Thread
            • Start Thread
            • Stop Thread
            • Take Facts
            • Take Result
          • Main-loop
          • Poke Agent
          • Scry
          • Take Fact
    • Kernel
      • Arvo
        • Cryptography
        • Move Trace
        • Scries
        • Subscriptions
      • Ames
        • Ames API Reference
        • Ames Cryptography
        • Ames Data Types
        • Ames Scry Reference
      • Behn
        • Behn API Reference
        • Behn Examples
        • Behn Scry Reference
      • Clay
        • Clay API Reference
        • Clay Architecture
        • Clay Data Types
        • Clay Examples
        • Clay Scry Reference
        • Filesystem Hierarchy
        • Marks
          • Mark Examples
          • Using Marks
          • Writing Marks
        • Using Clay
      • Dill
        • Dill API Reference
        • Dill Data Types
        • Dill Scry Reference
      • Eyre
        • EAuth
        • Eyre Data Types
        • Eyre External API
        • Eyre Internal API
        • Eyre Scry Reference
        • Low-Level Eyre Guide
        • Noun channels
      • Gall
        • Gall API Reference
        • Gall Data Types
        • Gall Scry Reference
      • Iris
        • Iris API Reference
        • Iris Data Types
        • Iris Example
      • Jael
        • Jael API Reference
        • Jael Data Types
        • Jael Examples
        • Jael Scry Reference
      • Khan
        • Khan API Reference
        • Khan Data Types
        • Khan Example
      • Lick
        • Lick API Reference
        • Lick Guide
        • Lick Examples
        • Lick Scry Reference
  • Hoon
    • Why Hoon?
    • Advanced Types
    • Arvo
    • Auras
    • Basic Types
    • Cheat Sheet
    • Cryptography
    • Examples
      • ABC Blocks
      • Competitive Programming
      • Emirp
      • Gleichniszahlenreihe
      • Islands
      • Luhn Number
      • Minimum Path Sum
      • Phone Letters
      • Restore IP
      • Rhonda Numbers
      • Roman Numerals
      • Solitaire Cipher
      • Water Towers
    • Generators
    • Hoon Errors
    • Hoon Style Guide
    • Implementing an Aura
    • Irregular forms
    • JSON
    • Limbs and wings
      • Limbs
      • Wings
    • Mips (Maps of Maps)
    • Parsing Text
    • Runes
      • | bar · Cores
      • $ buc · Structures
      • % cen · Calls
      • : col · Cells
      • . dot · Nock
      • / fas · Imports
      • ^ ket · Casts
      • + lus · Arms
      • ; mic · Make
      • ~ sig · Hints
      • = tis · Subject
      • ? wut · Conditionals
      • ! zap · Wild
      • Constants (Atoms and Strings)
      • --, == · Terminators
    • Sail (HTML)
    • Serialization
    • Sets
    • Standard Library
      • 1a: Basic Arithmetic
      • 1b: Tree Addressing
      • 1c: Molds and Mold-Builders
      • 2a: Unit Logic
      • 2b: List Logic
      • 2c: Bit Arithmetic
      • 2d: Bit Logic
      • 2e: Insecure Hashing
      • 2f: Noun Ordering
      • 2g: Unsigned Powers
      • 2h: Set Logic
      • 2i: Map Logic
      • 2j: Jar and Jug Logic
      • 2k: Queue Logic
      • 2l: Container from Container
      • 2m: Container from Noun
      • 2n: Functional Hacks
      • 2o: Normalizing Containers
      • 2p: Serialization
      • 2q: Molds and Mold-Builders
      • 3a: Modular and Signed Ints
      • 3b: Floating Point
      • 3c: Urbit Time
      • 3d: SHA Hash Family
      • 3e: AES encryption (Removed)
      • 3f: Scrambling
      • 3g: Molds and Mold-Builders
      • 4a: Exotic Bases
      • 4b: Text Processing
      • 4c: Tank Printer
      • 4d: Parsing (Tracing)
      • 4e: Parsing (Combinators)
      • 4f: Parsing (Rule-Builders)
      • 4g: Parsing (Outside Caller)
      • 4h: Parsing (ASCII Glyphs)
      • 4i: Parsing (Useful Idioms)
      • 4j: Parsing (Bases and Base Digits)
      • 4k: Atom Printing
      • 4l: Atom Parsing
      • 4m: Formatting Functions
      • 4n: Virtualization
      • 4o: Molds
      • 5a: Compiler Utilities
      • 5b: Macro Expansion
      • 5c: Compiler Backend & Prettyprinter
      • 5d: Parser
      • 5e: Molds and mold builders
      • 5f: Profiling support
    • Strings
    • The Engine Pattern
    • Udon (Markdown-esque)
    • Vases
    • Zuse
      • 2d(1-5): To JSON, Wains
      • 2d(6): From JSON
      • 2d(7): From JSON (unit)
      • 2e(2-3): Print & Parse JSON
      • 2m: Ordered Maps
  • Nock
    • What is Nock?
    • Decrement
    • Definition
    • Fast Hints and Jets
    • Implementations
    • Specification
  • User Manual
    • Contents
    • Running Urbit
      • Cloud Hosting
      • Home Servers
      • Runtime Reference
      • Self-hosting S3 Storage with MinIO
    • Urbit ID
      • Bridge Troubleshooting
      • Creating an Invite Pool
      • Get an Urbit ID
      • Guide to Factory Resets
      • HD Wallet (Master Ticket)
      • Layer 2 for planets
      • Layer 2 for stars
      • Proxies
      • Using Bridge
    • Urbit OS
      • Basics
      • Configuring S3 Storage
      • Dojo Tools
      • Filesystem
      • Shell
      • Ship Troubleshooting
      • Star and Galaxy Operations
      • Updates
Powered by GitBook

GitHub

  • Urbit ID
  • Urbit OS
  • Runtime

Resources

  • YouTube
  • Whitepaper
  • Awesome Urbit

Contact

  • X
  • Email
  • Gather
On this page
  • +egcd
  • +fo
  • ++dif:fo
  • ++exp:fo
  • ++fra:fo
  • ++inv:fo
  • ++pro:fo
  • ++sit:fo
  • ++sum:fo
  • +si
  • ++abs:si
  • ++dif:si
  • ++dul:si
  • ++fra:si
  • ++new:si
  • ++old:si
  • ++pro:si
  • ++rem:si
  • ++sum:si
  • ++sun:si
  • ++syn:si
  • ++cmp:si
Edit on GitHub
  1. Hoon
  2. Standard Library

3a: Modular and Signed Ints

+egcd

Extended Euclidean algorithm

Produces d, the greatest common divisor of a and b. Also produces u and v such that au + bv = GCD(a, b).

Accepts

a is an atom.

b is an atom.

Produces

d, the greatest common divisor, is an atom.

u, the coefficient of a, is a signed integer.

v, the coefficient of b, is a signed integer.

Source

++  egcd
  |=  [a=@ b=@]
  =+  si
  =+  [c=(sun a) d=(sun b)]
  =+  [u=[c=(sun 1) d=--0] v=[c=--0 d=(sun 1)]]
  |-  ^-  [d=@ u=@s v=@s]
  ?:  =(--0 c)
    [(abs d) d.u d.v]
  =+  q=(fra d c)
  %=  $
    c  (dif d (pro q c))
    d  c
    u  [(dif d.u (pro q c.u)) c.u]
    v  [(dif d.v (pro q c.v)) c.v]
  ==

Examples

> (egcd 11 2)
[d=1 u=--1 v=-5]

+fo

Modulo prime

Container door for modular arithmetic functions.

Accepts

a is an atom

Source

++  fo
  ^|
  |_  a=@

++dif:fo

Subtraction

Produces the difference between atoms b and c, with a as the modular base.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

c is an atom.

Produces

An atom.

Source

++  dif
  |=  [b=@ c=@]
  (sit (sub (add a b) (sit c)))

Examples

> (~(dif fo 6) 1 2)
5

> (~(dif fo 21) 11 45)
8

++exp:fo

Exponent

Produces the power of c raised to the b, with a as the modular base.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

c is an atom.

Produces

An atom.

Source

++  exp
  |=  [b=@ c=@]
  ?:  =(0 b)
    1
  =+  d=$(b (rsh 0 b))
  =+  e=(pro d d)
  ?:(=(0 (end 0 b)) e (pro c e))

Examples

    > (~(exp fo 5) 8 2)
    1

    > (~(exp fo 95) 8 2)
    66

    > (~(exp fo 195) 8 2)
    61

    > (~(exp fo 995) 8 2)
    256

++fra:fo

Divide

Produces the quotient of b divided by c, with a as the modular base.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

c is an atom.

Produces

An atom.

Source

++  fra
  |=  [b=@ c=@]
  (pro b (inv c))

Examples

> (~(fra fo 2) 8 2)
0

> (~(fra fo 3) 8 2)
1

> (~(fra fo 4) 8 2)
0

> (~(fra fo 5) 8 2)
4

++inv:fo

Inverse

Produces an atom by taking the signed modulus of a with the coefficient u; u is produced by taking the +egcd of a and b.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

Produces

An atom.

Source

++  inv
  |=  b=@
  =+  c=(dul:si u:(egcd b a) a)
  c

Examples

> (~(inv fo 11) 2)
6

> (~(inv fo 71) 255)
22

> (~(inv fo 79) 255)
22

> (~(inv fo 78) 255)
67

> (~(inv fo 70) 255)
67

++pro:fo

Multiplication

Produces the multiplication of b and c modulo a.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

c is an atom.

Produces

An atom.

Source

++  pro
  |=  [b=@ c=@]
  (sit (mul b c))

Examples

> (~(pro fo 3) 11 4)
2

> (mod 44 3)
2

++sit:fo

Modulus

Produces the remainder of b modulo a.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

Produces

An atom.

Source

++  sit
  |=  b=@
  (mod b a)

Examples

> (~(sit fo 3) 14)
2

++sum:fo

Modular sum

Produces the remainder of (b + c) mod a.

Accepts

a is an atom, and is the sample of +fo.

b is an atom.

c is an atom.

Produces

An atom.

Source

++  sum
  |=  [b=@ c=@]
  (sit (add b c))

Examples

> (~(sum fo 3) 14 3)
2

> (mod 17 3)
2

+si

Signed integer

Container core for signed integer functions.

Source

++  si
  ^?
  |%

Discussion

The signed-integer type is represented by the @s aura. Positive integers are prepended with a --, and negative integers are prepended with a -. For example, --1 represents positive one, and -1 represents negative one.

ZigZag encoding is used to convert atoms to signed integers. Positive signed integers correspond to even atoms of twice their absolute value, and negative signed integers correspond to odd atoms of twice their absolute value minus one. For example:

> `@`--4
8
> `@s`8
--4
> `@`-4
7
> `@s`7
-4

++abs:si

Absolute value

Produces the absolute value of signed integer a.

Accepts

a is a signed integer.

Produces

An atom.

Source

++  abs  |=(a=@s (add (end 0 a) (rsh 0 a)))

Examples

> (abs:si -11)
11

> (abs:si --520)
520

++dif:si

Subtraction

Produces the difference of a minus b.

Accepts

a is a signed integer.

b is a signed integer.

Produces

A signed integer.

Source

++  dif  |=  [a=@s b=@s]
         (sum a (new !(syn b) (abs b)))

Examples

> (dif:si --3 -2)
--5

> (dif:si -3 --2)
-5

++dul:si

Modulus

Produces the remainder of b modulo a.

Examples

a is a signed integer.

b is an atom.

Produces

An atom.

Source

++  dul  |=  [a=@s b=@]
         =+(c=(old a) ?:(-.c (mod +.c b) (sub b +.c)))

Examples

> `@s`(dul:si -1 --5)
-5

> `@`--5
10
> `@s`(dul:si -1 10)
-5

> `@s`(dul:si -11 -61)
--55

++fra:si

Divide

Produces the quotient of b divided by c.

Accepts

a is a signed integer.

b is a signed integer.

Produces

A signed atom.

Source

++  fra  |=  [a=@s b=@s]
         (new =(0 (mix (syn a) (syn b))) (div (abs a) (abs b)))

Examples

> (fra:si -1 -1)
--1

> (fra:si -11 --2)
-5

> (fra:si -0 -1)
--0

++new:si

Atom to @s

Produces a signed integer from an atom b. The product's sign is determined by the value of flag a: & will result in a prepending --, and | will result in a prepending -.

Accepts

a is a flag.

b is an atom.

Produces

A signed integer.

Source

++  new  |=  [a=? b=@]
         `@s`?:(a (mul 2 b) ?:(=(0 b) 0 +((mul 2 (dec b)))))

Examples

> (new:si | 2)
-2

> (new:si & 2)
--2

> (new:si & -2)
--3

> (new:si & --2)
--4

++old:si

Sign and absolute value

Produces a cell composed of a %.y or %.n, depending on whether a is positive or negative, and the absolute value of a.

Accepts

a is a signed integer.

Produces

A cell composed of a ? and an atom.

Source

      ++  old  |=(a=@s [(syn a) (abs a)])
++  old  |=(a=@s [(syn a) (abs a)])

Examples

> (old:si -2)
[%.n 2]

> (old:si --2)
[%.y 2]

++pro:si

Multiplication

Produces a signed integer by multiplying a and b.

Accepts

a is an unsigned integer.

b is an unsigned integer.

Source

++  pro  |=  [a=@s b=@s]
         (new =(0 (mix (syn a) (syn b))) (mul (abs a) (abs b)))

Examples

> (pro:si -3 -3)
--9

> (pro:si -3 --3)
-9

++rem:si

Remainder

Produces a signed integer that is the remainder of a divided by b.

Accepts

a is a signed integer.

b is a signed integer.

Produces

A signed integer.

Source

++  rem  |=([a=@s b=@s] (dif a (pro b (fra a b))))

Examples

> (rem:si -17 -3)
-2

> (rem:si --17 -3)
--2

> (rem:si -17 --3)
-2

> (rem:si --17 --3)
--2

++sum:si

Addition

Produces an atom by adding a and b.

Accepts

a is a signed integer.

b is a signed integer.

Produces

A signed integer.

Source

++  sum  |=  [a=@s b=@s]
         =+  [c=(old a) d=(old b)]
         ?:  -.c
           ?:  -.d
             (new & (add +.c +.d))
           ?:  (gte +.c +.d)
             (new & (sub +.c +.d))
           (new | (sub +.d +.c))
         ?:  -.d
           ?:  (gte +.c +.d)
             (new | (sub +.c +.d))
           (new & (sub +.d +.c))
         (new | (add +.c +.d))

Examples

> (sum:si -11 --2)
-9

> (sum:si --2 --2)
--4

++sun:si

@u to @s

Multiplies the unsigned integer a by two, producing an atom.

Accepts

a is an unsigned integer.

Produces

An atom.

Source

++  sun  |=(a=@u (mul 2 a))

Examples

> (sun:si 90)
180

> (sun:si --90)
360
> `@u`--90
180

> (sun:si --89)
356
> `@u`--89
178

> (sun:si -89)
354
> `@u`-89
177

++syn:si

Sign test

Tests whether signed atom a is positive or negative. %.y is produced if a is positive, and %.n is produced if a is negative.

Accepts

a is a signed integer.

Produces

A ?.

Source

++  syn  |=(a=@s =(0 (end 0 a)))

Examples

> (syn:si -2)
%.n

> (syn:si --2)
%.y

++cmp:si

Compare

Compares a and b to see which is greater. If a is greater than b, --1 is produced. If b is greater than a, -1 is produced. If a and b are equal, --0 is produced.

Accepts

a is a signed integer.

b is a signed integer.

Produces

A signed integer.

Source

++  cmp  |=  [a=@s b=@s]
         ^-  @s
         ?:  =(a b)
           --0
         ?:  (syn a)
           ?:  (syn b)
             ?:  (gth a b)
               --1
             -1
           --1
        ?:  (syn b)
          -1
        ?:  (gth a b)
          -1
        --1

Examples

> (cmp:si -2 --1)
-1

> (cmp:si -2 --1)
-1

> (cmp:si --2 --1)
--1

> (cmp:si --2 --2)
--0

> (cmp:si --2 --5)
-1

Previous2q: Molds and Mold-BuildersNext3b: Floating Point

Last updated 1 day ago