diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,3 @@ +# Version 0.1 + +* Initial version. diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2023, Renzo Carbonara. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + +1. Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. THIS SOFTWARE +IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md new file mode 100644 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ +# kind-rational + +Haskell type-level `Rational`s. Like `KnownNat`, but for `Rational`s. + diff --git a/kind-rational.cabal b/kind-rational.cabal new file mode 100644 --- /dev/null +++ b/kind-rational.cabal @@ -0,0 +1,49 @@ +cabal-version: 2.4 +name: kind-rational +version: 0.1 +license: BSD-3-Clause +license-file: LICENSE +extra-source-files: README.md CHANGELOG.md +author: Renzo Carbonara +maintainer: renλren.zone +copyright: Copyright (c) Renzo Carbonara 2023 +category: Types +build-type: Simple +synopsis: Type-level rationals. Like KnownNat, but for rationals. +description: Type-level rationals. Like KnownNat, but for rationals. +homepage: https://github.com/k0001/hs-kind +bug-reports: https://github.com/k0001/hs-kind/issues +tested-with: GHC ==9.4.3 + +source-repository head + type: git + location: https://github.com/k0001/hs-kind + subdir: kind-rational + +common basic + default-language: GHC2021 + ghc-options: -O2 -Wall -Werror=incomplete-patterns + build-depends: + base ==4.*, + kind-integer >=0.2, + default-extensions: + DataKinds + NoStarIsType + LambdaCase + PatternSynonyms + TypeFamilies + TypeOperators + ViewPatterns + +library + import: basic + hs-source-dirs: lib + build-depends: ghc-prim + exposed-modules: KindRational + +test-suite test + import: basic + type: exitcode-stdio-1.0 + hs-source-dirs: test + main-is: Main.hs + build-depends: kind-rational diff --git a/lib/KindRational.hs b/lib/KindRational.hs new file mode 100644 --- /dev/null +++ b/lib/KindRational.hs @@ -0,0 +1,717 @@ +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE UndecidableSuperClasses #-} + +-- | This module provides a type-level representation for term-level +-- 'P.Rational's. This type-level representation is also named 'P.Rational', +-- So import this module qualified to avoid name conflicts. +-- +-- @ +-- import "KindRational" qualified as KR +-- @ +-- +-- The implementation details are the same as the ones for type-level 'Natural's +-- in "GHC.TypeNats" as of @base-4.18@, and it will continue to evolve together +-- with @base@, trying to follow its core API as much as possible until the day +-- @base@ provides its own type-level rationals, making this module redundant. +module KindRational {--} + ( -- * Rational kind + Rational + , type (%) + , type (/) + , Normalize + , Num + , Den + + -- Prelude support + , rational + , fromPrelude + , toPrelude + , showsPrecTypeLit + + -- * Types ⇔ Terms + , KnownRational(rationalSing) + , rationalVal + , SomeRational(..) + , someRationalVal + , sameRational + + -- * Singletons + , SRational + , pattern SRational + , fromSRational + , withSomeSRational + , withKnownRational + + -- * Arithmethic + , type (+) + , type (*) + , type (-) + , Negate + , Sign + , Abs + , Recip + , Div + , div + , Mod + , mod + , Dif + , dif + , DivMod + , divMod + , DivDif + , divDif + , I.Round(..) + + -- * Decimals + , Terminating + , withTerminating + , Terminates + , terminates + + -- * Comparisons + , CmpRational + , cmpRational + + -- * Extra + -- + -- | This stuff should be exported by the "Data.Type.Ord" module. + , type (==?), type (==), type (/=?), type (/=) + ) --} + where + +import qualified Control.Exception as Ex +import Control.Monad +import Data.Proxy +import Data.Type.Bool (If) +import Data.Type.Coercion +import Data.Type.Equality (TestEquality(..), (:~:)(..)) +import Data.Type.Ord +import GHC.Base (WithDict(..)) +import GHC.Read qualified as Read +import GHC.Real qualified as P (Ratio(..), (%)) +import GHC.Show (appPrec, appPrec1) +import GHC.TypeLits qualified as L +import GHC.TypeNats qualified as N +import GHC.Types (TYPE, Constraint) +import KindInteger (Integer, N, P) +import KindInteger (type (==?), type (==), type (/=?), type (/=)) +import KindInteger qualified as I +import Numeric.Natural (Natural) +import Prelude hiding (Rational, Integer, Num, div, mod, divMod) +import Prelude qualified as P +import Text.ParserCombinators.ReadPrec as Read +import Text.Read.Lex qualified as Read +import Unsafe.Coerce(unsafeCoerce) + +-------------------------------------------------------------------------------- + +-- | Type-level version of 'P.Rational'. Use '/' to construct one, use '%' to +-- pattern-match on it. +-- +-- 'Rational' is mostly used as a kind, with its types constructed +-- using '/'. However, it might also be used as type, with its terms +-- constructed using 'rational' or 'fromPrelude'. One reason why you may want a +-- 'Rational' at the term-level is so that you embed it in larger data-types +-- (for example, this 'Rational' embeds the 'I.Integer' similarly offered by +-- the "KindInteger" module). But perhaps more importantly, this 'Rational' +-- offers better safety than the 'P.Rational' from "Prelude", since it's not +-- possible to construct one with a zero denominator, or so large that +-- operating with it would exhaust system resources. Notwithstanding this, for +-- ergonomic reasons, all of the functions exported by this module take +-- "Prelude" 'Rational's as input and produce "Prelude" 'Rational's as outputs. +-- Internally, however, the beforementioned checks are always performed, and +-- fail with 'Ex.throw' if necessary. If you want to be sure those 'error's +-- never happen, just filter your "Prelude" 'Rational's with 'fromPrelude'. In +-- practice, it's very unlikely that you will be affected by this unless if +-- you are unsafelly constructing "Prelude" 'Rational's. +data Rational + = -- | This constructor is /unsafe/ because it doesn't check for the things + -- that 'rational' checks for. + -- + -- * At the term-level, safely construct a 'Rational' using 'rational' + -- or 'fromPrelude' instead. + -- + -- * At the type-level, safely construct a 'Rational' using '/'. + I.Integer :% Natural + +num :: Rational -> I.Integer +num (n :% _) = n + +den :: Rational -> Natural +den (_ :% d) = d + +instance Eq Rational where + a == b = toPrelude a == toPrelude b + +instance Ord Rational where + compare a b = compare (toPrelude a) (toPrelude b) + a <= b = toPrelude a <= toPrelude b + +-- | Same as "Prelude" 'P.Rational'. +instance Show Rational where + showsPrec p = showsPrec p . toPrelude + +-- | Same as "Prelude" 'P.Rational'. +instance Read Rational where + readPrec = Read.parens $ Read.prec 7 $ do -- 7 is GHC.Real.ratioPrec + n :: P.Integer <- Read.step Read.readPrec + Read.expectP (Read.Symbol "%") + d :: P.Integer <- Read.step Read.readPrec + Just r <- pure (rational n d) + pure r + +-- | Shows the 'Rational' as it appears literally at the type-level. +-- +-- This is different from normal 'show' for 'Rational', which shows +-- the term-level value. +-- +-- @ +-- 'shows' 0 ('rationalVal' ('Proxy' \@(1'/'2))) \"z\" == \"1 % 2z\" +-- 'showsPrecTypeLit' 0 ('rationalVal' ('Proxy' \@(1'/'2))) \"z\" == \"P 1 % 2z\" +-- @ +showsPrecTypeLit :: Int -> Rational -> ShowS +showsPrecTypeLit p r = showParen (p > appPrec) $ + I.showsPrecTypeLit appPrec (num r) . showString " % " . shows (den r) + +-- | Make a term-level "KindRational" 'Rational' number, provided that +-- the numerator is not @0@, and that its numerator and denominator are +-- not so large that they would exhaust system resources. The 'Rational' +-- is 'Normalize'd. +rational :: (Integral num, Integral den) => num -> den -> Maybe Rational +rational = \(toInteger -> n) (toInteger -> d) -> do + guard (d /= 0 && abs n <= max_ && abs d <= max_) + pure $ let n1 P.:% d1 = n P.% d + in I.fromPrelude n1 :% fromInteger d1 + where + max_ :: P.Integer -- Some big enough number. TODO: Pick good number. + max_ = 10 ^ (1000 :: Int) + +-- | Try to obtain a term-level "KindRational" 'Rational' from a term-level +-- "Prelude" 'P.Rational'. This can fail if the "Prelude" 'P.Rational' is +-- infinite, or if it is so big that it would exhaust system resources. +-- +-- @ +-- 'fromPrelude' . 'toPrelude' == 'Just' +-- 'fmap' 'toPrelude' . 'fromPrelude' == 'Just' +-- @ +fromPrelude :: P.Rational -> Maybe Rational +fromPrelude (n P.:% d) = rational n d + +-- | Like 'fromPrelude', but 'Ex.throw's in situations where +-- 'fromPrelude' fails with 'Nothing'. +unsafeFromPrelude :: P.Rational -> Rational +unsafeFromPrelude = \case + n P.:% d + | d == 0 -> Ex.throw Ex.RatioZeroDenominator + | abs n > max_ || abs d > max_ -> Ex.throw Ex.Overflow + | otherwise -> + let n1 P.:% d1 = n P.% d + in I.fromPrelude n1 :% fromInteger d1 + where + max_ :: P.Integer -- Some big enough number. TODO: Pick good number. + max_ = 10 ^ (1000 :: Int) + +-- | Convert a term-level "KindRational" 'Rational' into a term-level +-- "Prelude" 'P.Rational'. +-- +-- @ +-- 'fromPrelude' . 'toPrelude' == 'Just' +-- 'fmap' 'toPrelude' . 'fromPrelude' == 'Just' +-- @ +toPrelude :: Rational -> P.Rational +toPrelude r = I.toPrelude (num r) P.:% toInteger (den r) + +-------------------------------------------------------------------------------- + +-- | 'Normalize'd /'Num'erator/ of the type-level 'Rational'. +type Num (r :: Rational) = Num_ (Normalize r) :: Integer +type family Num_ (r :: Rational) :: Integer where + Num_ (n :% _) = n + +-- | 'Normalize'd /'Den'ominator/ of the type-level 'Rational'. +type Den (r :: Rational) = Den_ (Normalize r) :: Natural +type family Den_ (r :: Rational) :: Natural where + Den_ (_ :% d) = d + +-- | Pattern-match on a type-level 'Rational'. +-- +-- __NB:__ When /constructing/ a 'Rational' number, prefer to use '/', +-- which not only accepts more polymorphic inputs, but also 'Normalize's +-- the type-level 'Rational'. Also note that while @n '%' 0@ is a valid +-- type, all tools in the "KindRational" will reject such input. +type (n :: I.Integer) % (d :: Natural) = n ':% d :: Rational + +-- | Normalize a type-level 'Rational' so that a /0/ denominator fails to +-- type-check, and that the 'Num'erator and denominator have no common factors. +-- +-- Only 'Normalize'd 'Rational's can be reliably constrained for equality +-- using '~'. +-- +-- All of the functions in the "KindRational" module accept both +-- 'Normalize'd and non-'Normalize'd inputs, but they always produce +-- 'Normalize'd output. +type family Normalize (r :: Rational) :: Rational where + Normalize (_ % 0) = L.TypeError ('L.Text "KindRational: Denominator is zero") + Normalize (P 0 % _) = P 0 % 1 + Normalize (N 0 % _) = P 0 % 1 + Normalize (P n % d) = P (L.Div n (GCD n d)) % L.Div d (GCD n d) + Normalize (N n % d) = N (L.Div n (GCD n d)) % L.Div d (GCD n d) + +-------------------------------------------------------------------------------- + +infixl 6 +, - +infixl 7 *, / + + +type (/) :: kn -> kd -> Rational +-- | @n'/'d@ constructs and 'Normalize's a type-level 'Rational' +-- with numerator @n@ and denominator @d@. +-- +-- This type-family accepts any combination of 'Natural', 'Integer' and +-- 'Rational' as input. +-- +-- @ +-- ('/') :: 'Natural' -> 'Natural' -> 'Rational' +-- ('/') :: 'Natural' -> 'Integer' -> 'Rational' +-- ('/') :: 'Natural' -> 'Rational' -> 'Rational' +-- +-- ('/') :: 'Integer' -> 'Natural' -> 'Rational' +-- ('/') :: 'Integer' -> 'Integer' -> 'Rational' +-- ('/') :: 'Integer' -> 'Rational' -> 'Rational' +-- +-- ('/') :: 'Rational' -> 'Natural' -> 'Rational' +-- ('/') :: 'Rational' -> 'Integer' -> 'Rational' +-- ('/') :: 'Rational' -> 'Rational' -> 'Rational' +-- @ +-- +-- It's not possible to pattern-match on @n'/'d@. Instead, you must +-- pattern match on @x'%'y@, where @x'%'y ~ n'/'d@. +type family n / d :: Rational where + -- Natural/Natural + (n :: Natural) / (d :: Natural) = Normalize (P n % d) + -- Natural/Integer + (n :: Natural) / (P d :: Integer) = Normalize (P n % d) + (n :: Natural) / (N d :: Integer) = Normalize (N n % d) + -- Natural/Rational + (n :: Natural) / (d :: Rational) = (P n % 1) * Recip d + -- Integer/Natural + (i :: Integer) / (d :: Natural) = Normalize (i % d) + -- Integer/Integer + (P n :: Integer) / (P d :: Integer) = Normalize (P n % d) + (N n :: Integer) / (N d :: Integer) = Normalize (P n % d) + (P n :: Integer) / (N d :: Integer) = Normalize (N n % d) + (N n :: Integer) / (P d :: Integer) = Normalize (N n % d) + -- Integer/Rational + (n :: Integer) / (d :: Rational) = (n % 1) * Recip d + -- Rational/Natural + (n :: Rational) / (d :: Natural) = n * Recip (P d % 1) + -- Rational/Integer + (n :: Rational) / (d :: Integer) = n * Recip (d % 1) + -- Rational/Rational + (n :: Rational) / (d :: Rational) = n * Recip d + +-------------------------------------------------------------------------------- + +-- | /'Negate'/ a type-level 'Rational'. Also known as /additive inverse/. +type family Negate (r :: Rational) :: Rational where + Negate (P n % d) = Normalize (N n % d) + Negate (N n % d) = Normalize (P n % d) + +-- | Sign of type-level 'Rational's, as a type-level 'Integer'. +-- +-- * @'P' 0@ if zero. +-- +-- * @'P' 1@ if positive. +-- +-- * @'N' 1@ if negative. +type Sign (r :: Rational) = I.Sign (Num r) :: Integer + +-- | /'Abs'olute/ value of a type-level 'Rational'. +type Abs (r :: Rational) = Normalize (P (I.Abs (Num_ r)) % Den_ r) :: Rational + +-------------------------------------------------------------------------------- + +-- | @a t'*' b@ multiplies type-level 'Rational's @a@ and @b@. +type (a :: Rational) * (b :: Rational) = + Mul_ (Normalize a) (Normalize b) :: Rational +type family Mul_ (a :: Rational) (b :: Rational) where + Mul_ (n1 % d1) (n2 % d2) = Normalize ((n1 I.* n2) % (d1 L.* d2)) + +-- | /'Recip'rocal/ of the type-level 'Rational'. +-- Also known as /multiplicative inverse/. +type Recip (a :: Rational) = Recip_ (Normalize a) :: Rational +type family Recip_ (a :: Rational) :: Rational where + Recip_ (P n % d) = Normalize (P d % n) + Recip_ (N n % d) = Normalize (N d % n) + +-- | @a t'+' b@ adds type-level 'Rational's @a@ and @b@. +type (a :: Rational) + (b :: Rational) = + Add_ (Normalize a) (Normalize b) :: Rational +type family Add_ (a :: Rational) (r :: Rational) :: Rational where + Add_ (an % ad) (bn % bd) = + Normalize ((an I.* P bd I.+ bn I.* P ad) % (ad L.* bd)) + +-- | @a t'-' b@ subtracts the type-level 'Rational' @b@ from +-- the type-level 'Rational' @a@. +type (a :: Rational) - (b :: Rational) = a + Negate b :: Rational + + +-------------------------------------------------------------------------------- + +-- | Quotient of the 'Div'ision of the 'Num'erator of type-level 'Rational' @a@ +-- by its 'Den'ominator, using the specified 'I.Round'ing @r@. +-- +-- @ +-- forall (r :: 'I.Round') (a :: 'Rational'). +-- ('Den' a '/=' 0) => +-- 'Mod' r a '==' 'Num' a 'I.-' 'P' ('Den' a) 'I.*' 'Div' r a +-- @ +type Div (r :: I.Round) (a :: Rational) = + Div_ r (Normalize a) :: Integer +type Div_ (r :: I.Round) (a :: Rational) = + I.Div r (Num_ a) (P (Den_ a)) :: Integer + +-- | 'Mod'ulus of the division of the 'Num'erator of type-level 'Rational' +-- @a@ by its 'Den'ominator, using the specified 'I.Round'ing @r@. +-- +-- @ +-- forall (r :: 'I.Round') (a :: 'Rational'). +-- ('Den' a '/=' 0) => +-- 'Mod' r a '==' 'Num' a 'I.-' 'P' ('Den' a) 'I.*' 'Div' r a +-- @ +type Mod (r :: I.Round) (a :: Rational) = Snd (DivMod r a) :: Integer + +-- | Get both the quotient and the 'Mod'ulus of the 'Div'ision of the +-- 'Num'erator of type-level 'Rational' @a@ by its 'Den'ominator, +-- using the specified 'I.Round'ing @r@. +-- +-- @ +-- forall (r :: 'I.Round') (a :: 'Rational'). +-- ('Den' a '/=' 0) => +-- 'DivMod' r a '==' '('Div' r a, 'Mod' r a) +-- @ +type DivMod (r :: I.Round) (a :: Rational) = + DivMod_ r (Normalize a) :: (Integer, Integer) +type DivMod_ (r :: I.Round) (a :: Rational) = + I.DivMod r (Num_ a) (P (Den_ a)) :: (Integer, Integer) + +-- | 'Dif'ference of the type-level 'Rational' @a@ and the 'Div'ision of +-- its 'Num'erator by its 'Den'ominator, using the specified 'I.Round'ing @r@. +-- +-- @ +-- forall (r :: 'I.Round') (a :: 'Rational'). +-- ('Den' a '/=' 0) => +-- 'Dif' r a '==' a '-' 'Div' r a '%' 1 +-- @ +-- +-- Note: We use the word /difference/ because talking about /remainder/ in this +-- context can be confusing, considering "Prelude"'s `rem`ainder function. +-- However, strictly speaking, @`Dif` r a@ is the 'Rational' that /remiains/ +-- after performing the 'I.Round'ed 'Div'ision. So, yes, 'Dif' could potentially +-- have been called @Rem@ instead. +type Dif (r :: I.Round) (a :: Rational) = Snd (DivDif r a) :: Rational + +-- | Get both the quotient and the 'Dif'ference of the 'Div'ision of the +-- 'Num'erator of type-level 'Rational' @a@ by its 'Den'ominator, +-- using the specified 'I.Round'ing @r@. +-- +-- @ +-- forall (r :: 'I.Round') (a :: 'Rational'). +-- ('Den' a '/=' 0) => +-- 'DivDif' r a '==' '('Div' r a, 'Dif' r a) +-- @ +type DivDif (r :: I.Round) (a :: Rational) = + DivDif_ r (Normalize a) :: (Integer, Rational) +type DivDif_ (r :: I.Round) (a :: Rational) = + DivDif__ a (Div_ r a) :: (Integer, Rational) +type DivDif__ (a :: Rational) (q :: Integer) = + '(q, a - q :% 1) :: (Integer, Rational) + +-- | Term-level version of 'Div'. +-- +-- Takes a "Prelude" 'P.Rational' as input, returns a "Prelude" 'P.Integer'. +div :: I.Round -> P.Rational -> P.Integer +div r = \(n P.:% d) -> f n d + where f = I.div r + +-- | Term-level version of 'Div'. +-- +-- Takes a "Prelude" 'P.Rational' as input, returns a "Prelude" 'P.Integer'. +mod :: I.Round -> P.Rational -> P.Integer +mod r = \(n P.:% d) -> f n d + where f = I.mod r + +-- | Term-level version of 'DivMod'. +-- Takes a "Prelude" 'P.Rational' as input, returns a pair of "Prelude" +-- 'P.Integer's /(quotient, modulus)/. +-- +-- @ +-- forall ('r' :: 'I.Round') (a :: 'P.Rational'). +-- ('P.denominator' a 'P./=' 0) => +-- 'divMod' r a 'P.==' ('div' r a, 'mod' r a) +-- @ +divMod :: I.Round -> P.Rational -> (P.Integer, P.Integer) +divMod r = \(n P.:% d) -> f n d + where f = I.divMod r + +-- | Term-level version of 'Dif'. +-- +-- Takes a "Prelude" 'P.Rational' as input, returns a "Prelude" 'P.Rational'. +dif :: I.Round -> P.Rational -> P.Rational +dif r = \a -> a - toRational (f a) + where f = div r + +-- | Term-level version of 'DivDif'. +-- +-- Takes a "Prelude" 'P.Rational' as input, returns a pair of "Prelude" +-- 'P.Rational's /(quotient, difference)/. +-- +-- @ +-- forall ('r' :: 'I.Round') (a :: 'P.Rational'). +-- ('P.denominator' a 'P./=' 0) => +-- 'divDif' r a 'P.==' ('div' r a, 'dif' r a) +-- @ +divDif :: I.Round -> P.Rational -> (P.Integer, P.Rational) +divDif r = \a -> let q = f a in (q, a - toRational q) + where f = div r + +-------------------------------------------------------------------------------- + +-- | 'Constraint' version of @'Terminates' r@. Satisfied by all type-level +-- 'Rational's that can be represented as a finite decimal number. + +-- Written as a class rather than as a type-synonym so that downstream doesn't +-- need to use UndecidableSuperClasses. +class (KnownRational r, Terminates r ~ True) + => Terminating (r :: Rational) + +-- Note: Even if @Terminates r ~ 'False@, GHC shows our @TypeError@ first. +instance + ( KnownRational r + , Terminates r ~ 'True + , If (Terminates r) + (() :: Constraint) + (L.TypeError ('L.Text "‘" 'L.:<>: 'L.ShowType r 'L.:<>: + 'L.Text "’ is not a terminating " + 'L.:<>: 'L.ShowType Rational)) + ) => Terminating r + +withTerminating + :: forall r a + . KnownRational r + => (Terminating r => a) + -> Maybe a +withTerminating g = do + guard (terminates' (rationalVal' (Proxy @r))) + case unsafeCoerce (Dict @(Terminating (P 1 % 1))) of + (Dict :: Dict (Terminating r)) -> pure g + +-- | Whether the type-level 'Rational' terminates. That is, whether +-- it can be fully represented as a finite decimal number. +type Terminates (r :: Rational) = Terminates_ (Den r) :: Bool +type family Terminates_ (n :: Natural) :: Bool where + Terminates_ 5 = 'True + Terminates_ 2 = 'True + Terminates_ 1 = 'True + Terminates_ d = Terminates_5 d (L.Mod d 5) + +-- @Terminates_5@ is here to prevent @Terminates_@ from recursing into +-- @Terminates_ (Div d 5)@ if it would diverge. +type family Terminates_5 (d :: Natural) (md5 :: Natural) :: Bool where + Terminates_5 d 0 = Terminates_ (L.Div d 5) + Terminates_5 d _ = Terminates_2 d (L.Mod d 2) + +-- @Terminates_2@ is here to prevent @Terminates_5@ from recursing into +-- @Terminates_ (Div d 2)@ if it would diverge, and also to prevent calculating +-- @Mod d 2@ unless necessary. +type family Terminates_2 (d :: Natural) (md2 :: Natural) :: Bool where + Terminates_2 d 0 = Terminates_ (L.Div d 2) + Terminates_2 _ _ = 'False + +-- | Term-level version of the "Terminates" function. +-- Takes a "Prelude" 'P.Rational' as input. +terminates :: P.Rational -> Bool +terminates = terminates' . unsafeFromPrelude + +-- | Term-level version of the "Terminates" function. +-- Takes a "KindRational" 'P.Rational' as input. +terminates' :: Rational -> Bool +terminates' = go . den + where + go = \case + 5 -> True + 2 -> True + 1 -> True + n | (q, 0) <- P.divMod n 5 -> go q + | (q, 0) <- P.divMod n 2 -> go q + _ -> False + +-------------------------------------------------------------------------------- + +-- | Comparison of type-level 'Rational's, as a function. +type CmpRational (a :: Rational) (b :: Rational) = + CmpRational_ (Normalize a) (Normalize b) :: Ordering +type family CmpRational_ (a :: Rational) (b :: Rational) :: Ordering where + CmpRational_ a a = 'EQ + CmpRational_ (an % ad) (bn % bd) = I.CmpInteger (an I.* P bd) (bn I.* P ad) + +-- | "Data.Type.Ord" support for type-level 'Rational's. +type instance Compare (a :: Rational) (b :: Rational) = CmpRational a b + +-------------------------------------------------------------------------------- + +-- | This class gives the rational associated with a type-level rational. +-- There are instances of the class for every rational. +class KnownRational (r :: Rational) where + rationalSing :: SRational r + +instance forall r n d. + ( Normalize r ~ n % d + , I.KnownInteger n + , L.KnownNat d + ) => KnownRational r where + rationalSing = UnsafeSRational + (I.fromPrelude (I.integerVal (Proxy @n)) :% N.natVal (Proxy @d)) + +-- | Term-level "KindRational" 'Rational' representation of the type-level +-- 'Rational' @r@. +rationalVal' :: forall r proxy. KnownRational r => proxy r -> Rational +rationalVal' _ = case rationalSing :: SRational r of + UnsafeSRational x -> x + +-- | Term-level "Prelude" 'P.Rational' representation of the type-level +-- 'Rational' @r@. +rationalVal :: forall r proxy. KnownRational r => proxy r -> P.Rational +rationalVal = toPrelude . rationalVal' + +-- | This type represents unknown type-level 'Rational'. +data SomeRational = forall n. KnownRational n => SomeRational (Proxy n) + +-- | Convert a term-level "Prelude" 'Rational' into an unknown +-- type-level 'Rational'. +someRationalVal :: P.Rational -> SomeRational +someRationalVal r = + withSomeSRational (unsafeFromPrelude r) $ \(sr :: SRational r) -> + withKnownRational sr (SomeRational @r Proxy) + +instance Eq SomeRational where + SomeRational x == SomeRational y = rationalVal x P.== rationalVal y + +instance Ord SomeRational where + SomeRational x <= SomeRational y = + rationalVal x <= rationalVal y + compare (SomeRational x) (SomeRational y) = + compare (rationalVal x) (rationalVal y) + +instance Show SomeRational where + showsPrec p (SomeRational x) = showsPrec p (rationalVal x) + +instance Read SomeRational where + readsPrec p xs = do (a, ys) <- readsPrec p xs + [(someRationalVal a, ys)] + + +-- | We either get evidence that this function was instantiated with the +-- same type-level 'Rational's, or 'Nothing'. +sameRational + :: forall a b proxy1 proxy2 + . (KnownRational a, KnownRational b) + => proxy1 a + -> proxy2 b + -> Maybe (a :~: b) +sameRational _ _ = testEquality (rationalSing @a) (rationalSing @b) + +-- | Like 'sameRational', but if the type-level 'Rational's aren't equal, this +-- additionally provides proof of 'LT' or 'GT'. +cmpRational + :: forall a b proxy1 proxy2 + . (KnownRational a, KnownRational b) + => proxy1 a + -> proxy2 b + -> OrderingI a b +cmpRational x y = case compare (rationalVal x) (rationalVal y) of + EQ -> case unsafeCoerce Refl :: CmpRational a b :~: 'EQ of + Refl -> case unsafeCoerce Refl :: a :~: b of + Refl -> EQI + LT -> case unsafeCoerce Refl :: (CmpRational a b :~: 'LT) of + Refl -> LTI + GT -> case unsafeCoerce Refl :: (CmpRational a b :~: 'GT) of + Refl -> GTI + +-------------------------------------------------------------------------------- + +-- | Singleton type for a type-level 'Rational' @r@. +newtype SRational (r :: Rational) = UnsafeSRational Rational + +-- | A explicitly bidirectional pattern synonym relating an 'SRational' to a +-- 'KnownRational' constraint. +-- +-- As an __expression__: Constructs an explicit @'SRational' r@ value from an +-- implicit @'KnownRational' r@ constraint: +-- +-- @ +-- 'SRational' @r :: 'KnownRational' r => 'SRational' r +-- @ +-- +-- As a __pattern__: Matches on an explicit @'SRational' r@ value bringing +-- an implicit @'KnownRational' r@ constraint into scope: +-- +-- @ +-- f :: 'SRational' r -> .. +-- f SRational = {- SRational r in scope -} +-- @ +pattern SRational :: forall r. () => KnownRational r => SRational r +pattern SRational <- (knownRationalInstance -> KnownRationalegerInstance) + where SRational = rationalSing + +-- | An internal data type that is only used for defining the 'SRational' pattern +-- synonym. +data KnownRationalegerInstance (r :: Rational) where + KnownRationalegerInstance :: KnownRational r => KnownRationalegerInstance r + +-- | An internal function that is only used for defining the 'SRational' pattern +-- synonym. +knownRationalInstance :: SRational r -> KnownRationalegerInstance r +knownRationalInstance si = withKnownRational si KnownRationalegerInstance + +instance Show (SRational r) where + showsPrec p (UnsafeSRational r) = showParen (p > appPrec) $ + showString "SRational @" . showsPrecTypeLit appPrec1 r + +instance TestEquality SRational where + testEquality (UnsafeSRational x) (UnsafeSRational y) = do + guard (toPrelude x P.== toPrelude y) + pure (unsafeCoerce Refl) + +instance TestCoercion SRational where + testCoercion x y = fmap (\Refl -> Coercion) (testEquality x y) + +-- | Return the term-level "Prelude" 'P.Rational' number corresponding +-- to @r@ in a @'SRational' r@ value. +fromSRational :: SRational r -> P.Rational +fromSRational (UnsafeSRational r) = toPrelude r + +-- | Convert an explicit @'SRational' r@ value into an implicit +-- @'KnownRational' r@ constraint. +withKnownRational + :: forall r rep (a :: TYPE rep). SRational r -> (KnownRational r => a) -> a +withKnownRational = withDict @(KnownRational r) + +-- | Convert a "Prelude" 'P.Rational' number into an @'SRational' n@ value, +-- where @n@ is a fresh type-level 'Rational'. +withSomeSRational + :: forall rep (a :: TYPE rep). Rational -> (forall r. SRational r -> a) -> a +withSomeSRational r k = k (UnsafeSRational r) +-- It's very important to keep this NOINLINE! See the docs at "GHC.TypeNats" +{-# NOINLINE withSomeSRational #-} + +-------------------------------------------------------------------------------- +-- Extra stuff that doesn't belong here. + +-- | /Greatest Common Divisor/ of 'Natural' numbers @a@ and @b@. +type GCD (a :: Natural) (b :: Natural) = I.GCD (P a) (P b) :: Natural + +data Dict c where Dict :: c => Dict c + +type family Snd (ab :: (a, b)) :: b where Snd '(a, b) = b + diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,1861 @@ +{-# OPTIONS_GHC -Wno-missing-signatures #-} +module Main {--} + ( main + ) --} + where + +import Control.Applicative +import Control.Monad +import Data.List qualified as List +import Data.Maybe +import Data.Proxy +import Data.Type.Ord (type (<=), type (<)) +import GHC.Exts (Constraint) +import System.Exit +import Text.Read +import GHC.Real qualified as P +import Prelude hiding (Rational, Integer) +import Prelude qualified as P + +import KindInteger (P, N) +import KindRational (type (%), type (/)) +import KindRational qualified as K + +-------------------------------------------------------------------------------- + +data Dict (c :: Constraint) where + Dict :: c => Dict c + +-------------------------------------------------------------------------------- + +_testNormalize = Dict +_testNormalize :: Dict + ( P 0 % 1 ~ K.Normalize (P 0 % 1) + , P 1 % 1 ~ K.Normalize (P 1 % 1) + , P 2 % 1 ~ K.Normalize (P 2 % 1) + , P 3 % 1 ~ K.Normalize (P 3 % 1) + , P 4 % 1 ~ K.Normalize (P 4 % 1) + , P 0 % 1 ~ K.Normalize (P 0 % 2) + , P 1 % 1 ~ K.Normalize (P 2 % 2) + , P 3 % 2 ~ K.Normalize (P 3 % 2) + , P 2 % 1 ~ K.Normalize (P 4 % 2) + , P 0 % 1 ~ K.Normalize (P 0 % 3) + , P 1 % 3 ~ K.Normalize (P 1 % 3) + , P 2 % 3 ~ K.Normalize (P 2 % 3) + , P 1 % 1 ~ K.Normalize (P 3 % 3) + , P 4 % 3 ~ K.Normalize (P 4 % 3) + , P 0 % 1 ~ K.Normalize (P 0 % 4) + , P 1 % 4 ~ K.Normalize (P 1 % 4) + , P 1 % 2 ~ K.Normalize (P 2 % 4) + , P 3 % 4 ~ K.Normalize (P 3 % 4) + , P 1 % 1 ~ K.Normalize (P 4 % 4) + , P 0 % 1 ~ K.Normalize (N 0 % 1) + , N 1 % 1 ~ K.Normalize (N 1 % 1) + , N 2 % 1 ~ K.Normalize (N 2 % 1) + , N 3 % 1 ~ K.Normalize (N 3 % 1) + , N 4 % 1 ~ K.Normalize (N 4 % 1) + , P 0 % 1 ~ K.Normalize (N 0 % 2) + , N 1 % 2 ~ K.Normalize (N 1 % 2) + , N 1 % 1 ~ K.Normalize (N 2 % 2) + , N 3 % 2 ~ K.Normalize (N 3 % 2) + , N 2 % 1 ~ K.Normalize (N 4 % 2) + , P 0 % 1 ~ K.Normalize (N 0 % 3) + , N 1 % 3 ~ K.Normalize (N 1 % 3) + , N 2 % 3 ~ K.Normalize (N 2 % 3) + , N 1 % 1 ~ K.Normalize (N 3 % 3) + , N 4 % 3 ~ K.Normalize (N 4 % 3) + , P 0 % 1 ~ K.Normalize (N 0 % 4) + , N 1 % 4 ~ K.Normalize (N 1 % 4) + , N 1 % 2 ~ K.Normalize (N 2 % 4) + , N 3 % 4 ~ K.Normalize (N 3 % 4) + , N 1 % 1 ~ K.Normalize (N 4 % 4) + ) + +_testNegate = Dict +_testNegate :: Dict + ( P 0 % 1 ~ K.Negate (P 0 % 1) + , P 0 % 1 ~ K.Negate (P 0 % 2) + , P 0 % 1 ~ K.Negate (N 0 % 1) + , P 0 % 1 ~ K.Negate (N 0 % 2) + + , P 1 % 1 ~ K.Negate (N 1 % 1) + , P 1 % 2 ~ K.Negate (N 1 % 2) + , P 1 % 1 ~ K.Negate (N 1 % 1) + , P 1 % 2 ~ K.Negate (N 1 % 2) + + , N 1 % 1 ~ K.Negate (P 1 % 1) + , N 1 % 2 ~ K.Negate (P 1 % 2) + , N 1 % 1 ~ K.Negate (P 1 % 1) + , N 1 % 2 ~ K.Negate (P 1 % 2) + + , P 1 % 1 ~ K.Negate (N 1 % 1) + , P 2 % 1 ~ K.Negate (N 2 % 1) + , P 1 % 1 ~ K.Negate (N 1 % 1) + , P 2 % 1 ~ K.Negate (N 2 % 1) + + , N 1 % 1 ~ K.Negate (P 1 % 1) + , N 2 % 1 ~ K.Negate (P 2 % 1) + , N 1 % 1 ~ K.Negate (P 1 % 1) + , N 2 % 1 ~ K.Negate (P 2 % 1) + ) + +_testSign = Dict +_testSign :: Dict + ( P 0 ~ K.Sign (P 0 % 1) + , P 0 ~ K.Sign (P 0 % 2) + , P 0 ~ K.Sign (N 0 % 1) + , P 0 ~ K.Sign (N 0 % 2) + + , N 1 ~ K.Sign (N 1 % 1) + , N 1 ~ K.Sign (N 1 % 2) + , N 1 ~ K.Sign (N 1 % 1) + , N 1 ~ K.Sign (N 1 % 2) + + , P 1 ~ K.Sign (P 1 % 1) + , P 1 ~ K.Sign (P 1 % 2) + , P 1 ~ K.Sign (P 1 % 1) + , P 1 ~ K.Sign (P 1 % 2) + + , N 1 ~ K.Sign (N 1 % 1) + , N 1 ~ K.Sign (N 2 % 1) + , N 1 ~ K.Sign (N 1 % 1) + , N 1 ~ K.Sign (N 2 % 1) + + , P 1 ~ K.Sign (P 1 % 1) + , P 1 ~ K.Sign (P 2 % 1) + , P 1 ~ K.Sign (P 1 % 1) + , P 1 ~ K.Sign (P 2 % 1) + ) + +_testAbs = Dict +_testAbs :: Dict + ( P 0 % 1 ~ K.Abs (P 0 % 1) + , P 0 % 1 ~ K.Abs (P 0 % 2) + , P 0 % 1 ~ K.Abs (N 0 % 1) + , P 0 % 1 ~ K.Abs (N 0 % 2) + + , P 1 % 1 ~ K.Abs (N 1 % 1) + , P 1 % 2 ~ K.Abs (N 1 % 2) + , P 1 % 1 ~ K.Abs (N 1 % 1) + , P 1 % 2 ~ K.Abs (N 1 % 2) + + , P 1 % 1 ~ K.Abs (P 1 % 1) + , P 1 % 2 ~ K.Abs (P 1 % 2) + , P 1 % 1 ~ K.Abs (P 1 % 1) + , P 1 % 2 ~ K.Abs (P 1 % 2) + + , P 1 % 1 ~ K.Abs (N 1 % 1) + , P 2 % 1 ~ K.Abs (N 2 % 1) + , P 1 % 1 ~ K.Abs (N 1 % 1) + , P 2 % 1 ~ K.Abs (N 2 % 1) + + , P 1 % 1 ~ K.Abs (P 1 % 1) + , P 2 % 1 ~ K.Abs (P 2 % 1) + , P 1 % 1 ~ K.Abs (P 1 % 1) + , P 2 % 1 ~ K.Abs (P 2 % 1) + ) + + +_testEq = Dict +_testEq :: Dict + ( 1/2 K.== 1/2 + , (1/2 K.==? 1/2) ~ 'True + + , 1/2 K.== 2/4 + , (1/2 K.==? 2/4) ~ 'True + + , 1/2 K./= 3/4 + , (1/2 K.==? 3/4) ~ 'False + , (1/2 K./=? 3/4) ~ 'True + ) + +_testCmp = Dict +_testCmp :: Dict + ( 1/4 <= 1/4 + , 2/8 <= 1/4 + , 1/4 <= 1/2 + , 1/4 <= 2/4 + , 2/8 <= 1/2 + , 1/4 < 1/2 + , 1/4 < 2/4 + , 2/8 < 1/2 + , 2/8 < 2/4 + ) + +_testAdd = Dict +_testAdd :: Dict + ( (P 0 / 1) ~ (N 0 / 1) K.+ (N 0 / 1) + , (N 0 / 1) ~ (N 5 / 1) K.+ (P 5 / 1) + , (N 5 / 9) ~ (N 0 / 1) K.+ (N 5 / 9) + , (N 9 / 2) ~ (N 3 / 2) K.+ (N 3 / 1) + , (9 / 2) ~ (3 / 2) K.+ (3 / 1) + , (N 11 / 3)~ (N 3 / 1) K.+ (N 2 / 3) + ) + +_testMul = Dict +_testMul :: Dict + ( (0 / 1) ~ (N 0 / 1) K.* (N 0 / 1) + , (N 25 / 1) ~ (N 5 / 1) K.* (5 / 1) + , (N 1 / 1) ~ (N 5 / 1) K.* (1 / 5) + , (5 / 9) ~ (N 1 / 1) K.* (N 5 / 9) + , (9 / 1) ~ (N 3 / 1) K.* (N 3 / 1) + , (2 / 1) ~ (N 3 / 1) K.* (N 2 / 3) + , (1 / 1) ~ (P 3 / 2) K.* (P 2 / 3) + ) + +_testRecip = Dict +_testRecip :: Dict + ( (1 / 1) ~ K.Recip (1 / 1) + , (1 / 2) ~ K.Recip (2 / 1) + , (4 / 3) ~ K.Recip (3 / 4) + , (N 1 / 1) ~ K.Recip (N 1 / 1) + , (N 1 / 2) ~ K.Recip (N 2 / 1) + , (N 4 / 3) ~ K.Recip (N 3 / 4) + ) + +-- Most tests for these are in kind-integer. +_testDivMod = Dict +_testDivMod :: Dict + ( '(P 1, P 1) ~ K.DivMod 'K.RoundDown (3 / 2) + , '(P 2, N 1) ~ K.DivMod 'K.RoundUp (3 / 2) + , '(P 1, P 1) ~ K.DivMod 'K.RoundZero (3 / 2) + , '(P 2, N 1) ~ K.DivMod 'K.RoundAway (3 / 2) + , '(P 1, P 1) ~ K.DivMod 'K.RoundHalfDown (3 / 2) + , '(P 2, N 1) ~ K.DivMod 'K.RoundHalfUp (3 / 2) + , '(P 1, P 1) ~ K.DivMod 'K.RoundHalfZero (3 / 2) + , '(P 2, N 1) ~ K.DivMod 'K.RoundHalfAway (3 / 2) + , '(P 2, N 1) ~ K.DivMod 'K.RoundHalfEven (3 / 2) + , '(P 1, P 1) ~ K.DivMod 'K.RoundHalfOdd (3 / 2) + + , '(N 2, P 1) ~ K.DivMod 'K.RoundDown (N 3 / 2) + , '(N 1, N 1) ~ K.DivMod 'K.RoundUp (N 3 / 2) + , '(N 1, N 1) ~ K.DivMod 'K.RoundZero (N 3 / 2) + , '(N 2, P 1) ~ K.DivMod 'K.RoundAway (N 3 / 2) + , '(N 2, P 1) ~ K.DivMod 'K.RoundHalfDown (N 3 / 2) + , '(N 1, N 1) ~ K.DivMod 'K.RoundHalfUp (N 3 / 2) + , '(N 1, N 1) ~ K.DivMod 'K.RoundHalfZero (N 3 / 2) + , '(N 2, P 1) ~ K.DivMod 'K.RoundHalfAway (N 3 / 2) + , '(N 2, P 1) ~ K.DivMod 'K.RoundHalfEven (N 3 / 2) + , '(N 1, N 1) ~ K.DivMod 'K.RoundHalfOdd (N 3 / 2) + ) + +_testDiv = Dict +_testDiv :: Dict + ( P 1 ~ K.Div 'K.RoundDown (3 / 2) + , P 2 ~ K.Div 'K.RoundUp (3 / 2) + , P 1 ~ K.Div 'K.RoundZero (3 / 2) + , P 2 ~ K.Div 'K.RoundAway (3 / 2) + , P 1 ~ K.Div 'K.RoundHalfDown (3 / 2) + , P 2 ~ K.Div 'K.RoundHalfUp (3 / 2) + , P 1 ~ K.Div 'K.RoundHalfZero (3 / 2) + , P 2 ~ K.Div 'K.RoundHalfAway (3 / 2) + , P 2 ~ K.Div 'K.RoundHalfEven (3 / 2) + , P 1 ~ K.Div 'K.RoundHalfOdd (3 / 2) + + , N 2 ~ K.Div 'K.RoundDown (N 3 / 2) + , N 1 ~ K.Div 'K.RoundUp (N 3 / 2) + , N 1 ~ K.Div 'K.RoundZero (N 3 / 2) + , N 2 ~ K.Div 'K.RoundAway (N 3 / 2) + , N 2 ~ K.Div 'K.RoundHalfDown (N 3 / 2) + , N 1 ~ K.Div 'K.RoundHalfUp (N 3 / 2) + , N 1 ~ K.Div 'K.RoundHalfZero (N 3 / 2) + , N 2 ~ K.Div 'K.RoundHalfAway (N 3 / 2) + , N 2 ~ K.Div 'K.RoundHalfEven (N 3 / 2) + , N 1 ~ K.Div 'K.RoundHalfOdd (N 3 / 2) + + , P 0 ~ K.Div 'K.RoundDown (3 / 4) + , P 1 ~ K.Div 'K.RoundUp (3 / 4) + , P 0 ~ K.Div 'K.RoundZero (3 / 4) + , P 1 ~ K.Div 'K.RoundAway (3 / 4) + , P 1 ~ K.Div 'K.RoundHalfDown (3 / 4) + , P 1 ~ K.Div 'K.RoundHalfUp (3 / 4) + , P 1 ~ K.Div 'K.RoundHalfZero (3 / 4) + , P 1 ~ K.Div 'K.RoundHalfAway (3 / 4) + , P 1 ~ K.Div 'K.RoundHalfEven (3 / 4) + , P 1 ~ K.Div 'K.RoundHalfOdd (3 / 4) + + , N 1 ~ K.Div 'K.RoundDown (N 3 / 4) + , P 0 ~ K.Div 'K.RoundUp (N 3 / 4) + , P 0 ~ K.Div 'K.RoundZero (N 3 / 4) + , N 1 ~ K.Div 'K.RoundAway (N 3 / 4) + , N 1 ~ K.Div 'K.RoundHalfDown (N 3 / 4) + , N 1 ~ K.Div 'K.RoundHalfUp (N 3 / 4) + , N 1 ~ K.Div 'K.RoundHalfZero (N 3 / 4) + , N 1 ~ K.Div 'K.RoundHalfAway (N 3 / 4) + , N 1 ~ K.Div 'K.RoundHalfEven (N 3 / 4) + , N 1 ~ K.Div 'K.RoundHalfOdd (N 3 / 4) + ) + +_testMod = Dict +_testMod :: Dict + ( P 1 ~ K.Mod 'K.RoundDown (3 / 2) + , N 1 ~ K.Mod 'K.RoundUp (3 / 2) + , P 1 ~ K.Mod 'K.RoundZero (3 / 2) + , N 1 ~ K.Mod 'K.RoundAway (3 / 2) + , P 1 ~ K.Mod 'K.RoundHalfDown (3 / 2) + , N 1 ~ K.Mod 'K.RoundHalfUp (3 / 2) + , P 1 ~ K.Mod 'K.RoundHalfZero (3 / 2) + , N 1 ~ K.Mod 'K.RoundHalfAway (3 / 2) + , N 1 ~ K.Mod 'K.RoundHalfEven (3 / 2) + , P 1 ~ K.Mod 'K.RoundHalfOdd (3 / 2) + + , P 1 ~ K.Mod 'K.RoundDown (N 3 / 2) + , N 1 ~ K.Mod 'K.RoundUp (N 3 / 2) + , N 1 ~ K.Mod 'K.RoundZero (N 3 / 2) + , P 1 ~ K.Mod 'K.RoundAway (N 3 / 2) + , P 1 ~ K.Mod 'K.RoundHalfDown (N 3 / 2) + , N 1 ~ K.Mod 'K.RoundHalfUp (N 3 / 2) + , N 1 ~ K.Mod 'K.RoundHalfZero (N 3 / 2) + , P 1 ~ K.Mod 'K.RoundHalfAway (N 3 / 2) + , P 1 ~ K.Mod 'K.RoundHalfEven (N 3 / 2) + , N 1 ~ K.Mod 'K.RoundHalfOdd (N 3 / 2) + ) + +_testDif = Dict +_testDif :: Dict + ( P 1 / 2 ~ K.Dif 'K.RoundDown (3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundUp (3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundZero (3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundAway (3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundHalfDown (3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundHalfUp (3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundHalfZero (3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundHalfAway (3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundHalfEven (3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundHalfOdd (3 / 2) + + , P 1 / 2 ~ K.Dif 'K.RoundDown (N 3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundUp (N 3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundZero (N 3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundAway (N 3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundHalfDown (N 3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundHalfUp (N 3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundHalfZero (N 3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundHalfAway (N 3 / 2) + , P 1 / 2 ~ K.Dif 'K.RoundHalfEven (N 3 / 2) + , N 1 / 2 ~ K.Dif 'K.RoundHalfOdd (N 3 / 2) + + , P 3 / 4 ~ K.Dif 'K.RoundDown (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundUp (3 / 4) + , P 3 / 4 ~ K.Dif 'K.RoundZero (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundAway (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundHalfDown (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundHalfUp (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundHalfZero (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundHalfAway (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundHalfEven (3 / 4) + , N 1 / 4 ~ K.Dif 'K.RoundHalfOdd (3 / 4) + + , P 1 / 4 ~ K.Dif 'K.RoundDown (N 3 / 4) + , N 3 / 4 ~ K.Dif 'K.RoundUp (N 3 / 4) + , N 3 / 4 ~ K.Dif 'K.RoundZero (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundAway (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundHalfDown (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundHalfUp (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundHalfZero (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundHalfAway (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundHalfEven (N 3 / 4) + , P 1 / 4 ~ K.Dif 'K.RoundHalfOdd (N 3 / 4) + ) + +_testDivDif = Dict +_testDivDif :: Dict + ( '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundDown (3 / 2) + , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundUp (3 / 2) + , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundZero (3 / 2) + , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundAway (3 / 2) + , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundHalfDown (3 / 2) + , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundHalfUp (3 / 2) + , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundHalfZero (3 / 2) + , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundHalfAway (3 / 2) + , '(P 2, N 1 / 2) ~ K.DivDif 'K.RoundHalfEven (3 / 2) + , '(P 1, P 1 / 2) ~ K.DivDif 'K.RoundHalfOdd (3 / 2) + + , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundDown (N 3 / 2) + , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundUp (N 3 / 2) + , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundZero (N 3 / 2) + , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundAway (N 3 / 2) + , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundHalfDown (N 3 / 2) + , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundHalfUp (N 3 / 2) + , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundHalfZero (N 3 / 2) + , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundHalfAway (N 3 / 2) + , '(N 2, P 1 / 2) ~ K.DivDif 'K.RoundHalfEven (N 3 / 2) + , '(N 1, N 1 / 2) ~ K.DivDif 'K.RoundHalfOdd (N 3 / 2) + + , '(P 0, P 3 / 4) ~ K.DivDif 'K.RoundDown (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundUp (3 / 4) + , '(P 0, P 3 / 4) ~ K.DivDif 'K.RoundZero (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundAway (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfDown (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfUp (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfZero (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfAway (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfEven (3 / 4) + , '(P 1, N 1 / 4) ~ K.DivDif 'K.RoundHalfOdd (3 / 4) + + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundDown (N 3 / 4) + , '(P 0, N 3 / 4) ~ K.DivDif 'K.RoundUp (N 3 / 4) + , '(P 0, N 3 / 4) ~ K.DivDif 'K.RoundZero (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundAway (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfDown (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfUp (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfZero (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfAway (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfEven (N 3 / 4) + , '(N 1, P 1 / 4) ~ K.DivDif 'K.RoundHalfOdd (N 3 / 4) + ) + +_testTerminates = Dict +_testTerminates :: Dict + ( K.Terminating (0/1) + , K.Terminating (N 1/1) + , K.Terminating (2/1) + , K.Terminating (N 1/2) + , K.Terminating (1/4) + , K.Terminating (N 1/5) + , K.Terminating (1/10) + , K.Terminating (N 1/20) + , K.Terminating (1/50) + , K.Terminating (N 1/10000000) + + , K.Terminating (3/1) + , K.Terminating (N 3/1) + , K.Terminating (3/2) + , K.Terminating (N 3/3) + , K.Terminating (3/4) + , K.Terminating (N 3/5) + , K.Terminating (3/6) + , K.Terminating (N 3/10) + , K.Terminating (3/20) + , K.Terminating (N 3/50) + , K.Terminating (3/10000000) + + , 'True ~ K.Terminates (N 0/1) + , 'True ~ K.Terminates (1/1) + , 'True ~ K.Terminates (N 2/1) + , 'True ~ K.Terminates (1/2) + , 'True ~ K.Terminates (N 1/4) + , 'True ~ K.Terminates (1/5) + , 'True ~ K.Terminates (N 1/10) + , 'True ~ K.Terminates (1/20) + , 'True ~ K.Terminates (N 1/50) + , 'True ~ K.Terminates (1/10000000) + + , 'True ~ K.Terminates (N 3/1) + , 'True ~ K.Terminates (3/1) + , 'True ~ K.Terminates (N 3/2) + , 'True ~ K.Terminates (3/3) + , 'True ~ K.Terminates (N 3/4) + , 'True ~ K.Terminates (3/5) + , 'True ~ K.Terminates (N 3/6) + , 'True ~ K.Terminates (3/10) + , 'True ~ K.Terminates (N 3/20) + , 'True ~ K.Terminates (3/50) + , 'True ~ K.Terminates (N 3/10000000) + + , 'False ~ K.Terminates (1/3) + , 'False ~ K.Terminates (N 1/12) + , 'False ~ K.Terminates (1/15) + , 'False ~ K.Terminates (N 2/3) + , 'False ~ K.Terminates (75/7) + , 'False ~ K.Terminates (N 8/3) + ) + +-------------------------------------------------------------------------------- + +assert + :: String -- ^ Test name + -> Bool -- ^ Successful is true + -> IO Bool -- ^ Return the same 'Bool' given as input. +assert n x = do + putStrLn ((if x then "[OK] " else "[FAIL] ") <> n) + pure x + +testsMain :: [IO Bool] -> IO a +testsMain xs = do + res <- sequence xs + let (oks, bads) = List.partition id res + putStrLn ("[TOTAL] OK: " <> show (length oks) <> + ". FAIL: " <> show (length bads) <> ".") + case bads of + [] -> exitSuccess + _ -> exitFailure + +rats :: P.Integer -> [P.Rational] +rats i = do n <- [negate i .. i] + d <- [negate i .. i] + guard (d /= 0) + pure (n P.% d) + +main :: IO () +main = testsMain $ + [ assert "rationalVal . someRationalVal == id" $ + flip all (rats 4) $ \r -> + case K.someRationalVal r of + K.SomeRational pa -> + r == K.rationalVal pa + + , assert "sameRationalVal a a" $ + flip all (rats 4) $ \r -> + case K.someRationalVal r of + K.SomeRational pa -> + isJust (K.sameRational pa pa) + + , assert "sameRationalVal a a'" $ + flip all (rats 4) $ \a -> + case (K.someRationalVal a, K.someRationalVal a) of + (K.SomeRational pa1, K.SomeRational pa2) -> + isJust (K.sameRational pa1 pa2) + + , assert "sameRationalVal a b" $ + flip all (liftA2 (,) (rats 4) (rats 4)) $ \(a, b) -> + case (K.someRationalVal a, K.someRationalVal b) of + (K.SomeRational pa, K.SomeRational pb) + | a == b -> isJust (K.sameRational pa pb) + | otherwise -> isNothing (K.sameRational pa pb) + + , assert "Eq SomeRational" $ + flip all (liftA2 (,) (rats 4) (rats 4))$ \(a, b) -> + (a == b) == (K.someRationalVal a == K.someRationalVal b) + + , assert "Ord SomeRational" $ + flip all (liftA2 (,) (rats 4) (rats 4))$ \(a, b) -> + (a `compare` b) == (K.someRationalVal a `compare` K.someRationalVal b) + + , assert "Show SomeRational" $ + flip all (rats 4) $ \a -> + show a == show (K.someRationalVal a) + + , assert "Read SomeRational" $ + flip all (rats 4) $ \r -> + let str = show r + in readMaybe @P.Rational str + == fmap (\(K.SomeRational p) -> K.rationalVal p) + (readMaybe @K.SomeRational str) + + ] <> testsDivModDif <> testsTerminating + +testsDivModDif :: [IO Bool] +testsDivModDif = do + a@(n P.:% d) <- rats 4 + r :: K.Round <- [minBound .. maxBound] + let tname :: String -> ShowS + tname t = showString t . showChar ' ' . shows r . showChar ' ' + . shows n . showChar ' ' . shows d + [ assert (tname "divMod" "") $ case K.divMod r a of + (q, m) -> m == n - d * q + , assert (tname "divMod/div" "") $ fst (K.divMod r a) == K.div r a + , assert (tname "divMod/mod" "") $ snd (K.divMod r a) == K.mod r a + + , assert (tname "divDif" "") $ case K.divDif r a of + (q, x) -> a == toRational q + x + , assert (tname "divDif/div" "") $ fst (K.divDif r a) == K.div r a + , assert (tname "divDif/dif" "") $ snd (K.divDif r a) == K.dif r a + ] + +testsTerminating :: [IO Bool] +testsTerminating = concat + [ do a <- ok + pure $ assert ("withTerminating(ok) (" <> show a <> ")") $ + case K.someRationalVal a of + K.SomeRational (_ :: Proxy a) -> + isJust (K.withTerminating @a () :: Maybe ()) + + , do a <- no + pure $ assert ("withTerminating(no) (" <> show a <> ")") $ + case K.someRationalVal a of + K.SomeRational (_ :: Proxy a) -> + isNothing (K.withTerminating @a () :: Maybe ()) + ] + where + ok :: [P.Rational] + ok = [ 0 P.% 1 + , -1 P.% 1 + , 2 P.% 1 + , -1 P.% 2 + , 1 P.% 4 + , -1 P.% 5 + , 1 P.% 10 + , -1 P.% 20 + , 1 P.% 50 + , -1 P.% 10000000 + , 3 P.% 1 + , -3 P.% 1 + , 3 P.% 2 + , -3 P.% 3 + , 3 P.% 4 + , -3 P.% 5 + , 3 P.% 6 + , -3 P.% 10 + , 3 P.% 20 + , -3 P.% 50 + , 3 P.% 10000000 + ] + no :: [P.Rational] + no = [ 1 P.% 3 + , -1 P.% 12 + , 1 P.% 15 + , -2 P.% 3 + , 75 P.% 7 + , -8 P.% 3 + ] + + +_testSlash_Nat0_Nat1 = Dict @((P 0 % 1) ~ (0 / 1)) +_testSlash_Nat0_Nat2 = Dict @((P 0 % 1) ~ (0 / 2)) +_testSlash_Nat0_Nat3 = Dict @((P 0 % 1) ~ (0 / 3)) +_testSlash_Nat0_Nat4 = Dict @((P 0 % 1) ~ (0 / 4)) +_testSlash_Nat0_IntN4 = Dict @((P 0 % 1) ~ (0 / (N 4))) +_testSlash_Nat0_IntN3 = Dict @((P 0 % 1) ~ (0 / (N 3))) +_testSlash_Nat0_IntN2 = Dict @((P 0 % 1) ~ (0 / (N 2))) +_testSlash_Nat0_IntN1 = Dict @((P 0 % 1) ~ (0 / (N 1))) +_testSlash_Nat0_IntP1 = Dict @((P 0 % 1) ~ (0 / (P 1))) +_testSlash_Nat0_IntP2 = Dict @((P 0 % 1) ~ (0 / (P 2))) +_testSlash_Nat0_IntP3 = Dict @((P 0 % 1) ~ (0 / (P 3))) +_testSlash_Nat0_IntP4 = Dict @((P 0 % 1) ~ (0 / (P 4))) +_testSlash_Nat0_Rat4N1 = Dict @((P 0 % 1) ~ (0 / (N 4 % 1))) +_testSlash_Nat0_Rat3N1 = Dict @((P 0 % 1) ~ (0 / (N 3 % 1))) +_testSlash_Nat0_Rat2N1 = Dict @((P 0 % 1) ~ (0 / (N 2 % 1))) +_testSlash_Nat0_Rat3N2 = Dict @((P 0 % 1) ~ (0 / (N 3 % 2))) +_testSlash_Nat0_Rat4N3 = Dict @((P 0 % 1) ~ (0 / (N 4 % 3))) +_testSlash_Nat0_Rat1N1 = Dict @((P 0 % 1) ~ (0 / (N 1 % 1))) +_testSlash_Nat0_Rat3N4 = Dict @((P 0 % 1) ~ (0 / (N 3 % 4))) +_testSlash_Nat0_Rat2N3 = Dict @((P 0 % 1) ~ (0 / (N 2 % 3))) +_testSlash_Nat0_Rat1N2 = Dict @((P 0 % 1) ~ (0 / (N 1 % 2))) +_testSlash_Nat0_Rat1N3 = Dict @((P 0 % 1) ~ (0 / (N 1 % 3))) +_testSlash_Nat0_Rat1N4 = Dict @((P 0 % 1) ~ (0 / (N 1 % 4))) +_testSlash_Nat0_Rat1P4 = Dict @((P 0 % 1) ~ (0 / (P 1 % 4))) +_testSlash_Nat0_Rat1P3 = Dict @((P 0 % 1) ~ (0 / (P 1 % 3))) +_testSlash_Nat0_Rat1P2 = Dict @((P 0 % 1) ~ (0 / (P 1 % 2))) +_testSlash_Nat0_Rat2P3 = Dict @((P 0 % 1) ~ (0 / (P 2 % 3))) +_testSlash_Nat0_Rat3P4 = Dict @((P 0 % 1) ~ (0 / (P 3 % 4))) +_testSlash_Nat0_Rat1P1 = Dict @((P 0 % 1) ~ (0 / (P 1 % 1))) +_testSlash_Nat0_Rat4P3 = Dict @((P 0 % 1) ~ (0 / (P 4 % 3))) +_testSlash_Nat0_Rat3P2 = Dict @((P 0 % 1) ~ (0 / (P 3 % 2))) +_testSlash_Nat0_Rat2P1 = Dict @((P 0 % 1) ~ (0 / (P 2 % 1))) +_testSlash_Nat0_Rat3P1 = Dict @((P 0 % 1) ~ (0 / (P 3 % 1))) +_testSlash_Nat0_Rat4P1 = Dict @((P 0 % 1) ~ (0 / (P 4 % 1))) +_testSlash_Nat1_Nat1 = Dict @((P 1 % 1) ~ (1 / 1)) +_testSlash_Nat1_Nat2 = Dict @((P 1 % 2) ~ (1 / 2)) +_testSlash_Nat1_Nat3 = Dict @((P 1 % 3) ~ (1 / 3)) +_testSlash_Nat1_Nat4 = Dict @((P 1 % 4) ~ (1 / 4)) +_testSlash_Nat1_IntN4 = Dict @((N 1 % 4) ~ (1 / (N 4))) +_testSlash_Nat1_IntN3 = Dict @((N 1 % 3) ~ (1 / (N 3))) +_testSlash_Nat1_IntN2 = Dict @((N 1 % 2) ~ (1 / (N 2))) +_testSlash_Nat1_IntN1 = Dict @((N 1 % 1) ~ (1 / (N 1))) +_testSlash_Nat1_IntP1 = Dict @((P 1 % 1) ~ (1 / (P 1))) +_testSlash_Nat1_IntP2 = Dict @((P 1 % 2) ~ (1 / (P 2))) +_testSlash_Nat1_IntP3 = Dict @((P 1 % 3) ~ (1 / (P 3))) +_testSlash_Nat1_IntP4 = Dict @((P 1 % 4) ~ (1 / (P 4))) +_testSlash_Nat1_Rat4N1 = Dict @((N 1 % 4) ~ (1 / (N 4 % 1))) +_testSlash_Nat1_Rat3N1 = Dict @((N 1 % 3) ~ (1 / (N 3 % 1))) +_testSlash_Nat1_Rat2N1 = Dict @((N 1 % 2) ~ (1 / (N 2 % 1))) +_testSlash_Nat1_Rat3N2 = Dict @((N 2 % 3) ~ (1 / (N 3 % 2))) +_testSlash_Nat1_Rat4N3 = Dict @((N 3 % 4) ~ (1 / (N 4 % 3))) +_testSlash_Nat1_Rat1N1 = Dict @((N 1 % 1) ~ (1 / (N 1 % 1))) +_testSlash_Nat1_Rat3N4 = Dict @((N 4 % 3) ~ (1 / (N 3 % 4))) +_testSlash_Nat1_Rat2N3 = Dict @((N 3 % 2) ~ (1 / (N 2 % 3))) +_testSlash_Nat1_Rat1N2 = Dict @((N 2 % 1) ~ (1 / (N 1 % 2))) +_testSlash_Nat1_Rat1N3 = Dict @((N 3 % 1) ~ (1 / (N 1 % 3))) +_testSlash_Nat1_Rat1N4 = Dict @((N 4 % 1) ~ (1 / (N 1 % 4))) +_testSlash_Nat1_Rat1P4 = Dict @((P 4 % 1) ~ (1 / (P 1 % 4))) +_testSlash_Nat1_Rat1P3 = Dict @((P 3 % 1) ~ (1 / (P 1 % 3))) +_testSlash_Nat1_Rat1P2 = Dict @((P 2 % 1) ~ (1 / (P 1 % 2))) +_testSlash_Nat1_Rat2P3 = Dict @((P 3 % 2) ~ (1 / (P 2 % 3))) +_testSlash_Nat1_Rat3P4 = Dict @((P 4 % 3) ~ (1 / (P 3 % 4))) +_testSlash_Nat1_Rat1P1 = Dict @((P 1 % 1) ~ (1 / (P 1 % 1))) +_testSlash_Nat1_Rat4P3 = Dict @((P 3 % 4) ~ (1 / (P 4 % 3))) +_testSlash_Nat1_Rat3P2 = Dict @((P 2 % 3) ~ (1 / (P 3 % 2))) +_testSlash_Nat1_Rat2P1 = Dict @((P 1 % 2) ~ (1 / (P 2 % 1))) +_testSlash_Nat1_Rat3P1 = Dict @((P 1 % 3) ~ (1 / (P 3 % 1))) +_testSlash_Nat1_Rat4P1 = Dict @((P 1 % 4) ~ (1 / (P 4 % 1))) +_testSlash_Nat2_Nat1 = Dict @((P 2 % 1) ~ (2 / 1)) +_testSlash_Nat2_Nat2 = Dict @((P 1 % 1) ~ (2 / 2)) +_testSlash_Nat2_Nat3 = Dict @((P 2 % 3) ~ (2 / 3)) +_testSlash_Nat2_Nat4 = Dict @((P 1 % 2) ~ (2 / 4)) +_testSlash_Nat2_IntN4 = Dict @((N 1 % 2) ~ (2 / (N 4))) +_testSlash_Nat2_IntN3 = Dict @((N 2 % 3) ~ (2 / (N 3))) +_testSlash_Nat2_IntN2 = Dict @((N 1 % 1) ~ (2 / (N 2))) +_testSlash_Nat2_IntN1 = Dict @((N 2 % 1) ~ (2 / (N 1))) +_testSlash_Nat2_IntP1 = Dict @((P 2 % 1) ~ (2 / (P 1))) +_testSlash_Nat2_IntP2 = Dict @((P 1 % 1) ~ (2 / (P 2))) +_testSlash_Nat2_IntP3 = Dict @((P 2 % 3) ~ (2 / (P 3))) +_testSlash_Nat2_IntP4 = Dict @((P 1 % 2) ~ (2 / (P 4))) +_testSlash_Nat2_Rat4N1 = Dict @((N 1 % 2) ~ (2 / (N 4 % 1))) +_testSlash_Nat2_Rat3N1 = Dict @((N 2 % 3) ~ (2 / (N 3 % 1))) +_testSlash_Nat2_Rat2N1 = Dict @((N 1 % 1) ~ (2 / (N 2 % 1))) +_testSlash_Nat2_Rat3N2 = Dict @((N 4 % 3) ~ (2 / (N 3 % 2))) +_testSlash_Nat2_Rat4N3 = Dict @((N 3 % 2) ~ (2 / (N 4 % 3))) +_testSlash_Nat2_Rat1N1 = Dict @((N 2 % 1) ~ (2 / (N 1 % 1))) +_testSlash_Nat2_Rat3N4 = Dict @((N 8 % 3) ~ (2 / (N 3 % 4))) +_testSlash_Nat2_Rat2N3 = Dict @((N 3 % 1) ~ (2 / (N 2 % 3))) +_testSlash_Nat2_Rat1N2 = Dict @((N 4 % 1) ~ (2 / (N 1 % 2))) +_testSlash_Nat2_Rat1N3 = Dict @((N 6 % 1) ~ (2 / (N 1 % 3))) +_testSlash_Nat2_Rat1N4 = Dict @((N 8 % 1) ~ (2 / (N 1 % 4))) +_testSlash_Nat2_Rat1P4 = Dict @((P 8 % 1) ~ (2 / (P 1 % 4))) +_testSlash_Nat2_Rat1P3 = Dict @((P 6 % 1) ~ (2 / (P 1 % 3))) +_testSlash_Nat2_Rat1P2 = Dict @((P 4 % 1) ~ (2 / (P 1 % 2))) +_testSlash_Nat2_Rat2P3 = Dict @((P 3 % 1) ~ (2 / (P 2 % 3))) +_testSlash_Nat2_Rat3P4 = Dict @((P 8 % 3) ~ (2 / (P 3 % 4))) +_testSlash_Nat2_Rat1P1 = Dict @((P 2 % 1) ~ (2 / (P 1 % 1))) +_testSlash_Nat2_Rat4P3 = Dict @((P 3 % 2) ~ (2 / (P 4 % 3))) +_testSlash_Nat2_Rat3P2 = Dict @((P 4 % 3) ~ (2 / (P 3 % 2))) +_testSlash_Nat2_Rat2P1 = Dict @((P 1 % 1) ~ (2 / (P 2 % 1))) +_testSlash_Nat2_Rat3P1 = Dict @((P 2 % 3) ~ (2 / (P 3 % 1))) +_testSlash_Nat2_Rat4P1 = Dict @((P 1 % 2) ~ (2 / (P 4 % 1))) +_testSlash_Nat3_Nat1 = Dict @((P 3 % 1) ~ (3 / 1)) +_testSlash_Nat3_Nat2 = Dict @((P 3 % 2) ~ (3 / 2)) +_testSlash_Nat3_Nat3 = Dict @((P 1 % 1) ~ (3 / 3)) +_testSlash_Nat3_Nat4 = Dict @((P 3 % 4) ~ (3 / 4)) +_testSlash_Nat3_IntN4 = Dict @((N 3 % 4) ~ (3 / (N 4))) +_testSlash_Nat3_IntN3 = Dict @((N 1 % 1) ~ (3 / (N 3))) +_testSlash_Nat3_IntN2 = Dict @((N 3 % 2) ~ (3 / (N 2))) +_testSlash_Nat3_IntN1 = Dict @((N 3 % 1) ~ (3 / (N 1))) +_testSlash_Nat3_IntP1 = Dict @((P 3 % 1) ~ (3 / (P 1))) +_testSlash_Nat3_IntP2 = Dict @((P 3 % 2) ~ (3 / (P 2))) +_testSlash_Nat3_IntP3 = Dict @((P 1 % 1) ~ (3 / (P 3))) +_testSlash_Nat3_IntP4 = Dict @((P 3 % 4) ~ (3 / (P 4))) +_testSlash_Nat3_Rat4N1 = Dict @((N 3 % 4) ~ (3 / (N 4 % 1))) +_testSlash_Nat3_Rat3N1 = Dict @((N 1 % 1) ~ (3 / (N 3 % 1))) +_testSlash_Nat3_Rat2N1 = Dict @((N 3 % 2) ~ (3 / (N 2 % 1))) +_testSlash_Nat3_Rat3N2 = Dict @((N 2 % 1) ~ (3 / (N 3 % 2))) +_testSlash_Nat3_Rat4N3 = Dict @((N 9 % 4) ~ (3 / (N 4 % 3))) +_testSlash_Nat3_Rat1N1 = Dict @((N 3 % 1) ~ (3 / (N 1 % 1))) +_testSlash_Nat3_Rat3N4 = Dict @((N 4 % 1) ~ (3 / (N 3 % 4))) +_testSlash_Nat3_Rat2N3 = Dict @((N 9 % 2) ~ (3 / (N 2 % 3))) +_testSlash_Nat3_Rat1N2 = Dict @((N 6 % 1) ~ (3 / (N 1 % 2))) +_testSlash_Nat3_Rat1N3 = Dict @((N 9 % 1) ~ (3 / (N 1 % 3))) +_testSlash_Nat3_Rat1N4 = Dict @((N 12 % 1) ~ (3 / (N 1 % 4))) +_testSlash_Nat3_Rat1P4 = Dict @((P 12 % 1) ~ (3 / (P 1 % 4))) +_testSlash_Nat3_Rat1P3 = Dict @((P 9 % 1) ~ (3 / (P 1 % 3))) +_testSlash_Nat3_Rat1P2 = Dict @((P 6 % 1) ~ (3 / (P 1 % 2))) +_testSlash_Nat3_Rat2P3 = Dict @((P 9 % 2) ~ (3 / (P 2 % 3))) +_testSlash_Nat3_Rat3P4 = Dict @((P 4 % 1) ~ (3 / (P 3 % 4))) +_testSlash_Nat3_Rat1P1 = Dict @((P 3 % 1) ~ (3 / (P 1 % 1))) +_testSlash_Nat3_Rat4P3 = Dict @((P 9 % 4) ~ (3 / (P 4 % 3))) +_testSlash_Nat3_Rat3P2 = Dict @((P 2 % 1) ~ (3 / (P 3 % 2))) +_testSlash_Nat3_Rat2P1 = Dict @((P 3 % 2) ~ (3 / (P 2 % 1))) +_testSlash_Nat3_Rat3P1 = Dict @((P 1 % 1) ~ (3 / (P 3 % 1))) +_testSlash_Nat3_Rat4P1 = Dict @((P 3 % 4) ~ (3 / (P 4 % 1))) +_testSlash_Nat4_Nat1 = Dict @((P 4 % 1) ~ (4 / 1)) +_testSlash_Nat4_Nat2 = Dict @((P 2 % 1) ~ (4 / 2)) +_testSlash_Nat4_Nat3 = Dict @((P 4 % 3) ~ (4 / 3)) +_testSlash_Nat4_Nat4 = Dict @((P 1 % 1) ~ (4 / 4)) +_testSlash_Nat4_IntN4 = Dict @((N 1 % 1) ~ (4 / (N 4))) +_testSlash_Nat4_IntN3 = Dict @((N 4 % 3) ~ (4 / (N 3))) +_testSlash_Nat4_IntN2 = Dict @((N 2 % 1) ~ (4 / (N 2))) +_testSlash_Nat4_IntN1 = Dict @((N 4 % 1) ~ (4 / (N 1))) +_testSlash_Nat4_IntP1 = Dict @((P 4 % 1) ~ (4 / (P 1))) +_testSlash_Nat4_IntP2 = Dict @((P 2 % 1) ~ (4 / (P 2))) +_testSlash_Nat4_IntP3 = Dict @((P 4 % 3) ~ (4 / (P 3))) +_testSlash_Nat4_IntP4 = Dict @((P 1 % 1) ~ (4 / (P 4))) +_testSlash_Nat4_Rat4N1 = Dict @((N 1 % 1) ~ (4 / (N 4 % 1))) +_testSlash_Nat4_Rat3N1 = Dict @((N 4 % 3) ~ (4 / (N 3 % 1))) +_testSlash_Nat4_Rat2N1 = Dict @((N 2 % 1) ~ (4 / (N 2 % 1))) +_testSlash_Nat4_Rat3N2 = Dict @((N 8 % 3) ~ (4 / (N 3 % 2))) +_testSlash_Nat4_Rat4N3 = Dict @((N 3 % 1) ~ (4 / (N 4 % 3))) +_testSlash_Nat4_Rat1N1 = Dict @((N 4 % 1) ~ (4 / (N 1 % 1))) +_testSlash_Nat4_Rat3N4 = Dict @((N 16 % 3) ~ (4 / (N 3 % 4))) +_testSlash_Nat4_Rat2N3 = Dict @((N 6 % 1) ~ (4 / (N 2 % 3))) +_testSlash_Nat4_Rat1N2 = Dict @((N 8 % 1) ~ (4 / (N 1 % 2))) +_testSlash_Nat4_Rat1N3 = Dict @((N 12 % 1) ~ (4 / (N 1 % 3))) +_testSlash_Nat4_Rat1N4 = Dict @((N 16 % 1) ~ (4 / (N 1 % 4))) +_testSlash_Nat4_Rat1P4 = Dict @((P 16 % 1) ~ (4 / (P 1 % 4))) +_testSlash_Nat4_Rat1P3 = Dict @((P 12 % 1) ~ (4 / (P 1 % 3))) +_testSlash_Nat4_Rat1P2 = Dict @((P 8 % 1) ~ (4 / (P 1 % 2))) +_testSlash_Nat4_Rat2P3 = Dict @((P 6 % 1) ~ (4 / (P 2 % 3))) +_testSlash_Nat4_Rat3P4 = Dict @((P 16 % 3) ~ (4 / (P 3 % 4))) +_testSlash_Nat4_Rat1P1 = Dict @((P 4 % 1) ~ (4 / (P 1 % 1))) +_testSlash_Nat4_Rat4P3 = Dict @((P 3 % 1) ~ (4 / (P 4 % 3))) +_testSlash_Nat4_Rat3P2 = Dict @((P 8 % 3) ~ (4 / (P 3 % 2))) +_testSlash_Nat4_Rat2P1 = Dict @((P 2 % 1) ~ (4 / (P 2 % 1))) +_testSlash_Nat4_Rat3P1 = Dict @((P 4 % 3) ~ (4 / (P 3 % 1))) +_testSlash_Nat4_Rat4P1 = Dict @((P 1 % 1) ~ (4 / (P 4 % 1))) +_testSlash_IntN4_Nat1 = Dict @((N 4 % 1) ~ ((N 4) / 1)) +_testSlash_IntN4_Nat2 = Dict @((N 2 % 1) ~ ((N 4) / 2)) +_testSlash_IntN4_Nat3 = Dict @((N 4 % 3) ~ ((N 4) / 3)) +_testSlash_IntN4_Nat4 = Dict @((N 1 % 1) ~ ((N 4) / 4)) +_testSlash_IntN4_IntN4 = Dict @((P 1 % 1) ~ ((N 4) / (N 4))) +_testSlash_IntN4_IntN3 = Dict @((P 4 % 3) ~ ((N 4) / (N 3))) +_testSlash_IntN4_IntN2 = Dict @((P 2 % 1) ~ ((N 4) / (N 2))) +_testSlash_IntN4_IntN1 = Dict @((P 4 % 1) ~ ((N 4) / (N 1))) +_testSlash_IntN4_IntP1 = Dict @((N 4 % 1) ~ ((N 4) / (P 1))) +_testSlash_IntN4_IntP2 = Dict @((N 2 % 1) ~ ((N 4) / (P 2))) +_testSlash_IntN4_IntP3 = Dict @((N 4 % 3) ~ ((N 4) / (P 3))) +_testSlash_IntN4_IntP4 = Dict @((N 1 % 1) ~ ((N 4) / (P 4))) +_testSlash_IntN4_Rat4N1 = Dict @((P 1 % 1) ~ ((N 4) / (N 4 % 1))) +_testSlash_IntN4_Rat3N1 = Dict @((P 4 % 3) ~ ((N 4) / (N 3 % 1))) +_testSlash_IntN4_Rat2N1 = Dict @((P 2 % 1) ~ ((N 4) / (N 2 % 1))) +_testSlash_IntN4_Rat3N2 = Dict @((P 8 % 3) ~ ((N 4) / (N 3 % 2))) +_testSlash_IntN4_Rat4N3 = Dict @((P 3 % 1) ~ ((N 4) / (N 4 % 3))) +_testSlash_IntN4_Rat1N1 = Dict @((P 4 % 1) ~ ((N 4) / (N 1 % 1))) +_testSlash_IntN4_Rat3N4 = Dict @((P 16 % 3) ~ ((N 4) / (N 3 % 4))) +_testSlash_IntN4_Rat2N3 = Dict @((P 6 % 1) ~ ((N 4) / (N 2 % 3))) +_testSlash_IntN4_Rat1N2 = Dict @((P 8 % 1) ~ ((N 4) / (N 1 % 2))) +_testSlash_IntN4_Rat1N3 = Dict @((P 12 % 1) ~ ((N 4) / (N 1 % 3))) +_testSlash_IntN4_Rat1N4 = Dict @((P 16 % 1) ~ ((N 4) / (N 1 % 4))) +_testSlash_IntN4_Rat1P4 = Dict @((N 16 % 1) ~ ((N 4) / (P 1 % 4))) +_testSlash_IntN4_Rat1P3 = Dict @((N 12 % 1) ~ ((N 4) / (P 1 % 3))) +_testSlash_IntN4_Rat1P2 = Dict @((N 8 % 1) ~ ((N 4) / (P 1 % 2))) +_testSlash_IntN4_Rat2P3 = Dict @((N 6 % 1) ~ ((N 4) / (P 2 % 3))) +_testSlash_IntN4_Rat3P4 = Dict @((N 16 % 3) ~ ((N 4) / (P 3 % 4))) +_testSlash_IntN4_Rat1P1 = Dict @((N 4 % 1) ~ ((N 4) / (P 1 % 1))) +_testSlash_IntN4_Rat4P3 = Dict @((N 3 % 1) ~ ((N 4) / (P 4 % 3))) +_testSlash_IntN4_Rat3P2 = Dict @((N 8 % 3) ~ ((N 4) / (P 3 % 2))) +_testSlash_IntN4_Rat2P1 = Dict @((N 2 % 1) ~ ((N 4) / (P 2 % 1))) +_testSlash_IntN4_Rat3P1 = Dict @((N 4 % 3) ~ ((N 4) / (P 3 % 1))) +_testSlash_IntN4_Rat4P1 = Dict @((N 1 % 1) ~ ((N 4) / (P 4 % 1))) +_testSlash_IntN3_Nat1 = Dict @((N 3 % 1) ~ ((N 3) / 1)) +_testSlash_IntN3_Nat2 = Dict @((N 3 % 2) ~ ((N 3) / 2)) +_testSlash_IntN3_Nat3 = Dict @((N 1 % 1) ~ ((N 3) / 3)) +_testSlash_IntN3_Nat4 = Dict @((N 3 % 4) ~ ((N 3) / 4)) +_testSlash_IntN3_IntN4 = Dict @((P 3 % 4) ~ ((N 3) / (N 4))) +_testSlash_IntN3_IntN3 = Dict @((P 1 % 1) ~ ((N 3) / (N 3))) +_testSlash_IntN3_IntN2 = Dict @((P 3 % 2) ~ ((N 3) / (N 2))) +_testSlash_IntN3_IntN1 = Dict @((P 3 % 1) ~ ((N 3) / (N 1))) +_testSlash_IntN3_IntP1 = Dict @((N 3 % 1) ~ ((N 3) / (P 1))) +_testSlash_IntN3_IntP2 = Dict @((N 3 % 2) ~ ((N 3) / (P 2))) +_testSlash_IntN3_IntP3 = Dict @((N 1 % 1) ~ ((N 3) / (P 3))) +_testSlash_IntN3_IntP4 = Dict @((N 3 % 4) ~ ((N 3) / (P 4))) +_testSlash_IntN3_Rat4N1 = Dict @((P 3 % 4) ~ ((N 3) / (N 4 % 1))) +_testSlash_IntN3_Rat3N1 = Dict @((P 1 % 1) ~ ((N 3) / (N 3 % 1))) +_testSlash_IntN3_Rat2N1 = Dict @((P 3 % 2) ~ ((N 3) / (N 2 % 1))) +_testSlash_IntN3_Rat3N2 = Dict @((P 2 % 1) ~ ((N 3) / (N 3 % 2))) +_testSlash_IntN3_Rat4N3 = Dict @((P 9 % 4) ~ ((N 3) / (N 4 % 3))) +_testSlash_IntN3_Rat1N1 = Dict @((P 3 % 1) ~ ((N 3) / (N 1 % 1))) +_testSlash_IntN3_Rat3N4 = Dict @((P 4 % 1) ~ ((N 3) / (N 3 % 4))) +_testSlash_IntN3_Rat2N3 = Dict @((P 9 % 2) ~ ((N 3) / (N 2 % 3))) +_testSlash_IntN3_Rat1N2 = Dict @((P 6 % 1) ~ ((N 3) / (N 1 % 2))) +_testSlash_IntN3_Rat1N3 = Dict @((P 9 % 1) ~ ((N 3) / (N 1 % 3))) +_testSlash_IntN3_Rat1N4 = Dict @((P 12 % 1) ~ ((N 3) / (N 1 % 4))) +_testSlash_IntN3_Rat1P4 = Dict @((N 12 % 1) ~ ((N 3) / (P 1 % 4))) +_testSlash_IntN3_Rat1P3 = Dict @((N 9 % 1) ~ ((N 3) / (P 1 % 3))) +_testSlash_IntN3_Rat1P2 = Dict @((N 6 % 1) ~ ((N 3) / (P 1 % 2))) +_testSlash_IntN3_Rat2P3 = Dict @((N 9 % 2) ~ ((N 3) / (P 2 % 3))) +_testSlash_IntN3_Rat3P4 = Dict @((N 4 % 1) ~ ((N 3) / (P 3 % 4))) +_testSlash_IntN3_Rat1P1 = Dict @((N 3 % 1) ~ ((N 3) / (P 1 % 1))) +_testSlash_IntN3_Rat4P3 = Dict @((N 9 % 4) ~ ((N 3) / (P 4 % 3))) +_testSlash_IntN3_Rat3P2 = Dict @((N 2 % 1) ~ ((N 3) / (P 3 % 2))) +_testSlash_IntN3_Rat2P1 = Dict @((N 3 % 2) ~ ((N 3) / (P 2 % 1))) +_testSlash_IntN3_Rat3P1 = Dict @((N 1 % 1) ~ ((N 3) / (P 3 % 1))) +_testSlash_IntN3_Rat4P1 = Dict @((N 3 % 4) ~ ((N 3) / (P 4 % 1))) +_testSlash_IntN2_Nat1 = Dict @((N 2 % 1) ~ ((N 2) / 1)) +_testSlash_IntN2_Nat2 = Dict @((N 1 % 1) ~ ((N 2) / 2)) +_testSlash_IntN2_Nat3 = Dict @((N 2 % 3) ~ ((N 2) / 3)) +_testSlash_IntN2_Nat4 = Dict @((N 1 % 2) ~ ((N 2) / 4)) +_testSlash_IntN2_IntN4 = Dict @((P 1 % 2) ~ ((N 2) / (N 4))) +_testSlash_IntN2_IntN3 = Dict @((P 2 % 3) ~ ((N 2) / (N 3))) +_testSlash_IntN2_IntN2 = Dict @((P 1 % 1) ~ ((N 2) / (N 2))) +_testSlash_IntN2_IntN1 = Dict @((P 2 % 1) ~ ((N 2) / (N 1))) +_testSlash_IntN2_IntP1 = Dict @((N 2 % 1) ~ ((N 2) / (P 1))) +_testSlash_IntN2_IntP2 = Dict @((N 1 % 1) ~ ((N 2) / (P 2))) +_testSlash_IntN2_IntP3 = Dict @((N 2 % 3) ~ ((N 2) / (P 3))) +_testSlash_IntN2_IntP4 = Dict @((N 1 % 2) ~ ((N 2) / (P 4))) +_testSlash_IntN2_Rat4N1 = Dict @((P 1 % 2) ~ ((N 2) / (N 4 % 1))) +_testSlash_IntN2_Rat3N1 = Dict @((P 2 % 3) ~ ((N 2) / (N 3 % 1))) +_testSlash_IntN2_Rat2N1 = Dict @((P 1 % 1) ~ ((N 2) / (N 2 % 1))) +_testSlash_IntN2_Rat3N2 = Dict @((P 4 % 3) ~ ((N 2) / (N 3 % 2))) +_testSlash_IntN2_Rat4N3 = Dict @((P 3 % 2) ~ ((N 2) / (N 4 % 3))) +_testSlash_IntN2_Rat1N1 = Dict @((P 2 % 1) ~ ((N 2) / (N 1 % 1))) +_testSlash_IntN2_Rat3N4 = Dict @((P 8 % 3) ~ ((N 2) / (N 3 % 4))) +_testSlash_IntN2_Rat2N3 = Dict @((P 3 % 1) ~ ((N 2) / (N 2 % 3))) +_testSlash_IntN2_Rat1N2 = Dict @((P 4 % 1) ~ ((N 2) / (N 1 % 2))) +_testSlash_IntN2_Rat1N3 = Dict @((P 6 % 1) ~ ((N 2) / (N 1 % 3))) +_testSlash_IntN2_Rat1N4 = Dict @((P 8 % 1) ~ ((N 2) / (N 1 % 4))) +_testSlash_IntN2_Rat1P4 = Dict @((N 8 % 1) ~ ((N 2) / (P 1 % 4))) +_testSlash_IntN2_Rat1P3 = Dict @((N 6 % 1) ~ ((N 2) / (P 1 % 3))) +_testSlash_IntN2_Rat1P2 = Dict @((N 4 % 1) ~ ((N 2) / (P 1 % 2))) +_testSlash_IntN2_Rat2P3 = Dict @((N 3 % 1) ~ ((N 2) / (P 2 % 3))) +_testSlash_IntN2_Rat3P4 = Dict @((N 8 % 3) ~ ((N 2) / (P 3 % 4))) +_testSlash_IntN2_Rat1P1 = Dict @((N 2 % 1) ~ ((N 2) / (P 1 % 1))) +_testSlash_IntN2_Rat4P3 = Dict @((N 3 % 2) ~ ((N 2) / (P 4 % 3))) +_testSlash_IntN2_Rat3P2 = Dict @((N 4 % 3) ~ ((N 2) / (P 3 % 2))) +_testSlash_IntN2_Rat2P1 = Dict @((N 1 % 1) ~ ((N 2) / (P 2 % 1))) +_testSlash_IntN2_Rat3P1 = Dict @((N 2 % 3) ~ ((N 2) / (P 3 % 1))) +_testSlash_IntN2_Rat4P1 = Dict @((N 1 % 2) ~ ((N 2) / (P 4 % 1))) +_testSlash_IntN1_Nat1 = Dict @((N 1 % 1) ~ ((N 1) / 1)) +_testSlash_IntN1_Nat2 = Dict @((N 1 % 2) ~ ((N 1) / 2)) +_testSlash_IntN1_Nat3 = Dict @((N 1 % 3) ~ ((N 1) / 3)) +_testSlash_IntN1_Nat4 = Dict @((N 1 % 4) ~ ((N 1) / 4)) +_testSlash_IntN1_IntN4 = Dict @((P 1 % 4) ~ ((N 1) / (N 4))) +_testSlash_IntN1_IntN3 = Dict @((P 1 % 3) ~ ((N 1) / (N 3))) +_testSlash_IntN1_IntN2 = Dict @((P 1 % 2) ~ ((N 1) / (N 2))) +_testSlash_IntN1_IntN1 = Dict @((P 1 % 1) ~ ((N 1) / (N 1))) +_testSlash_IntN1_IntP1 = Dict @((N 1 % 1) ~ ((N 1) / (P 1))) +_testSlash_IntN1_IntP2 = Dict @((N 1 % 2) ~ ((N 1) / (P 2))) +_testSlash_IntN1_IntP3 = Dict @((N 1 % 3) ~ ((N 1) / (P 3))) +_testSlash_IntN1_IntP4 = Dict @((N 1 % 4) ~ ((N 1) / (P 4))) +_testSlash_IntN1_Rat4N1 = Dict @((P 1 % 4) ~ ((N 1) / (N 4 % 1))) +_testSlash_IntN1_Rat3N1 = Dict @((P 1 % 3) ~ ((N 1) / (N 3 % 1))) +_testSlash_IntN1_Rat2N1 = Dict @((P 1 % 2) ~ ((N 1) / (N 2 % 1))) +_testSlash_IntN1_Rat3N2 = Dict @((P 2 % 3) ~ ((N 1) / (N 3 % 2))) +_testSlash_IntN1_Rat4N3 = Dict @((P 3 % 4) ~ ((N 1) / (N 4 % 3))) +_testSlash_IntN1_Rat1N1 = Dict @((P 1 % 1) ~ ((N 1) / (N 1 % 1))) +_testSlash_IntN1_Rat3N4 = Dict @((P 4 % 3) ~ ((N 1) / (N 3 % 4))) +_testSlash_IntN1_Rat2N3 = Dict @((P 3 % 2) ~ ((N 1) / (N 2 % 3))) +_testSlash_IntN1_Rat1N2 = Dict @((P 2 % 1) ~ ((N 1) / (N 1 % 2))) +_testSlash_IntN1_Rat1N3 = Dict @((P 3 % 1) ~ ((N 1) / (N 1 % 3))) +_testSlash_IntN1_Rat1N4 = Dict @((P 4 % 1) ~ ((N 1) / (N 1 % 4))) +_testSlash_IntN1_Rat1P4 = Dict @((N 4 % 1) ~ ((N 1) / (P 1 % 4))) +_testSlash_IntN1_Rat1P3 = Dict @((N 3 % 1) ~ ((N 1) / (P 1 % 3))) +_testSlash_IntN1_Rat1P2 = Dict @((N 2 % 1) ~ ((N 1) / (P 1 % 2))) +_testSlash_IntN1_Rat2P3 = Dict @((N 3 % 2) ~ ((N 1) / (P 2 % 3))) +_testSlash_IntN1_Rat3P4 = Dict @((N 4 % 3) ~ ((N 1) / (P 3 % 4))) +_testSlash_IntN1_Rat1P1 = Dict @((N 1 % 1) ~ ((N 1) / (P 1 % 1))) +_testSlash_IntN1_Rat4P3 = Dict @((N 3 % 4) ~ ((N 1) / (P 4 % 3))) +_testSlash_IntN1_Rat3P2 = Dict @((N 2 % 3) ~ ((N 1) / (P 3 % 2))) +_testSlash_IntN1_Rat2P1 = Dict @((N 1 % 2) ~ ((N 1) / (P 2 % 1))) +_testSlash_IntN1_Rat3P1 = Dict @((N 1 % 3) ~ ((N 1) / (P 3 % 1))) +_testSlash_IntN1_Rat4P1 = Dict @((N 1 % 4) ~ ((N 1) / (P 4 % 1))) +_testSlash_IntP0_Nat1 = Dict @((P 0 % 1) ~ ((P 0) / 1)) +_testSlash_IntP0_Nat2 = Dict @((P 0 % 1) ~ ((P 0) / 2)) +_testSlash_IntP0_Nat3 = Dict @((P 0 % 1) ~ ((P 0) / 3)) +_testSlash_IntP0_Nat4 = Dict @((P 0 % 1) ~ ((P 0) / 4)) +_testSlash_IntP0_IntN4 = Dict @((P 0 % 1) ~ ((P 0) / (N 4))) +_testSlash_IntP0_IntN3 = Dict @((P 0 % 1) ~ ((P 0) / (N 3))) +_testSlash_IntP0_IntN2 = Dict @((P 0 % 1) ~ ((P 0) / (N 2))) +_testSlash_IntP0_IntN1 = Dict @((P 0 % 1) ~ ((P 0) / (N 1))) +_testSlash_IntP0_IntP1 = Dict @((P 0 % 1) ~ ((P 0) / (P 1))) +_testSlash_IntP0_IntP2 = Dict @((P 0 % 1) ~ ((P 0) / (P 2))) +_testSlash_IntP0_IntP3 = Dict @((P 0 % 1) ~ ((P 0) / (P 3))) +_testSlash_IntP0_IntP4 = Dict @((P 0 % 1) ~ ((P 0) / (P 4))) +_testSlash_IntP0_Rat4N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 4 % 1))) +_testSlash_IntP0_Rat3N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 3 % 1))) +_testSlash_IntP0_Rat2N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 2 % 1))) +_testSlash_IntP0_Rat3N2 = Dict @((P 0 % 1) ~ ((P 0) / (N 3 % 2))) +_testSlash_IntP0_Rat4N3 = Dict @((P 0 % 1) ~ ((P 0) / (N 4 % 3))) +_testSlash_IntP0_Rat1N1 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 1))) +_testSlash_IntP0_Rat3N4 = Dict @((P 0 % 1) ~ ((P 0) / (N 3 % 4))) +_testSlash_IntP0_Rat2N3 = Dict @((P 0 % 1) ~ ((P 0) / (N 2 % 3))) +_testSlash_IntP0_Rat1N2 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 2))) +_testSlash_IntP0_Rat1N3 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 3))) +_testSlash_IntP0_Rat1N4 = Dict @((P 0 % 1) ~ ((P 0) / (N 1 % 4))) +_testSlash_IntP0_Rat1P4 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 4))) +_testSlash_IntP0_Rat1P3 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 3))) +_testSlash_IntP0_Rat1P2 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 2))) +_testSlash_IntP0_Rat2P3 = Dict @((P 0 % 1) ~ ((P 0) / (P 2 % 3))) +_testSlash_IntP0_Rat3P4 = Dict @((P 0 % 1) ~ ((P 0) / (P 3 % 4))) +_testSlash_IntP0_Rat1P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 1 % 1))) +_testSlash_IntP0_Rat4P3 = Dict @((P 0 % 1) ~ ((P 0) / (P 4 % 3))) +_testSlash_IntP0_Rat3P2 = Dict @((P 0 % 1) ~ ((P 0) / (P 3 % 2))) +_testSlash_IntP0_Rat2P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 2 % 1))) +_testSlash_IntP0_Rat3P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 3 % 1))) +_testSlash_IntP0_Rat4P1 = Dict @((P 0 % 1) ~ ((P 0) / (P 4 % 1))) +_testSlash_IntP1_Nat1 = Dict @((P 1 % 1) ~ ((P 1) / 1)) +_testSlash_IntP1_Nat2 = Dict @((P 1 % 2) ~ ((P 1) / 2)) +_testSlash_IntP1_Nat3 = Dict @((P 1 % 3) ~ ((P 1) / 3)) +_testSlash_IntP1_Nat4 = Dict @((P 1 % 4) ~ ((P 1) / 4)) +_testSlash_IntP1_IntN4 = Dict @((N 1 % 4) ~ ((P 1) / (N 4))) +_testSlash_IntP1_IntN3 = Dict @((N 1 % 3) ~ ((P 1) / (N 3))) +_testSlash_IntP1_IntN2 = Dict @((N 1 % 2) ~ ((P 1) / (N 2))) +_testSlash_IntP1_IntN1 = Dict @((N 1 % 1) ~ ((P 1) / (N 1))) +_testSlash_IntP1_IntP1 = Dict @((P 1 % 1) ~ ((P 1) / (P 1))) +_testSlash_IntP1_IntP2 = Dict @((P 1 % 2) ~ ((P 1) / (P 2))) +_testSlash_IntP1_IntP3 = Dict @((P 1 % 3) ~ ((P 1) / (P 3))) +_testSlash_IntP1_IntP4 = Dict @((P 1 % 4) ~ ((P 1) / (P 4))) +_testSlash_IntP1_Rat4N1 = Dict @((N 1 % 4) ~ ((P 1) / (N 4 % 1))) +_testSlash_IntP1_Rat3N1 = Dict @((N 1 % 3) ~ ((P 1) / (N 3 % 1))) +_testSlash_IntP1_Rat2N1 = Dict @((N 1 % 2) ~ ((P 1) / (N 2 % 1))) +_testSlash_IntP1_Rat3N2 = Dict @((N 2 % 3) ~ ((P 1) / (N 3 % 2))) +_testSlash_IntP1_Rat4N3 = Dict @((N 3 % 4) ~ ((P 1) / (N 4 % 3))) +_testSlash_IntP1_Rat1N1 = Dict @((N 1 % 1) ~ ((P 1) / (N 1 % 1))) +_testSlash_IntP1_Rat3N4 = Dict @((N 4 % 3) ~ ((P 1) / (N 3 % 4))) +_testSlash_IntP1_Rat2N3 = Dict @((N 3 % 2) ~ ((P 1) / (N 2 % 3))) +_testSlash_IntP1_Rat1N2 = Dict @((N 2 % 1) ~ ((P 1) / (N 1 % 2))) +_testSlash_IntP1_Rat1N3 = Dict @((N 3 % 1) ~ ((P 1) / (N 1 % 3))) +_testSlash_IntP1_Rat1N4 = Dict @((N 4 % 1) ~ ((P 1) / (N 1 % 4))) +_testSlash_IntP1_Rat1P4 = Dict @((P 4 % 1) ~ ((P 1) / (P 1 % 4))) +_testSlash_IntP1_Rat1P3 = Dict @((P 3 % 1) ~ ((P 1) / (P 1 % 3))) +_testSlash_IntP1_Rat1P2 = Dict @((P 2 % 1) ~ ((P 1) / (P 1 % 2))) +_testSlash_IntP1_Rat2P3 = Dict @((P 3 % 2) ~ ((P 1) / (P 2 % 3))) +_testSlash_IntP1_Rat3P4 = Dict @((P 4 % 3) ~ ((P 1) / (P 3 % 4))) +_testSlash_IntP1_Rat1P1 = Dict @((P 1 % 1) ~ ((P 1) / (P 1 % 1))) +_testSlash_IntP1_Rat4P3 = Dict @((P 3 % 4) ~ ((P 1) / (P 4 % 3))) +_testSlash_IntP1_Rat3P2 = Dict @((P 2 % 3) ~ ((P 1) / (P 3 % 2))) +_testSlash_IntP1_Rat2P1 = Dict @((P 1 % 2) ~ ((P 1) / (P 2 % 1))) +_testSlash_IntP1_Rat3P1 = Dict @((P 1 % 3) ~ ((P 1) / (P 3 % 1))) +_testSlash_IntP1_Rat4P1 = Dict @((P 1 % 4) ~ ((P 1) / (P 4 % 1))) +_testSlash_IntP2_Nat1 = Dict @((P 2 % 1) ~ ((P 2) / 1)) +_testSlash_IntP2_Nat2 = Dict @((P 1 % 1) ~ ((P 2) / 2)) +_testSlash_IntP2_Nat3 = Dict @((P 2 % 3) ~ ((P 2) / 3)) +_testSlash_IntP2_Nat4 = Dict @((P 1 % 2) ~ ((P 2) / 4)) +_testSlash_IntP2_IntN4 = Dict @((N 1 % 2) ~ ((P 2) / (N 4))) +_testSlash_IntP2_IntN3 = Dict @((N 2 % 3) ~ ((P 2) / (N 3))) +_testSlash_IntP2_IntN2 = Dict @((N 1 % 1) ~ ((P 2) / (N 2))) +_testSlash_IntP2_IntN1 = Dict @((N 2 % 1) ~ ((P 2) / (N 1))) +_testSlash_IntP2_IntP1 = Dict @((P 2 % 1) ~ ((P 2) / (P 1))) +_testSlash_IntP2_IntP2 = Dict @((P 1 % 1) ~ ((P 2) / (P 2))) +_testSlash_IntP2_IntP3 = Dict @((P 2 % 3) ~ ((P 2) / (P 3))) +_testSlash_IntP2_IntP4 = Dict @((P 1 % 2) ~ ((P 2) / (P 4))) +_testSlash_IntP2_Rat4N1 = Dict @((N 1 % 2) ~ ((P 2) / (N 4 % 1))) +_testSlash_IntP2_Rat3N1 = Dict @((N 2 % 3) ~ ((P 2) / (N 3 % 1))) +_testSlash_IntP2_Rat2N1 = Dict @((N 1 % 1) ~ ((P 2) / (N 2 % 1))) +_testSlash_IntP2_Rat3N2 = Dict @((N 4 % 3) ~ ((P 2) / (N 3 % 2))) +_testSlash_IntP2_Rat4N3 = Dict @((N 3 % 2) ~ ((P 2) / (N 4 % 3))) +_testSlash_IntP2_Rat1N1 = Dict @((N 2 % 1) ~ ((P 2) / (N 1 % 1))) +_testSlash_IntP2_Rat3N4 = Dict @((N 8 % 3) ~ ((P 2) / (N 3 % 4))) +_testSlash_IntP2_Rat2N3 = Dict @((N 3 % 1) ~ ((P 2) / (N 2 % 3))) +_testSlash_IntP2_Rat1N2 = Dict @((N 4 % 1) ~ ((P 2) / (N 1 % 2))) +_testSlash_IntP2_Rat1N3 = Dict @((N 6 % 1) ~ ((P 2) / (N 1 % 3))) +_testSlash_IntP2_Rat1N4 = Dict @((N 8 % 1) ~ ((P 2) / (N 1 % 4))) +_testSlash_IntP2_Rat1P4 = Dict @((P 8 % 1) ~ ((P 2) / (P 1 % 4))) +_testSlash_IntP2_Rat1P3 = Dict @((P 6 % 1) ~ ((P 2) / (P 1 % 3))) +_testSlash_IntP2_Rat1P2 = Dict @((P 4 % 1) ~ ((P 2) / (P 1 % 2))) +_testSlash_IntP2_Rat2P3 = Dict @((P 3 % 1) ~ ((P 2) / (P 2 % 3))) +_testSlash_IntP2_Rat3P4 = Dict @((P 8 % 3) ~ ((P 2) / (P 3 % 4))) +_testSlash_IntP2_Rat1P1 = Dict @((P 2 % 1) ~ ((P 2) / (P 1 % 1))) +_testSlash_IntP2_Rat4P3 = Dict @((P 3 % 2) ~ ((P 2) / (P 4 % 3))) +_testSlash_IntP2_Rat3P2 = Dict @((P 4 % 3) ~ ((P 2) / (P 3 % 2))) +_testSlash_IntP2_Rat2P1 = Dict @((P 1 % 1) ~ ((P 2) / (P 2 % 1))) +_testSlash_IntP2_Rat3P1 = Dict @((P 2 % 3) ~ ((P 2) / (P 3 % 1))) +_testSlash_IntP2_Rat4P1 = Dict @((P 1 % 2) ~ ((P 2) / (P 4 % 1))) +_testSlash_IntP3_Nat1 = Dict @((P 3 % 1) ~ ((P 3) / 1)) +_testSlash_IntP3_Nat2 = Dict @((P 3 % 2) ~ ((P 3) / 2)) +_testSlash_IntP3_Nat3 = Dict @((P 1 % 1) ~ ((P 3) / 3)) +_testSlash_IntP3_Nat4 = Dict @((P 3 % 4) ~ ((P 3) / 4)) +_testSlash_IntP3_IntN4 = Dict @((N 3 % 4) ~ ((P 3) / (N 4))) +_testSlash_IntP3_IntN3 = Dict @((N 1 % 1) ~ ((P 3) / (N 3))) +_testSlash_IntP3_IntN2 = Dict @((N 3 % 2) ~ ((P 3) / (N 2))) +_testSlash_IntP3_IntN1 = Dict @((N 3 % 1) ~ ((P 3) / (N 1))) +_testSlash_IntP3_IntP1 = Dict @((P 3 % 1) ~ ((P 3) / (P 1))) +_testSlash_IntP3_IntP2 = Dict @((P 3 % 2) ~ ((P 3) / (P 2))) +_testSlash_IntP3_IntP3 = Dict @((P 1 % 1) ~ ((P 3) / (P 3))) +_testSlash_IntP3_IntP4 = Dict @((P 3 % 4) ~ ((P 3) / (P 4))) +_testSlash_IntP3_Rat4N1 = Dict @((N 3 % 4) ~ ((P 3) / (N 4 % 1))) +_testSlash_IntP3_Rat3N1 = Dict @((N 1 % 1) ~ ((P 3) / (N 3 % 1))) +_testSlash_IntP3_Rat2N1 = Dict @((N 3 % 2) ~ ((P 3) / (N 2 % 1))) +_testSlash_IntP3_Rat3N2 = Dict @((N 2 % 1) ~ ((P 3) / (N 3 % 2))) +_testSlash_IntP3_Rat4N3 = Dict @((N 9 % 4) ~ ((P 3) / (N 4 % 3))) +_testSlash_IntP3_Rat1N1 = Dict @((N 3 % 1) ~ ((P 3) / (N 1 % 1))) +_testSlash_IntP3_Rat3N4 = Dict @((N 4 % 1) ~ ((P 3) / (N 3 % 4))) +_testSlash_IntP3_Rat2N3 = Dict @((N 9 % 2) ~ ((P 3) / (N 2 % 3))) +_testSlash_IntP3_Rat1N2 = Dict @((N 6 % 1) ~ ((P 3) / (N 1 % 2))) +_testSlash_IntP3_Rat1N3 = Dict @((N 9 % 1) ~ ((P 3) / (N 1 % 3))) +_testSlash_IntP3_Rat1N4 = Dict @((N 12 % 1) ~ ((P 3) / (N 1 % 4))) +_testSlash_IntP3_Rat1P4 = Dict @((P 12 % 1) ~ ((P 3) / (P 1 % 4))) +_testSlash_IntP3_Rat1P3 = Dict @((P 9 % 1) ~ ((P 3) / (P 1 % 3))) +_testSlash_IntP3_Rat1P2 = Dict @((P 6 % 1) ~ ((P 3) / (P 1 % 2))) +_testSlash_IntP3_Rat2P3 = Dict @((P 9 % 2) ~ ((P 3) / (P 2 % 3))) +_testSlash_IntP3_Rat3P4 = Dict @((P 4 % 1) ~ ((P 3) / (P 3 % 4))) +_testSlash_IntP3_Rat1P1 = Dict @((P 3 % 1) ~ ((P 3) / (P 1 % 1))) +_testSlash_IntP3_Rat4P3 = Dict @((P 9 % 4) ~ ((P 3) / (P 4 % 3))) +_testSlash_IntP3_Rat3P2 = Dict @((P 2 % 1) ~ ((P 3) / (P 3 % 2))) +_testSlash_IntP3_Rat2P1 = Dict @((P 3 % 2) ~ ((P 3) / (P 2 % 1))) +_testSlash_IntP3_Rat3P1 = Dict @((P 1 % 1) ~ ((P 3) / (P 3 % 1))) +_testSlash_IntP3_Rat4P1 = Dict @((P 3 % 4) ~ ((P 3) / (P 4 % 1))) +_testSlash_IntP4_Nat1 = Dict @((P 4 % 1) ~ ((P 4) / 1)) +_testSlash_IntP4_Nat2 = Dict @((P 2 % 1) ~ ((P 4) / 2)) +_testSlash_IntP4_Nat3 = Dict @((P 4 % 3) ~ ((P 4) / 3)) +_testSlash_IntP4_Nat4 = Dict @((P 1 % 1) ~ ((P 4) / 4)) +_testSlash_IntP4_IntN4 = Dict @((N 1 % 1) ~ ((P 4) / (N 4))) +_testSlash_IntP4_IntN3 = Dict @((N 4 % 3) ~ ((P 4) / (N 3))) +_testSlash_IntP4_IntN2 = Dict @((N 2 % 1) ~ ((P 4) / (N 2))) +_testSlash_IntP4_IntN1 = Dict @((N 4 % 1) ~ ((P 4) / (N 1))) +_testSlash_IntP4_IntP1 = Dict @((P 4 % 1) ~ ((P 4) / (P 1))) +_testSlash_IntP4_IntP2 = Dict @((P 2 % 1) ~ ((P 4) / (P 2))) +_testSlash_IntP4_IntP3 = Dict @((P 4 % 3) ~ ((P 4) / (P 3))) +_testSlash_IntP4_IntP4 = Dict @((P 1 % 1) ~ ((P 4) / (P 4))) +_testSlash_IntP4_Rat4N1 = Dict @((N 1 % 1) ~ ((P 4) / (N 4 % 1))) +_testSlash_IntP4_Rat3N1 = Dict @((N 4 % 3) ~ ((P 4) / (N 3 % 1))) +_testSlash_IntP4_Rat2N1 = Dict @((N 2 % 1) ~ ((P 4) / (N 2 % 1))) +_testSlash_IntP4_Rat3N2 = Dict @((N 8 % 3) ~ ((P 4) / (N 3 % 2))) +_testSlash_IntP4_Rat4N3 = Dict @((N 3 % 1) ~ ((P 4) / (N 4 % 3))) +_testSlash_IntP4_Rat1N1 = Dict @((N 4 % 1) ~ ((P 4) / (N 1 % 1))) +_testSlash_IntP4_Rat3N4 = Dict @((N 16 % 3) ~ ((P 4) / (N 3 % 4))) +_testSlash_IntP4_Rat2N3 = Dict @((N 6 % 1) ~ ((P 4) / (N 2 % 3))) +_testSlash_IntP4_Rat1N2 = Dict @((N 8 % 1) ~ ((P 4) / (N 1 % 2))) +_testSlash_IntP4_Rat1N3 = Dict @((N 12 % 1) ~ ((P 4) / (N 1 % 3))) +_testSlash_IntP4_Rat1N4 = Dict @((N 16 % 1) ~ ((P 4) / (N 1 % 4))) +_testSlash_IntP4_Rat1P4 = Dict @((P 16 % 1) ~ ((P 4) / (P 1 % 4))) +_testSlash_IntP4_Rat1P3 = Dict @((P 12 % 1) ~ ((P 4) / (P 1 % 3))) +_testSlash_IntP4_Rat1P2 = Dict @((P 8 % 1) ~ ((P 4) / (P 1 % 2))) +_testSlash_IntP4_Rat2P3 = Dict @((P 6 % 1) ~ ((P 4) / (P 2 % 3))) +_testSlash_IntP4_Rat3P4 = Dict @((P 16 % 3) ~ ((P 4) / (P 3 % 4))) +_testSlash_IntP4_Rat1P1 = Dict @((P 4 % 1) ~ ((P 4) / (P 1 % 1))) +_testSlash_IntP4_Rat4P3 = Dict @((P 3 % 1) ~ ((P 4) / (P 4 % 3))) +_testSlash_IntP4_Rat3P2 = Dict @((P 8 % 3) ~ ((P 4) / (P 3 % 2))) +_testSlash_IntP4_Rat2P1 = Dict @((P 2 % 1) ~ ((P 4) / (P 2 % 1))) +_testSlash_IntP4_Rat3P1 = Dict @((P 4 % 3) ~ ((P 4) / (P 3 % 1))) +_testSlash_IntP4_Rat4P1 = Dict @((P 1 % 1) ~ ((P 4) / (P 4 % 1))) +_testSlash_Rat4N1_Nat1 = Dict @((N 4 % 1) ~ ((N 4 % 1) / 1)) +_testSlash_Rat4N1_Nat2 = Dict @((N 2 % 1) ~ ((N 4 % 1) / 2)) +_testSlash_Rat4N1_Nat3 = Dict @((N 4 % 3) ~ ((N 4 % 1) / 3)) +_testSlash_Rat4N1_Nat4 = Dict @((N 1 % 1) ~ ((N 4 % 1) / 4)) +_testSlash_Rat4N1_IntN4 = Dict @((P 1 % 1) ~ ((N 4 % 1) / (N 4))) +_testSlash_Rat4N1_IntN3 = Dict @((P 4 % 3) ~ ((N 4 % 1) / (N 3))) +_testSlash_Rat4N1_IntN2 = Dict @((P 2 % 1) ~ ((N 4 % 1) / (N 2))) +_testSlash_Rat4N1_IntN1 = Dict @((P 4 % 1) ~ ((N 4 % 1) / (N 1))) +_testSlash_Rat4N1_IntP1 = Dict @((N 4 % 1) ~ ((N 4 % 1) / (P 1))) +_testSlash_Rat4N1_IntP2 = Dict @((N 2 % 1) ~ ((N 4 % 1) / (P 2))) +_testSlash_Rat4N1_IntP3 = Dict @((N 4 % 3) ~ ((N 4 % 1) / (P 3))) +_testSlash_Rat4N1_IntP4 = Dict @((N 1 % 1) ~ ((N 4 % 1) / (P 4))) +_testSlash_Rat4N1_Rat4N1 = Dict @((P 1 % 1) ~ ((N 4 % 1) / (N 4 % 1))) +_testSlash_Rat4N1_Rat3N1 = Dict @((P 4 % 3) ~ ((N 4 % 1) / (N 3 % 1))) +_testSlash_Rat4N1_Rat2N1 = Dict @((P 2 % 1) ~ ((N 4 % 1) / (N 2 % 1))) +_testSlash_Rat4N1_Rat3N2 = Dict @((P 8 % 3) ~ ((N 4 % 1) / (N 3 % 2))) +_testSlash_Rat4N1_Rat4N3 = Dict @((P 3 % 1) ~ ((N 4 % 1) / (N 4 % 3))) +_testSlash_Rat4N1_Rat1N1 = Dict @((P 4 % 1) ~ ((N 4 % 1) / (N 1 % 1))) +_testSlash_Rat4N1_Rat3N4 = Dict @((P 16 % 3) ~ ((N 4 % 1) / (N 3 % 4))) +_testSlash_Rat4N1_Rat2N3 = Dict @((P 6 % 1) ~ ((N 4 % 1) / (N 2 % 3))) +_testSlash_Rat4N1_Rat1N2 = Dict @((P 8 % 1) ~ ((N 4 % 1) / (N 1 % 2))) +_testSlash_Rat4N1_Rat1N3 = Dict @((P 12 % 1) ~ ((N 4 % 1) / (N 1 % 3))) +_testSlash_Rat4N1_Rat1N4 = Dict @((P 16 % 1) ~ ((N 4 % 1) / (N 1 % 4))) +_testSlash_Rat4N1_Rat1P4 = Dict @((N 16 % 1) ~ ((N 4 % 1) / (P 1 % 4))) +_testSlash_Rat4N1_Rat1P3 = Dict @((N 12 % 1) ~ ((N 4 % 1) / (P 1 % 3))) +_testSlash_Rat4N1_Rat1P2 = Dict @((N 8 % 1) ~ ((N 4 % 1) / (P 1 % 2))) +_testSlash_Rat4N1_Rat2P3 = Dict @((N 6 % 1) ~ ((N 4 % 1) / (P 2 % 3))) +_testSlash_Rat4N1_Rat3P4 = Dict @((N 16 % 3) ~ ((N 4 % 1) / (P 3 % 4))) +_testSlash_Rat4N1_Rat1P1 = Dict @((N 4 % 1) ~ ((N 4 % 1) / (P 1 % 1))) +_testSlash_Rat4N1_Rat4P3 = Dict @((N 3 % 1) ~ ((N 4 % 1) / (P 4 % 3))) +_testSlash_Rat4N1_Rat3P2 = Dict @((N 8 % 3) ~ ((N 4 % 1) / (P 3 % 2))) +_testSlash_Rat4N1_Rat2P1 = Dict @((N 2 % 1) ~ ((N 4 % 1) / (P 2 % 1))) +_testSlash_Rat4N1_Rat3P1 = Dict @((N 4 % 3) ~ ((N 4 % 1) / (P 3 % 1))) +_testSlash_Rat4N1_Rat4P1 = Dict @((N 1 % 1) ~ ((N 4 % 1) / (P 4 % 1))) +_testSlash_Rat3N1_Nat1 = Dict @((N 3 % 1) ~ ((N 3 % 1) / 1)) +_testSlash_Rat3N1_Nat2 = Dict @((N 3 % 2) ~ ((N 3 % 1) / 2)) +_testSlash_Rat3N1_Nat3 = Dict @((N 1 % 1) ~ ((N 3 % 1) / 3)) +_testSlash_Rat3N1_Nat4 = Dict @((N 3 % 4) ~ ((N 3 % 1) / 4)) +_testSlash_Rat3N1_IntN4 = Dict @((P 3 % 4) ~ ((N 3 % 1) / (N 4))) +_testSlash_Rat3N1_IntN3 = Dict @((P 1 % 1) ~ ((N 3 % 1) / (N 3))) +_testSlash_Rat3N1_IntN2 = Dict @((P 3 % 2) ~ ((N 3 % 1) / (N 2))) +_testSlash_Rat3N1_IntN1 = Dict @((P 3 % 1) ~ ((N 3 % 1) / (N 1))) +_testSlash_Rat3N1_IntP1 = Dict @((N 3 % 1) ~ ((N 3 % 1) / (P 1))) +_testSlash_Rat3N1_IntP2 = Dict @((N 3 % 2) ~ ((N 3 % 1) / (P 2))) +_testSlash_Rat3N1_IntP3 = Dict @((N 1 % 1) ~ ((N 3 % 1) / (P 3))) +_testSlash_Rat3N1_IntP4 = Dict @((N 3 % 4) ~ ((N 3 % 1) / (P 4))) +_testSlash_Rat3N1_Rat4N1 = Dict @((P 3 % 4) ~ ((N 3 % 1) / (N 4 % 1))) +_testSlash_Rat3N1_Rat3N1 = Dict @((P 1 % 1) ~ ((N 3 % 1) / (N 3 % 1))) +_testSlash_Rat3N1_Rat2N1 = Dict @((P 3 % 2) ~ ((N 3 % 1) / (N 2 % 1))) +_testSlash_Rat3N1_Rat3N2 = Dict @((P 2 % 1) ~ ((N 3 % 1) / (N 3 % 2))) +_testSlash_Rat3N1_Rat4N3 = Dict @((P 9 % 4) ~ ((N 3 % 1) / (N 4 % 3))) +_testSlash_Rat3N1_Rat1N1 = Dict @((P 3 % 1) ~ ((N 3 % 1) / (N 1 % 1))) +_testSlash_Rat3N1_Rat3N4 = Dict @((P 4 % 1) ~ ((N 3 % 1) / (N 3 % 4))) +_testSlash_Rat3N1_Rat2N3 = Dict @((P 9 % 2) ~ ((N 3 % 1) / (N 2 % 3))) +_testSlash_Rat3N1_Rat1N2 = Dict @((P 6 % 1) ~ ((N 3 % 1) / (N 1 % 2))) +_testSlash_Rat3N1_Rat1N3 = Dict @((P 9 % 1) ~ ((N 3 % 1) / (N 1 % 3))) +_testSlash_Rat3N1_Rat1N4 = Dict @((P 12 % 1) ~ ((N 3 % 1) / (N 1 % 4))) +_testSlash_Rat3N1_Rat1P4 = Dict @((N 12 % 1) ~ ((N 3 % 1) / (P 1 % 4))) +_testSlash_Rat3N1_Rat1P3 = Dict @((N 9 % 1) ~ ((N 3 % 1) / (P 1 % 3))) +_testSlash_Rat3N1_Rat1P2 = Dict @((N 6 % 1) ~ ((N 3 % 1) / (P 1 % 2))) +_testSlash_Rat3N1_Rat2P3 = Dict @((N 9 % 2) ~ ((N 3 % 1) / (P 2 % 3))) +_testSlash_Rat3N1_Rat3P4 = Dict @((N 4 % 1) ~ ((N 3 % 1) / (P 3 % 4))) +_testSlash_Rat3N1_Rat1P1 = Dict @((N 3 % 1) ~ ((N 3 % 1) / (P 1 % 1))) +_testSlash_Rat3N1_Rat4P3 = Dict @((N 9 % 4) ~ ((N 3 % 1) / (P 4 % 3))) +_testSlash_Rat3N1_Rat3P2 = Dict @((N 2 % 1) ~ ((N 3 % 1) / (P 3 % 2))) +_testSlash_Rat3N1_Rat2P1 = Dict @((N 3 % 2) ~ ((N 3 % 1) / (P 2 % 1))) +_testSlash_Rat3N1_Rat3P1 = Dict @((N 1 % 1) ~ ((N 3 % 1) / (P 3 % 1))) +_testSlash_Rat3N1_Rat4P1 = Dict @((N 3 % 4) ~ ((N 3 % 1) / (P 4 % 1))) +_testSlash_Rat2N1_Nat1 = Dict @((N 2 % 1) ~ ((N 2 % 1) / 1)) +_testSlash_Rat2N1_Nat2 = Dict @((N 1 % 1) ~ ((N 2 % 1) / 2)) +_testSlash_Rat2N1_Nat3 = Dict @((N 2 % 3) ~ ((N 2 % 1) / 3)) +_testSlash_Rat2N1_Nat4 = Dict @((N 1 % 2) ~ ((N 2 % 1) / 4)) +_testSlash_Rat2N1_IntN4 = Dict @((P 1 % 2) ~ ((N 2 % 1) / (N 4))) +_testSlash_Rat2N1_IntN3 = Dict @((P 2 % 3) ~ ((N 2 % 1) / (N 3))) +_testSlash_Rat2N1_IntN2 = Dict @((P 1 % 1) ~ ((N 2 % 1) / (N 2))) +_testSlash_Rat2N1_IntN1 = Dict @((P 2 % 1) ~ ((N 2 % 1) / (N 1))) +_testSlash_Rat2N1_IntP1 = Dict @((N 2 % 1) ~ ((N 2 % 1) / (P 1))) +_testSlash_Rat2N1_IntP2 = Dict @((N 1 % 1) ~ ((N 2 % 1) / (P 2))) +_testSlash_Rat2N1_IntP3 = Dict @((N 2 % 3) ~ ((N 2 % 1) / (P 3))) +_testSlash_Rat2N1_IntP4 = Dict @((N 1 % 2) ~ ((N 2 % 1) / (P 4))) +_testSlash_Rat2N1_Rat4N1 = Dict @((P 1 % 2) ~ ((N 2 % 1) / (N 4 % 1))) +_testSlash_Rat2N1_Rat3N1 = Dict @((P 2 % 3) ~ ((N 2 % 1) / (N 3 % 1))) +_testSlash_Rat2N1_Rat2N1 = Dict @((P 1 % 1) ~ ((N 2 % 1) / (N 2 % 1))) +_testSlash_Rat2N1_Rat3N2 = Dict @((P 4 % 3) ~ ((N 2 % 1) / (N 3 % 2))) +_testSlash_Rat2N1_Rat4N3 = Dict @((P 3 % 2) ~ ((N 2 % 1) / (N 4 % 3))) +_testSlash_Rat2N1_Rat1N1 = Dict @((P 2 % 1) ~ ((N 2 % 1) / (N 1 % 1))) +_testSlash_Rat2N1_Rat3N4 = Dict @((P 8 % 3) ~ ((N 2 % 1) / (N 3 % 4))) +_testSlash_Rat2N1_Rat2N3 = Dict @((P 3 % 1) ~ ((N 2 % 1) / (N 2 % 3))) +_testSlash_Rat2N1_Rat1N2 = Dict @((P 4 % 1) ~ ((N 2 % 1) / (N 1 % 2))) +_testSlash_Rat2N1_Rat1N3 = Dict @((P 6 % 1) ~ ((N 2 % 1) / (N 1 % 3))) +_testSlash_Rat2N1_Rat1N4 = Dict @((P 8 % 1) ~ ((N 2 % 1) / (N 1 % 4))) +_testSlash_Rat2N1_Rat1P4 = Dict @((N 8 % 1) ~ ((N 2 % 1) / (P 1 % 4))) +_testSlash_Rat2N1_Rat1P3 = Dict @((N 6 % 1) ~ ((N 2 % 1) / (P 1 % 3))) +_testSlash_Rat2N1_Rat1P2 = Dict @((N 4 % 1) ~ ((N 2 % 1) / (P 1 % 2))) +_testSlash_Rat2N1_Rat2P3 = Dict @((N 3 % 1) ~ ((N 2 % 1) / (P 2 % 3))) +_testSlash_Rat2N1_Rat3P4 = Dict @((N 8 % 3) ~ ((N 2 % 1) / (P 3 % 4))) +_testSlash_Rat2N1_Rat1P1 = Dict @((N 2 % 1) ~ ((N 2 % 1) / (P 1 % 1))) +_testSlash_Rat2N1_Rat4P3 = Dict @((N 3 % 2) ~ ((N 2 % 1) / (P 4 % 3))) +_testSlash_Rat2N1_Rat3P2 = Dict @((N 4 % 3) ~ ((N 2 % 1) / (P 3 % 2))) +_testSlash_Rat2N1_Rat2P1 = Dict @((N 1 % 1) ~ ((N 2 % 1) / (P 2 % 1))) +_testSlash_Rat2N1_Rat3P1 = Dict @((N 2 % 3) ~ ((N 2 % 1) / (P 3 % 1))) +_testSlash_Rat2N1_Rat4P1 = Dict @((N 1 % 2) ~ ((N 2 % 1) / (P 4 % 1))) +_testSlash_Rat3N2_Nat1 = Dict @((N 3 % 2) ~ ((N 3 % 2) / 1)) +_testSlash_Rat3N2_Nat2 = Dict @((N 3 % 4) ~ ((N 3 % 2) / 2)) +_testSlash_Rat3N2_Nat3 = Dict @((N 1 % 2) ~ ((N 3 % 2) / 3)) +_testSlash_Rat3N2_Nat4 = Dict @((N 3 % 8) ~ ((N 3 % 2) / 4)) +_testSlash_Rat3N2_IntN4 = Dict @((P 3 % 8) ~ ((N 3 % 2) / (N 4))) +_testSlash_Rat3N2_IntN3 = Dict @((P 1 % 2) ~ ((N 3 % 2) / (N 3))) +_testSlash_Rat3N2_IntN2 = Dict @((P 3 % 4) ~ ((N 3 % 2) / (N 2))) +_testSlash_Rat3N2_IntN1 = Dict @((P 3 % 2) ~ ((N 3 % 2) / (N 1))) +_testSlash_Rat3N2_IntP1 = Dict @((N 3 % 2) ~ ((N 3 % 2) / (P 1))) +_testSlash_Rat3N2_IntP2 = Dict @((N 3 % 4) ~ ((N 3 % 2) / (P 2))) +_testSlash_Rat3N2_IntP3 = Dict @((N 1 % 2) ~ ((N 3 % 2) / (P 3))) +_testSlash_Rat3N2_IntP4 = Dict @((N 3 % 8) ~ ((N 3 % 2) / (P 4))) +_testSlash_Rat3N2_Rat4N1 = Dict @((P 3 % 8) ~ ((N 3 % 2) / (N 4 % 1))) +_testSlash_Rat3N2_Rat3N1 = Dict @((P 1 % 2) ~ ((N 3 % 2) / (N 3 % 1))) +_testSlash_Rat3N2_Rat2N1 = Dict @((P 3 % 4) ~ ((N 3 % 2) / (N 2 % 1))) +_testSlash_Rat3N2_Rat3N2 = Dict @((P 1 % 1) ~ ((N 3 % 2) / (N 3 % 2))) +_testSlash_Rat3N2_Rat4N3 = Dict @((P 9 % 8) ~ ((N 3 % 2) / (N 4 % 3))) +_testSlash_Rat3N2_Rat1N1 = Dict @((P 3 % 2) ~ ((N 3 % 2) / (N 1 % 1))) +_testSlash_Rat3N2_Rat3N4 = Dict @((P 2 % 1) ~ ((N 3 % 2) / (N 3 % 4))) +_testSlash_Rat3N2_Rat2N3 = Dict @((P 9 % 4) ~ ((N 3 % 2) / (N 2 % 3))) +_testSlash_Rat3N2_Rat1N2 = Dict @((P 3 % 1) ~ ((N 3 % 2) / (N 1 % 2))) +_testSlash_Rat3N2_Rat1N3 = Dict @((P 9 % 2) ~ ((N 3 % 2) / (N 1 % 3))) +_testSlash_Rat3N2_Rat1N4 = Dict @((P 6 % 1) ~ ((N 3 % 2) / (N 1 % 4))) +_testSlash_Rat3N2_Rat1P4 = Dict @((N 6 % 1) ~ ((N 3 % 2) / (P 1 % 4))) +_testSlash_Rat3N2_Rat1P3 = Dict @((N 9 % 2) ~ ((N 3 % 2) / (P 1 % 3))) +_testSlash_Rat3N2_Rat1P2 = Dict @((N 3 % 1) ~ ((N 3 % 2) / (P 1 % 2))) +_testSlash_Rat3N2_Rat2P3 = Dict @((N 9 % 4) ~ ((N 3 % 2) / (P 2 % 3))) +_testSlash_Rat3N2_Rat3P4 = Dict @((N 2 % 1) ~ ((N 3 % 2) / (P 3 % 4))) +_testSlash_Rat3N2_Rat1P1 = Dict @((N 3 % 2) ~ ((N 3 % 2) / (P 1 % 1))) +_testSlash_Rat3N2_Rat4P3 = Dict @((N 9 % 8) ~ ((N 3 % 2) / (P 4 % 3))) +_testSlash_Rat3N2_Rat3P2 = Dict @((N 1 % 1) ~ ((N 3 % 2) / (P 3 % 2))) +_testSlash_Rat3N2_Rat2P1 = Dict @((N 3 % 4) ~ ((N 3 % 2) / (P 2 % 1))) +_testSlash_Rat3N2_Rat3P1 = Dict @((N 1 % 2) ~ ((N 3 % 2) / (P 3 % 1))) +_testSlash_Rat3N2_Rat4P1 = Dict @((N 3 % 8) ~ ((N 3 % 2) / (P 4 % 1))) +_testSlash_Rat4N3_Nat1 = Dict @((N 4 % 3) ~ ((N 4 % 3) / 1)) +_testSlash_Rat4N3_Nat2 = Dict @((N 2 % 3) ~ ((N 4 % 3) / 2)) +_testSlash_Rat4N3_Nat3 = Dict @((N 4 % 9) ~ ((N 4 % 3) / 3)) +_testSlash_Rat4N3_Nat4 = Dict @((N 1 % 3) ~ ((N 4 % 3) / 4)) +_testSlash_Rat4N3_IntN4 = Dict @((P 1 % 3) ~ ((N 4 % 3) / (N 4))) +_testSlash_Rat4N3_IntN3 = Dict @((P 4 % 9) ~ ((N 4 % 3) / (N 3))) +_testSlash_Rat4N3_IntN2 = Dict @((P 2 % 3) ~ ((N 4 % 3) / (N 2))) +_testSlash_Rat4N3_IntN1 = Dict @((P 4 % 3) ~ ((N 4 % 3) / (N 1))) +_testSlash_Rat4N3_IntP1 = Dict @((N 4 % 3) ~ ((N 4 % 3) / (P 1))) +_testSlash_Rat4N3_IntP2 = Dict @((N 2 % 3) ~ ((N 4 % 3) / (P 2))) +_testSlash_Rat4N3_IntP3 = Dict @((N 4 % 9) ~ ((N 4 % 3) / (P 3))) +_testSlash_Rat4N3_IntP4 = Dict @((N 1 % 3) ~ ((N 4 % 3) / (P 4))) +_testSlash_Rat4N3_Rat4N1 = Dict @((P 1 % 3) ~ ((N 4 % 3) / (N 4 % 1))) +_testSlash_Rat4N3_Rat3N1 = Dict @((P 4 % 9) ~ ((N 4 % 3) / (N 3 % 1))) +_testSlash_Rat4N3_Rat2N1 = Dict @((P 2 % 3) ~ ((N 4 % 3) / (N 2 % 1))) +_testSlash_Rat4N3_Rat3N2 = Dict @((P 8 % 9) ~ ((N 4 % 3) / (N 3 % 2))) +_testSlash_Rat4N3_Rat4N3 = Dict @((P 1 % 1) ~ ((N 4 % 3) / (N 4 % 3))) +_testSlash_Rat4N3_Rat1N1 = Dict @((P 4 % 3) ~ ((N 4 % 3) / (N 1 % 1))) +_testSlash_Rat4N3_Rat3N4 = Dict @((P 16 % 9) ~ ((N 4 % 3) / (N 3 % 4))) +_testSlash_Rat4N3_Rat2N3 = Dict @((P 2 % 1) ~ ((N 4 % 3) / (N 2 % 3))) +_testSlash_Rat4N3_Rat1N2 = Dict @((P 8 % 3) ~ ((N 4 % 3) / (N 1 % 2))) +_testSlash_Rat4N3_Rat1N3 = Dict @((P 4 % 1) ~ ((N 4 % 3) / (N 1 % 3))) +_testSlash_Rat4N3_Rat1N4 = Dict @((P 16 % 3) ~ ((N 4 % 3) / (N 1 % 4))) +_testSlash_Rat4N3_Rat1P4 = Dict @((N 16 % 3) ~ ((N 4 % 3) / (P 1 % 4))) +_testSlash_Rat4N3_Rat1P3 = Dict @((N 4 % 1) ~ ((N 4 % 3) / (P 1 % 3))) +_testSlash_Rat4N3_Rat1P2 = Dict @((N 8 % 3) ~ ((N 4 % 3) / (P 1 % 2))) +_testSlash_Rat4N3_Rat2P3 = Dict @((N 2 % 1) ~ ((N 4 % 3) / (P 2 % 3))) +_testSlash_Rat4N3_Rat3P4 = Dict @((N 16 % 9) ~ ((N 4 % 3) / (P 3 % 4))) +_testSlash_Rat4N3_Rat1P1 = Dict @((N 4 % 3) ~ ((N 4 % 3) / (P 1 % 1))) +_testSlash_Rat4N3_Rat4P3 = Dict @((N 1 % 1) ~ ((N 4 % 3) / (P 4 % 3))) +_testSlash_Rat4N3_Rat3P2 = Dict @((N 8 % 9) ~ ((N 4 % 3) / (P 3 % 2))) +_testSlash_Rat4N3_Rat2P1 = Dict @((N 2 % 3) ~ ((N 4 % 3) / (P 2 % 1))) +_testSlash_Rat4N3_Rat3P1 = Dict @((N 4 % 9) ~ ((N 4 % 3) / (P 3 % 1))) +_testSlash_Rat4N3_Rat4P1 = Dict @((N 1 % 3) ~ ((N 4 % 3) / (P 4 % 1))) +_testSlash_Rat1N1_Nat1 = Dict @((N 1 % 1) ~ ((N 1 % 1) / 1)) +_testSlash_Rat1N1_Nat2 = Dict @((N 1 % 2) ~ ((N 1 % 1) / 2)) +_testSlash_Rat1N1_Nat3 = Dict @((N 1 % 3) ~ ((N 1 % 1) / 3)) +_testSlash_Rat1N1_Nat4 = Dict @((N 1 % 4) ~ ((N 1 % 1) / 4)) +_testSlash_Rat1N1_IntN4 = Dict @((P 1 % 4) ~ ((N 1 % 1) / (N 4))) +_testSlash_Rat1N1_IntN3 = Dict @((P 1 % 3) ~ ((N 1 % 1) / (N 3))) +_testSlash_Rat1N1_IntN2 = Dict @((P 1 % 2) ~ ((N 1 % 1) / (N 2))) +_testSlash_Rat1N1_IntN1 = Dict @((P 1 % 1) ~ ((N 1 % 1) / (N 1))) +_testSlash_Rat1N1_IntP1 = Dict @((N 1 % 1) ~ ((N 1 % 1) / (P 1))) +_testSlash_Rat1N1_IntP2 = Dict @((N 1 % 2) ~ ((N 1 % 1) / (P 2))) +_testSlash_Rat1N1_IntP3 = Dict @((N 1 % 3) ~ ((N 1 % 1) / (P 3))) +_testSlash_Rat1N1_IntP4 = Dict @((N 1 % 4) ~ ((N 1 % 1) / (P 4))) +_testSlash_Rat1N1_Rat4N1 = Dict @((P 1 % 4) ~ ((N 1 % 1) / (N 4 % 1))) +_testSlash_Rat1N1_Rat3N1 = Dict @((P 1 % 3) ~ ((N 1 % 1) / (N 3 % 1))) +_testSlash_Rat1N1_Rat2N1 = Dict @((P 1 % 2) ~ ((N 1 % 1) / (N 2 % 1))) +_testSlash_Rat1N1_Rat3N2 = Dict @((P 2 % 3) ~ ((N 1 % 1) / (N 3 % 2))) +_testSlash_Rat1N1_Rat4N3 = Dict @((P 3 % 4) ~ ((N 1 % 1) / (N 4 % 3))) +_testSlash_Rat1N1_Rat1N1 = Dict @((P 1 % 1) ~ ((N 1 % 1) / (N 1 % 1))) +_testSlash_Rat1N1_Rat3N4 = Dict @((P 4 % 3) ~ ((N 1 % 1) / (N 3 % 4))) +_testSlash_Rat1N1_Rat2N3 = Dict @((P 3 % 2) ~ ((N 1 % 1) / (N 2 % 3))) +_testSlash_Rat1N1_Rat1N2 = Dict @((P 2 % 1) ~ ((N 1 % 1) / (N 1 % 2))) +_testSlash_Rat1N1_Rat1N3 = Dict @((P 3 % 1) ~ ((N 1 % 1) / (N 1 % 3))) +_testSlash_Rat1N1_Rat1N4 = Dict @((P 4 % 1) ~ ((N 1 % 1) / (N 1 % 4))) +_testSlash_Rat1N1_Rat1P4 = Dict @((N 4 % 1) ~ ((N 1 % 1) / (P 1 % 4))) +_testSlash_Rat1N1_Rat1P3 = Dict @((N 3 % 1) ~ ((N 1 % 1) / (P 1 % 3))) +_testSlash_Rat1N1_Rat1P2 = Dict @((N 2 % 1) ~ ((N 1 % 1) / (P 1 % 2))) +_testSlash_Rat1N1_Rat2P3 = Dict @((N 3 % 2) ~ ((N 1 % 1) / (P 2 % 3))) +_testSlash_Rat1N1_Rat3P4 = Dict @((N 4 % 3) ~ ((N 1 % 1) / (P 3 % 4))) +_testSlash_Rat1N1_Rat1P1 = Dict @((N 1 % 1) ~ ((N 1 % 1) / (P 1 % 1))) +_testSlash_Rat1N1_Rat4P3 = Dict @((N 3 % 4) ~ ((N 1 % 1) / (P 4 % 3))) +_testSlash_Rat1N1_Rat3P2 = Dict @((N 2 % 3) ~ ((N 1 % 1) / (P 3 % 2))) +_testSlash_Rat1N1_Rat2P1 = Dict @((N 1 % 2) ~ ((N 1 % 1) / (P 2 % 1))) +_testSlash_Rat1N1_Rat3P1 = Dict @((N 1 % 3) ~ ((N 1 % 1) / (P 3 % 1))) +_testSlash_Rat1N1_Rat4P1 = Dict @((N 1 % 4) ~ ((N 1 % 1) / (P 4 % 1))) +_testSlash_Rat3N4_Nat1 = Dict @((N 3 % 4) ~ ((N 3 % 4) / 1)) +_testSlash_Rat3N4_Nat2 = Dict @((N 3 % 8) ~ ((N 3 % 4) / 2)) +_testSlash_Rat3N4_Nat3 = Dict @((N 1 % 4) ~ ((N 3 % 4) / 3)) +_testSlash_Rat3N4_Nat4 = Dict @((N 3 % 16) ~ ((N 3 % 4) / 4)) +_testSlash_Rat3N4_IntN4 = Dict @((P 3 % 16) ~ ((N 3 % 4) / (N 4))) +_testSlash_Rat3N4_IntN3 = Dict @((P 1 % 4) ~ ((N 3 % 4) / (N 3))) +_testSlash_Rat3N4_IntN2 = Dict @((P 3 % 8) ~ ((N 3 % 4) / (N 2))) +_testSlash_Rat3N4_IntN1 = Dict @((P 3 % 4) ~ ((N 3 % 4) / (N 1))) +_testSlash_Rat3N4_IntP1 = Dict @((N 3 % 4) ~ ((N 3 % 4) / (P 1))) +_testSlash_Rat3N4_IntP2 = Dict @((N 3 % 8) ~ ((N 3 % 4) / (P 2))) +_testSlash_Rat3N4_IntP3 = Dict @((N 1 % 4) ~ ((N 3 % 4) / (P 3))) +_testSlash_Rat3N4_IntP4 = Dict @((N 3 % 16) ~ ((N 3 % 4) / (P 4))) +_testSlash_Rat3N4_Rat4N1 = Dict @((P 3 % 16) ~ ((N 3 % 4) / (N 4 % 1))) +_testSlash_Rat3N4_Rat3N1 = Dict @((P 1 % 4) ~ ((N 3 % 4) / (N 3 % 1))) +_testSlash_Rat3N4_Rat2N1 = Dict @((P 3 % 8) ~ ((N 3 % 4) / (N 2 % 1))) +_testSlash_Rat3N4_Rat3N2 = Dict @((P 1 % 2) ~ ((N 3 % 4) / (N 3 % 2))) +_testSlash_Rat3N4_Rat4N3 = Dict @((P 9 % 16) ~ ((N 3 % 4) / (N 4 % 3))) +_testSlash_Rat3N4_Rat1N1 = Dict @((P 3 % 4) ~ ((N 3 % 4) / (N 1 % 1))) +_testSlash_Rat3N4_Rat3N4 = Dict @((P 1 % 1) ~ ((N 3 % 4) / (N 3 % 4))) +_testSlash_Rat3N4_Rat2N3 = Dict @((P 9 % 8) ~ ((N 3 % 4) / (N 2 % 3))) +_testSlash_Rat3N4_Rat1N2 = Dict @((P 3 % 2) ~ ((N 3 % 4) / (N 1 % 2))) +_testSlash_Rat3N4_Rat1N3 = Dict @((P 9 % 4) ~ ((N 3 % 4) / (N 1 % 3))) +_testSlash_Rat3N4_Rat1N4 = Dict @((P 3 % 1) ~ ((N 3 % 4) / (N 1 % 4))) +_testSlash_Rat3N4_Rat1P4 = Dict @((N 3 % 1) ~ ((N 3 % 4) / (P 1 % 4))) +_testSlash_Rat3N4_Rat1P3 = Dict @((N 9 % 4) ~ ((N 3 % 4) / (P 1 % 3))) +_testSlash_Rat3N4_Rat1P2 = Dict @((N 3 % 2) ~ ((N 3 % 4) / (P 1 % 2))) +_testSlash_Rat3N4_Rat2P3 = Dict @((N 9 % 8) ~ ((N 3 % 4) / (P 2 % 3))) +_testSlash_Rat3N4_Rat3P4 = Dict @((N 1 % 1) ~ ((N 3 % 4) / (P 3 % 4))) +_testSlash_Rat3N4_Rat1P1 = Dict @((N 3 % 4) ~ ((N 3 % 4) / (P 1 % 1))) +_testSlash_Rat3N4_Rat4P3 = Dict @((N 9 % 16) ~ ((N 3 % 4) / (P 4 % 3))) +_testSlash_Rat3N4_Rat3P2 = Dict @((N 1 % 2) ~ ((N 3 % 4) / (P 3 % 2))) +_testSlash_Rat3N4_Rat2P1 = Dict @((N 3 % 8) ~ ((N 3 % 4) / (P 2 % 1))) +_testSlash_Rat3N4_Rat3P1 = Dict @((N 1 % 4) ~ ((N 3 % 4) / (P 3 % 1))) +_testSlash_Rat3N4_Rat4P1 = Dict @((N 3 % 16) ~ ((N 3 % 4) / (P 4 % 1))) +_testSlash_Rat2N3_Nat1 = Dict @((N 2 % 3) ~ ((N 2 % 3) / 1)) +_testSlash_Rat2N3_Nat2 = Dict @((N 1 % 3) ~ ((N 2 % 3) / 2)) +_testSlash_Rat2N3_Nat3 = Dict @((N 2 % 9) ~ ((N 2 % 3) / 3)) +_testSlash_Rat2N3_Nat4 = Dict @((N 1 % 6) ~ ((N 2 % 3) / 4)) +_testSlash_Rat2N3_IntN4 = Dict @((P 1 % 6) ~ ((N 2 % 3) / (N 4))) +_testSlash_Rat2N3_IntN3 = Dict @((P 2 % 9) ~ ((N 2 % 3) / (N 3))) +_testSlash_Rat2N3_IntN2 = Dict @((P 1 % 3) ~ ((N 2 % 3) / (N 2))) +_testSlash_Rat2N3_IntN1 = Dict @((P 2 % 3) ~ ((N 2 % 3) / (N 1))) +_testSlash_Rat2N3_IntP1 = Dict @((N 2 % 3) ~ ((N 2 % 3) / (P 1))) +_testSlash_Rat2N3_IntP2 = Dict @((N 1 % 3) ~ ((N 2 % 3) / (P 2))) +_testSlash_Rat2N3_IntP3 = Dict @((N 2 % 9) ~ ((N 2 % 3) / (P 3))) +_testSlash_Rat2N3_IntP4 = Dict @((N 1 % 6) ~ ((N 2 % 3) / (P 4))) +_testSlash_Rat2N3_Rat4N1 = Dict @((P 1 % 6) ~ ((N 2 % 3) / (N 4 % 1))) +_testSlash_Rat2N3_Rat3N1 = Dict @((P 2 % 9) ~ ((N 2 % 3) / (N 3 % 1))) +_testSlash_Rat2N3_Rat2N1 = Dict @((P 1 % 3) ~ ((N 2 % 3) / (N 2 % 1))) +_testSlash_Rat2N3_Rat3N2 = Dict @((P 4 % 9) ~ ((N 2 % 3) / (N 3 % 2))) +_testSlash_Rat2N3_Rat4N3 = Dict @((P 1 % 2) ~ ((N 2 % 3) / (N 4 % 3))) +_testSlash_Rat2N3_Rat1N1 = Dict @((P 2 % 3) ~ ((N 2 % 3) / (N 1 % 1))) +_testSlash_Rat2N3_Rat3N4 = Dict @((P 8 % 9) ~ ((N 2 % 3) / (N 3 % 4))) +_testSlash_Rat2N3_Rat2N3 = Dict @((P 1 % 1) ~ ((N 2 % 3) / (N 2 % 3))) +_testSlash_Rat2N3_Rat1N2 = Dict @((P 4 % 3) ~ ((N 2 % 3) / (N 1 % 2))) +_testSlash_Rat2N3_Rat1N3 = Dict @((P 2 % 1) ~ ((N 2 % 3) / (N 1 % 3))) +_testSlash_Rat2N3_Rat1N4 = Dict @((P 8 % 3) ~ ((N 2 % 3) / (N 1 % 4))) +_testSlash_Rat2N3_Rat1P4 = Dict @((N 8 % 3) ~ ((N 2 % 3) / (P 1 % 4))) +_testSlash_Rat2N3_Rat1P3 = Dict @((N 2 % 1) ~ ((N 2 % 3) / (P 1 % 3))) +_testSlash_Rat2N3_Rat1P2 = Dict @((N 4 % 3) ~ ((N 2 % 3) / (P 1 % 2))) +_testSlash_Rat2N3_Rat2P3 = Dict @((N 1 % 1) ~ ((N 2 % 3) / (P 2 % 3))) +_testSlash_Rat2N3_Rat3P4 = Dict @((N 8 % 9) ~ ((N 2 % 3) / (P 3 % 4))) +_testSlash_Rat2N3_Rat1P1 = Dict @((N 2 % 3) ~ ((N 2 % 3) / (P 1 % 1))) +_testSlash_Rat2N3_Rat4P3 = Dict @((N 1 % 2) ~ ((N 2 % 3) / (P 4 % 3))) +_testSlash_Rat2N3_Rat3P2 = Dict @((N 4 % 9) ~ ((N 2 % 3) / (P 3 % 2))) +_testSlash_Rat2N3_Rat2P1 = Dict @((N 1 % 3) ~ ((N 2 % 3) / (P 2 % 1))) +_testSlash_Rat2N3_Rat3P1 = Dict @((N 2 % 9) ~ ((N 2 % 3) / (P 3 % 1))) +_testSlash_Rat2N3_Rat4P1 = Dict @((N 1 % 6) ~ ((N 2 % 3) / (P 4 % 1))) +_testSlash_Rat1N2_Nat1 = Dict @((N 1 % 2) ~ ((N 1 % 2) / 1)) +_testSlash_Rat1N2_Nat2 = Dict @((N 1 % 4) ~ ((N 1 % 2) / 2)) +_testSlash_Rat1N2_Nat3 = Dict @((N 1 % 6) ~ ((N 1 % 2) / 3)) +_testSlash_Rat1N2_Nat4 = Dict @((N 1 % 8) ~ ((N 1 % 2) / 4)) +_testSlash_Rat1N2_IntN4 = Dict @((P 1 % 8) ~ ((N 1 % 2) / (N 4))) +_testSlash_Rat1N2_IntN3 = Dict @((P 1 % 6) ~ ((N 1 % 2) / (N 3))) +_testSlash_Rat1N2_IntN2 = Dict @((P 1 % 4) ~ ((N 1 % 2) / (N 2))) +_testSlash_Rat1N2_IntN1 = Dict @((P 1 % 2) ~ ((N 1 % 2) / (N 1))) +_testSlash_Rat1N2_IntP1 = Dict @((N 1 % 2) ~ ((N 1 % 2) / (P 1))) +_testSlash_Rat1N2_IntP2 = Dict @((N 1 % 4) ~ ((N 1 % 2) / (P 2))) +_testSlash_Rat1N2_IntP3 = Dict @((N 1 % 6) ~ ((N 1 % 2) / (P 3))) +_testSlash_Rat1N2_IntP4 = Dict @((N 1 % 8) ~ ((N 1 % 2) / (P 4))) +_testSlash_Rat1N2_Rat4N1 = Dict @((P 1 % 8) ~ ((N 1 % 2) / (N 4 % 1))) +_testSlash_Rat1N2_Rat3N1 = Dict @((P 1 % 6) ~ ((N 1 % 2) / (N 3 % 1))) +_testSlash_Rat1N2_Rat2N1 = Dict @((P 1 % 4) ~ ((N 1 % 2) / (N 2 % 1))) +_testSlash_Rat1N2_Rat3N2 = Dict @((P 1 % 3) ~ ((N 1 % 2) / (N 3 % 2))) +_testSlash_Rat1N2_Rat4N3 = Dict @((P 3 % 8) ~ ((N 1 % 2) / (N 4 % 3))) +_testSlash_Rat1N2_Rat1N1 = Dict @((P 1 % 2) ~ ((N 1 % 2) / (N 1 % 1))) +_testSlash_Rat1N2_Rat3N4 = Dict @((P 2 % 3) ~ ((N 1 % 2) / (N 3 % 4))) +_testSlash_Rat1N2_Rat2N3 = Dict @((P 3 % 4) ~ ((N 1 % 2) / (N 2 % 3))) +_testSlash_Rat1N2_Rat1N2 = Dict @((P 1 % 1) ~ ((N 1 % 2) / (N 1 % 2))) +_testSlash_Rat1N2_Rat1N3 = Dict @((P 3 % 2) ~ ((N 1 % 2) / (N 1 % 3))) +_testSlash_Rat1N2_Rat1N4 = Dict @((P 2 % 1) ~ ((N 1 % 2) / (N 1 % 4))) +_testSlash_Rat1N2_Rat1P4 = Dict @((N 2 % 1) ~ ((N 1 % 2) / (P 1 % 4))) +_testSlash_Rat1N2_Rat1P3 = Dict @((N 3 % 2) ~ ((N 1 % 2) / (P 1 % 3))) +_testSlash_Rat1N2_Rat1P2 = Dict @((N 1 % 1) ~ ((N 1 % 2) / (P 1 % 2))) +_testSlash_Rat1N2_Rat2P3 = Dict @((N 3 % 4) ~ ((N 1 % 2) / (P 2 % 3))) +_testSlash_Rat1N2_Rat3P4 = Dict @((N 2 % 3) ~ ((N 1 % 2) / (P 3 % 4))) +_testSlash_Rat1N2_Rat1P1 = Dict @((N 1 % 2) ~ ((N 1 % 2) / (P 1 % 1))) +_testSlash_Rat1N2_Rat4P3 = Dict @((N 3 % 8) ~ ((N 1 % 2) / (P 4 % 3))) +_testSlash_Rat1N2_Rat3P2 = Dict @((N 1 % 3) ~ ((N 1 % 2) / (P 3 % 2))) +_testSlash_Rat1N2_Rat2P1 = Dict @((N 1 % 4) ~ ((N 1 % 2) / (P 2 % 1))) +_testSlash_Rat1N2_Rat3P1 = Dict @((N 1 % 6) ~ ((N 1 % 2) / (P 3 % 1))) +_testSlash_Rat1N2_Rat4P1 = Dict @((N 1 % 8) ~ ((N 1 % 2) / (P 4 % 1))) +_testSlash_Rat1N3_Nat1 = Dict @((N 1 % 3) ~ ((N 1 % 3) / 1)) +_testSlash_Rat1N3_Nat2 = Dict @((N 1 % 6) ~ ((N 1 % 3) / 2)) +_testSlash_Rat1N3_Nat3 = Dict @((N 1 % 9) ~ ((N 1 % 3) / 3)) +_testSlash_Rat1N3_Nat4 = Dict @((N 1 % 12) ~ ((N 1 % 3) / 4)) +_testSlash_Rat1N3_IntN4 = Dict @((P 1 % 12) ~ ((N 1 % 3) / (N 4))) +_testSlash_Rat1N3_IntN3 = Dict @((P 1 % 9) ~ ((N 1 % 3) / (N 3))) +_testSlash_Rat1N3_IntN2 = Dict @((P 1 % 6) ~ ((N 1 % 3) / (N 2))) +_testSlash_Rat1N3_IntN1 = Dict @((P 1 % 3) ~ ((N 1 % 3) / (N 1))) +_testSlash_Rat1N3_IntP1 = Dict @((N 1 % 3) ~ ((N 1 % 3) / (P 1))) +_testSlash_Rat1N3_IntP2 = Dict @((N 1 % 6) ~ ((N 1 % 3) / (P 2))) +_testSlash_Rat1N3_IntP3 = Dict @((N 1 % 9) ~ ((N 1 % 3) / (P 3))) +_testSlash_Rat1N3_IntP4 = Dict @((N 1 % 12) ~ ((N 1 % 3) / (P 4))) +_testSlash_Rat1N3_Rat4N1 = Dict @((P 1 % 12) ~ ((N 1 % 3) / (N 4 % 1))) +_testSlash_Rat1N3_Rat3N1 = Dict @((P 1 % 9) ~ ((N 1 % 3) / (N 3 % 1))) +_testSlash_Rat1N3_Rat2N1 = Dict @((P 1 % 6) ~ ((N 1 % 3) / (N 2 % 1))) +_testSlash_Rat1N3_Rat3N2 = Dict @((P 2 % 9) ~ ((N 1 % 3) / (N 3 % 2))) +_testSlash_Rat1N3_Rat4N3 = Dict @((P 1 % 4) ~ ((N 1 % 3) / (N 4 % 3))) +_testSlash_Rat1N3_Rat1N1 = Dict @((P 1 % 3) ~ ((N 1 % 3) / (N 1 % 1))) +_testSlash_Rat1N3_Rat3N4 = Dict @((P 4 % 9) ~ ((N 1 % 3) / (N 3 % 4))) +_testSlash_Rat1N3_Rat2N3 = Dict @((P 1 % 2) ~ ((N 1 % 3) / (N 2 % 3))) +_testSlash_Rat1N3_Rat1N2 = Dict @((P 2 % 3) ~ ((N 1 % 3) / (N 1 % 2))) +_testSlash_Rat1N3_Rat1N3 = Dict @((P 1 % 1) ~ ((N 1 % 3) / (N 1 % 3))) +_testSlash_Rat1N3_Rat1N4 = Dict @((P 4 % 3) ~ ((N 1 % 3) / (N 1 % 4))) +_testSlash_Rat1N3_Rat1P4 = Dict @((N 4 % 3) ~ ((N 1 % 3) / (P 1 % 4))) +_testSlash_Rat1N3_Rat1P3 = Dict @((N 1 % 1) ~ ((N 1 % 3) / (P 1 % 3))) +_testSlash_Rat1N3_Rat1P2 = Dict @((N 2 % 3) ~ ((N 1 % 3) / (P 1 % 2))) +_testSlash_Rat1N3_Rat2P3 = Dict @((N 1 % 2) ~ ((N 1 % 3) / (P 2 % 3))) +_testSlash_Rat1N3_Rat3P4 = Dict @((N 4 % 9) ~ ((N 1 % 3) / (P 3 % 4))) +_testSlash_Rat1N3_Rat1P1 = Dict @((N 1 % 3) ~ ((N 1 % 3) / (P 1 % 1))) +_testSlash_Rat1N3_Rat4P3 = Dict @((N 1 % 4) ~ ((N 1 % 3) / (P 4 % 3))) +_testSlash_Rat1N3_Rat3P2 = Dict @((N 2 % 9) ~ ((N 1 % 3) / (P 3 % 2))) +_testSlash_Rat1N3_Rat2P1 = Dict @((N 1 % 6) ~ ((N 1 % 3) / (P 2 % 1))) +_testSlash_Rat1N3_Rat3P1 = Dict @((N 1 % 9) ~ ((N 1 % 3) / (P 3 % 1))) +_testSlash_Rat1N3_Rat4P1 = Dict @((N 1 % 12) ~ ((N 1 % 3) / (P 4 % 1))) +_testSlash_Rat1N4_Nat1 = Dict @((N 1 % 4) ~ ((N 1 % 4) / 1)) +_testSlash_Rat1N4_Nat2 = Dict @((N 1 % 8) ~ ((N 1 % 4) / 2)) +_testSlash_Rat1N4_Nat3 = Dict @((N 1 % 12) ~ ((N 1 % 4) / 3)) +_testSlash_Rat1N4_Nat4 = Dict @((N 1 % 16) ~ ((N 1 % 4) / 4)) +_testSlash_Rat1N4_IntN4 = Dict @((P 1 % 16) ~ ((N 1 % 4) / (N 4))) +_testSlash_Rat1N4_IntN3 = Dict @((P 1 % 12) ~ ((N 1 % 4) / (N 3))) +_testSlash_Rat1N4_IntN2 = Dict @((P 1 % 8) ~ ((N 1 % 4) / (N 2))) +_testSlash_Rat1N4_IntN1 = Dict @((P 1 % 4) ~ ((N 1 % 4) / (N 1))) +_testSlash_Rat1N4_IntP1 = Dict @((N 1 % 4) ~ ((N 1 % 4) / (P 1))) +_testSlash_Rat1N4_IntP2 = Dict @((N 1 % 8) ~ ((N 1 % 4) / (P 2))) +_testSlash_Rat1N4_IntP3 = Dict @((N 1 % 12) ~ ((N 1 % 4) / (P 3))) +_testSlash_Rat1N4_IntP4 = Dict @((N 1 % 16) ~ ((N 1 % 4) / (P 4))) +_testSlash_Rat1N4_Rat4N1 = Dict @((P 1 % 16) ~ ((N 1 % 4) / (N 4 % 1))) +_testSlash_Rat1N4_Rat3N1 = Dict @((P 1 % 12) ~ ((N 1 % 4) / (N 3 % 1))) +_testSlash_Rat1N4_Rat2N1 = Dict @((P 1 % 8) ~ ((N 1 % 4) / (N 2 % 1))) +_testSlash_Rat1N4_Rat3N2 = Dict @((P 1 % 6) ~ ((N 1 % 4) / (N 3 % 2))) +_testSlash_Rat1N4_Rat4N3 = Dict @((P 3 % 16) ~ ((N 1 % 4) / (N 4 % 3))) +_testSlash_Rat1N4_Rat1N1 = Dict @((P 1 % 4) ~ ((N 1 % 4) / (N 1 % 1))) +_testSlash_Rat1N4_Rat3N4 = Dict @((P 1 % 3) ~ ((N 1 % 4) / (N 3 % 4))) +_testSlash_Rat1N4_Rat2N3 = Dict @((P 3 % 8) ~ ((N 1 % 4) / (N 2 % 3))) +_testSlash_Rat1N4_Rat1N2 = Dict @((P 1 % 2) ~ ((N 1 % 4) / (N 1 % 2))) +_testSlash_Rat1N4_Rat1N3 = Dict @((P 3 % 4) ~ ((N 1 % 4) / (N 1 % 3))) +_testSlash_Rat1N4_Rat1N4 = Dict @((P 1 % 1) ~ ((N 1 % 4) / (N 1 % 4))) +_testSlash_Rat1N4_Rat1P4 = Dict @((N 1 % 1) ~ ((N 1 % 4) / (P 1 % 4))) +_testSlash_Rat1N4_Rat1P3 = Dict @((N 3 % 4) ~ ((N 1 % 4) / (P 1 % 3))) +_testSlash_Rat1N4_Rat1P2 = Dict @((N 1 % 2) ~ ((N 1 % 4) / (P 1 % 2))) +_testSlash_Rat1N4_Rat2P3 = Dict @((N 3 % 8) ~ ((N 1 % 4) / (P 2 % 3))) +_testSlash_Rat1N4_Rat3P4 = Dict @((N 1 % 3) ~ ((N 1 % 4) / (P 3 % 4))) +_testSlash_Rat1N4_Rat1P1 = Dict @((N 1 % 4) ~ ((N 1 % 4) / (P 1 % 1))) +_testSlash_Rat1N4_Rat4P3 = Dict @((N 3 % 16) ~ ((N 1 % 4) / (P 4 % 3))) +_testSlash_Rat1N4_Rat3P2 = Dict @((N 1 % 6) ~ ((N 1 % 4) / (P 3 % 2))) +_testSlash_Rat1N4_Rat2P1 = Dict @((N 1 % 8) ~ ((N 1 % 4) / (P 2 % 1))) +_testSlash_Rat1N4_Rat3P1 = Dict @((N 1 % 12) ~ ((N 1 % 4) / (P 3 % 1))) +_testSlash_Rat1N4_Rat4P1 = Dict @((N 1 % 16) ~ ((N 1 % 4) / (P 4 % 1))) +_testSlash_Rat0P1_Nat1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 1)) +_testSlash_Rat0P1_Nat2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 2)) +_testSlash_Rat0P1_Nat3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 3)) +_testSlash_Rat0P1_Nat4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / 4)) +_testSlash_Rat0P1_IntN4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 4))) +_testSlash_Rat0P1_IntN3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3))) +_testSlash_Rat0P1_IntN2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 2))) +_testSlash_Rat0P1_IntN1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1))) +_testSlash_Rat0P1_IntP1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1))) +_testSlash_Rat0P1_IntP2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 2))) +_testSlash_Rat0P1_IntP3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3))) +_testSlash_Rat0P1_IntP4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 4))) +_testSlash_Rat0P1_Rat4N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 4 % 1))) +_testSlash_Rat0P1_Rat3N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3 % 1))) +_testSlash_Rat0P1_Rat2N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 2 % 1))) +_testSlash_Rat0P1_Rat3N2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3 % 2))) +_testSlash_Rat0P1_Rat4N3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 4 % 3))) +_testSlash_Rat0P1_Rat1N1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 1))) +_testSlash_Rat0P1_Rat3N4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 3 % 4))) +_testSlash_Rat0P1_Rat2N3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 2 % 3))) +_testSlash_Rat0P1_Rat1N2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 2))) +_testSlash_Rat0P1_Rat1N3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 3))) +_testSlash_Rat0P1_Rat1N4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (N 1 % 4))) +_testSlash_Rat0P1_Rat1P4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 4))) +_testSlash_Rat0P1_Rat1P3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 3))) +_testSlash_Rat0P1_Rat1P2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 2))) +_testSlash_Rat0P1_Rat2P3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 2 % 3))) +_testSlash_Rat0P1_Rat3P4 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3 % 4))) +_testSlash_Rat0P1_Rat1P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 1 % 1))) +_testSlash_Rat0P1_Rat4P3 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 4 % 3))) +_testSlash_Rat0P1_Rat3P2 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3 % 2))) +_testSlash_Rat0P1_Rat2P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 2 % 1))) +_testSlash_Rat0P1_Rat3P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 3 % 1))) +_testSlash_Rat0P1_Rat4P1 = Dict @((P 0 % 1) ~ ((P 0 % 1) / (P 4 % 1))) +_testSlash_Rat1P4_Nat1 = Dict @((P 1 % 4) ~ ((P 1 % 4) / 1)) +_testSlash_Rat1P4_Nat2 = Dict @((P 1 % 8) ~ ((P 1 % 4) / 2)) +_testSlash_Rat1P4_Nat3 = Dict @((P 1 % 12) ~ ((P 1 % 4) / 3)) +_testSlash_Rat1P4_Nat4 = Dict @((P 1 % 16) ~ ((P 1 % 4) / 4)) +_testSlash_Rat1P4_IntN4 = Dict @((N 1 % 16) ~ ((P 1 % 4) / (N 4))) +_testSlash_Rat1P4_IntN3 = Dict @((N 1 % 12) ~ ((P 1 % 4) / (N 3))) +_testSlash_Rat1P4_IntN2 = Dict @((N 1 % 8) ~ ((P 1 % 4) / (N 2))) +_testSlash_Rat1P4_IntN1 = Dict @((N 1 % 4) ~ ((P 1 % 4) / (N 1))) +_testSlash_Rat1P4_IntP1 = Dict @((P 1 % 4) ~ ((P 1 % 4) / (P 1))) +_testSlash_Rat1P4_IntP2 = Dict @((P 1 % 8) ~ ((P 1 % 4) / (P 2))) +_testSlash_Rat1P4_IntP3 = Dict @((P 1 % 12) ~ ((P 1 % 4) / (P 3))) +_testSlash_Rat1P4_IntP4 = Dict @((P 1 % 16) ~ ((P 1 % 4) / (P 4))) +_testSlash_Rat1P4_Rat4N1 = Dict @((N 1 % 16) ~ ((P 1 % 4) / (N 4 % 1))) +_testSlash_Rat1P4_Rat3N1 = Dict @((N 1 % 12) ~ ((P 1 % 4) / (N 3 % 1))) +_testSlash_Rat1P4_Rat2N1 = Dict @((N 1 % 8) ~ ((P 1 % 4) / (N 2 % 1))) +_testSlash_Rat1P4_Rat3N2 = Dict @((N 1 % 6) ~ ((P 1 % 4) / (N 3 % 2))) +_testSlash_Rat1P4_Rat4N3 = Dict @((N 3 % 16) ~ ((P 1 % 4) / (N 4 % 3))) +_testSlash_Rat1P4_Rat1N1 = Dict @((N 1 % 4) ~ ((P 1 % 4) / (N 1 % 1))) +_testSlash_Rat1P4_Rat3N4 = Dict @((N 1 % 3) ~ ((P 1 % 4) / (N 3 % 4))) +_testSlash_Rat1P4_Rat2N3 = Dict @((N 3 % 8) ~ ((P 1 % 4) / (N 2 % 3))) +_testSlash_Rat1P4_Rat1N2 = Dict @((N 1 % 2) ~ ((P 1 % 4) / (N 1 % 2))) +_testSlash_Rat1P4_Rat1N3 = Dict @((N 3 % 4) ~ ((P 1 % 4) / (N 1 % 3))) +_testSlash_Rat1P4_Rat1N4 = Dict @((N 1 % 1) ~ ((P 1 % 4) / (N 1 % 4))) +_testSlash_Rat1P4_Rat1P4 = Dict @((P 1 % 1) ~ ((P 1 % 4) / (P 1 % 4))) +_testSlash_Rat1P4_Rat1P3 = Dict @((P 3 % 4) ~ ((P 1 % 4) / (P 1 % 3))) +_testSlash_Rat1P4_Rat1P2 = Dict @((P 1 % 2) ~ ((P 1 % 4) / (P 1 % 2))) +_testSlash_Rat1P4_Rat2P3 = Dict @((P 3 % 8) ~ ((P 1 % 4) / (P 2 % 3))) +_testSlash_Rat1P4_Rat3P4 = Dict @((P 1 % 3) ~ ((P 1 % 4) / (P 3 % 4))) +_testSlash_Rat1P4_Rat1P1 = Dict @((P 1 % 4) ~ ((P 1 % 4) / (P 1 % 1))) +_testSlash_Rat1P4_Rat4P3 = Dict @((P 3 % 16) ~ ((P 1 % 4) / (P 4 % 3))) +_testSlash_Rat1P4_Rat3P2 = Dict @((P 1 % 6) ~ ((P 1 % 4) / (P 3 % 2))) +_testSlash_Rat1P4_Rat2P1 = Dict @((P 1 % 8) ~ ((P 1 % 4) / (P 2 % 1))) +_testSlash_Rat1P4_Rat3P1 = Dict @((P 1 % 12) ~ ((P 1 % 4) / (P 3 % 1))) +_testSlash_Rat1P4_Rat4P1 = Dict @((P 1 % 16) ~ ((P 1 % 4) / (P 4 % 1))) +_testSlash_Rat1P3_Nat1 = Dict @((P 1 % 3) ~ ((P 1 % 3) / 1)) +_testSlash_Rat1P3_Nat2 = Dict @((P 1 % 6) ~ ((P 1 % 3) / 2)) +_testSlash_Rat1P3_Nat3 = Dict @((P 1 % 9) ~ ((P 1 % 3) / 3)) +_testSlash_Rat1P3_Nat4 = Dict @((P 1 % 12) ~ ((P 1 % 3) / 4)) +_testSlash_Rat1P3_IntN4 = Dict @((N 1 % 12) ~ ((P 1 % 3) / (N 4))) +_testSlash_Rat1P3_IntN3 = Dict @((N 1 % 9) ~ ((P 1 % 3) / (N 3))) +_testSlash_Rat1P3_IntN2 = Dict @((N 1 % 6) ~ ((P 1 % 3) / (N 2))) +_testSlash_Rat1P3_IntN1 = Dict @((N 1 % 3) ~ ((P 1 % 3) / (N 1))) +_testSlash_Rat1P3_IntP1 = Dict @((P 1 % 3) ~ ((P 1 % 3) / (P 1))) +_testSlash_Rat1P3_IntP2 = Dict @((P 1 % 6) ~ ((P 1 % 3) / (P 2))) +_testSlash_Rat1P3_IntP3 = Dict @((P 1 % 9) ~ ((P 1 % 3) / (P 3))) +_testSlash_Rat1P3_IntP4 = Dict @((P 1 % 12) ~ ((P 1 % 3) / (P 4))) +_testSlash_Rat1P3_Rat4N1 = Dict @((N 1 % 12) ~ ((P 1 % 3) / (N 4 % 1))) +_testSlash_Rat1P3_Rat3N1 = Dict @((N 1 % 9) ~ ((P 1 % 3) / (N 3 % 1))) +_testSlash_Rat1P3_Rat2N1 = Dict @((N 1 % 6) ~ ((P 1 % 3) / (N 2 % 1))) +_testSlash_Rat1P3_Rat3N2 = Dict @((N 2 % 9) ~ ((P 1 % 3) / (N 3 % 2))) +_testSlash_Rat1P3_Rat4N3 = Dict @((N 1 % 4) ~ ((P 1 % 3) / (N 4 % 3))) +_testSlash_Rat1P3_Rat1N1 = Dict @((N 1 % 3) ~ ((P 1 % 3) / (N 1 % 1))) +_testSlash_Rat1P3_Rat3N4 = Dict @((N 4 % 9) ~ ((P 1 % 3) / (N 3 % 4))) +_testSlash_Rat1P3_Rat2N3 = Dict @((N 1 % 2) ~ ((P 1 % 3) / (N 2 % 3))) +_testSlash_Rat1P3_Rat1N2 = Dict @((N 2 % 3) ~ ((P 1 % 3) / (N 1 % 2))) +_testSlash_Rat1P3_Rat1N3 = Dict @((N 1 % 1) ~ ((P 1 % 3) / (N 1 % 3))) +_testSlash_Rat1P3_Rat1N4 = Dict @((N 4 % 3) ~ ((P 1 % 3) / (N 1 % 4))) +_testSlash_Rat1P3_Rat1P4 = Dict @((P 4 % 3) ~ ((P 1 % 3) / (P 1 % 4))) +_testSlash_Rat1P3_Rat1P3 = Dict @((P 1 % 1) ~ ((P 1 % 3) / (P 1 % 3))) +_testSlash_Rat1P3_Rat1P2 = Dict @((P 2 % 3) ~ ((P 1 % 3) / (P 1 % 2))) +_testSlash_Rat1P3_Rat2P3 = Dict @((P 1 % 2) ~ ((P 1 % 3) / (P 2 % 3))) +_testSlash_Rat1P3_Rat3P4 = Dict @((P 4 % 9) ~ ((P 1 % 3) / (P 3 % 4))) +_testSlash_Rat1P3_Rat1P1 = Dict @((P 1 % 3) ~ ((P 1 % 3) / (P 1 % 1))) +_testSlash_Rat1P3_Rat4P3 = Dict @((P 1 % 4) ~ ((P 1 % 3) / (P 4 % 3))) +_testSlash_Rat1P3_Rat3P2 = Dict @((P 2 % 9) ~ ((P 1 % 3) / (P 3 % 2))) +_testSlash_Rat1P3_Rat2P1 = Dict @((P 1 % 6) ~ ((P 1 % 3) / (P 2 % 1))) +_testSlash_Rat1P3_Rat3P1 = Dict @((P 1 % 9) ~ ((P 1 % 3) / (P 3 % 1))) +_testSlash_Rat1P3_Rat4P1 = Dict @((P 1 % 12) ~ ((P 1 % 3) / (P 4 % 1))) +_testSlash_Rat1P2_Nat1 = Dict @((P 1 % 2) ~ ((P 1 % 2) / 1)) +_testSlash_Rat1P2_Nat2 = Dict @((P 1 % 4) ~ ((P 1 % 2) / 2)) +_testSlash_Rat1P2_Nat3 = Dict @((P 1 % 6) ~ ((P 1 % 2) / 3)) +_testSlash_Rat1P2_Nat4 = Dict @((P 1 % 8) ~ ((P 1 % 2) / 4)) +_testSlash_Rat1P2_IntN4 = Dict @((N 1 % 8) ~ ((P 1 % 2) / (N 4))) +_testSlash_Rat1P2_IntN3 = Dict @((N 1 % 6) ~ ((P 1 % 2) / (N 3))) +_testSlash_Rat1P2_IntN2 = Dict @((N 1 % 4) ~ ((P 1 % 2) / (N 2))) +_testSlash_Rat1P2_IntN1 = Dict @((N 1 % 2) ~ ((P 1 % 2) / (N 1))) +_testSlash_Rat1P2_IntP1 = Dict @((P 1 % 2) ~ ((P 1 % 2) / (P 1))) +_testSlash_Rat1P2_IntP2 = Dict @((P 1 % 4) ~ ((P 1 % 2) / (P 2))) +_testSlash_Rat1P2_IntP3 = Dict @((P 1 % 6) ~ ((P 1 % 2) / (P 3))) +_testSlash_Rat1P2_IntP4 = Dict @((P 1 % 8) ~ ((P 1 % 2) / (P 4))) +_testSlash_Rat1P2_Rat4N1 = Dict @((N 1 % 8) ~ ((P 1 % 2) / (N 4 % 1))) +_testSlash_Rat1P2_Rat3N1 = Dict @((N 1 % 6) ~ ((P 1 % 2) / (N 3 % 1))) +_testSlash_Rat1P2_Rat2N1 = Dict @((N 1 % 4) ~ ((P 1 % 2) / (N 2 % 1))) +_testSlash_Rat1P2_Rat3N2 = Dict @((N 1 % 3) ~ ((P 1 % 2) / (N 3 % 2))) +_testSlash_Rat1P2_Rat4N3 = Dict @((N 3 % 8) ~ ((P 1 % 2) / (N 4 % 3))) +_testSlash_Rat1P2_Rat1N1 = Dict @((N 1 % 2) ~ ((P 1 % 2) / (N 1 % 1))) +_testSlash_Rat1P2_Rat3N4 = Dict @((N 2 % 3) ~ ((P 1 % 2) / (N 3 % 4))) +_testSlash_Rat1P2_Rat2N3 = Dict @((N 3 % 4) ~ ((P 1 % 2) / (N 2 % 3))) +_testSlash_Rat1P2_Rat1N2 = Dict @((N 1 % 1) ~ ((P 1 % 2) / (N 1 % 2))) +_testSlash_Rat1P2_Rat1N3 = Dict @((N 3 % 2) ~ ((P 1 % 2) / (N 1 % 3))) +_testSlash_Rat1P2_Rat1N4 = Dict @((N 2 % 1) ~ ((P 1 % 2) / (N 1 % 4))) +_testSlash_Rat1P2_Rat1P4 = Dict @((P 2 % 1) ~ ((P 1 % 2) / (P 1 % 4))) +_testSlash_Rat1P2_Rat1P3 = Dict @((P 3 % 2) ~ ((P 1 % 2) / (P 1 % 3))) +_testSlash_Rat1P2_Rat1P2 = Dict @((P 1 % 1) ~ ((P 1 % 2) / (P 1 % 2))) +_testSlash_Rat1P2_Rat2P3 = Dict @((P 3 % 4) ~ ((P 1 % 2) / (P 2 % 3))) +_testSlash_Rat1P2_Rat3P4 = Dict @((P 2 % 3) ~ ((P 1 % 2) / (P 3 % 4))) +_testSlash_Rat1P2_Rat1P1 = Dict @((P 1 % 2) ~ ((P 1 % 2) / (P 1 % 1))) +_testSlash_Rat1P2_Rat4P3 = Dict @((P 3 % 8) ~ ((P 1 % 2) / (P 4 % 3))) +_testSlash_Rat1P2_Rat3P2 = Dict @((P 1 % 3) ~ ((P 1 % 2) / (P 3 % 2))) +_testSlash_Rat1P2_Rat2P1 = Dict @((P 1 % 4) ~ ((P 1 % 2) / (P 2 % 1))) +_testSlash_Rat1P2_Rat3P1 = Dict @((P 1 % 6) ~ ((P 1 % 2) / (P 3 % 1))) +_testSlash_Rat1P2_Rat4P1 = Dict @((P 1 % 8) ~ ((P 1 % 2) / (P 4 % 1))) +_testSlash_Rat2P3_Nat1 = Dict @((P 2 % 3) ~ ((P 2 % 3) / 1)) +_testSlash_Rat2P3_Nat2 = Dict @((P 1 % 3) ~ ((P 2 % 3) / 2)) +_testSlash_Rat2P3_Nat3 = Dict @((P 2 % 9) ~ ((P 2 % 3) / 3)) +_testSlash_Rat2P3_Nat4 = Dict @((P 1 % 6) ~ ((P 2 % 3) / 4)) +_testSlash_Rat2P3_IntN4 = Dict @((N 1 % 6) ~ ((P 2 % 3) / (N 4))) +_testSlash_Rat2P3_IntN3 = Dict @((N 2 % 9) ~ ((P 2 % 3) / (N 3))) +_testSlash_Rat2P3_IntN2 = Dict @((N 1 % 3) ~ ((P 2 % 3) / (N 2))) +_testSlash_Rat2P3_IntN1 = Dict @((N 2 % 3) ~ ((P 2 % 3) / (N 1))) +_testSlash_Rat2P3_IntP1 = Dict @((P 2 % 3) ~ ((P 2 % 3) / (P 1))) +_testSlash_Rat2P3_IntP2 = Dict @((P 1 % 3) ~ ((P 2 % 3) / (P 2))) +_testSlash_Rat2P3_IntP3 = Dict @((P 2 % 9) ~ ((P 2 % 3) / (P 3))) +_testSlash_Rat2P3_IntP4 = Dict @((P 1 % 6) ~ ((P 2 % 3) / (P 4))) +_testSlash_Rat2P3_Rat4N1 = Dict @((N 1 % 6) ~ ((P 2 % 3) / (N 4 % 1))) +_testSlash_Rat2P3_Rat3N1 = Dict @((N 2 % 9) ~ ((P 2 % 3) / (N 3 % 1))) +_testSlash_Rat2P3_Rat2N1 = Dict @((N 1 % 3) ~ ((P 2 % 3) / (N 2 % 1))) +_testSlash_Rat2P3_Rat3N2 = Dict @((N 4 % 9) ~ ((P 2 % 3) / (N 3 % 2))) +_testSlash_Rat2P3_Rat4N3 = Dict @((N 1 % 2) ~ ((P 2 % 3) / (N 4 % 3))) +_testSlash_Rat2P3_Rat1N1 = Dict @((N 2 % 3) ~ ((P 2 % 3) / (N 1 % 1))) +_testSlash_Rat2P3_Rat3N4 = Dict @((N 8 % 9) ~ ((P 2 % 3) / (N 3 % 4))) +_testSlash_Rat2P3_Rat2N3 = Dict @((N 1 % 1) ~ ((P 2 % 3) / (N 2 % 3))) +_testSlash_Rat2P3_Rat1N2 = Dict @((N 4 % 3) ~ ((P 2 % 3) / (N 1 % 2))) +_testSlash_Rat2P3_Rat1N3 = Dict @((N 2 % 1) ~ ((P 2 % 3) / (N 1 % 3))) +_testSlash_Rat2P3_Rat1N4 = Dict @((N 8 % 3) ~ ((P 2 % 3) / (N 1 % 4))) +_testSlash_Rat2P3_Rat1P4 = Dict @((P 8 % 3) ~ ((P 2 % 3) / (P 1 % 4))) +_testSlash_Rat2P3_Rat1P3 = Dict @((P 2 % 1) ~ ((P 2 % 3) / (P 1 % 3))) +_testSlash_Rat2P3_Rat1P2 = Dict @((P 4 % 3) ~ ((P 2 % 3) / (P 1 % 2))) +_testSlash_Rat2P3_Rat2P3 = Dict @((P 1 % 1) ~ ((P 2 % 3) / (P 2 % 3))) +_testSlash_Rat2P3_Rat3P4 = Dict @((P 8 % 9) ~ ((P 2 % 3) / (P 3 % 4))) +_testSlash_Rat2P3_Rat1P1 = Dict @((P 2 % 3) ~ ((P 2 % 3) / (P 1 % 1))) +_testSlash_Rat2P3_Rat4P3 = Dict @((P 1 % 2) ~ ((P 2 % 3) / (P 4 % 3))) +_testSlash_Rat2P3_Rat3P2 = Dict @((P 4 % 9) ~ ((P 2 % 3) / (P 3 % 2))) +_testSlash_Rat2P3_Rat2P1 = Dict @((P 1 % 3) ~ ((P 2 % 3) / (P 2 % 1))) +_testSlash_Rat2P3_Rat3P1 = Dict @((P 2 % 9) ~ ((P 2 % 3) / (P 3 % 1))) +_testSlash_Rat2P3_Rat4P1 = Dict @((P 1 % 6) ~ ((P 2 % 3) / (P 4 % 1))) +_testSlash_Rat3P4_Nat1 = Dict @((P 3 % 4) ~ ((P 3 % 4) / 1)) +_testSlash_Rat3P4_Nat2 = Dict @((P 3 % 8) ~ ((P 3 % 4) / 2)) +_testSlash_Rat3P4_Nat3 = Dict @((P 1 % 4) ~ ((P 3 % 4) / 3)) +_testSlash_Rat3P4_Nat4 = Dict @((P 3 % 16) ~ ((P 3 % 4) / 4)) +_testSlash_Rat3P4_IntN4 = Dict @((N 3 % 16) ~ ((P 3 % 4) / (N 4))) +_testSlash_Rat3P4_IntN3 = Dict @((N 1 % 4) ~ ((P 3 % 4) / (N 3))) +_testSlash_Rat3P4_IntN2 = Dict @((N 3 % 8) ~ ((P 3 % 4) / (N 2))) +_testSlash_Rat3P4_IntN1 = Dict @((N 3 % 4) ~ ((P 3 % 4) / (N 1))) +_testSlash_Rat3P4_IntP1 = Dict @((P 3 % 4) ~ ((P 3 % 4) / (P 1))) +_testSlash_Rat3P4_IntP2 = Dict @((P 3 % 8) ~ ((P 3 % 4) / (P 2))) +_testSlash_Rat3P4_IntP3 = Dict @((P 1 % 4) ~ ((P 3 % 4) / (P 3))) +_testSlash_Rat3P4_IntP4 = Dict @((P 3 % 16) ~ ((P 3 % 4) / (P 4))) +_testSlash_Rat3P4_Rat4N1 = Dict @((N 3 % 16) ~ ((P 3 % 4) / (N 4 % 1))) +_testSlash_Rat3P4_Rat3N1 = Dict @((N 1 % 4) ~ ((P 3 % 4) / (N 3 % 1))) +_testSlash_Rat3P4_Rat2N1 = Dict @((N 3 % 8) ~ ((P 3 % 4) / (N 2 % 1))) +_testSlash_Rat3P4_Rat3N2 = Dict @((N 1 % 2) ~ ((P 3 % 4) / (N 3 % 2))) +_testSlash_Rat3P4_Rat4N3 = Dict @((N 9 % 16) ~ ((P 3 % 4) / (N 4 % 3))) +_testSlash_Rat3P4_Rat1N1 = Dict @((N 3 % 4) ~ ((P 3 % 4) / (N 1 % 1))) +_testSlash_Rat3P4_Rat3N4 = Dict @((N 1 % 1) ~ ((P 3 % 4) / (N 3 % 4))) +_testSlash_Rat3P4_Rat2N3 = Dict @((N 9 % 8) ~ ((P 3 % 4) / (N 2 % 3))) +_testSlash_Rat3P4_Rat1N2 = Dict @((N 3 % 2) ~ ((P 3 % 4) / (N 1 % 2))) +_testSlash_Rat3P4_Rat1N3 = Dict @((N 9 % 4) ~ ((P 3 % 4) / (N 1 % 3))) +_testSlash_Rat3P4_Rat1N4 = Dict @((N 3 % 1) ~ ((P 3 % 4) / (N 1 % 4))) +_testSlash_Rat3P4_Rat1P4 = Dict @((P 3 % 1) ~ ((P 3 % 4) / (P 1 % 4))) +_testSlash_Rat3P4_Rat1P3 = Dict @((P 9 % 4) ~ ((P 3 % 4) / (P 1 % 3))) +_testSlash_Rat3P4_Rat1P2 = Dict @((P 3 % 2) ~ ((P 3 % 4) / (P 1 % 2))) +_testSlash_Rat3P4_Rat2P3 = Dict @((P 9 % 8) ~ ((P 3 % 4) / (P 2 % 3))) +_testSlash_Rat3P4_Rat3P4 = Dict @((P 1 % 1) ~ ((P 3 % 4) / (P 3 % 4))) +_testSlash_Rat3P4_Rat1P1 = Dict @((P 3 % 4) ~ ((P 3 % 4) / (P 1 % 1))) +_testSlash_Rat3P4_Rat4P3 = Dict @((P 9 % 16) ~ ((P 3 % 4) / (P 4 % 3))) +_testSlash_Rat3P4_Rat3P2 = Dict @((P 1 % 2) ~ ((P 3 % 4) / (P 3 % 2))) +_testSlash_Rat3P4_Rat2P1 = Dict @((P 3 % 8) ~ ((P 3 % 4) / (P 2 % 1))) +_testSlash_Rat3P4_Rat3P1 = Dict @((P 1 % 4) ~ ((P 3 % 4) / (P 3 % 1))) +_testSlash_Rat3P4_Rat4P1 = Dict @((P 3 % 16) ~ ((P 3 % 4) / (P 4 % 1))) +_testSlash_Rat1P1_Nat1 = Dict @((P 1 % 1) ~ ((P 1 % 1) / 1)) +_testSlash_Rat1P1_Nat2 = Dict @((P 1 % 2) ~ ((P 1 % 1) / 2)) +_testSlash_Rat1P1_Nat3 = Dict @((P 1 % 3) ~ ((P 1 % 1) / 3)) +_testSlash_Rat1P1_Nat4 = Dict @((P 1 % 4) ~ ((P 1 % 1) / 4)) +_testSlash_Rat1P1_IntN4 = Dict @((N 1 % 4) ~ ((P 1 % 1) / (N 4))) +_testSlash_Rat1P1_IntN3 = Dict @((N 1 % 3) ~ ((P 1 % 1) / (N 3))) +_testSlash_Rat1P1_IntN2 = Dict @((N 1 % 2) ~ ((P 1 % 1) / (N 2))) +_testSlash_Rat1P1_IntN1 = Dict @((N 1 % 1) ~ ((P 1 % 1) / (N 1))) +_testSlash_Rat1P1_IntP1 = Dict @((P 1 % 1) ~ ((P 1 % 1) / (P 1))) +_testSlash_Rat1P1_IntP2 = Dict @((P 1 % 2) ~ ((P 1 % 1) / (P 2))) +_testSlash_Rat1P1_IntP3 = Dict @((P 1 % 3) ~ ((P 1 % 1) / (P 3))) +_testSlash_Rat1P1_IntP4 = Dict @((P 1 % 4) ~ ((P 1 % 1) / (P 4))) +_testSlash_Rat1P1_Rat4N1 = Dict @((N 1 % 4) ~ ((P 1 % 1) / (N 4 % 1))) +_testSlash_Rat1P1_Rat3N1 = Dict @((N 1 % 3) ~ ((P 1 % 1) / (N 3 % 1))) +_testSlash_Rat1P1_Rat2N1 = Dict @((N 1 % 2) ~ ((P 1 % 1) / (N 2 % 1))) +_testSlash_Rat1P1_Rat3N2 = Dict @((N 2 % 3) ~ ((P 1 % 1) / (N 3 % 2))) +_testSlash_Rat1P1_Rat4N3 = Dict @((N 3 % 4) ~ ((P 1 % 1) / (N 4 % 3))) +_testSlash_Rat1P1_Rat1N1 = Dict @((N 1 % 1) ~ ((P 1 % 1) / (N 1 % 1))) +_testSlash_Rat1P1_Rat3N4 = Dict @((N 4 % 3) ~ ((P 1 % 1) / (N 3 % 4))) +_testSlash_Rat1P1_Rat2N3 = Dict @((N 3 % 2) ~ ((P 1 % 1) / (N 2 % 3))) +_testSlash_Rat1P1_Rat1N2 = Dict @((N 2 % 1) ~ ((P 1 % 1) / (N 1 % 2))) +_testSlash_Rat1P1_Rat1N3 = Dict @((N 3 % 1) ~ ((P 1 % 1) / (N 1 % 3))) +_testSlash_Rat1P1_Rat1N4 = Dict @((N 4 % 1) ~ ((P 1 % 1) / (N 1 % 4))) +_testSlash_Rat1P1_Rat1P4 = Dict @((P 4 % 1) ~ ((P 1 % 1) / (P 1 % 4))) +_testSlash_Rat1P1_Rat1P3 = Dict @((P 3 % 1) ~ ((P 1 % 1) / (P 1 % 3))) +_testSlash_Rat1P1_Rat1P2 = Dict @((P 2 % 1) ~ ((P 1 % 1) / (P 1 % 2))) +_testSlash_Rat1P1_Rat2P3 = Dict @((P 3 % 2) ~ ((P 1 % 1) / (P 2 % 3))) +_testSlash_Rat1P1_Rat3P4 = Dict @((P 4 % 3) ~ ((P 1 % 1) / (P 3 % 4))) +_testSlash_Rat1P1_Rat1P1 = Dict @((P 1 % 1) ~ ((P 1 % 1) / (P 1 % 1))) +_testSlash_Rat1P1_Rat4P3 = Dict @((P 3 % 4) ~ ((P 1 % 1) / (P 4 % 3))) +_testSlash_Rat1P1_Rat3P2 = Dict @((P 2 % 3) ~ ((P 1 % 1) / (P 3 % 2))) +_testSlash_Rat1P1_Rat2P1 = Dict @((P 1 % 2) ~ ((P 1 % 1) / (P 2 % 1))) +_testSlash_Rat1P1_Rat3P1 = Dict @((P 1 % 3) ~ ((P 1 % 1) / (P 3 % 1))) +_testSlash_Rat1P1_Rat4P1 = Dict @((P 1 % 4) ~ ((P 1 % 1) / (P 4 % 1))) +_testSlash_Rat4P3_Nat1 = Dict @((P 4 % 3) ~ ((P 4 % 3) / 1)) +_testSlash_Rat4P3_Nat2 = Dict @((P 2 % 3) ~ ((P 4 % 3) / 2)) +_testSlash_Rat4P3_Nat3 = Dict @((P 4 % 9) ~ ((P 4 % 3) / 3)) +_testSlash_Rat4P3_Nat4 = Dict @((P 1 % 3) ~ ((P 4 % 3) / 4)) +_testSlash_Rat4P3_IntN4 = Dict @((N 1 % 3) ~ ((P 4 % 3) / (N 4))) +_testSlash_Rat4P3_IntN3 = Dict @((N 4 % 9) ~ ((P 4 % 3) / (N 3))) +_testSlash_Rat4P3_IntN2 = Dict @((N 2 % 3) ~ ((P 4 % 3) / (N 2))) +_testSlash_Rat4P3_IntN1 = Dict @((N 4 % 3) ~ ((P 4 % 3) / (N 1))) +_testSlash_Rat4P3_IntP1 = Dict @((P 4 % 3) ~ ((P 4 % 3) / (P 1))) +_testSlash_Rat4P3_IntP2 = Dict @((P 2 % 3) ~ ((P 4 % 3) / (P 2))) +_testSlash_Rat4P3_IntP3 = Dict @((P 4 % 9) ~ ((P 4 % 3) / (P 3))) +_testSlash_Rat4P3_IntP4 = Dict @((P 1 % 3) ~ ((P 4 % 3) / (P 4))) +_testSlash_Rat4P3_Rat4N1 = Dict @((N 1 % 3) ~ ((P 4 % 3) / (N 4 % 1))) +_testSlash_Rat4P3_Rat3N1 = Dict @((N 4 % 9) ~ ((P 4 % 3) / (N 3 % 1))) +_testSlash_Rat4P3_Rat2N1 = Dict @((N 2 % 3) ~ ((P 4 % 3) / (N 2 % 1))) +_testSlash_Rat4P3_Rat3N2 = Dict @((N 8 % 9) ~ ((P 4 % 3) / (N 3 % 2))) +_testSlash_Rat4P3_Rat4N3 = Dict @((N 1 % 1) ~ ((P 4 % 3) / (N 4 % 3))) +_testSlash_Rat4P3_Rat1N1 = Dict @((N 4 % 3) ~ ((P 4 % 3) / (N 1 % 1))) +_testSlash_Rat4P3_Rat3N4 = Dict @((N 16 % 9) ~ ((P 4 % 3) / (N 3 % 4))) +_testSlash_Rat4P3_Rat2N3 = Dict @((N 2 % 1) ~ ((P 4 % 3) / (N 2 % 3))) +_testSlash_Rat4P3_Rat1N2 = Dict @((N 8 % 3) ~ ((P 4 % 3) / (N 1 % 2))) +_testSlash_Rat4P3_Rat1N3 = Dict @((N 4 % 1) ~ ((P 4 % 3) / (N 1 % 3))) +_testSlash_Rat4P3_Rat1N4 = Dict @((N 16 % 3) ~ ((P 4 % 3) / (N 1 % 4))) +_testSlash_Rat4P3_Rat1P4 = Dict @((P 16 % 3) ~ ((P 4 % 3) / (P 1 % 4))) +_testSlash_Rat4P3_Rat1P3 = Dict @((P 4 % 1) ~ ((P 4 % 3) / (P 1 % 3))) +_testSlash_Rat4P3_Rat1P2 = Dict @((P 8 % 3) ~ ((P 4 % 3) / (P 1 % 2))) +_testSlash_Rat4P3_Rat2P3 = Dict @((P 2 % 1) ~ ((P 4 % 3) / (P 2 % 3))) +_testSlash_Rat4P3_Rat3P4 = Dict @((P 16 % 9) ~ ((P 4 % 3) / (P 3 % 4))) +_testSlash_Rat4P3_Rat1P1 = Dict @((P 4 % 3) ~ ((P 4 % 3) / (P 1 % 1))) +_testSlash_Rat4P3_Rat4P3 = Dict @((P 1 % 1) ~ ((P 4 % 3) / (P 4 % 3))) +_testSlash_Rat4P3_Rat3P2 = Dict @((P 8 % 9) ~ ((P 4 % 3) / (P 3 % 2))) +_testSlash_Rat4P3_Rat2P1 = Dict @((P 2 % 3) ~ ((P 4 % 3) / (P 2 % 1))) +_testSlash_Rat4P3_Rat3P1 = Dict @((P 4 % 9) ~ ((P 4 % 3) / (P 3 % 1))) +_testSlash_Rat4P3_Rat4P1 = Dict @((P 1 % 3) ~ ((P 4 % 3) / (P 4 % 1))) +_testSlash_Rat3P2_Nat1 = Dict @((P 3 % 2) ~ ((P 3 % 2) / 1)) +_testSlash_Rat3P2_Nat2 = Dict @((P 3 % 4) ~ ((P 3 % 2) / 2)) +_testSlash_Rat3P2_Nat3 = Dict @((P 1 % 2) ~ ((P 3 % 2) / 3)) +_testSlash_Rat3P2_Nat4 = Dict @((P 3 % 8) ~ ((P 3 % 2) / 4)) +_testSlash_Rat3P2_IntN4 = Dict @((N 3 % 8) ~ ((P 3 % 2) / (N 4))) +_testSlash_Rat3P2_IntN3 = Dict @((N 1 % 2) ~ ((P 3 % 2) / (N 3))) +_testSlash_Rat3P2_IntN2 = Dict @((N 3 % 4) ~ ((P 3 % 2) / (N 2))) +_testSlash_Rat3P2_IntN1 = Dict @((N 3 % 2) ~ ((P 3 % 2) / (N 1))) +_testSlash_Rat3P2_IntP1 = Dict @((P 3 % 2) ~ ((P 3 % 2) / (P 1))) +_testSlash_Rat3P2_IntP2 = Dict @((P 3 % 4) ~ ((P 3 % 2) / (P 2))) +_testSlash_Rat3P2_IntP3 = Dict @((P 1 % 2) ~ ((P 3 % 2) / (P 3))) +_testSlash_Rat3P2_IntP4 = Dict @((P 3 % 8) ~ ((P 3 % 2) / (P 4))) +_testSlash_Rat3P2_Rat4N1 = Dict @((N 3 % 8) ~ ((P 3 % 2) / (N 4 % 1))) +_testSlash_Rat3P2_Rat3N1 = Dict @((N 1 % 2) ~ ((P 3 % 2) / (N 3 % 1))) +_testSlash_Rat3P2_Rat2N1 = Dict @((N 3 % 4) ~ ((P 3 % 2) / (N 2 % 1))) +_testSlash_Rat3P2_Rat3N2 = Dict @((N 1 % 1) ~ ((P 3 % 2) / (N 3 % 2))) +_testSlash_Rat3P2_Rat4N3 = Dict @((N 9 % 8) ~ ((P 3 % 2) / (N 4 % 3))) +_testSlash_Rat3P2_Rat1N1 = Dict @((N 3 % 2) ~ ((P 3 % 2) / (N 1 % 1))) +_testSlash_Rat3P2_Rat3N4 = Dict @((N 2 % 1) ~ ((P 3 % 2) / (N 3 % 4))) +_testSlash_Rat3P2_Rat2N3 = Dict @((N 9 % 4) ~ ((P 3 % 2) / (N 2 % 3))) +_testSlash_Rat3P2_Rat1N2 = Dict @((N 3 % 1) ~ ((P 3 % 2) / (N 1 % 2))) +_testSlash_Rat3P2_Rat1N3 = Dict @((N 9 % 2) ~ ((P 3 % 2) / (N 1 % 3))) +_testSlash_Rat3P2_Rat1N4 = Dict @((N 6 % 1) ~ ((P 3 % 2) / (N 1 % 4))) +_testSlash_Rat3P2_Rat1P4 = Dict @((P 6 % 1) ~ ((P 3 % 2) / (P 1 % 4))) +_testSlash_Rat3P2_Rat1P3 = Dict @((P 9 % 2) ~ ((P 3 % 2) / (P 1 % 3))) +_testSlash_Rat3P2_Rat1P2 = Dict @((P 3 % 1) ~ ((P 3 % 2) / (P 1 % 2))) +_testSlash_Rat3P2_Rat2P3 = Dict @((P 9 % 4) ~ ((P 3 % 2) / (P 2 % 3))) +_testSlash_Rat3P2_Rat3P4 = Dict @((P 2 % 1) ~ ((P 3 % 2) / (P 3 % 4))) +_testSlash_Rat3P2_Rat1P1 = Dict @((P 3 % 2) ~ ((P 3 % 2) / (P 1 % 1))) +_testSlash_Rat3P2_Rat4P3 = Dict @((P 9 % 8) ~ ((P 3 % 2) / (P 4 % 3))) +_testSlash_Rat3P2_Rat3P2 = Dict @((P 1 % 1) ~ ((P 3 % 2) / (P 3 % 2))) +_testSlash_Rat3P2_Rat2P1 = Dict @((P 3 % 4) ~ ((P 3 % 2) / (P 2 % 1))) +_testSlash_Rat3P2_Rat3P1 = Dict @((P 1 % 2) ~ ((P 3 % 2) / (P 3 % 1))) +_testSlash_Rat3P2_Rat4P1 = Dict @((P 3 % 8) ~ ((P 3 % 2) / (P 4 % 1))) +_testSlash_Rat2P1_Nat1 = Dict @((P 2 % 1) ~ ((P 2 % 1) / 1)) +_testSlash_Rat2P1_Nat2 = Dict @((P 1 % 1) ~ ((P 2 % 1) / 2)) +_testSlash_Rat2P1_Nat3 = Dict @((P 2 % 3) ~ ((P 2 % 1) / 3)) +_testSlash_Rat2P1_Nat4 = Dict @((P 1 % 2) ~ ((P 2 % 1) / 4)) +_testSlash_Rat2P1_IntN4 = Dict @((N 1 % 2) ~ ((P 2 % 1) / (N 4))) +_testSlash_Rat2P1_IntN3 = Dict @((N 2 % 3) ~ ((P 2 % 1) / (N 3))) +_testSlash_Rat2P1_IntN2 = Dict @((N 1 % 1) ~ ((P 2 % 1) / (N 2))) +_testSlash_Rat2P1_IntN1 = Dict @((N 2 % 1) ~ ((P 2 % 1) / (N 1))) +_testSlash_Rat2P1_IntP1 = Dict @((P 2 % 1) ~ ((P 2 % 1) / (P 1))) +_testSlash_Rat2P1_IntP2 = Dict @((P 1 % 1) ~ ((P 2 % 1) / (P 2))) +_testSlash_Rat2P1_IntP3 = Dict @((P 2 % 3) ~ ((P 2 % 1) / (P 3))) +_testSlash_Rat2P1_IntP4 = Dict @((P 1 % 2) ~ ((P 2 % 1) / (P 4))) +_testSlash_Rat2P1_Rat4N1 = Dict @((N 1 % 2) ~ ((P 2 % 1) / (N 4 % 1))) +_testSlash_Rat2P1_Rat3N1 = Dict @((N 2 % 3) ~ ((P 2 % 1) / (N 3 % 1))) +_testSlash_Rat2P1_Rat2N1 = Dict @((N 1 % 1) ~ ((P 2 % 1) / (N 2 % 1))) +_testSlash_Rat2P1_Rat3N2 = Dict @((N 4 % 3) ~ ((P 2 % 1) / (N 3 % 2))) +_testSlash_Rat2P1_Rat4N3 = Dict @((N 3 % 2) ~ ((P 2 % 1) / (N 4 % 3))) +_testSlash_Rat2P1_Rat1N1 = Dict @((N 2 % 1) ~ ((P 2 % 1) / (N 1 % 1))) +_testSlash_Rat2P1_Rat3N4 = Dict @((N 8 % 3) ~ ((P 2 % 1) / (N 3 % 4))) +_testSlash_Rat2P1_Rat2N3 = Dict @((N 3 % 1) ~ ((P 2 % 1) / (N 2 % 3))) +_testSlash_Rat2P1_Rat1N2 = Dict @((N 4 % 1) ~ ((P 2 % 1) / (N 1 % 2))) +_testSlash_Rat2P1_Rat1N3 = Dict @((N 6 % 1) ~ ((P 2 % 1) / (N 1 % 3))) +_testSlash_Rat2P1_Rat1N4 = Dict @((N 8 % 1) ~ ((P 2 % 1) / (N 1 % 4))) +_testSlash_Rat2P1_Rat1P4 = Dict @((P 8 % 1) ~ ((P 2 % 1) / (P 1 % 4))) +_testSlash_Rat2P1_Rat1P3 = Dict @((P 6 % 1) ~ ((P 2 % 1) / (P 1 % 3))) +_testSlash_Rat2P1_Rat1P2 = Dict @((P 4 % 1) ~ ((P 2 % 1) / (P 1 % 2))) +_testSlash_Rat2P1_Rat2P3 = Dict @((P 3 % 1) ~ ((P 2 % 1) / (P 2 % 3))) +_testSlash_Rat2P1_Rat3P4 = Dict @((P 8 % 3) ~ ((P 2 % 1) / (P 3 % 4))) +_testSlash_Rat2P1_Rat1P1 = Dict @((P 2 % 1) ~ ((P 2 % 1) / (P 1 % 1))) +_testSlash_Rat2P1_Rat4P3 = Dict @((P 3 % 2) ~ ((P 2 % 1) / (P 4 % 3))) +_testSlash_Rat2P1_Rat3P2 = Dict @((P 4 % 3) ~ ((P 2 % 1) / (P 3 % 2))) +_testSlash_Rat2P1_Rat2P1 = Dict @((P 1 % 1) ~ ((P 2 % 1) / (P 2 % 1))) +_testSlash_Rat2P1_Rat3P1 = Dict @((P 2 % 3) ~ ((P 2 % 1) / (P 3 % 1))) +_testSlash_Rat2P1_Rat4P1 = Dict @((P 1 % 2) ~ ((P 2 % 1) / (P 4 % 1))) +_testSlash_Rat3P1_Nat1 = Dict @((P 3 % 1) ~ ((P 3 % 1) / 1)) +_testSlash_Rat3P1_Nat2 = Dict @((P 3 % 2) ~ ((P 3 % 1) / 2)) +_testSlash_Rat3P1_Nat3 = Dict @((P 1 % 1) ~ ((P 3 % 1) / 3)) +_testSlash_Rat3P1_Nat4 = Dict @((P 3 % 4) ~ ((P 3 % 1) / 4)) +_testSlash_Rat3P1_IntN4 = Dict @((N 3 % 4) ~ ((P 3 % 1) / (N 4))) +_testSlash_Rat3P1_IntN3 = Dict @((N 1 % 1) ~ ((P 3 % 1) / (N 3))) +_testSlash_Rat3P1_IntN2 = Dict @((N 3 % 2) ~ ((P 3 % 1) / (N 2))) +_testSlash_Rat3P1_IntN1 = Dict @((N 3 % 1) ~ ((P 3 % 1) / (N 1))) +_testSlash_Rat3P1_IntP1 = Dict @((P 3 % 1) ~ ((P 3 % 1) / (P 1))) +_testSlash_Rat3P1_IntP2 = Dict @((P 3 % 2) ~ ((P 3 % 1) / (P 2))) +_testSlash_Rat3P1_IntP3 = Dict @((P 1 % 1) ~ ((P 3 % 1) / (P 3))) +_testSlash_Rat3P1_IntP4 = Dict @((P 3 % 4) ~ ((P 3 % 1) / (P 4))) +_testSlash_Rat3P1_Rat4N1 = Dict @((N 3 % 4) ~ ((P 3 % 1) / (N 4 % 1))) +_testSlash_Rat3P1_Rat3N1 = Dict @((N 1 % 1) ~ ((P 3 % 1) / (N 3 % 1))) +_testSlash_Rat3P1_Rat2N1 = Dict @((N 3 % 2) ~ ((P 3 % 1) / (N 2 % 1))) +_testSlash_Rat3P1_Rat3N2 = Dict @((N 2 % 1) ~ ((P 3 % 1) / (N 3 % 2))) +_testSlash_Rat3P1_Rat4N3 = Dict @((N 9 % 4) ~ ((P 3 % 1) / (N 4 % 3))) +_testSlash_Rat3P1_Rat1N1 = Dict @((N 3 % 1) ~ ((P 3 % 1) / (N 1 % 1))) +_testSlash_Rat3P1_Rat3N4 = Dict @((N 4 % 1) ~ ((P 3 % 1) / (N 3 % 4))) +_testSlash_Rat3P1_Rat2N3 = Dict @((N 9 % 2) ~ ((P 3 % 1) / (N 2 % 3))) +_testSlash_Rat3P1_Rat1N2 = Dict @((N 6 % 1) ~ ((P 3 % 1) / (N 1 % 2))) +_testSlash_Rat3P1_Rat1N3 = Dict @((N 9 % 1) ~ ((P 3 % 1) / (N 1 % 3))) +_testSlash_Rat3P1_Rat1N4 = Dict @((N 12 % 1) ~ ((P 3 % 1) / (N 1 % 4))) +_testSlash_Rat3P1_Rat1P4 = Dict @((P 12 % 1) ~ ((P 3 % 1) / (P 1 % 4))) +_testSlash_Rat3P1_Rat1P3 = Dict @((P 9 % 1) ~ ((P 3 % 1) / (P 1 % 3))) +_testSlash_Rat3P1_Rat1P2 = Dict @((P 6 % 1) ~ ((P 3 % 1) / (P 1 % 2))) +_testSlash_Rat3P1_Rat2P3 = Dict @((P 9 % 2) ~ ((P 3 % 1) / (P 2 % 3))) +_testSlash_Rat3P1_Rat3P4 = Dict @((P 4 % 1) ~ ((P 3 % 1) / (P 3 % 4))) +_testSlash_Rat3P1_Rat1P1 = Dict @((P 3 % 1) ~ ((P 3 % 1) / (P 1 % 1))) +_testSlash_Rat3P1_Rat4P3 = Dict @((P 9 % 4) ~ ((P 3 % 1) / (P 4 % 3))) +_testSlash_Rat3P1_Rat3P2 = Dict @((P 2 % 1) ~ ((P 3 % 1) / (P 3 % 2))) +_testSlash_Rat3P1_Rat2P1 = Dict @((P 3 % 2) ~ ((P 3 % 1) / (P 2 % 1))) +_testSlash_Rat3P1_Rat3P1 = Dict @((P 1 % 1) ~ ((P 3 % 1) / (P 3 % 1))) +_testSlash_Rat3P1_Rat4P1 = Dict @((P 3 % 4) ~ ((P 3 % 1) / (P 4 % 1))) +_testSlash_Rat4P1_Nat1 = Dict @((P 4 % 1) ~ ((P 4 % 1) / 1)) +_testSlash_Rat4P1_Nat2 = Dict @((P 2 % 1) ~ ((P 4 % 1) / 2)) +_testSlash_Rat4P1_Nat3 = Dict @((P 4 % 3) ~ ((P 4 % 1) / 3)) +_testSlash_Rat4P1_Nat4 = Dict @((P 1 % 1) ~ ((P 4 % 1) / 4)) +_testSlash_Rat4P1_IntN4 = Dict @((N 1 % 1) ~ ((P 4 % 1) / (N 4))) +_testSlash_Rat4P1_IntN3 = Dict @((N 4 % 3) ~ ((P 4 % 1) / (N 3))) +_testSlash_Rat4P1_IntN2 = Dict @((N 2 % 1) ~ ((P 4 % 1) / (N 2))) +_testSlash_Rat4P1_IntN1 = Dict @((N 4 % 1) ~ ((P 4 % 1) / (N 1))) +_testSlash_Rat4P1_IntP1 = Dict @((P 4 % 1) ~ ((P 4 % 1) / (P 1))) +_testSlash_Rat4P1_IntP2 = Dict @((P 2 % 1) ~ ((P 4 % 1) / (P 2))) +_testSlash_Rat4P1_IntP3 = Dict @((P 4 % 3) ~ ((P 4 % 1) / (P 3))) +_testSlash_Rat4P1_IntP4 = Dict @((P 1 % 1) ~ ((P 4 % 1) / (P 4))) +_testSlash_Rat4P1_Rat4N1 = Dict @((N 1 % 1) ~ ((P 4 % 1) / (N 4 % 1))) +_testSlash_Rat4P1_Rat3N1 = Dict @((N 4 % 3) ~ ((P 4 % 1) / (N 3 % 1))) +_testSlash_Rat4P1_Rat2N1 = Dict @((N 2 % 1) ~ ((P 4 % 1) / (N 2 % 1))) +_testSlash_Rat4P1_Rat3N2 = Dict @((N 8 % 3) ~ ((P 4 % 1) / (N 3 % 2))) +_testSlash_Rat4P1_Rat4N3 = Dict @((N 3 % 1) ~ ((P 4 % 1) / (N 4 % 3))) +_testSlash_Rat4P1_Rat1N1 = Dict @((N 4 % 1) ~ ((P 4 % 1) / (N 1 % 1))) +_testSlash_Rat4P1_Rat3N4 = Dict @((N 16 % 3) ~ ((P 4 % 1) / (N 3 % 4))) +_testSlash_Rat4P1_Rat2N3 = Dict @((N 6 % 1) ~ ((P 4 % 1) / (N 2 % 3))) +_testSlash_Rat4P1_Rat1N2 = Dict @((N 8 % 1) ~ ((P 4 % 1) / (N 1 % 2))) +_testSlash_Rat4P1_Rat1N3 = Dict @((N 12 % 1) ~ ((P 4 % 1) / (N 1 % 3))) +_testSlash_Rat4P1_Rat1N4 = Dict @((N 16 % 1) ~ ((P 4 % 1) / (N 1 % 4))) +_testSlash_Rat4P1_Rat1P4 = Dict @((P 16 % 1) ~ ((P 4 % 1) / (P 1 % 4))) +_testSlash_Rat4P1_Rat1P3 = Dict @((P 12 % 1) ~ ((P 4 % 1) / (P 1 % 3))) +_testSlash_Rat4P1_Rat1P2 = Dict @((P 8 % 1) ~ ((P 4 % 1) / (P 1 % 2))) +_testSlash_Rat4P1_Rat2P3 = Dict @((P 6 % 1) ~ ((P 4 % 1) / (P 2 % 3))) +_testSlash_Rat4P1_Rat3P4 = Dict @((P 16 % 3) ~ ((P 4 % 1) / (P 3 % 4))) +_testSlash_Rat4P1_Rat1P1 = Dict @((P 4 % 1) ~ ((P 4 % 1) / (P 1 % 1))) +_testSlash_Rat4P1_Rat4P3 = Dict @((P 3 % 1) ~ ((P 4 % 1) / (P 4 % 3))) +_testSlash_Rat4P1_Rat3P2 = Dict @((P 8 % 3) ~ ((P 4 % 1) / (P 3 % 2))) +_testSlash_Rat4P1_Rat2P1 = Dict @((P 2 % 1) ~ ((P 4 % 1) / (P 2 % 1))) +_testSlash_Rat4P1_Rat3P1 = Dict @((P 4 % 3) ~ ((P 4 % 1) / (P 3 % 1))) +_testSlash_Rat4P1_Rat4P1 = Dict @((P 1 % 1) ~ ((P 4 % 1) / (P 4 % 1)))