diff --git a/Haschoo.cabal b/Haschoo.cabal new file mode 100644 --- /dev/null +++ b/Haschoo.cabal @@ -0,0 +1,58 @@ +Cabal-Version: >= 1.6 + +Name: Haschoo +Version: 0.0 +Homepage: http://iki.fi/matti.niemenmaa/misc-projects.html#haschoo +Synopsis: Minimalist R5RS Scheme interpreter +Category: Compilers/Interpreters +Description: + Haschoo is a minimalist R5RS interpreter written in Haskell for a university + course. + +Author: Matti Niemenmaa +Maintainer: Matti Niemenmaa +License: BSD3 +License-File: LICENSE.txt + +Build-Type: Simple + +Extra-Source-Files: README.txt + tests/*.scm + tests/macros/*.scm + tests/macros/r5rs/4.3.1.scm + tests/macros/r5rs/4.3.2.scm + tests/macros/xfail/*.scm + +Executable haschoo + Main-Is: Haschoo/Main.hs + + Build-Depends: base == 4.* + , array == 0.2.* + , mtl == 1.1.* + , list-tries == 0.1.* + , numbers >= 2009.5.28 && <= 2009.8.9 + , monad-loops == 0.3.* + , parsec == 2.1.* + + Other-Modules: Haschoo.Evaluator + Haschoo.Evaluator.Eval + Haschoo.Evaluator.Macros + Haschoo.Evaluator.Primitives + Haschoo.Evaluator.Standard + Haschoo.Evaluator.Standard.Boolean + Haschoo.Evaluator.Standard.Characters + Haschoo.Evaluator.Standard.Control + Haschoo.Evaluator.Standard.Equivalence + Haschoo.Evaluator.Standard.Eval + Haschoo.Evaluator.Standard.IO + Haschoo.Evaluator.Standard.Numeric + Haschoo.Evaluator.Standard.PairsLists + Haschoo.Evaluator.Standard.Strings + Haschoo.Evaluator.Standard.Symbols + Haschoo.Evaluator.Standard.Vectors + Haschoo.Evaluator.Utils + Haschoo.Parser + Haschoo.Running + Haschoo.Stdlib + Haschoo.Types + Haschoo.Utils diff --git a/Haschoo/Evaluator.hs b/Haschoo/Evaluator.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator.hs @@ -0,0 +1,59 @@ +-- File created: 2009-07-14 14:37:46 + +module Haschoo.Evaluator (evalToplevel) where + +import Control.Monad.Error (throwError) +import Control.Monad.State (get) +import Data.IORef (IORef) + +import Haschoo.Types ( Haschoo, runHaschoo + , ScmValue( ScmList, ScmIdentifier, ScmSyntax + , ScmVoid) + , Context) +import Haschoo.Utils (ErrOr) +import Haschoo.Evaluator.Eval (eval, evalBody, define) +import Haschoo.Evaluator.Macros (mkMacro) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs) + +-- Programs consist of three things: +-- expressions - valid anywhere +-- definitions - valid at toplevel or at the beginning of a +-- syntax definitions - valid at toplevel +-- +-- Where is a body of one of: +-- lambda, let, let*, letrec, let-syntax, letrec-syntax, +-- or procedure definition +-- +-- Hence we need three eval functions (the following, evalBody, and eval) and +-- hence definitions are handled separately in the former two instead of being +-- ordinary primitives. +-- +-- "begin" needs special treatment as well, since it depends on the evaluation +-- level (R5RS 5.1, 5.2.2). We special-case it here and in evalBody, leaving +-- ordinary expression usage to the definition given in R5RS 7.3. + +evalToplevel :: [IORef Context] -> ScmValue -> IO (ErrOr ScmValue) +evalToplevel ctx = runHaschoo ctx . f + where + f (ScmList (ScmIdentifier i : xs)) + | i == "define-syntax" = do + scmDefineSyntax xs + return ScmVoid + + | i == "begin" = fmap last $ mapM f xs + + f d = evalBody [d] + +scmDefineSyntax :: [ScmValue] -> Haschoo () +scmDefineSyntax [ScmIdentifier var, x] = do + x' <- eval x + case x' of + ScmSyntax pats lits -> do + ctx <- get + define var (mkMacro ctx var pats lits) + + _ -> throwError "define-syntax :: expected instance of syntax-rules" + +scmDefineSyntax [_,_] = throwError "define-syntax :: expected identifier" +scmDefineSyntax (_:_:_) = tooManyArgs "define-syntax" +scmDefineSyntax _ = tooFewArgs "define-syntax" diff --git a/Haschoo/Evaluator/Eval.hs b/Haschoo/Evaluator/Eval.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Eval.hs @@ -0,0 +1,105 @@ +-- File created: 2009-07-26 16:26:13 + +module Haschoo.Evaluator.Eval (eval, maybeEval, evalBody, define) where + +import Control.Monad (msum) +import Control.Monad.Error (throwError, catchError) +import Control.Monad.State (get) +import Control.Monad.Trans (liftIO) +import Data.IORef (IORef, readIORef, modifyIORef) + +import qualified Data.ListTrie.Patricia.Map.Enum as TM +import Data.ListTrie.Patricia.Map.Enum (TrieMap) + +import Haschoo.Types ( Haschoo + , ScmValue( ScmPrim, ScmFunc, ScmMacro + , ScmList, ScmDottedList + , ScmVoid, ScmIdentifier) + , MacroCall(..) + , Context, addToContext, contextLookup) +import Haschoo.Utils (lazyMapM, modifyM) +import Haschoo.Evaluator.Utils (tooFewArgs) + +eval :: ScmValue -> Haschoo ScmValue +eval = evalWithSpecialCases TM.empty + +evalWithSpecialCases :: TrieMap Char [IORef Context] + -> ScmValue -> Haschoo ScmValue +evalWithSpecialCases specials (ScmIdentifier s) = + case TM.lookup s specials of + Just specialCtx -> lookupId specialCtx + Nothing -> lookupId =<< get + where + lookupId ctx = do + lookups <- lazyMapM (fmap (contextLookup s) . readIORef) ctx + case msum lookups of + Nothing -> throwError $ "Unbound identifier '" ++ s ++ "'" + Just v -> return v + +evalWithSpecialCases _ (ScmList []) = throwError "Empty application" +evalWithSpecialCases sp (ScmList (x:xs)) = do + evaledHead <- evalWithSpecialCases sp x + case evaledHead of + ScmPrim _ f -> f xs + ScmFunc _ f -> do + args <- mapM (evalWithSpecialCases sp) xs + result <- liftIO $ f args + case result of + Left s -> throwError s + Right val -> return val + + m@(ScmMacro _ _) -> evalMacro sp m (MCList xs) + + _ -> throwError "Can't apply non-function" + +evalWithSpecialCases sp (ScmDottedList (x:xs) y) = do + evaledHead <- evalWithSpecialCases sp x + case evaledHead of + m@(ScmMacro _ _) -> evalMacro sp m (MCDotted xs y) + + _ -> throwError "Ill-formed procedure application: no dots allowed" + +evalWithSpecialCases _ v = return v + +evalMacro :: TrieMap Char [IORef Context] + -> ScmValue -> MacroCall -> Haschoo ScmValue +evalMacro sp (ScmMacro _ f) xs = do + (expansion, frees) <- f xs + evalWithSpecialCases (TM.union frees sp) expansion + +evalMacro _ _ _ = error "evalMacro :: the impossible happened: not a macro" + +maybeEval :: ScmValue -> Haschoo (Maybe ScmValue) +maybeEval = (`catchError` const (return Nothing)) . fmap Just . eval + +evalBody :: [ScmValue] -> Haschoo ScmValue +evalBody (ScmList (ScmIdentifier i : xs) : ds) + | i == "define" = scmDefine xs >> evalBody ds + | i == "begin" = evalBody (xs ++ ds) + +evalBody ds@(_:_) = fmap last . mapM eval $ ds +evalBody [] = return ScmVoid + +define :: String -> ScmValue -> Haschoo () +define var body = eval body >>= modifyM . f + where + f e (c:cs) = do + liftIO $ modifyIORef c (addToContext var e) + return (c:cs) + f _ [] = error "define :: the impossible happened: empty context stack" + +scmDefine :: [ScmValue] -> Haschoo () +scmDefine [ScmIdentifier var, expr] = define var expr + +scmDefine (ScmList (ScmIdentifier func : params) : body) = + define func . ScmList $ ScmIdentifier "lambda" : ScmList params : body + +scmDefine (ScmDottedList (ScmIdentifier func : params) final : body) = + define func . ScmList $ ScmIdentifier "lambda" + : (if null params + then final + else ScmDottedList params final) + : body + +scmDefine (_:_:_) = throwError "define :: expected identifier" +scmDefine _ = tooFewArgs "define" diff --git a/Haschoo/Evaluator/Macros.hs b/Haschoo/Evaluator/Macros.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Macros.hs @@ -0,0 +1,275 @@ +-- File created: 2009-07-26 16:12:14 + +{-# LANGUAGE PatternGuards #-} + +module Haschoo.Evaluator.Macros (mkMacro) where + +import Control.Applicative ((<$>)) +import Control.Arrow (first) +import Control.Monad (liftM2, when) +import Control.Monad.Error (throwError) +import Control.Monad.Loops (andM, allM, firstM, untilM) +import Control.Monad.State.Strict (State, runState, put, get, modify) +import Control.Monad.Trans (MonadIO, lift, liftIO) +import Control.Monad.Writer.Strict (WriterT, runWriterT, tell) +import Data.Array.IArray (elems) +import Data.IORef (IORef) +import Data.List (find) +import Data.Maybe (catMaybes, isNothing) +import Data.Monoid (Monoid(mempty, mappend)) + +import qualified Data.ListTrie.Patricia.Map.Enum as TM +import Data.ListTrie.Patricia.Map.Enum (TrieMap) + +import Haschoo.Types ( Haschoo + , ScmValue + ( ScmMacro, ScmIdentifier + , ScmList, ScmDottedList + , ScmVector) + , MacroCall(..) + , Context + , isAggregate, toScmVector) +import Haschoo.Utils ( fst3, initLast2Maybe + , ptrEq, eqWithM, ErrOr) +import Haschoo.Evaluator.Eval (maybeEval) +import Haschoo.Evaluator.Standard.Equivalence (scmEqual) + +-- The Left case is for ellipses +newtype PatternMatches = PM (TrieMap Char (Either [ScmValue] ScmValue)) + +-- Right-biased union instead of the default left-biased: so we can overwrite +-- keys in a Writer with a second call to tell +instance Monoid PatternMatches where + mempty = PM mempty + mappend (PM a) (PM b) = PM (TM.union b a) + +type Lits = [(String, Maybe ScmValue)] + +mkMacro :: [IORef Context] -> String -> [(ScmValue, ScmValue, [String])] + -> Lits -> ScmValue +mkMacro ctx name pats ls = ScmMacro name f + where + f args = do + (matching,replacements) <- + runWriterT $ firstM (match ls args . fst3) pats + + case matching of + Nothing -> throwError ("Invalid use of macro " ++ name) + Just (_,v,frees) -> + case replaceVars (map fst ls) frees replacements v of + Left s -> throwError s + Right replaced -> + return ( simplifyList replaced + , TM.fromList (zip frees (repeat ctx))) + +-- Turning MCDotted to ScmDottedList here means that the list in the +-- ScmDottedList may actually be empty, which can't happen normally +match :: Lits -> MacroCall -> ScmValue -> WriterT PatternMatches Haschoo Bool +match lits (MCList xs) = match1 lits (ScmList xs) +match lits (MCDotted xs x) = match1 lits (ScmDottedList xs x) + +-- Paraphrasing R5RS 4.3.2: +-- +-- "... formally, an input form F matches a pattern P iff:" ... +match1 :: Lits -> ScmValue -> ScmValue -> WriterT PatternMatches Haschoo Bool +match1 lits arg (ScmIdentifier i) = + case find ((== i).fst) lits of + -- ... "P is a non-literal identifier" ... + Nothing -> do tell (PM $ TM.singleton i (Right arg)) + return True + Just (_, binding) -> + case arg of + -- ... "P is a literal identifier and F is an identifier with + -- the same binding, or the two identifiers are equal and both + -- have no lexical binding" ... + x@(ScmIdentifier i2) -> do + xb <- lift $ maybeEval x + case binding of + Nothing -> return (isNothing xb && i == i2) + Just pb -> maybe (return False) (liftIO . ptrEq pb) xb + + _ -> return False + +match1 lits (ScmList args) (ScmList ps) = + case initLast2Maybe ps of + -- ... "P is of the form (P1 ... Pn Pm ) where is + -- the identifier ... and F is a list of at least n forms, the first n + -- of which match P1 through Pn and each remaining element matches Pm" + -- ... + Just (ps', p, ScmIdentifier "...") -> + let (xs, ys) = splitAt (length ps') args + in do m <- andM [ allMatch lits xs ps' + , allM (flip (match1 lits) p) ys] + when m (assignMatches ys p) + return m + + -- ... "P is a list (P1 ... Pn) and F is a list of n forms that match + -- P1 through Pn" ... + _ -> allMatch lits args ps + + where + assignMatches ys (ScmIdentifier i) = tell (PM $ TM.singleton i (Left ys)) + + -- E.g. pl = (x y z) and ys = [(1 2 3),(4 5 6)] + -- + -- Bind x to [1,4], y to [2,5], z to [3,6] + assignMatches ys p = + case p of + ScmList _ -> assignList (\(ScmList l) -> l) + ScmVector _ -> assignList (\(ScmVector v) -> elems v) + ScmDottedList _ _ -> assignList (\(ScmDottedList l x) -> x:l) + _ -> return () + + where + assignList toList = + let -- Continuing the above example, this would give + -- [(x,1),(x,4),(y,2),(y,5),(z,3),(z,6)] + lpat = toList p + paired = concatMap (zip lpat . toList) ys + + -- From then on it's quite trivial. + -- + -- Just be sure to add an initial empty match for each identifier. + -- This ensures that patterns such as ((x) ...), when matched + -- against (), result in any x in the output being replaced with + -- nothing, instead of them not being seen as matches. + matched = [(i, []) | ScmIdentifier i <- lpat] + ++ [(i, [x]) | (ScmIdentifier i, x) <- paired] + + in tell . PM . TM.map Left $ TM.fromListWith (flip (++)) matched + +-- ... "P is an improper list (P1 ... Pn . Pm)" ... +match1 lits args (ScmDottedList ps p) = + case args of + -- ... "and F is a list or improper list of n or more forms that match + -- P1 through Pn and whose nth cdr matches Pm" ... + ScmList as -> let (xs, ys) = splitAt (length ps) as + in andM [ allMatch lits xs ps + , match1 lits (ScmList ys) p] + + ScmDottedList as a -> andM [allMatch lits as ps, match1 lits a p] + _ -> return False + +-- ... "P is a vector of the form #(P1 ... Pn) and F is a vector of n forms +-- that match P1 through Pn" ... +-- +-- ... "P is of the form #(P1 ... Pn Pm ) where is the +-- identifier ... and F is a vector of n or more forms, the first n of which +-- match P1 through Pn and each remaining element matches Pm" ... +-- +-- Just forward to the list one, the rules are identical +match1 lits (ScmVector args) (ScmVector ps) = + match1 lits (ScmList $ elems args) (ScmList $ elems ps) + +-- ... "P is a datum and F is equal to P in the sense of the equal? procedure". +match1 _ arg p = liftIO $ scmEqual arg p + +allMatch :: Lits -> [ScmValue] -> [ScmValue] + -> WriterT PatternMatches Haschoo Bool +allMatch = eqWithM . match1 + +replaceVars :: [String] -> [String] -> PatternMatches + -> ScmValue -> ErrOr [ScmValue] +replaceVars _ _ (PM replacements) (ScmIdentifier i) + | Just r <- TM.lookup i replacements = case r of + Right r' -> return [r'] + Left rs -> return rs + | i == "..." = return [] + +replaceVars lits frees rs (ScmList l) = + (:[]) . ScmList <$> replaceInAggregate lits frees rs l +replaceVars lits frees rs (ScmVector v) = + (:[]) . toScmVector <$> replaceInAggregate lits frees rs (elems v) + +replaceVars lits frees rs (ScmDottedList l x) = + (:[]) <$> liftM2 ScmDottedList + (replaceInAggregate lits frees rs l) + (simplifyList <$> replaceVars lits frees rs x) + +replaceVars _ _ _ v = return [v] + +replaceInAggregate :: [String] -> [String] -> PatternMatches + -> [ScmValue] -> ErrOr [ScmValue] +replaceInAggregate lits frees rs (ag : ScmIdentifier "..." : vs) + | isAggregate ag = + liftM2 (++) (replaceInEllipticAggregate lits frees rs ag) + (replaceInAggregate lits frees rs vs) + +replaceInAggregate lits frees rs (v:vs) = + liftM2 (++) (replaceVars lits frees rs v) + (replaceInAggregate lits frees rs vs) + +replaceInAggregate _ _ _ [] = return [] + +-- "Pattern variables that occur in subpatterns followed by one or more +-- instances of the identifier ... are allowed only in subtemplates that are +-- followed by as many instances of .... +-- +-- They [the subtemplates] are replaced in the output by all of the subforms +-- they [the subpatterns] match in the input, distributed as indicated [in the +-- template, by the positions of the pattern variables]." +-- +-- With square-bracketed stuff added to make some sense of the last sentence +-- there. +-- +-- E.g. pattern (_ (#(a b) ...)) and corresponding template ((a b) ...). +-- +-- Pattern variables a and b are in a subpattern followed by one ellipsis. We +-- also have a subtemplate followed by as many ellipses, and a and b are found +-- nowhere else, so it's valid. Calling this with (_ (#(1 2) #(3 4))) we get +-- the subtemplate '(a b) ...' replaced by '(1 2) (3 4)'. +replaceInEllipticAggregate :: [String] -> [String] -> PatternMatches + -> ScmValue -> ErrOr [ScmValue] +replaceInEllipticAggregate lits frees pms val = + let (replaced, (replacementsLeft,_)) = + flip runState (TM.empty, pms) $ + (go val `untilM` + do rsLeft <- fst <$> get + return (TM.null rsLeft || anyT (==0) rsLeft)) + + in if allT (==0) replacementsLeft + then return$ catMaybes replaced + else -- For example: + -- Pattern has (a ...) (b ...) + -- Template has ((a b) ...) + -- (a ...) was (1 2) and (b ...) was (3) + -- The first (1 3) is fine, but the next (2 ??) isn't + throwError "Inconsistent match counts for elliptic variables" + where + go :: ScmValue -> State (TrieMap Char Int, PatternMatches) (Maybe ScmValue) + go (ScmIdentifier i) + | i `elem` frees || i `elem` lits = return Nothing + | otherwise = do + (replacementsLeft, PM pm) <- get + let (v, pm') = + TM.updateLookup (Just . either (Left . drop 1) Right) i pm + case v of + Just (Right r') -> return (Just r') + Just (Left []) -> do modify (first $ TM.insert i 0) + return Nothing + Just (Left (r:rs)) -> do + let rsLeft' = + TM.alter' (Just . maybe (length rs) (subtract 1)) + i replacementsLeft + put (rsLeft', PM pm') + return (Just r) + + -- Blank match: e.g. pattern (a ...) matched () + Nothing -> return Nothing + + go (ScmList l) = fmap ScmList . sequence <$> mapM go l + go (ScmVector v) = fmap toScmVector . sequence <$> mapM go (elems v) + + go (ScmDottedList l x) = do + l' <- sequence <$> mapM go l + x' <- go x + return (liftM2 ScmDottedList l' x') + + go x = return (Just x) + + anyT f = TM.foldr ((||).f) False + allT f = TM.foldr ((&&).f) True + +simplifyList :: [ScmValue] -> ScmValue +simplifyList [v] = v +simplifyList vs = ScmList vs diff --git a/Haschoo/Evaluator/Primitives.hs b/Haschoo/Evaluator/Primitives.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Primitives.hs @@ -0,0 +1,534 @@ +-- File created: 2009-07-19 18:34:38 + +{-# LANGUAGE PatternGuards #-} +module Haschoo.Evaluator.Primitives (context) where + +import Control.Applicative ((<$>)) +import Control.Arrow (first, (&&&)) +import Control.Monad (when) +import Control.Monad.Error (throwError) +import Control.Monad.State (get) +import Control.Monad.Trans (liftIO) +import Data.Array.IArray (listArray, elems, bounds) +import Data.IORef ( IORef, readIORef + , newIORef, modifyIORef, writeIORef) +import Data.Maybe (isJust, catMaybes) +import Numeric (showHex) + +import qualified Control.Monad.State.Strict as S +import qualified Data.ListTrie.Patricia.Set.Enum as TS + +import Haschoo.Types ( Haschoo, runHaschoo, withHaschoo + , ScmValue(..), isTrue + , Context, mkContext, contextSize + , addToContext, contextLookup + , listToPair) +import Haschoo.Utils ( compareLength, compareLengths, (.:) + , fromRights, modifyM) +import Haschoo.Evaluator.Eval (eval, evalBody, maybeEval) +import Haschoo.Evaluator.Macros (mkMacro) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs) + +import Haschoo.Evaluator.Standard.PairsLists (scmAppend) + +context :: Context +context = mkContext primitives + +primitives :: [(String, ScmValue)] +primitives = map (\(a,b) -> (a, ScmPrim a b)) $ + [ ("lambda", scmLambda) + , ("quote", scmQuote) + , ("if", scmIf) + , ("set!", scmSet) + , ("letrec", scmLetRec) + , ("syntax-rules", scmSyntaxRules) + , ("let-syntax", scmLetSyntax) + , ("letrec-syntax", scmLetRecSyntax) + , ("quasiquote", scmQuasiQuote) + , ("do", scmDo) ] + +scmLambda :: [ScmValue] -> Haschoo ScmValue +scmLambda [] = tooFewArgs "lambda" +scmLambda [_] = tooFewArgs "lambda" +scmLambda (ScmList ps : body) = mkΛ ps Nothing body +scmLambda ( ScmIdentifier t : body) = mkΛ [] (Just t) body +scmLambda (ScmDottedList ps (ScmIdentifier t) : body) = mkΛ ps (Just t) body + +scmLambda _ = throwError "Invalid parameters to lambda" + +mkΛ :: [ScmValue] -> Maybe String -> [ScmValue] -> Haschoo ScmValue +mkΛ formals tailParams body = ScmFunc name . func <$> get + where + func ctx = \args -> do + case compareLengths args formals of + (LT,_) -> return$ tooFewArgs name + (order,len) -> do + case tailParams of + Nothing -> + if order == EQ + then make id args + else return$ tooManyArgs name + Just n -> + let (normal, tailArgs) = splitAt len args + in make (++[n]) (normal ++ [ScmList tailArgs]) + where + make mkParams args = + case paramNames of + Just ns -> + let ns' = mkParams ns + c = subContext ns' args + in case compareLength ns' (contextSize c) of + EQ -> do + c' <- newIORef c + runHaschoo (c':ctx) $ evalBody body + + GT -> return duplicateParam + LT -> error "lambda :: the impossible happened" + + Nothing -> return badParam + + paramNames = mapM f formals + where + f (ScmIdentifier x) = Just x + f _ = Nothing + + name = "" + subContext = mkContext .: zip + + duplicateParam = + throwError.concat $ ["Duplicate in parameter list of ", name] + badParam = + throwError.concat $ ["Invalid identifier in parameter list of ", name] + +scmQuote :: [ScmValue] -> Haschoo ScmValue +scmQuote [x] = return x +scmQuote [] = tooFewArgs "quote" +scmQuote _ = tooManyArgs "quote" + +scmIf :: [ScmValue] -> Haschoo ScmValue +scmIf [b,x,y] = eval b >>= \t -> eval $ if isTrue t then x else y +scmIf [b,x] = eval b >>= \t -> if isTrue t then eval x else return ScmVoid +scmIf (_:_:_) = tooManyArgs "if" +scmIf _ = tooFewArgs "if" + +scmSet :: [ScmValue] -> Haschoo ScmValue +scmSet [ScmIdentifier var, expr] = do + e <- eval expr + set var e + return ScmVoid + +scmSet [_,_] = throwError $ "Non-identifier argument to set!" +scmSet (_:_:_) = tooManyArgs "set!" +scmSet _ = tooFewArgs "set!" + +scmLetRec :: [ScmValue] -> Haschoo ScmValue +scmLetRec (ScmList l : b@(_:_)) = doLetRec l b +scmLetRec (_:_:_) = throwError "Invalid list of bindings to letrec" +scmLetRec _ = tooFewArgs "letrec" + +doLetRec :: [ScmValue] -> [ScmValue] -> Haschoo ScmValue +doLetRec bindings body = do + ctx <- liftIO $ newIORef (mkContext []) + newStack <- fmap (ctx:) get + mapM_ (bind newStack ctx) bindings + withHaschoo newStack (evalBody body) + where + bind ctxStack ctx (ScmList [ScmIdentifier var, val]) = do + evaled <- withHaschoo ctxStack (eval val) + liftIO $ modifyIORef ctx (addToContext var evaled) + + bind _ _ _ = throwError "Invalid binding to letrec" + +scmSyntaxRules :: [ScmValue] -> Haschoo ScmValue +scmSyntaxRules (ScmList lits : rest) = do + evaledLits <- mapM unlit lits + pats <- mapM unpat rest + return$ ScmSyntax pats evaledLits + where + unpat (ScmList [pattern, template]) = do + pat <- case pattern of + -- It really does seem to me that the keyword in a syntax + -- rule is ignored according to R5RS 4.3.2: what names the + -- macro is the identifier in define-syntax / let-syntax / + -- letrec-syntax, the name in the pattern match is + -- irrelevant. + ScmList (ScmIdentifier _keyword : pat) -> + return (ScmList pat) + ScmDottedList (ScmIdentifier _keyword : pat) pat' -> + return (ScmDottedList pat pat') + + ScmVector xs | maxIdx >= 0 -> + case elems xs of + ScmIdentifier _keyword : pat -> + return (ScmVector $ listArray (0, maxIdx-1) pat) + + _ -> badPattern + where + maxIdx = snd (bounds xs) + + _ -> badPattern + + checkPat pat + let renamedTmp = + flip S.evalState 0 $ renameBinds (frees template) template + + return (pat, renamedTmp, TS.toList (frees renamedTmp)) + where + -- R5RS 4.3: "If a macro transformer inserts a binding for an identifier + -- (variable or keyword), the identifier will in effect be renamed + -- throughout its scope to avoid conflicts with other identifiers." + -- + -- This is a HACK! + -- + -- It's also buggy: + -- FIXME: top-level defines don't introduce bindings if the variable is + -- already bound, this doesn't take that into account. + -- + -- FIXME: nested binding-creators won't work (fixable by calling + -- renameBinds from renameUses before doing the rename) + -- + -- Not sure how to deal with this properly... doing the same thing at + -- macro expansion time would fix the FIXME but it's still really hacky. + renameBinds :: TS.TrieSet Char -> ScmValue -> S.State Int ScmValue + renameBinds fs (ScmList (l@(ScmIdentifier lt) : ScmList bs : body)) + | isLetLike lt = do + (rens, bs') <- first catMaybes . unzip <$> mapM renameInLet bs + return$ ScmList (l : ScmList bs' : map (renameUses rens) body) + where + isLetLike "let" = True + isLetLike "let*" = True + isLetLike "letrec" = True + isLetLike "do" = True -- The syntax is close enough + isLetLike _ = False + + renameInLet (ScmList (ScmIdentifier i : val)) + | i `TS.member` fs = do + i' <- renameBinding i + return (Just (i,i'), ScmList (i' : val)) + + renameInLet x = return (Nothing, x) + + renameBinds fs + (ScmList (l@(ScmIdentifier "lambda") : ScmList bs : body)) = do + (rens, bs') <- first catMaybes . unzip <$> mapM renameInLambda bs + return$ ScmList (l : ScmList bs' : map (renameUses rens) body) + where + renameInLambda (ScmIdentifier i) | i `TS.member` fs = + (Just . (,) i &&& id) <$> renameBinding i + + renameInLambda x = return (Nothing, x) + + renameBinds fs + (ScmList (d@(ScmIdentifier "define") : ScmList (b:bs) : body)) = do + (rens, bs') <- first catMaybes . unzip <$> mapM renameInDefine bs + return$ ScmList (d : ScmList (b:bs') : map (renameUses rens) body) + where + renameInDefine (ScmIdentifier i) | i `TS.member` fs = + (Just . (,) i &&& id) <$> renameBinding i + + renameInDefine x = return (Nothing, x) + + renameBinds _ x = return x + + renameUses :: [(String,ScmValue)] -> ScmValue -> ScmValue + renameUses [] x = x + renameUses rens (ScmIdentifier i) + | Just i' <- lookup i rens = i' + + renameUses rens (ScmList xs) = ScmList ( map (renameUses rens) xs) + renameUses rens (ScmVector v) = ScmVector (fmap (renameUses rens) v) + renameUses rens (ScmDottedList xs x) = + ScmDottedList (map (renameUses rens) xs) (renameUses rens x) + + renameUses _ x = x + + -- ; is the comment character and thus can't normally be used in + -- identifier names, so using it here guarantees the user hasn't + -- otherwise used it + renameBinding s = do + n <- S.get + S.put (n+1) + return$ ScmIdentifier (';' : showHex n s) + + frees :: ScmValue -> TS.TrieSet Char + frees (ScmIdentifier i) = if isLocal i + then TS.empty + else TS.singleton i + frees (ScmList xs) = TS.unions . map frees $ xs + frees (ScmVector v) = TS.unions . map frees $ elems v + frees (ScmDottedList xs x) = TS.unions . map frees $ (x:xs) + frees _ = TS.empty + + isLocal s = go pattern + where + go (ScmIdentifier i) = s == i + go (ScmList xs) = any go xs + go (ScmVector v) = any go (elems v) + go (ScmDottedList xs x) = any go xs || go x + go _ = False + + checkPat p = do + found <- go False p + when (not found) (assertNoEllipses template) + where + go found (ScmList ls) = + case findEllipsis ls of + Just (_, after) + | not (all elliptic after) -> + srErr + "Nonelliptic identifier follows ellipsis in pattern" + + Just (Nothing, _) -> + srErr "Ellipsis not preceded by anything in pattern" + + Just (Just (ScmIdentifier i), after) -> do + checkEllipsisUse i (length after) template + or <$> mapM (go True) ls + + Nothing -> or <$> mapM (go found) ls + _ -> or <$> mapM (go True) ls + + go _ (ScmDottedList _ (ScmIdentifier "...")) = + srErr "Ellipsis terminating improper list" + + go _ (ScmDottedList ls _) | isJust (findEllipsis ls) = + srErr "Ellipsis in improper list" + + go found (ScmDottedList ls x) = do + found' <- or <$> mapM (go found) ls + go found' x + + go found (ScmVector v) = go found (ScmList $ elems v) + + go found _ = return found + + checkEllipsisUse var n (ScmList ls) = + case findEllipsis ls of + Just (Just (ScmIdentifier i), after) | var == i -> + + if (length . filter elliptic . take n $ after) == n + then mapM_ (checkEllipsisUse var n) ls + else srErr $ "Ellipsis use matches pattern variable " ++ + "but not ellipsis count" + + _ -> mapM_ (checkEllipsisUse var n) ls + + checkEllipsisUse var n (ScmDottedList ls x) = do + mapM_ (checkEllipsisUse var n) ls + checkEllipsisUse var n x + + checkEllipsisUse var n (ScmVector v) = + checkEllipsisUse var n (ScmList $ elems v) + + checkEllipsisUse _ _ _ = return () + + assertNoEllipses (ScmList ls) = + if isJust (findEllipsis ls) + then srErr "Ellipsis used as identifier in template" + else mapM_ assertNoEllipses ls + + assertNoEllipses (ScmDottedList ls x) = + mapM_ assertNoEllipses ls >> assertNoEllipses x + + assertNoEllipses _ = return () + + findEllipsis [] = Nothing + findEllipsis ( ScmIdentifier "..." : xs) = Just (Nothing, xs) + findEllipsis (x : ScmIdentifier "..." : xs) = Just (Just x, xs) + findEllipsis (_:xs) = findEllipsis xs + + unpat _ = badPattern + + badPattern = throwError "Invalid pattern in syntax-rules" + + unlit lit@(ScmIdentifier i) = + if elliptic lit + then throwError "Elliptic literal to syntax-rules" + else fmap ((,) i) (maybeEval lit) + + unlit _ = throwError "Nonidentifier literal to syntax-rules" + + elliptic (ScmIdentifier "...") = True + elliptic _ = False + + srErr = throwError . (++ " in syntax-rules") + +scmSyntaxRules [] = tooFewArgs "syntax-rules" +scmSyntaxRules _ = throwError "Invalid list of literals to syntax-rules" + +scmLetSyntax, scmLetRecSyntax :: [ScmValue] -> Haschoo ScmValue +scmLetSyntax = syntaxLet (flip const) "let-syntax" +scmLetRecSyntax = syntaxLet (:) "letrec-syntax" + +syntaxLet :: (IORef Context -> [IORef Context] -> [IORef Context]) -> String + -> [ScmValue] -> Haschoo ScmValue + +syntaxLet f s (ScmList bindings : body@(_:_)) = do + ctx <- liftIO $ newIORef (mkContext []) + stack <- fmap (f ctx) get + mapM_ (go stack ctx) bindings + withHaschoo (ctx:stack) (evalBody body) + where + go stack ctx (ScmList [ScmIdentifier var, binding]) = do + syntax <- eval binding + case syntax of + ScmSyntax pats lits -> + let macro = mkMacro stack var (map addVar pats) lits + in liftIO $ modifyIORef ctx (addToContext var macro) + where + -- Add the macro's name to the list of free variables to create + -- the difference between let-syntax and letrec-syntax + addVar (pat, repl, frees) = (pat, repl, var:frees) + + _ -> badBinding s + + go _ _ _ = badBinding s + + badBinding = throwError . ("Invalid binding to " ++) + +syntaxLet _ s (_:_:_) = throwError ("Invalid list of bindings to " ++ s) +syntaxLet _ s _ = tooFewArgs s + +scmQuasiQuote :: [ScmValue] -> Haschoo ScmValue +scmQuasiQuote [expr] = finishUnqq <$> unqq 0 expr + where + finishUnqq = either (either (uncurry ScmPair) ScmList) id + + finishWrapUnqq s v = Right $ ScmList [ScmIdentifier s, finishUnqq v] + + -- Left results are stuff that need to be spliced + unqq :: Int + -> ScmValue + -> Haschoo (Either (Either (IORef ScmValue, IORef ScmValue) [ScmValue]) + ScmValue) + + unqq n (ScmList (ScmIdentifier s@"unquote" : vs)) = + case vs of + [v] | n == 0 -> Right <$> eval v + | otherwise -> finishWrapUnqq s <$> unqq (n-1) v + [] -> tooFewArgs s + _ -> tooManyArgs s + + unqq n (ScmList (ScmIdentifier s@"unquote-splicing" : vs)) = + case vs of + [v] | n == 0 -> do + ev <- eval v + case ev of + ScmList evs -> return$ Left . Right $ evs + ScmPair a b -> return$ Left . Left $ (a,b) + _ -> notList + + | otherwise -> unqq (n-1) v + + [] -> tooFewArgs s + _ -> tooManyArgs s + + unqq n (ScmList (ScmIdentifier s@"quasiquote" : vs)) = + case vs of + [v] -> finishWrapUnqq s <$> unqq (n+1) v + [] -> tooFewArgs s + _ -> tooManyArgs s + + unqq n (ScmList xs) = + Right . either (uncurry ScmPair) ScmList <$> + (splice =<< mapM (unqq n) xs) + + unqq n (ScmDottedList xs x) = do + xs' <- splice =<< mapM (unqq n) xs + x' <- unqq n x + case x' of + Left _ -> throwError "quasiquote :: unexpected unquote-splicing" + Right v -> + case xs' of + Left (a,b) -> Right <$> (liftIO $ snocPair (ScmPair a b) v) + Right ys -> return$ Right $ ScmDottedList ys v + + unqq _ x = return (Right x) + + splice :: [Either (Either (IORef ScmValue, IORef ScmValue) [ScmValue]) + ScmValue] + -> Haschoo (Either (IORef ScmValue, IORef ScmValue) [ScmValue]) + splice xs = + case fromRights xs of + Just xs' -> return$ Right xs' + Nothing -> + let listified = map (either id (Right . (:[]))) xs + in case fromRights listified of + Just xs' -> return$ Right (concat xs') + Nothing -> do + cat <- liftIO $ + scmAppend =<< + mapM (either (return . uncurry ScmPair) + (fmap fst . listToPair)) + listified + case cat of + Left _ -> notList + Right (ScmPair a b) -> return$ Left (a,b) + Right _ -> + error "splice :: the impossible happened" + + snocPair :: ScmValue -> ScmValue -> IO ScmValue + snocPair p@(ScmPair _ b) x = do + b' <- liftIO $ readIORef b + case b' of + ScmList xs -> do liftIO $ writeIORef b (ScmList (xs ++ [x])) + return p + q@(ScmPair _ _) -> snocPair q x + + -- splice's return value should be a proper list + _ -> error "snocPair :: the impossible happened" + + snocPair _ _ = error "snocPair :: the impossible happened" + + notList :: Haschoo a + notList = throwError "quasiquote :: unquote-splicing did not return a list" + +scmQuasiQuote [] = tooFewArgs "quasiquote" +scmQuasiQuote _ = tooManyArgs "quasiquote" + +scmDo :: [ScmValue] -> Haschoo ScmValue +scmDo (ScmList vars : ScmList (test:result) : cmds) = do + inited <- mapM initVar vars + c' <- liftIO $ newIORef (mkContext $ map fst inited) + ctx <- get + withHaschoo (c':ctx) (go $ map (first fst) inited) + where + go :: [(String, ScmValue)] -> Haschoo ScmValue + go varSteps = do + stop <- eval test + if isTrue stop + then if null result then return ScmVoid else last <$> mapM eval result + else do + mapM_ eval cmds + evalSteps <- mapM (eval.snd) varSteps + mapM_ (uncurry set) $ zip (map fst varSteps) evalSteps + go varSteps + + initVar :: ScmValue -> Haschoo ((String, ScmValue), ScmValue) + initVar (ScmList (var@(ScmIdentifier v) : i : step)) = do + step' <- case step of + [] -> return var + [s] -> return s + _ -> throwError "do :: more than one step expression?" + ei <- eval i + return ((v, ei), step') + + initVar _ = throwError "do :: expected list of variables and initializers" + +scmDo (_:_:_:_) = tooManyArgs "do" +scmDo (_:_:_) = throwError "do :: no tests or nonlist arguments" +scmDo _ = tooFewArgs "do" + +set :: String -> ScmValue -> Haschoo () +set var evaled = modifyM f + where + f (c:cs) = do + c' <- liftIO $ readIORef c + case contextLookup var c' of + Just _ -> do + liftIO $ modifyIORef c (addToContext var evaled) + return (c:cs) + + Nothing -> (c:) <$> f cs + + f [] = throwError $ "Unbound identifier '" ++ var ++ "'" diff --git a/Haschoo/Evaluator/Standard.hs b/Haschoo/Evaluator/Standard.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard.hs @@ -0,0 +1,32 @@ +-- File created: 2009-07-15 11:00:10 + +module Haschoo.Evaluator.Standard (context) where + +import Haschoo.Types (ScmValue, Context, mkContext) +import qualified Haschoo.Evaluator.Standard.Boolean as Boolean +import qualified Haschoo.Evaluator.Standard.Characters as Characters +import qualified Haschoo.Evaluator.Standard.Control as Control +import qualified Haschoo.Evaluator.Standard.Equivalence as Equivalence +import qualified Haschoo.Evaluator.Standard.Eval as Eval +import qualified Haschoo.Evaluator.Standard.IO as IO +import qualified Haschoo.Evaluator.Standard.Numeric as Numeric +import qualified Haschoo.Evaluator.Standard.PairsLists as PairsLists +import qualified Haschoo.Evaluator.Standard.Strings as Strings +import qualified Haschoo.Evaluator.Standard.Symbols as Symbols +import qualified Haschoo.Evaluator.Standard.Vectors as Vectors + +procedures :: [(String, ScmValue)] +procedures = concat [ Boolean.procedures + , Characters.procedures + , Control.procedures + , Equivalence.procedures + , Eval.procedures + , IO.procedures + , Numeric.procedures + , PairsLists.procedures + , Strings.procedures + , Symbols.procedures + , Vectors.procedures ] + +context :: Context +context = mkContext procedures diff --git a/Haschoo/Evaluator/Standard/Boolean.hs b/Haschoo/Evaluator/Standard/Boolean.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Boolean.hs @@ -0,0 +1,22 @@ +-- File created: 2009-07-21 22:04:14 + +module Haschoo.Evaluator.Standard.Boolean (procedures) where + +import Haschoo.Types (ScmValue(..), isTrue) +import Haschoo.Utils (ErrOr) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a (return . b))) + [ ("not", fmap ScmBool . scmNot) + , ("boolean?", fmap ScmBool . scmIsBoolean) ] + +scmNot, scmIsBoolean :: [ScmValue] -> ErrOr Bool +scmNot [x] = Right . not . isTrue $ x +scmNot [] = tooFewArgs "not" +scmNot _ = tooManyArgs "not" + +scmIsBoolean [ScmBool _] = Right True +scmIsBoolean [_] = Right False +scmIsBoolean [] = tooFewArgs "boolean?" +scmIsBoolean _ = tooManyArgs "boolean?" diff --git a/Haschoo/Evaluator/Standard/Characters.hs b/Haschoo/Evaluator/Standard/Characters.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Characters.hs @@ -0,0 +1,92 @@ +-- File created: 2009-08-04 19:35:58 + +module Haschoo.Evaluator.Standard.Characters (procedures) where + +import Control.Arrow ((&&&)) +import Data.Char ( isAlpha, isDigit, isSpace, isLower, isUpper + , isLetter, toLower, toUpper) + +import Haschoo.Types (ScmValue(..)) +import Haschoo.Utils (ErrOr, ($<), (.:)) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notInt, notChar) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a (return . b))) + [ ("char?", fmap ScmBool . scmIsChar) + + , "char=?" $< id &&& fmap ScmBool .: scmCompare (==) (,) + , "char?" $< id &&& fmap ScmBool .: scmCompare (>) (,) + , "char<=?" $< id &&& fmap ScmBool .: scmCompare (<=) (,) + , "char>=?" $< id &&& fmap ScmBool .: scmCompare (>=) (,) + + , "char-ci=?" $< id &&& fmap ScmBool .: scmCompare (==) lower + , "char-ci?" $< id &&& fmap ScmBool .: scmCompare (>) lower + , "char-ci<=?" $< id &&& fmap ScmBool .: scmCompare (<=) lower + , "char-ci>=?" $< id &&& fmap ScmBool .: scmCompare (>=) lower + + , "char-alphabetic?" $< id &&& fmap ScmBool .: scmProperty isAlpha + , "char-numeric?" $< id &&& fmap ScmBool .: scmProperty isDigit + , "char-whitespace?" $< id &&& fmap ScmBool .: scmProperty isSpace + , "char-upper-case?" $< id &&& fmap ScmBool .: scmProperty isUpper + , "char-lower-case?" $< id &&& fmap ScmBool .: scmProperty isLower + + , ("char->integer", scmToInt) + , ("integer->char", scmToChar) + + , "char-upcase" $< id &&& fmap ScmChar .: scmApply toUpper + , "char-downcase" $< id &&& fmap ScmChar .: scmApply toLower + ] + where + lower a b = if isLetter a && isLetter b + then (toLower a, toLower b) + else (a,b) + +scmIsChar :: [ScmValue] -> ErrOr Bool +scmIsChar [ScmChar _] = Right True +scmIsChar [_] = Right False +scmIsChar [] = tooFewArgs "char?" +scmIsChar _ = tooManyArgs "char?" + +scmCompare :: (Char -> Char -> Bool) -> (Char -> Char -> (Char,Char)) -> String + -> [ScmValue] -> ErrOr Bool +scmCompare p f _ [ScmChar a, ScmChar b] = Right . uncurry p $ f a b +scmCompare _ _ s [_,_] = notChar s +scmCompare _ _ s (_:_:_) = tooManyArgs s +scmCompare _ _ s _ = tooFewArgs s + +scmProperty :: (Char -> Bool) -> String -> [ScmValue] -> ErrOr Bool +scmProperty f _ [ScmChar c] = Right $ f c +scmProperty _ s [_] = notChar s +scmProperty _ s [] = tooFewArgs s +scmProperty _ s _ = tooManyArgs s + +scmToInt, scmToChar :: [ScmValue] -> ErrOr ScmValue +scmToInt [ScmChar c] = Right . ScmInt . toInt $ c +scmToInt [_] = notChar "char->integer" +scmToInt [] = tooFewArgs "char->integer" +scmToInt _ = tooManyArgs "char->integer" + +scmToChar [ScmInt i] = + if i >= toInt (minBound :: Char) && i <= toInt (maxBound :: Char) + then Right . ScmChar . toChar $ i + else fail "Out-of-range integer to integer->char" + +scmToChar [_] = notInt "integer->char" +scmToChar [] = tooFewArgs "integer->char" +scmToChar _ = tooManyArgs "integer->char" + +scmApply :: (Char -> Char) -> String -> [ScmValue] -> ErrOr Char +scmApply f _ [ScmChar c] = Right $ f c +scmApply _ s [_] = notChar s +scmApply _ s [] = tooFewArgs s +scmApply _ s _ = tooManyArgs s + +------ + +toChar :: Integer -> Char +toChar = toEnum . fromInteger + +toInt :: Char -> Integer +toInt = toInteger . fromEnum diff --git a/Haschoo/Evaluator/Standard/Control.hs b/Haschoo/Evaluator/Standard/Control.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Control.hs @@ -0,0 +1,100 @@ +-- File created: 2009-07-22 21:05:24 + +{-# LANGUAGE ScopedTypeVariables #-} + +module Haschoo.Evaluator.Standard.Control (procedures) where + +import Data.List (transpose, genericLength) +import Data.Number.Natural (Natural) + +import Haschoo.Types (ScmValue(..), pairToList, listToPair) +import Haschoo.Utils (ErrOr, initLast, (.:)) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notList, notProcedure) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ ("procedure?", return . fmap ScmBool . scmIsProcedure) + , ("apply", scmApply) + , ("map", scmMap) + , ("for-each", scmForEach) + ] + +--- procedure? + +scmIsProcedure :: [ScmValue] -> ErrOr Bool +scmIsProcedure [ScmFunc _ _] = Right True +scmIsProcedure [_] = Right False +scmIsProcedure [] = tooFewArgs "procedure?" +scmIsProcedure _ = tooManyArgs "procedure?" + +--- apply + +scmApply :: [ScmValue] -> IO (ErrOr ScmValue) +scmApply (ScmFunc _ f : args@(_:_)) = + case initLast args of + (xs, ScmList ys) -> f (xs ++ ys) + (xs, ys@(ScmPair _ _)) -> do + ys' <- pairToList ys + case ys' of + Right (ScmList l) -> f (xs ++ l) + _ -> return$ notList "apply" + + (_, _) -> return$ notList "apply" + +scmApply (_:_) = return$ notProcedure "apply" +scmApply _ = return$ tooFewArgs "apply" + +--- map for-each + +scmMap, scmForEach :: [ScmValue] -> IO (ErrOr ScmValue) +scmMap (ScmFunc _ f : args@(_:_)) = do + l <- scmIterate "map" [] (:) f args + case l of + Left s -> return (Left s) + Right xs -> fmap (Right . fst) (listToPair xs) + +scmMap (_:_) = return$ notProcedure "map" +scmMap _ = return$ tooFewArgs "map" + +scmForEach (ScmFunc _ f : args@(_:_)) = do + err <- scmIterate "for-each" () (\_ _ -> ()) f args + return$ either Left (const $ Right ScmVoid) err + +scmForEach (_:_:_) = return$ notProcedure "for-each" +scmForEach _ = return$ tooFewArgs "for-each" + +scmIterate :: forall a. String -> a -> (ScmValue -> a -> a) + -> ([ScmValue] -> IO (ErrOr ScmValue)) + -> [ScmValue] + -> IO (ErrOr a) +scmIterate s end fuse f args = do + args' <- prepArgs s args + case args' of + Right as -> go (genericLength.head $ as) as + Left err -> return$ Left err + where + go :: Natural -> [[ScmValue]] -> IO (ErrOr a) + go _ [] = return (Right end) + go len (a:as) = if genericLength a == len + then do + fa <- f a + case fa of + Right a' -> do + bs <- go len as + case bs of + Right bs' -> return.Right $ fuse a' bs' + Left err -> return.Left $ err + Left err -> return.Left $ err + + else return.Left $ s ++ " :: unmatching list lengths" + +prepArgs :: String -> [ScmValue] -> IO (ErrOr [[ScmValue]]) +prepArgs s = fmap (fmap transpose . sequence) .: mapM $ \a -> + case a of + ScmList xs -> return.Right $ xs + xs@(ScmPair _ _) -> do + ys <- pairToList xs + return$ case ys of + Right (ScmList l) -> Right l + _ -> notList s + _ -> return$ notList s diff --git a/Haschoo/Evaluator/Standard/Equivalence.hs b/Haschoo/Evaluator/Standard/Equivalence.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Equivalence.hs @@ -0,0 +1,99 @@ +-- File created: 2009-07-21 10:36:31 + +module Haschoo.Evaluator.Standard.Equivalence + (procedures, scmEq, scmEqv, scmEqual) where + +import Control.Arrow ((&&&)) +import Control.Monad (liftM2, join) +import Control.Monad.Loops (allM) +import Data.Array.IArray (bounds, elems) +import Data.Array.MArray (getBounds, getElems, unsafeFreeze) +import Data.Function (on) + +import Haschoo.Types (ScmValue(..), pairToList) +import Haschoo.Utils (ErrOr, ($<), (.:), eqWithM, ptrEq) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs) +import Haschoo.Evaluator.Standard.Numeric (isExact, isNumeric, numEq) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ "eq?" $< id &&& fmap (fmap ScmBool) .: scmEquivalence scmEq + , "eqv?" $< id &&& fmap (fmap ScmBool) .: scmEquivalence scmEqv + , "equal?" $< id &&& fmap (fmap ScmBool) .: scmEquivalence scmEqual + ] + +scmEq, scmEqv, scmEqual :: ScmValue -> ScmValue -> IO Bool +scmEqv (ScmBool a) (ScmBool b) = return$ a == b +scmEqv (ScmIdentifier a) (ScmIdentifier b) = return$ a == b +scmEqv (ScmChar a) (ScmChar b) = return$ a == b +scmEqv (ScmList a) (ScmList b) = ptrEq a b +scmEqv (ScmString a) (ScmString b) = ptrEq a b +scmEqv (ScmMString a) (ScmMString b) = ptrEq a b +scmEqv (ScmVector a) (ScmVector b) = ptrEq a b +scmEqv (ScmMVector a) (ScmMVector b) = ptrEq a b +scmEqv (ScmFunc _ a) (ScmFunc _ b) = ptrEq a b +scmEqv (ScmPrim _ a) (ScmPrim _ b) = ptrEq a b +scmEqv (ScmMacro _ a) (ScmMacro _ b) = ptrEq a b + +scmEqv (ScmDottedList a b) (ScmDottedList x y) = + liftM2 (&&) (ptrEq a x) (ptrEq b y) + +scmEqv (ScmPair a b) (ScmPair x y) = liftM2 (&&) (ptrEq a x) (ptrEq b y) +scmEqv a b = + if isNumeric a && isNumeric b + then return$ isExact a == isExact b && numEq a b + else ptrEq a b + +scmEq a b = if isNumeric a && isNumeric b + then ptrEq a b + else scmEqv a b + +scmEqual x@(ScmPair _ _) y@(ScmPair _ _) = + join $ (liftM2 scmEqual `on` fmap (either id id) . pairToList) x y + +scmEqual (ScmList x) (ScmList y) = eqWithM scmEqual x y +scmEqual (ScmDottedList x a) (ScmDottedList y b) = do + ab <- scmEqual a b + if ab + then eqWithM scmEqual x y + else return False + +scmEqual x@(ScmList _) y@(ScmPair _ _) = + either (const $ return False) (scmEqual x) =<< pairToList y + +scmEqual x@(ScmDottedList _ _) y@(ScmPair _ _) = + either (scmEqual x) (const $ return False) =<< pairToList y + +scmEqual y@(ScmPair _ _) x@(ScmList _) = scmEqual x y +scmEqual y@(ScmPair _ _) x@(ScmDottedList _ _) = scmEqual x y + +scmEqual (ScmString a) (ScmString b) = return$ a == b +scmEqual (ScmMString a) (ScmMString b) = liftM2 (==) (getElems a) (getElems b) +scmEqual (ScmString a) (ScmMString b) = fmap (elems a==) $ getElems b +scmEqual (ScmMString a) (ScmString b) = fmap (==elems b) $ getElems a + +scmEqual (ScmVector a) (ScmVector b) = + if bounds a == bounds b + then allM (uncurry scmEqual) $ (zip`on`elems) a b + else return False + +scmEqual (ScmMVector a) (ScmMVector b) = do + ba <- getBounds a + bb <- getBounds b + if ba == bb + then join $ (liftM2 (allM (uncurry scmEqual) .: zip) `on` getElems) a b + else return False + +scmEqual a@(ScmVector _) (ScmMVector b) = + unsafeFreeze b >>= scmEqual a . ScmVector +scmEqual (ScmMVector a) b@(ScmVector _) = + unsafeFreeze a >>= scmEqual b . ScmVector + +scmEqual a b = scmEqv a b + +scmEquivalence :: (ScmValue -> ScmValue -> IO Bool) -> String + -> [ScmValue] -> IO (ErrOr Bool) + +scmEquivalence f _ [x,y] = fmap Right $ f x y +scmEquivalence _ s (_:_:_) = return$ tooManyArgs s +scmEquivalence _ s _ = return$ tooFewArgs s diff --git a/Haschoo/Evaluator/Standard/Eval.hs b/Haschoo/Evaluator/Standard/Eval.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Eval.hs @@ -0,0 +1,24 @@ +-- File created: 2009-08-08 16:39:10 + +module Haschoo.Evaluator.Standard.Eval (procedures) where + +import Data.IORef (newIORef) + +import Haschoo.Types (ScmValue(..), runHaschoo) +import Haschoo.Utils (ErrOr) +import Haschoo.Evaluator.Eval (eval) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ ("eval", scmEval) + + -- scheme-report-environment and null-environment are in Haschoo.Stdlib to + -- avoid circular dependencies + ] + +scmEval :: [ScmValue] -> IO (ErrOr ScmValue) +scmEval [v, ScmContext ctx] = mapM newIORef ctx >>= flip runHaschoo (eval v) +scmEval [_,_] = return$ Left "Nonenvironmental argument to eval" +scmEval (_:_:_) = return$ tooManyArgs "eval" +scmEval _ = return$ tooFewArgs "eval" diff --git a/Haschoo/Evaluator/Standard/IO.hs b/Haschoo/Evaluator/Standard/IO.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/IO.hs @@ -0,0 +1,200 @@ +-- File created: 2009-07-20 13:30:25 + +module Haschoo.Evaluator.Standard.IO (procedures) where + +import Control.Arrow ((&&&)) +import Control.Exception (bracket) +import Control.Monad (liftM2) +import Data.Array.IArray (elems) +import Data.Array.MArray (getElems) +import System.IO ( Handle, IOMode(..), stdin, stdout + , openFile, hClose, hIsEOF + , hGetChar, hLookAhead, hReady + , hPutStr, hPutStrLn, hPutChar) + +import Haschoo.Parser (runParser, value) +import Haschoo.Types ( ScmValue(..), scmShow, scmShowWith + , isAggregate) +import Haschoo.Utils (ErrOr, ($<), (.:)) +import Haschoo.Evaluator.Utils ( tooFewArgs, tooManyArgs + , notProcedure, notString, notChar) + +import Haschoo.Evaluator.Standard.Strings (isString, strToList) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ ("port?", return . fmap ScmBool . scmIsPort) + , "input-port?" $< id &&& return .: fmap ScmBool .: scmIsInputPort + , "output-port?" $< id &&& return .: fmap ScmBool .: scmIsOutputPort + + , ("eof-object?", return . fmap ScmBool . scmIsEof) + + , "call-with-input-file" $< id &&& scmCallWithFile ReadMode ScmInput + , "call-with-output-file" $< id &&& scmCallWithFile WriteMode ScmOutput + + , "current-input-port" $< id &&& flip constant (return $ ScmInput stdin) + , "current-output-port" $< id &&& flip constant (return $ ScmOutput stdout) + + , "open-input-file" $< id &&& scmOpenFile ReadMode ScmInput + , "open-output-file" $< id &&& scmOpenFile WriteMode ScmOutput + + , ("close-input-port", scmCloseInputPort) + , ("close-output-port", scmCloseOutputPort) + + , "read" $< id &&& \s -> withInput 0 s (constant s . scmRead) + , "read-char" $< id &&& \s -> withInput 0 s (constant s . scmReadChar) + , "peek-char" $< id &&& \s -> withInput 0 s (constant s . scmPeekChar) + , "char-ready" $< id &&& \s -> withInput 0 s (constant s . scmCharReady) + + , "write" $< id &&& \s -> withOutput 1 s scmWrite + , "display" $< id &&& \s -> withOutput 1 s scmDisplay + , "newline" $< id &&& \s -> withOutput 0 s (constant s . scmNewline) + , "write-char" $< id &&& \s -> withOutput 1 s scmWriteChar + ] + +scmIsInputPort, scmIsOutputPort :: String -> [ScmValue] -> ErrOr Bool +scmIsInputPort _ [ScmInput _] = Right True +scmIsInputPort _ [_] = Right False +scmIsInputPort s [] = tooFewArgs s +scmIsInputPort s _ = tooManyArgs s +scmIsOutputPort _ [ScmOutput _] = Right True +scmIsOutputPort _ [_] = Right False +scmIsOutputPort s [] = tooFewArgs s +scmIsOutputPort s _ = tooManyArgs s + +scmIsPort :: [ScmValue] -> ErrOr Bool +scmIsPort x = + liftM2 (||) (scmIsInputPort "port?" x) (scmIsOutputPort "port?" x) + +scmIsEof :: [ScmValue] -> ErrOr Bool +scmIsEof [ScmEOF] = Right True +scmIsEof [_] = Right False +scmIsEof [] = tooFewArgs "eof-object?" +scmIsEof _ = tooManyArgs "eof-object?" + +scmCallWithFile :: IOMode -> (Handle -> ScmValue) -> String + -> [ScmValue] -> IO (ErrOr ScmValue) +scmCallWithFile mode toPort _ [s, ScmFunc _ f] | isString s = do + path <- strToList s + bracket (openFile path mode) hClose (f . (:[]) . toPort) + +scmCallWithFile _ _ s [_, ScmFunc _ _] = return$ notString s +scmCallWithFile _ _ s [_,_] = return$ notProcedure s +scmCallWithFile _ _ s (_:_:_) = return$ tooManyArgs s +scmCallWithFile _ _ s _ = return$ tooFewArgs s + +scmOpenFile :: IOMode -> (Handle -> ScmValue) -> String + -> [ScmValue] -> IO (ErrOr ScmValue) +scmOpenFile mode toPort _ [s] | isString s = do + path <- strToList s + fmap (Right . toPort) (openFile path mode) + +scmOpenFile _ _ s [_] = return$ notString s +scmOpenFile _ _ s [] = return$ tooFewArgs s +scmOpenFile _ _ s _ = return$ tooManyArgs s + +scmCloseInputPort, scmCloseOutputPort :: [ScmValue] -> IO (ErrOr ScmValue) +scmCloseInputPort [ScmInput h] = hClose h >> return (Right ScmVoid) +scmCloseInputPort [_] = return$ notInput "close-input-port" +scmCloseInputPort [] = return$ tooFewArgs "close-input-port" +scmCloseInputPort _ = return$ tooManyArgs "close-input-port" +scmCloseOutputPort [ScmOutput h] = hClose h >> return (Right ScmVoid) +scmCloseOutputPort [_] = return$ notOutput "close-output-port" +scmCloseOutputPort [] = return$ tooFewArgs "close-output-port" +scmCloseOutputPort _ = return$ tooManyArgs "close-output-port" + +-- Meh, this is a pain. The parser is pure so we'd basically need to give it +-- the result of hGetContents; but that breaks any further input ("semi-closes" +-- the handle). So just read a char at a time until we get a successful parse. +-- +-- The spec doesn't say what to do if we get nonsense like anything starting +-- with ")", so we choose to loop forever (or until EOF). +-- +-- O(n^2 + np) where n is the length of the input and p the time it takes for a +-- parse. +scmRead :: Handle -> IO ScmValue +scmRead hdl = go [] + where + go s = do + eof <- hIsEOF hdl + if eof + then return ScmEOF + else do + c <- hGetChar hdl + let s' = s ++ [c] + either (const $ go s') return (runParser value "" s') + +scmReadChar, scmPeekChar, scmCharReady :: Handle -> IO ScmValue +scmReadChar = fmap ScmChar . hGetChar +scmPeekChar = fmap ScmChar . hLookAhead +scmCharReady = fmap ScmBool . hReady + +scmWrite, scmDisplay :: Handle -> [ScmValue] -> IO (ErrOr ScmValue) +scmWrite = scmPrint scmShow "write" +scmDisplay = scmPrint f "display" + where + f (ScmString s) = return (elems s) + f (ScmMString s) = getElems s + f (ScmChar c) = return [c] + f x | isAggregate x = scmShowWith f x + | otherwise = scmShow x + +scmPrint :: (ScmValue -> IO String) -> String + -> Handle -> [ScmValue] -> IO (ErrOr ScmValue) +scmPrint f _ h [x] = f x >>= hPutStr h >> return (Right ScmVoid) +scmPrint _ s _ [] = return$ tooFewArgs s +scmPrint _ s _ _ = return$ tooManyArgs s + +scmNewline :: Handle -> IO ScmValue +scmNewline h = hPutStrLn h "" >> return ScmVoid + +scmWriteChar :: Handle -> [ScmValue] -> IO (ErrOr ScmValue) +scmWriteChar h [ScmChar c] = hPutChar h c >> return (Right ScmVoid) +scmWriteChar _ [_] = return$ notChar "write-char" +scmWriteChar _ [] = return$ tooFewArgs "write-char" +scmWriteChar _ _ = return$ tooManyArgs "write-char" + +----- + +notInput, notOutput :: String -> ErrOr a +notInput = fail . ("Non-input-port argument to " ++) +notOutput = fail . ("Non-output-port argument to " ++) + +constant :: String -> IO ScmValue -> [ScmValue] -> IO (ErrOr ScmValue) +constant _ x [] = fmap Right x +constant s _ _ = return$ tooManyArgs s + +-- These take advantage of the fact that the port is always the last argument +-- +-- withInput does an EOF check as well +withInput, withOutput :: Int + -> String + -> (Handle -> [ScmValue] -> IO (ErrOr ScmValue)) + -> [ScmValue] -> IO (ErrOr ScmValue) +withInput idx s f = withPort stdin apply idx s f + where + apply (ScmInput h) xs = do + eof <- hIsEOF h + if eof + then return$ Right ScmEOF + else f h xs + apply _ _ = return$ notInput s + +withOutput idx s f = withPort stdout apply idx s f + where + apply (ScmOutput h) = f h + apply _ = const.return$ notOutput s + +withPort :: Handle + -> (ScmValue -> ([ScmValue] -> IO (ErrOr ScmValue))) + -> Int + -> String + -> (Handle -> [ScmValue] -> IO (ErrOr ScmValue)) + -> [ScmValue] -> IO (ErrOr ScmValue) + +withPort defaultHdl apply idx s f args = + let (xs, p) = splitAt idx args + in case p of + [x] -> apply x xs + [] -> f defaultHdl xs + _ -> return$ tooManyArgs s diff --git a/Haschoo/Evaluator/Standard/Numeric.hs b/Haschoo/Evaluator/Standard/Numeric.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Numeric.hs @@ -0,0 +1,744 @@ +-- File created: 2009-07-15 21:15:44 + +{-# LANGUAGE Rank2Types #-} + +module Haschoo.Evaluator.Standard.Numeric + (procedures, isNumeric, isExact, numEq, asInt) where + +import Control.Arrow ((&&&), (***)) +import Control.Monad (ap, foldM) +import Data.Array.IArray (elems) +import Data.Array.MArray (getElems) +import Data.Char (intToDigit) +import Data.Complex ( Complex((:+)), mkPolar + , imagPart, realPart, phase, magnitude) +import Data.Ratio (numerator, denominator, approxRational) +import Data.Function (on) +import Numeric (showIntAtBase, showSigned) + +import qualified Haschoo.Parser as Parser +import Haschoo.Types (ScmValue(..), toScmMString) +import Haschoo.Utils (ErrOr, allM, ($<), (.:)) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notInt) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a (return . b))) + [ ("number?", fmap ScmBool . scmIsNumber) + , ("complex?", fmap ScmBool . scmIsNumber) + , ("real?", fmap ScmBool . scmIsReal) + , ("rational?", fmap ScmBool . scmIsRational) + , ("integer?", fmap ScmBool . scmIsInteger) + + , "exact?" $< id &&& fmap ScmBool .: scmIsExact + , "inexact?" $< id &&& fmap (ScmBool . not) .: scmIsExact + + , ("=", fmap ScmBool . scmNumEq) + , "<" $< id &&& fmap ScmBool .: scmCompare (<) + , ">" $< id &&& fmap ScmBool .: scmCompare (>) + , "<=" $< id &&& fmap ScmBool .: scmCompare (<=) + , ">=" $< id &&& fmap ScmBool .: scmCompare (>=) + + , ("zero?", fmap ScmBool . scmIsZero) + , ("positive?", fmap ScmBool . scmIsPos) + , ("negative?", fmap ScmBool . scmIsNeg) + , "even?" $< id &&& fmap ScmBool .: scmIsEven + , "odd?" $< id &&& fmap (ScmBool . not) .: scmIsEven + + , ("max", scmMax) + , ("min", scmMin) + + , ("+", scmPlus) + , ("-", scmMinus) + , ("*", scmMul) + , ("/", scmDiv) + + , ("abs", scmAbs) + + , ("quotient", scmQuot) + , ("remainder", scmRem) + , ("modulo", scmMod) + + , ("gcd", scmGcd) + , ("lcm", scmLcm) + + , ("numerator", scmNumerator) + , ("denominator", scmDenominator) + + , ("floor", scmFloor) + , ("ceiling", scmCeil) + , ("truncate", scmTrunc) + , ("round", scmRound) + + , ("rationalize", scmRationalize) + + , ("exp", scmExp) + , ("log", scmLog) + , ("sin", scmSin) + , ("cos", scmCos) + , ("tan", scmTan) + , ("asin", scmAsin) + , ("acos", scmAcos) + , ("atan", scmAtan) + + , ("sqrt", scmSqrt) + , ("expt", scmExpt) + + , ("make-rectangular", scmMakeRectangular) + , ("make-polar", scmMakePolar) + , ("real-part", scmRealPart) + , ("imag-part", scmImagPart) + , ("magnitude", scmNorm) + , ("angle", scmAngle) + + , ("exact->inexact", scmToInexact) + , ("inexact->exact", scmToExact) ] + + ++ map (\(a,b) -> (a, ScmFunc a b)) + [ ("number->string", scmToString) + , ("string->number", scmToNumber) ] + +---- Predicates + +scmIsNumber, scmIsReal, scmIsRational, scmIsInteger :: [ScmValue] -> ErrOr Bool +scmIsNumber [x] = Right $ isNumeric x +scmIsNumber [] = tooFewArgs "number?" +scmIsNumber _ = tooManyArgs "number?" + +scmIsReal [x] = Right $ isReal x +scmIsReal [] = tooFewArgs "real?" +scmIsReal _ = tooManyArgs "real?" + +scmIsRational [ScmRat _] = Right True +scmIsRational [x] = Right $ isInteger x +scmIsRational [] = tooFewArgs "rational?" +scmIsRational _ = tooManyArgs "rational?" + +scmIsInteger [x] = Right $ isInteger x +scmIsInteger [] = tooFewArgs "integer?" +scmIsInteger _ = tooManyArgs "integer?" + +scmIsExact :: String -> [ScmValue] -> ErrOr Bool +scmIsExact _ [x] | isNumeric x = Right $ isExact x +scmIsExact s [_] = notNum s +scmIsExact s [] = tooFewArgs s +scmIsExact s _ = tooManyArgs s + +isExact :: ScmValue -> Bool +isExact (ScmInt _) = True +isExact (ScmRat _) = True +isExact _ = False + +---- Comparison + +scmNumEq :: [ScmValue] -> ErrOr Bool +scmNumEq [] = tooFewArgs "=" +scmNumEq xs = allM f . (zip`ap`tail) $ xs + where + f (a,b) = if isNumeric a && isNumeric b + then Right $ numEq a b + else notNum "=" + +numEq :: ScmValue -> ScmValue -> Bool +numEq x y = + case pairScmComplex x y of + Right (ScmInt a, ScmInt b) -> a == b + Right (ScmRat a, ScmRat b) -> a == b + Right (ScmReal a, ScmReal b) -> a == b + Right (ScmComplex a, ScmComplex b) -> a == b + _ -> error "numEq :: the impossible happened" + +scmCompare :: (forall a. Real a => a -> a -> Bool) + -> String -> [ScmValue] -> ErrOr Bool +scmCompare p s xs@(_:_:_) = allM f . (zip`ap`tail) $ xs + where + f (a,b) = case liftScmRealA2 p a b of + Left _ -> notReal s + x -> x + +scmCompare _ s _ = tooFewArgs s + +scmIsZero :: [ScmValue] -> ErrOr Bool +scmIsZero [ScmInt 0] = Right True +scmIsZero [ScmRat 0] = Right True +scmIsZero [ScmReal 0] = Right True +scmIsZero [ScmComplex 0] = Right True +scmIsZero [x] | isNumeric x = Right False +scmIsZero [_] = notNum "zero?" +scmIsZero _ = tooManyArgs "zero?" + +scmIsPos, scmIsNeg :: [ScmValue] -> ErrOr Bool +scmIsPos [x] = scmCompare (>) "positive?" [x, ScmInt 0] +scmIsPos _ = tooManyArgs "positive?" + +scmIsNeg [x] = scmCompare (<) "negative?" [x, ScmInt 0] +scmIsNeg _ = tooManyArgs "negative?" + +scmIsEven :: String -> [ScmValue] -> ErrOr Bool +scmIsEven s [x] = if isInteger x + then (scmIsZero.return) =<< scmMod [x, ScmInt 2] + else notInt s +scmIsEven s _ = tooManyArgs s + +scmMax, scmMin :: [ScmValue] -> ErrOr ScmValue +scmMax = scmMinMax max "max" +scmMin = scmMinMax min "min" + +scmMinMax :: (forall a. Real a => a -> a -> a) -> String + -> [ScmValue] -> ErrOr ScmValue +scmMinMax _ s [] = tooFewArgs s +scmMinMax f s (x:xs) = if isNumeric x then foldM go x xs else notNum s + where + go n a = if isNumeric a + then case liftScmReal2 f n a of + Left _ -> notReal s + m -> m + else notNum s + +---- +-*/ + +scmPlus, scmMinus, scmMul, scmDiv :: [ScmValue] -> ErrOr ScmValue +scmPlus [] = Right $ ScmInt 0 +scmPlus xs = foldM go (ScmInt 0) xs + where + go n x = if isNumeric x then liftScmNum2 (+) n x else notNum "+" + +scmMinus [] = tooFewArgs "-" +scmMinus (x:_) | not (isNumeric x) = notNum "-" +scmMinus [x] = liftScmNum negate x +scmMinus (x:xs) = foldM go x xs + where + go n a = if isNumeric a then liftScmNum2 (-) n a else notNum "-" + +scmMul [] = Right $ ScmInt 1 +scmMul xs = foldM go (ScmInt 1) xs + where + go n x = if isNumeric x then liftScmNum2 (*) n x else notNum "*" + +scmDiv [] = tooFewArgs "/" +scmDiv (x:xs) = + unint x >>= case xs of + [] -> liftScmFrac recip + _:_ -> flip (foldM go) xs + where + go n a = unint a >>= liftScmFrac2 (/) n + + unint (ScmInt n) = Right $ ScmRat (fromInteger n) + unint n = if isNumeric x then Right n else notNum "/" + +---- abs + +scmAbs :: [ScmValue] -> ErrOr ScmValue +scmAbs [x] = + if isReal x + then liftScmNum abs x + else notReal "abs" +scmAbs [] = tooFewArgs "abs" +scmAbs _ = tooManyArgs "abs" + +---- quot rem mod + +scmQuot, scmRem, scmMod :: [ScmValue] -> ErrOr ScmValue +scmQuot = scmQuotRemMod quot "quotient" +scmRem = scmQuotRemMod rem "remainder" +scmMod = scmQuotRemMod mod "modulo" + +scmQuotRemMod :: (Integer -> Integer -> Integer) -> String + -> [ScmValue] -> ErrOr ScmValue +scmQuotRemMod f s [x,y] = do + (e1,a) <- asInt s x + (e2,b) <- asInt s y + return . (if e1 && e2 then ScmInt else ScmReal . fromInteger) $ f a b +scmQuotRemMod _ s (_:_:_) = tooManyArgs s +scmQuotRemMod _ s _ = tooFewArgs s + +---- gcd lcm + +scmGcd, scmLcm :: [ScmValue] -> ErrOr ScmValue +scmGcd = scmGcdLcm (\a b -> if a == 0 && b == 0 then 0 else gcd a b) 0 "gcd" +scmLcm = scmGcdLcm lcm 1 "lcm" + +scmGcdLcm :: (Integer -> Integer -> Integer) -> Integer -> String + -> [ScmValue] -> ErrOr ScmValue +scmGcdLcm f i s = fmap fin . foldM go (True,i) + where + go (exact, n) = fmap ((exact &&) *** f n) . asInt s + fin (exact, n) = if exact then ScmInt n else ScmReal (fromInteger n) + +---- numerator denominator + +scmNumerator, scmDenominator :: [ScmValue] -> ErrOr ScmValue +scmNumerator = scmNumerDenom numerator "numerator" +scmDenominator = scmNumerDenom denominator "denominator" + +scmNumerDenom :: (Rational -> Integer) -> String + -> [ScmValue] -> ErrOr ScmValue +scmNumerDenom f s [n] = + case n of + ScmInt x -> Right . ScmInt $ f (fromInteger x) + ScmRat x -> Right . ScmInt $ f x + ScmReal x -> Right . ScmReal . fromInteger $ f (realToFrac x) + ScmComplex (x :+ 0) -> Right . ScmReal . fromInteger $ f (realToFrac x) + _ -> notRat s + +scmNumerDenom _ s [] = tooFewArgs s +scmNumerDenom _ s _ = tooManyArgs s + +---- floor ceil trunc round + +scmFloor, scmCeil, scmTrunc, scmRound :: [ScmValue] -> ErrOr ScmValue +scmFloor = scmGenericRound floor "floor" +scmCeil = scmGenericRound ceiling "ceiling" +scmTrunc = scmGenericRound truncate "truncate" +scmRound = scmGenericRound round "round" + +scmGenericRound :: (forall a. RealFrac a => a -> Integer) -> String + -> [ScmValue] -> ErrOr ScmValue +scmGenericRound _ _ [ ScmInt x] = Right . ScmInt $ x +scmGenericRound f _ [ ScmRat x] = Right . ScmInt $ f x +scmGenericRound f _ [ ScmReal x] = Right . ScmReal . fromInteger $ f x +scmGenericRound _ s [n@(ScmComplex _)] = + case asInt s n of + Right (_,x) -> Right . ScmInt $ x + Left _ -> notReal s +scmGenericRound _ s [_] = notNum s +scmGenericRound _ s [] = tooFewArgs s +scmGenericRound _ s _ = tooManyArgs s + +---- rationalize + +scmRationalize :: [ScmValue] -> ErrOr ScmValue +scmRationalize (_:_:_:_) = tooManyArgs "rationalize" +scmRationalize [x,y] = + case liftScmRealFracB2 approxRational x y of + Left _ -> notReal "rationalize" + Right (True , n) -> Right (ScmRat n) + Right (False, n) -> Right (ScmReal (fromRational n)) + +scmRationalize _ = tooFewArgs "rationalize" + +---- exp log sin cos tan asin acos atan sqrt + +scmExp, scmLog, + scmSin, scmCos, scmTan, + scmAsin, scmAcos, scmAtan, + scmSqrt :: [ScmValue] -> ErrOr ScmValue + +scmExp = scmComplex1 exp "exp" +scmLog = scmComplex1 log "log" +scmSin = scmComplex1 sin "sin" +scmCos = scmComplex1 cos "cos" +scmTan = scmComplex1 tan "tan" +scmAsin = scmComplex1 asin "asin" +scmAcos = scmComplex1 acos "acos" + +scmAtan [y,x] = + case pairScmReal x y of + Left _ -> notReal "atan" + Right (ScmReal a, ScmReal b) -> Right (ScmReal $ phase $ a :+ b) + Right (ScmInt a, ScmInt b) -> + Right (ScmReal $ phase $ fromInteger a :+ fromInteger b) + Right (ScmRat a, ScmRat b) -> + Right (ScmReal $ phase $ fromRational a :+ fromRational b) + Right _ -> error "scmAtan :: internal error" + +scmAtan xs = scmComplex1 atan "atan" xs + +scmSqrt = scmComplex1 sqrt "sqrt" + +scmComplex1 :: (Complex Double -> Complex Double) -> String + -> [ScmValue] -> ErrOr ScmValue +scmComplex1 f _ [ScmInt x] = Right . fromComplex $ f (fromInteger x :+ 0) +scmComplex1 f _ [ScmRat x] = Right . fromComplex $ f (fromRational x :+ 0) +scmComplex1 f _ [ScmReal x] = Right . fromComplex $ f (x :+ 0) +scmComplex1 f _ [ScmComplex x] = Right . fromComplex $ f x +scmComplex1 _ s [_] = notNum s +scmComplex1 _ s [] = tooFewArgs s +scmComplex1 _ s _ = tooManyArgs s + +---- expt + +scmExpt :: [ScmValue] -> ErrOr ScmValue +scmExpt [x,y] = + case pairScmComplex x y of + Left _ -> notNum "expt" + Right (ScmInt a, ScmInt b) -> + if b < 0 + then Right . ScmReal $ fromInteger a ^^ b + else Right . ScmInt $ a ^ b + Right (ScmReal a, ScmReal b) -> Right . ScmReal $ a ** b + Right (ScmComplex a, ScmComplex b) -> Right . ScmComplex $ a ** b + Right (ScmRat a, ScmRat b) -> + Right . ScmReal $ fromRational a ** fromRational b + Right _ -> error "expt :: internal error" + +scmExpt (_:_:_) = tooManyArgs "expt" +scmExpt _ = tooFewArgs "expt" + +---- make-rectangular make-polar real-part imag-part magnitude angle + +scmMakeRectangular, scmMakePolar :: [ScmValue] -> ErrOr ScmValue +scmMakeRectangular = scmMakeComplex (:+) "make-rectangular" +scmMakePolar = scmMakeComplex mkPolar "make-polar" + +scmMakeComplex :: (Double -> Double -> Complex Double) -> String + -> [ScmValue] -> ErrOr ScmValue +scmMakeComplex f s [x,y] = + case pairScmReal x y of + Left _ -> notReal s + Right (ScmReal a, ScmReal b) -> Right . ScmComplex $ f a b + Right (ScmRat a, ScmRat b) -> + Right . ScmComplex $ (f `on` fromRational) a b + Right (ScmInt a, ScmInt b) -> + Right . ScmComplex $ (f `on` fromInteger) a b + Right _ -> + error $ s ++ " :: internal error" + +scmMakeComplex _ s (_:_:_) = tooManyArgs s +scmMakeComplex _ s _ = tooFewArgs s + +scmRealPart, scmImagPart, scmNorm, scmAngle :: [ScmValue] -> ErrOr ScmValue +scmRealPart = scmComplexPart realPart Right "real-part" +scmImagPart = scmComplexPart imagPart (liftScmNum $ const 0) "imag-part" +scmNorm = scmComplexPart magnitude (liftScmNum abs) "magnitude" +scmAngle = scmComplexPart phase (Right . angle) "angle" + where + angle (ScmReal n) = f ScmReal n + angle (ScmRat n) = f ScmRat n + angle (ScmInt n) = f ScmInt n + angle _ = error "angle :: the impossible happened" + + f c n = if n >= 0 then c 0 else ScmReal pi + +scmComplexPart :: (Complex Double -> Double) + -> (ScmValue -> ErrOr ScmValue) + -> String + -> [ScmValue] -> ErrOr ScmValue +scmComplexPart f _ _ [ScmComplex x] = Right $ ScmReal (f x) +scmComplexPart _ g _ [x] | isNumeric x = g x +scmComplexPart _ _ s [_] = notNum s +scmComplexPart _ _ s [] = tooFewArgs s +scmComplexPart _ _ s _ = tooManyArgs s + +---- exact->inexact inexact->exact + +scmToInexact, scmToExact :: [ScmValue] -> ErrOr ScmValue +scmToInexact [ScmInt x] = Right $ ScmReal (fromInteger x) +scmToInexact [ScmRat x] = Right $ ScmReal (fromRational x) +scmToInexact [x] | isNumeric x = Right x +scmToInexact [_] = notNum "exact->inexact" +scmToInexact [] = tooFewArgs "exact->inexact" +scmToInexact _ = tooManyArgs "exact->inexact" + +scmToExact [ScmReal x] = + let r = toRational x + in Right $ if denominator r == 1 + then ScmInt (numerator r) + else ScmRat r +scmToExact [ScmComplex x] = + case imagPart x of + 0 -> Right $ ScmReal (realPart x) + _ -> fail $ "inexact->exact :: implementation restriction: " ++ + "can't exactify complex numbers" +scmToExact [x] | isNumeric x = Right x +scmToExact [_] = notNum "exact->inexact" +scmToExact [] = tooFewArgs "exact->inexact" +scmToExact _ = tooManyArgs "exact->inexact" + +---- number->string string->number + +scmToString, scmToNumber :: [ScmValue] -> IO (ErrOr ScmValue) + +-- TODO: scmShow should use this or vice versa +scmToString (x:xs) | isNumeric x = + case xs of + [] -> g x 10 + [ScmInt radix] -> + if radix `elem` [2,8,10,16] + then g x (fromInteger radix) + else return. fail $ + "number->string :: invalid radix " ++ show radix + + [_] -> return$ notInt "number->string" + _ -> return$ tooManyArgs "number->string" + where + g n radix = case f n radix of + Left err -> return$ fail err + Right s -> fmap Right $ toScmMString s + + f (ScmInt i) radix = Right $ showInt radix i + f (ScmRat r) radix = Right $ + if denominator r == 1 + then showInt radix (numerator r) + else concat [ showInt radix (numerator r) + , "/" + , showInt radix (denominator r) ] + + f (ScmReal r) radix = + if radix == 10 + then Right $ + case () of + _| isNaN r -> "+nan.#" + | isInfinite r -> (if r < 0 then '-' else '+') : "inf.#" + + -- R5RS 6.2.6 specifies that "the result contains a + -- decimal point" if inexact and a decimal-point + -- containing result can make it work + | otherwise -> show r + else fail "number->string :: nondecimal radix for inexact real" + + f (ScmComplex (a :+ b)) radix = + -- As in the ScmReal case + if radix == 10 + then Right . concat $ let bs = either undefined id $ f (ScmReal b) 10 + in [ either undefined id $ f (ScmReal a) 10 + , if head bs `elem` "-+" then [] else "+" + , bs + , "i" ] + + else fail "number->string :: nondecimal radix for inexact complex" + + f _ _ = error "number->string :: the impossible happened" + + showInt radix i = showSigned (showIntAtBase radix intToDigit) 0 i "" + +scmToString [] = return$ tooFewArgs "number->string" +scmToString _ = return$ notNum "number->string" + +scmToNumber (ScmString s : xs) = return$ toNumHelper xs (elems s) +scmToNumber (ScmMString s : xs) = fmap (toNumHelper xs) (getElems s) +scmToNumber [] = return$ tooFewArgs "string->number" +scmToNumber _ = return$ fail "Nonstring argument to string->number" + +toNumHelper :: [ScmValue] -> String -> ErrOr ScmValue +toNumHelper xs s = + case xs of + [] -> Right $ f s 10 + [ScmInt radix] -> + if radix `elem` [2,8,10,16] + then Right $ f s (fromInteger radix) + else fail $ "string->number :: invalid radix " ++ show radix + + [_] -> notInt "string->number" + _ -> tooManyArgs "string->number" + where + f str radix = + case Parser.runParser (Parser.number radix) "" str of + Right n | isNumeric n -> n + _ -> ScmBool False + +------------- + +notNum, notReal, notRat :: String -> ErrOr a +notNum = fail . ("Nonnumeric argument to " ++) +notReal = fail . ("Nonreal argument to " ++) +notRat = fail . ("Nonrational argument to " ++) + +isNumeric, isInteger, isReal :: ScmValue -> Bool +isNumeric (ScmInt _) = True +isNumeric (ScmRat _) = True +isNumeric (ScmReal _) = True +isNumeric (ScmComplex _) = True +isNumeric _ = False + +isInteger (ScmInt _) = True +isInteger (ScmRat x) = denominator x == 1 +isInteger (ScmReal x) = x == fromInteger (round x) +isInteger (ScmComplex (a:+b)) = b == 0 && a == fromInteger (round a) +isInteger _ = False + +isReal (ScmComplex (_ :+ b)) = b == 0 +isReal x = isNumeric x + +asInt :: String -> ScmValue -> ErrOr (Bool, Integer) +asInt s x | not (isInteger x) = notInt s +asInt _ (ScmInt x) = Right (True, x) +asInt _ (ScmRat x) = Right (True, numerator x) +asInt _ (ScmReal x) = Right (False, round x) +asInt _ (ScmComplex (x:+0)) = Right (False, round x) +asInt _ _ = error "This can't happen" + +fromComplex :: Complex Double -> ScmValue +fromComplex (x :+ 0) = ScmReal x +fromComplex x = ScmComplex x + +-- Lift ScmValue's numeric types to a common type +-- +-- Versions without 'A' at the end also return results in the correct +-- constructor of the two given. Versions with 'B' just return whether the +-- result should be exact or not. +-- +-- Ugly and verbose... too lazy to metaize these {{{ + +--- Num +liftScmNum :: (forall a. Num a => a -> a) -> ScmValue -> ErrOr ScmValue +liftScmNum f (ScmInt a) = Right . ScmInt $ f a +liftScmNum f (ScmRat a) = Right . ScmRat $ f a +liftScmNum f (ScmReal a) = Right . ScmReal $ f a +liftScmNum f (ScmComplex a) = Right . ScmComplex $ f a +liftScmNum _ _ = fail "liftScmNum :: internal error" + +liftScmNum2 :: (forall a. Num a => a -> a -> a) + -> (ScmValue -> ScmValue -> ErrOr ScmValue) +liftScmNum2 f (ScmInt a) (ScmInt b) = Right . ScmInt $ f a b +liftScmNum2 f (ScmRat a) (ScmRat b) = Right . ScmRat $ f a b +liftScmNum2 f (ScmReal a) (ScmReal b) = Right . ScmReal $ f a b +liftScmNum2 f (ScmComplex a) (ScmComplex b) = Right . ScmComplex$ f a b + +-- Int+{Rat,Real,Complex} +liftScmNum2 f (ScmInt a) (ScmRat b) = Right . ScmRat $ f (fInt a) b +liftScmNum2 f (ScmRat a) (ScmInt b) = Right . ScmRat $ f a (fInt b) +liftScmNum2 f (ScmInt a) (ScmReal b) = Right . ScmReal $ f (fInt a) b +liftScmNum2 f (ScmReal a) (ScmInt b) = Right . ScmReal $ f a (fInt b) +liftScmNum2 f (ScmInt a) (ScmComplex b) = Right . ScmComplex$ f (fInt a) b +liftScmNum2 f (ScmComplex a) (ScmInt b) = Right . ScmComplex$ f a (fInt b) + +-- Rat+{Real,Complex} +liftScmNum2 f (ScmRat a) (ScmReal b) = Right . ScmReal $ f (fRat a) b +liftScmNum2 f (ScmReal a) (ScmRat b) = Right . ScmReal $ f a (fRat b) +liftScmNum2 f (ScmRat a) (ScmComplex b) = Right . ScmComplex$ f (fRat a) b +liftScmNum2 f (ScmComplex a) (ScmRat b) = Right . ScmComplex$ f a (fRat b) + +-- Real+Complex +liftScmNum2 f (ScmReal a) (ScmComplex b) = Right . ScmComplex$ f (a :+ 0) b +liftScmNum2 f (ScmComplex a) (ScmReal b) = Right . ScmComplex$ f a (b :+ 0) + +liftScmNum2 _ _ _ = fail "liftScmNum2 :: internal error" + +--- Frac +liftScmFrac :: (forall a. Fractional a => a -> a) -> ScmValue -> ErrOr ScmValue +liftScmFrac f (ScmRat a) = Right . ScmRat $ f a +liftScmFrac f (ScmReal a) = Right . ScmReal $ f a +liftScmFrac f (ScmComplex a) = Right . ScmComplex $ f a +liftScmFrac _ _ = fail "liftScmFrac :: internal error" + +liftScmFrac2 :: (forall a. Fractional a => a -> a -> a) + -> (ScmValue -> ScmValue -> ErrOr ScmValue) +liftScmFrac2 f (ScmRat a) (ScmRat b) = Right . ScmRat $ f a b +liftScmFrac2 f (ScmReal a) (ScmReal b) = Right . ScmReal $ f a b +liftScmFrac2 f (ScmComplex a) (ScmComplex b) = Right . ScmComplex$ f a b + +-- Rat+{Real,Complex} +liftScmFrac2 f (ScmRat a) (ScmReal b) = Right . ScmReal $ f (fRat a) b +liftScmFrac2 f (ScmReal a) (ScmRat b) = Right . ScmReal $ f a (fRat b) +liftScmFrac2 f (ScmRat a) (ScmComplex b) = Right . ScmComplex$ f (fRat a) b +liftScmFrac2 f (ScmComplex a) (ScmRat b) = Right . ScmComplex$ f a (fRat b) + +-- Real+Complex +liftScmFrac2 f (ScmReal a) (ScmComplex b) = Right . ScmComplex$ f (a :+ 0) b +liftScmFrac2 f (ScmComplex a) (ScmReal b) = Right . ScmComplex$ f a (b :+ 0) + +liftScmFrac2 _ _ _ = fail "liftScmFrac2 :: internal error" + +--- Real +liftScmReal2 :: (forall a. Real a => a -> a -> a) + -> (ScmValue -> ScmValue -> ErrOr ScmValue) +liftScmReal2 f x y = + case pairScmReal x y of + Right (ScmReal a, ScmReal b) -> Right . ScmReal $ f a b + Right (ScmRat a, ScmRat b) -> Right . ScmRat $ f a b + Right (ScmInt a, ScmInt b) -> Right . ScmInt $ f a b + Left s -> Left s + Right _ -> fail "liftScmReal2 :: internal error" + +liftScmRealA2 :: (forall a. Real a => a -> a -> b) + -> (ScmValue -> ScmValue -> ErrOr b) +liftScmRealA2 f x y = + case pairScmReal x y of + Right (ScmReal a, ScmReal b) -> Right $ f a b + Right (ScmRat a, ScmRat b) -> Right $ f a b + Right (ScmInt a, ScmInt b) -> Right $ f a b + Left s -> Left s + Right _ -> fail "liftScmRealA2 :: internal error" + +--- RealFrac +liftScmRealFracB2 :: (forall a. RealFrac a => a -> a -> b) + -> (ScmValue -> ScmValue -> ErrOr (Bool, b)) +liftScmRealFracB2 f x y = + case pairScmReal x y of + Right (ScmReal a, ScmReal b) -> Right (False, f a b) + Right (ScmRat a, ScmRat b) -> Right (True, f a b) + Right (ScmInt a, ScmInt b) -> + Right (True, f (fInt a) (fInt b :: Rational)) + Left s -> Left s + Right _ -> + fail "liftScmRealFracB2 :: internal error" + +pairScmReal :: ScmValue -> ScmValue -> ErrOr (ScmValue, ScmValue) +pairScmReal (ScmComplex a) _ | imagPart a /= 0 = fail "pairScmReal :: complex" +pairScmReal _ (ScmComplex b) | imagPart b /= 0 = fail "pairScmReal :: complex" + +pairScmReal a@(ScmInt _) b@(ScmInt _) = Right (a,b) +pairScmReal a@(ScmRat _) b@(ScmRat _) = Right (a,b) +pairScmReal a@(ScmReal _) b@(ScmReal _) = Right (a,b) +pairScmReal (ScmComplex a) (ScmComplex b) = + Right $ ((,) `on` ScmReal . realPart) a b + +-- Int+{Rat,Real,Complex} +pairScmReal (ScmInt a) (ScmRat b) = Right $ ((,)`on`ScmRat) (fInt a) b +pairScmReal (ScmRat a) (ScmInt b) = Right $ ((,)`on`ScmRat) a (fInt b) +pairScmReal (ScmInt a) (ScmReal b) = Right $ ((,)`on`ScmReal) (fInt a) b +pairScmReal (ScmReal a) (ScmInt b) = Right $ ((,)`on`ScmReal) a (fInt b) +pairScmReal (ScmInt a) (ScmComplex b) = + Right $ ((,)`on`ScmReal) (fInt a) (realPart b) +pairScmReal (ScmComplex a) (ScmInt b) = + Right $ ((,)`on`ScmReal) (realPart a) (fInt b) + +-- Rat+{Real,Complex} +pairScmReal (ScmRat a) (ScmReal b) = Right $ ((,)`on`ScmReal) (fRat a) b +pairScmReal (ScmReal a) (ScmRat b) = Right $ ((,)`on`ScmReal) a (fRat b) +pairScmReal (ScmRat a) (ScmComplex b) = + Right $ ((,)`on`ScmReal) (fRat a) (realPart b) +pairScmReal (ScmComplex a) (ScmRat b) = + Right $ ((,)`on`ScmReal) (realPart a) (fRat b) + +-- Real+Complex +pairScmReal (ScmReal a) (ScmComplex b) = + Right $ ((,)`on`ScmReal) a (realPart b) +pairScmReal (ScmComplex a) (ScmReal b) = + Right $ ((,)`on`ScmReal) (realPart a) b + +pairScmReal _ _ = fail "pairScmReal :: internal error" + +pairScmComplex :: ScmValue -> ScmValue -> ErrOr (ScmValue, ScmValue) +pairScmComplex a@(ScmInt _) b@(ScmInt _) = Right (a,b) +pairScmComplex a@(ScmRat _) b@(ScmRat _) = Right (a,b) +pairScmComplex a@(ScmReal _) b@(ScmReal _) = Right (a,b) +pairScmComplex a@(ScmComplex _) b@(ScmComplex _) = Right (a,b) + +-- Int+{Rat,Real,Complex} +pairScmComplex (ScmInt a) (ScmRat b) = Right$((,)`on`ScmRat) (fInt a) b +pairScmComplex (ScmRat a) (ScmInt b) = Right$((,)`on`ScmRat) a (fInt b) +pairScmComplex (ScmInt a) (ScmReal b) = + Right $ ((,)`on`ScmReal) (fInt a) b +pairScmComplex (ScmReal a) (ScmInt b) = + Right $ ((,)`on`ScmReal) a (fInt b) +pairScmComplex (ScmInt a) (ScmComplex b) = + Right $ ((,)`on`ScmComplex) (fInt a) b +pairScmComplex (ScmComplex a) (ScmInt b) = + Right $ ((,)`on`ScmComplex) a (fInt b) + +-- Rat+{Real,Complex} +pairScmComplex (ScmRat a) (ScmReal b) = + Right $ ((,)`on`ScmReal) (fRat a) b +pairScmComplex (ScmReal a) (ScmRat b) = + Right $ ((,)`on`ScmReal) a (fRat b) +pairScmComplex (ScmRat a) (ScmComplex b) = + Right $ ((,)`on`ScmComplex) (fRat a) b +pairScmComplex (ScmComplex a) (ScmRat b) = + Right $ ((,)`on`ScmComplex) a (fRat b) + +-- Real+Complex +pairScmComplex (ScmReal a) (ScmComplex b) = + Right $ ((,)`on`ScmComplex) (a:+0) b +pairScmComplex (ScmComplex a) (ScmReal b) = + Right $ ((,)`on`ScmComplex) a (b:+0) + +pairScmComplex _ _ = fail "pairScmComplex :: internal error" + +fInt :: Num a => Integer -> a +fInt = fromInteger + +fRat :: Fractional a => Rational -> a +fRat = fromRational + +-- }}} diff --git a/Haschoo/Evaluator/Standard/PairsLists.hs b/Haschoo/Evaluator/Standard/PairsLists.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/PairsLists.hs @@ -0,0 +1,331 @@ +-- File created: 2009-07-21 22:13:29 + +module Haschoo.Evaluator.Standard.PairsLists (procedures, scmAppend) where + +import Control.Applicative ((<$>)) +import Control.Arrow ((&&&)) +import Control.Monad (join, replicateM, (>=>)) +import Control.Monad.Loops (dropWhileM, firstM) +import Data.Foldable (foldrM) +import Data.IORef (IORef, newIORef, readIORef, writeIORef) +import Data.List (genericDrop) +import Data.Maybe (fromMaybe) + +import Haschoo.Types ( ScmValue(..) + , pairToList, listToPair) +import Haschoo.Utils (ErrOr, ($<), ptrEq) +import Haschoo.Evaluator.Utils (tooFewArgs,tooManyArgs, notList) +import Haschoo.Evaluator.Standard.Equivalence (scmEq, scmEqv, scmEqual) +import Haschoo.Evaluator.Standard.Numeric (asInt) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) $ + [ ("pair?", return . fmap ScmBool . scmIsPair) + , ("cons", scmCons) + , "car" $< id &&& scmCar + , "cdr" $< id &&& scmCdr + , ("set-car!", scmSetCar) + , ("set-cdr!", scmSetCdr) ] + + ++ carCdrCompositions ++ + + [ ("null?", return . fmap ScmBool . scmIsNull) + , ("list?", fmap (fmap ScmBool) . scmIsList) + , ("list", fmap Right . scmList) + , ("length", scmLength) + , ("append", scmAppend) + , ("reverse", scmReverse) + , ("list-ref", scmListRef) + , ("memq", scmMemq) + , ("memv", scmMemv) + , ("member", scmMember) + , ("assq", scmAssq) + , ("assv", scmAssv) + , ("assoc", scmAssoc) ] + +---- Pairs + +--- pair? + +scmIsPair :: [ScmValue] -> ErrOr Bool +scmIsPair [ScmPair _ _] = Right True +scmIsPair [ScmList (_:_)] = Right True +scmIsPair [ScmDottedList _ _] = Right True +scmIsPair [_] = Right False +scmIsPair [] = tooFewArgs "pair?" +scmIsPair _ = tooManyArgs "pair?" + +--- cons + +scmCons :: [ScmValue] -> IO (ErrOr ScmValue) +scmCons [a, b] = do + x <- newIORef a + y <- newIORef b + return.Right $ ScmPair x y +scmCons (_:_:_) = return$ tooManyArgs "cons" +scmCons _ = return$ tooFewArgs "cons" + +--- car cdr + +scmCar, scmCdr :: String -> [ScmValue] -> IO (ErrOr ScmValue) +scmCar _ [ScmPair a _] = return . Right =<< readIORef a +scmCar _ [ScmList (a:_)] = return . Right $ a +scmCar _ [ScmDottedList (a:_) _] = return . Right $ a +scmCar s [ScmList []] = return . fail $ s ++ " :: empty list" +scmCar s [_] = return$ notPair s +scmCar s [] = return$ tooFewArgs s +scmCar s _ = return$ tooManyArgs s + +scmCdr _ [ScmPair _ b] = return . Right =<< readIORef b +scmCdr _ [ScmList (_:bs)] = return . Right $ ScmList bs +scmCdr _ [ScmDottedList [_] b] = return . Right $ b +scmCdr _ [ScmDottedList (_:a) b] = return . Right $ ScmDottedList a b +scmCdr s [ScmList []] = return . fail $ s ++ " :: empty list" +scmCdr s [_] = return$ notPair s +scmCdr s [] = return$ tooFewArgs s +scmCdr s _ = return$ tooManyArgs s + +--- set-car! set-cdr! + +scmSetCar, scmSetCdr :: [ScmValue] -> IO (ErrOr ScmValue) +scmSetCar = scmSet (const . writeIORef) "set-car!" +scmSetCdr = scmSet (const writeIORef) "set-cdr!" + +scmSet :: (IORef ScmValue -> IORef ScmValue -> ScmValue -> IO ()) -> String + -> [ScmValue] -> IO (ErrOr ScmValue) + +scmSet f _ [ScmPair a b, v] = f a b v >> return (Right ScmVoid) +scmSet _ s [ScmList _, _] = return$ immutable s +scmSet _ s [ScmDottedList _ _, _] = return$ immutable s +scmSet _ s [_,_] = return$ notPair s +scmSet _ s (_:_:_) = return$ tooManyArgs s +scmSet _ s _ = return$ tooFewArgs s + +--- caar cadr ... cddddr + +carCdrCompositions :: [(String, [ScmValue] -> IO (ErrOr ScmValue))] +carCdrCompositions = map (name &&& join func) + (concatMap (flip replicateM "ad") [2..depth]) + where + -- R5RS 6.3.2 + depth = 4 + + name a = concat ["c",a,"r"] + + func :: String -> String -> [ScmValue] -> IO (ErrOr ScmValue) + func _ [] = return . Right . head + func s ('a':xs) = func s xs >=> next s scmCar + func s ('d':xs) = func s xs >=> next s scmCdr + func s _ = error (name s ++ " :: the impossible happened!") + + next _ _ x@(Left _) = return x + next s f (Right v) = f (name s) [v] + +---- Lists + +--- null? list? + +scmIsNull :: [ScmValue] -> ErrOr Bool +scmIsNull [ScmList []] = Right True +scmIsNull [_] = Right False +scmIsNull [] = tooFewArgs "null?" +scmIsNull _ = tooManyArgs "null?" + +scmIsList :: [ScmValue] -> IO (ErrOr Bool) +scmIsList [ScmList _] = return$ Right True +scmIsList [ScmPair _ b] = Right <$> (readIORef b >>= join go) + where + go (ScmPair _ sn) fast@(ScmPair _ fn) = do + fn' <- readIORef fn + case fn' of + ScmPair _ fn2 -> do + eq <- ptrEq fast fn' + if eq + then return False -- Cycle + else do + fn2' <- readIORef fn2 + case fn2' of + ScmPair _ _ -> readIORef sn >>= flip go fn2' + ScmList _ -> return True + _ -> return False + ScmList _ -> return True + _ -> return False + + go _ (ScmList _) = return True + go _ _ = return False + +scmIsList [_] = return$ Right False +scmIsList [] = return$ tooFewArgs "list?" +scmIsList _ = return$ tooManyArgs "list?" + +--- list + +scmList :: [ScmValue] -> IO ScmValue +scmList [] = return (ScmList []) +scmList (x:xs) = do + ys <- scmList xs + y <- newIORef x + z <- newIORef ys + return (ScmPair y z) + +--- length + +scmLength :: [ScmValue] -> IO (ErrOr ScmValue) +scmLength [ScmPair _ p] = readIORef p >>= go 1 + where + go n _ | n `seq` False = undefined + go n (ScmList []) = return . Right . ScmInt . toInteger $ (n :: Int) + go n (ScmPair _ b) = readIORef b >>= go (n+1) + go _ _ = return$ notList "length" + +scmLength [ScmList xs] = return . Right . ScmInt . toInteger $ length xs +scmLength [_] = return$ notList "length" +scmLength [] = return$ tooFewArgs "length" +scmLength _ = return$ tooManyArgs "length" + +--- append + +scmAppend :: [ScmValue] -> IO (ErrOr ScmValue) +scmAppend [] = Right . fst <$> listToPair [] +scmAppend args = foldrM fold (Left "") args + where + -- The last argument is allowed to be a nonlist: this is a bit of a hack to + -- catch that case + -- + -- If we were to just match on ScmList [] in f, we'd allow an arbitrary + -- number of '() to follow the final argument + fold x (Left "") = return (Right x) + + fold _ err@(Left _) = return err + fold a (Right b) = f a b + + f (p@(ScmPair _ _)) rhs = next rhs p + f (ScmList xs) rhs = do + (xs', fin) <- listToPair xs + case fin of + Nothing -> return . Right $ rhs + Just p -> do + writeIORef p rhs + return . Right $ xs' + + f _ _ = return$ notList "append" + + -- Builds up the list as we iterate through it + next rhs (ScmPair a b) = do + b' <- go rhs =<< readIORef b + case b' of + Left _ -> return b' + Right y -> do + newA <- newIORef =<< readIORef a + newB <- newIORef y + return . Right $ ScmPair newA newB + + next _ _ = error "append :: the impossible happened" + + go rhs x@(ScmPair _ _) = next rhs x + go rhs x@(ScmList _) = f x rhs + go _ _ = return$ notList "append" + +--- reverse + +scmReverse :: [ScmValue] -> IO (ErrOr ScmValue) +scmReverse [ScmList xs] = fmap (Right . fst) . listToPair $ reverse xs +scmReverse [x@(ScmPair _ _)] = do + x' <- pairToList x + case x' of + Right (ScmList l) -> fmap (Right . fst) . listToPair $ reverse l + Left _ -> return $ notList "reverse" + Right _ -> error "reverse :: the impossible happened" +scmReverse [_] = return$ notList "reverse" +scmReverse [] = return$ tooFewArgs "reverse" +scmReverse _ = return$ tooManyArgs "reverse" + +--- list-ref + +scmListRef :: [ScmValue] -> IO (ErrOr ScmValue) +scmListRef [x, n] = + case fmap snd $ asInt "list-ref" n of + Right i -> f x i + Left s -> return (Left s) + where + f (ScmList xs) i = return$ case genericDrop i xs of + [] -> fail "list-ref :: overlarge index" + v:_ -> Right v + + f (ScmPair a _) 0 = Right <$> readIORef a + f (ScmPair _ b) i = readIORef b >>= flip f (i-1) + f _ _ = return$ notList "list-ref" + +scmListRef (_:_:_) = return$ tooManyArgs "list-ref" +scmListRef _ = return$ tooFewArgs "list-ref" + +--- memq memv member + +scmMemq, scmMemv, scmMember :: [ScmValue] -> IO (ErrOr ScmValue) +scmMemq = scmFind scmEq "memq" +scmMemv = scmFind scmEqv "memv" +scmMember = scmFind scmEqual "member" + +scmFind :: (ScmValue -> ScmValue -> IO Bool) -> String + -> [ScmValue] -> IO (ErrOr ScmValue) +scmFind p s [obj, list] = + case list of + ScmList _ -> go list + ScmPair _ _ -> go list + _ -> return$ notList s + where + go (ScmList xs) = do + ys <- dropWhileM (fmap not . p obj) xs + return.Right $ if null ys + then ScmBool False + else ScmList ys + + go x@(ScmPair a b) = do + found <- p obj =<< readIORef a + if found + then return . Right $ x + else readIORef b >>= go + + go _ = return$ notList s + +scmFind _ s (_:_:_) = return$ tooManyArgs s +scmFind _ s _ = return$ tooFewArgs s + +--- assq assv assoc + +scmAssq, scmAssv, scmAssoc :: [ScmValue] -> IO (ErrOr ScmValue) +scmAssq = scmLookup scmEq "assq" +scmAssv = scmLookup scmEqv "assv" +scmAssoc = scmLookup scmEqual "assoc" + +scmLookup :: (ScmValue -> ScmValue -> IO Bool) -> String + -> [ScmValue] -> IO (ErrOr ScmValue) +scmLookup p s [obj, list] = + case list of + ScmList _ -> go list + ScmPair _ _ -> go list + _ -> return$ notList s + where + go (ScmList xs) = Right . fromMaybe (ScmBool False) <$> firstM match xs + go (ScmPair a b) = do + a' <- readIORef a + found <- match a' + if found + then return . Right $ a' + else readIORef b >>= go + + go _ = return$ notList s + + match (ScmPair a _) = p obj =<< readIORef a + match (ScmDottedList (a:_) _) = p obj a + match (ScmList (a:_)) = p obj a + match _ = return False + +scmLookup _ s (_:_:_) = return$ tooManyArgs s +scmLookup _ s _ = return$ tooFewArgs s + +---- Utils + +immutable, notPair :: String -> ErrOr a +immutable = fail . ("Immutable argument to " ++) +notPair = fail . ("Nonpair argument to " ++) diff --git a/Haschoo/Evaluator/Standard/Strings.hs b/Haschoo/Evaluator/Standard/Strings.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Strings.hs @@ -0,0 +1,256 @@ +-- File created: 2009-08-05 20:14:14 + +module Haschoo.Evaluator.Standard.Strings (procedures, isString, strToList) + where + +import Control.Applicative ((<$>)) +import Control.Arrow ((&&&)) +import Control.Monad (join, liftM2) +import Data.Array.IArray ((!), bounds, elems) +import Data.Array.IO (IOUArray) +import Data.Array.MArray ( readArray, writeArray + , newArray, newListArray + , getBounds, getElems + , freeze, thaw, unsafeFreeze, unsafeThaw) +import Data.Array.Unboxed (UArray) +import Data.Char (isLetter, toLower) +import Data.Foldable (foldrM) +import Data.Function (on) + +import Haschoo.Types ( ScmValue(..), toScmMString + , listToPair, pairToList) +import Haschoo.Utils (ErrOr, ($<), (.:), mapOnPairs) +import Haschoo.Evaluator.Utils ( tooFewArgs, tooManyArgs, immutable + , notChar, notInt, notList, notString) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ ("string?", return . fmap ScmBool . scmIsString) + + , ("make-string", scmMakeString) + , ("string", scmString) + + , ("string-length", scmLength) + + , ("string-ref", scmRef) + , ("string-set!", scmSet) + + , "string=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (==) (,) + , "string?" $< id &&& fmap (fmap ScmBool) .: scmCompare (>) (,) + , "string<=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (<=) (,) + , "string>=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (>=) (,) + + , "string-ci=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (==) lower + , "string-ci?" $< id &&& fmap (fmap ScmBool) .: scmCompare (>) lower + , "string-ci<=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (<=) lower + , "string-ci>=?" $< id &&& fmap (fmap ScmBool) .: scmCompare (>=) lower + + , ("substring", scmSubstring) + + , ("string-append", scmAppend) + + , ("string->list", scmToList) + , ("list->string", scmFromList) + + , ("string-copy", scmCopy) + , ("string-fill!", scmFill) + ] + where + lower a b = if isLetter a && isLetter b + then (toLower a, toLower b) + else (a,b) + +scmIsString :: [ScmValue] -> ErrOr Bool +scmIsString [x] = Right (isString x) +scmIsString [] = tooFewArgs "string?" +scmIsString _ = tooManyArgs "string?" + +scmMakeString, scmString :: [ScmValue] -> IO (ErrOr ScmValue) +scmMakeString (ScmInt l : xs) = + case xs of + [] -> f (flip newArray '*') + [ScmChar c] -> f (flip newArray c) + [_] -> return$ notChar "make-string" + _ -> return$ tooManyArgs "make-string" + where + f mk = tryToLen "make-string" l $ \i -> ScmMString <$> mk (0, i-1) + +scmMakeString [_, ScmChar _] = return$ notInt "make-string" +scmMakeString (_:_:_:_) = return$ tooManyArgs "make-string" +scmMakeString [] = return$ tooFewArgs "make-string" +scmMakeString _ = return$ notChar "make-string" + +scmString xs = case mapM (fromChar "string") xs of + Left e -> return$ Left e + Right s -> fmap Right $ toScmMString s + +scmLength :: [ScmValue] -> IO (ErrOr ScmValue) +scmLength [x] = case x of + ScmString s -> Right . ScmInt . toInteger <$> sLen s + ScmMString s -> Right . ScmInt . toInteger <$> msLen s + _ -> return$ notString "string-length" + +scmLength [] = return$ tooFewArgs "string-length" +scmLength _ = return$ tooManyArgs "string-length" + +scmRef, scmSet :: [ScmValue] -> IO (ErrOr ScmValue) +scmRef [x, ScmInt i] = case x of + ScmString s -> f (sLen s) (return . (s!)) + ScmMString s -> f (msLen s) (readArray s) + _ -> return$ notString "string-ref" + where + f len = fmap (fmap ScmChar) . tryToIdx "string-ref" len i + +scmRef [_,_] = return$ notInt "string-ref" +scmRef (_:_:_) = return$ tooManyArgs "string-ref" +scmRef _ = return$ tooFewArgs "string-ref" + +scmSet [x, ScmInt idx, ScmChar c] = + case x of + ScmMString s -> do + tryToIdx "string-set!" (msLen s) idx (\i -> writeArray s i c) + return (Right ScmVoid) + + ScmString _ -> return$ immutable "string-set!" + _ -> return$ notString "string-set!" + +scmSet [_, _, ScmChar _] = return$ notInt "string-set!" +scmSet [_, _, _] = return$ notChar "string-set!" +scmSet (_:_:_:_) = return$ tooManyArgs "string-set!" +scmSet _ = return$ tooFewArgs "string-set!" + +scmCompare :: (String -> String -> Bool) + -> (Char -> Char -> (Char, Char)) + -> String + -> [ScmValue] -> IO (ErrOr Bool) +scmCompare p f s [a, b] = + if isString a && isString b + then Right <$> (liftM2 (uncurry p .: mapOnPairs f `on` elems) `on` conv) + a b + else return$ notString s + where + conv (ScmString x) = return x + conv (ScmMString x) = unsafeFreeze x + conv _ = error $ s ++ " :: the impossible happpened" +scmCompare _ _ s (_:_:_) = return$ tooManyArgs s +scmCompare _ _ s _ = return$ tooFewArgs s + +scmSubstring :: [ScmValue] -> IO (ErrOr ScmValue) +scmSubstring [x, ScmInt a, ScmInt b] = + case x of + ScmMString s -> f (msLen s) (getElems s) + ScmString s -> f (sLen s) (return $ elems s) + _ -> return$ notString "substring" + where + f mlen els = mlen >>= \len -> + fmap join $ + tryRange 0 (toInteger len) "substring" b $ \b' -> + tryRange 0 (toInteger b') "substring" a $ \a' -> + fmap ScmMString $ els >>= newListArray (0, b'-a'-1) . drop a' + +scmSubstring [_, _, _] = return$ notInt "substring" +scmSubstring (_:_:_:_) = return$ tooManyArgs "substring" +scmSubstring _ = return$ tooFewArgs "substring" + +scmAppend :: [ScmValue] -> IO (ErrOr ScmValue) +scmAppend args = do + x <- foldrM f (Right (0, "")) args + case x of + Left err -> return (Left err) + Right (len, cat) -> Right . ScmMString <$> newListArray (0, len-1) cat + where + f (ScmString a) (Right x) = make (sLen a) (return $ elems a) x + f (ScmMString a) (Right x) = make (msLen a) (getElems a) x + f _ (Left err) = return (Left err) + f _ _ = return$ notString "string-append" + + make ml me (n,s) = ml >>= \l -> me >>= \e -> return.Right $ (n+l, e++s) + +scmToList, scmFromList :: [ScmValue] -> IO (ErrOr ScmValue) +scmToList [x] | isString x = + fmap (Right . fst) . listToPair . map ScmChar =<< strToList x + +scmToList [_] = return$ notString "string->list" +scmToList [] = return$ tooFewArgs "string->list" +scmToList _ = return$ tooManyArgs "string->list" + +scmFromList [x] = + case x of + ScmList l -> f l + p@(ScmPair _ _) -> do + l <- pairToList p + case l of + Left _ -> return$ notList "list->string" + Right (ScmList l') -> f l' + + _ -> error "list->string :: the impossible happened" + + _ -> return$ notList "list->string" + where + f l = case mapM (fromChar "list->string") l of + Left e -> return$ Left e + Right s -> Right <$> toScmMString s + +scmFromList [] = return$ tooFewArgs "list->string" +scmFromList _ = return$ tooManyArgs "list->string" + +scmCopy :: [ScmValue] -> IO (ErrOr ScmValue) +scmCopy [ScmString s] = Right . ScmMString <$> thaw s +scmCopy [ScmMString s] = + Right . ScmMString <$> + (freeze s >>= \a -> unsafeThaw (a :: UArray Int Char)) + +scmCopy [_] = return$ notString "string-copy" +scmCopy [] = return$ tooFewArgs "string-copy" +scmCopy _ = return$ tooManyArgs "string-copy" + +scmFill :: [ScmValue] -> IO (ErrOr ScmValue) +scmFill [x, ScmChar c] = + case x of + ScmMString s -> do + (a,b) <- getBounds s + mapM_ (\i -> writeArray s i c) [a..b] + return (Right ScmVoid) + + ScmString _ -> return$ immutable "string-fill!" + _ -> return$ notString "string-fill!" + +scmFill [_, _] = return$ notChar "string-fill!" +scmFill (_:_:_) = return$ tooManyArgs "string-fill!" +scmFill _ = return$ tooFewArgs "string-fill!" + +------ + +isString :: ScmValue -> Bool +isString (ScmString _) = True +isString (ScmMString _) = True +isString _ = False + +strToList :: ScmValue -> IO String +strToList (ScmString s) = return (elems s) +strToList (ScmMString s) = getElems s +strToList _ = error "strToList :: the impossible happened" + +tryToLen :: String -> Integer -> (Int -> IO a) -> IO (ErrOr a) +tryToLen = tryRange 0 (toInteger (maxBound :: Int)) + +tryToIdx :: String -> IO Int -> Integer -> (Int -> IO a) -> IO (ErrOr a) +tryToIdx s mlen i f = mlen >>= \len -> tryRange 0 (toInteger len - 1) s i f + +tryRange :: Integer -> Integer -> String -> Integer -> (Int -> IO a) + -> IO (ErrOr a) +tryRange a b s i f = if i >= a && i <= b + then Right <$> f (fromInteger i) + else return.Left $ "Out-of-range integer to " ++ s + +fromChar :: String -> ScmValue -> ErrOr Char +fromChar _ (ScmChar c) = Right c +fromChar s _ = notChar s + +sLen :: UArray Int Char -> IO Int +sLen = return . (+1) . snd . bounds + +msLen :: IOUArray Int Char -> IO Int +msLen = fmap ((+1) . snd) . getBounds diff --git a/Haschoo/Evaluator/Standard/Symbols.hs b/Haschoo/Evaluator/Standard/Symbols.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Symbols.hs @@ -0,0 +1,39 @@ +-- File created: 2009-07-22 20:39:04 + +module Haschoo.Evaluator.Standard.Symbols (procedures) where + +import Data.Array.IArray (elems) +import Data.Array.MArray (getElems) + +import Haschoo.Types (ScmValue(..), toScmString) +import Haschoo.Utils (ErrOr) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ ("symbol?", return . fmap ScmBool . scmIsSymbol) + , ("symbol->string", return . scmToString) + , ("string->symbol", scmToSymbol) + ] + +scmIsSymbol :: [ScmValue] -> ErrOr Bool +scmIsSymbol [ScmIdentifier _] = Right True +scmIsSymbol [_] = Right False +scmIsSymbol [] = tooFewArgs "symbol?" +scmIsSymbol _ = tooManyArgs "symbol?" + +scmToString :: [ScmValue] -> ErrOr ScmValue +scmToString [ScmIdentifier x] = Right (toScmString x) +scmToString [_] = notSymbol "symbol->string" +scmToString [] = tooFewArgs "symbol->string" +scmToString _ = tooManyArgs "symbol->string" + +scmToSymbol :: [ScmValue] -> IO (ErrOr ScmValue) +scmToSymbol [ScmString x] = return$ Right . ScmIdentifier $ elems x +scmToSymbol [ScmMString x] = fmap (Right . ScmIdentifier) $ getElems x +scmToSymbol [_] = return$ notSymbol "string->symbol" +scmToSymbol [] = return$ tooFewArgs "string->symbol" +scmToSymbol _ = return$ tooManyArgs "string->symbol" + +notSymbol :: String -> ErrOr a +notSymbol = fail . ("Nonsymbolic argument to " ++) diff --git a/Haschoo/Evaluator/Standard/Vectors.hs b/Haschoo/Evaluator/Standard/Vectors.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Standard/Vectors.hs @@ -0,0 +1,158 @@ +-- File created: 2009-08-06 20:47:49 + +module Haschoo.Evaluator.Standard.Vectors (procedures) where + +import Control.Applicative ((<$>)) +import Data.Array (Array) +import Data.Array.IArray ((!), bounds, elems) +import Data.Array.IO (IOArray) +import Data.Array.MArray ( readArray, writeArray + , newArray, newListArray + , getBounds, getElems) +import Data.Complex (Complex((:+))) + +import Haschoo.Types (ScmValue(..), listToPair, pairToList) +import Haschoo.Utils (ErrOr) +import Haschoo.Evaluator.Utils ( tooFewArgs, tooManyArgs, immutable + , notInt, notList) + +procedures :: [(String, ScmValue)] +procedures = map (\(a,b) -> (a, ScmFunc a b)) + [ ("vector?", return . fmap ScmBool . scmIsVector) + + , ("make-vector", scmMakeVector) + , ("vector", scmVector) + + , ("vector-length", scmLength) + + , ("vector-ref", scmRef) + , ("vector-set!", scmSet) + + , ("vector->list", scmToList) + , ("list->vector", scmFromList) + + , ("vector-fill!", scmFill) + ] + +scmIsVector :: [ScmValue] -> ErrOr Bool +scmIsVector [ScmMVector _] = Right True +scmIsVector [ScmVector _] = Right True +scmIsVector [_] = Right False +scmIsVector [] = tooFewArgs "vector?" +scmIsVector _ = tooManyArgs "vector?" + +scmMakeVector, scmVector :: [ScmValue] -> IO (ErrOr ScmValue) +scmMakeVector (ScmInt l : xs) = + case xs of + [] -> f (flip newArray (ScmComplex $ 0 :+ 42)) + [x] -> f (flip newArray x) + _ -> return$ tooManyArgs "make-vector" + where + f mk = tryToLen "make-vector" l $ \i -> ScmMVector <$> mk (0, i-1) + +scmMakeVector (_:_:_:_) = return$ tooManyArgs "make-vector" +scmMakeVector [] = return$ tooFewArgs "make-vector" +scmMakeVector _ = return$ notInt "make-vector" + +scmVector xs = Right <$> toScmMVector xs + +scmLength :: [ScmValue] -> IO (ErrOr ScmValue) +scmLength [x] = case x of + ScmVector s -> Right . ScmInt . toInteger <$> vLen s + ScmMVector s -> Right . ScmInt . toInteger <$> mvLen s + _ -> return$ notVector "vector-length" + +scmLength [] = return$ tooFewArgs "vector-length" +scmLength _ = return$ tooManyArgs "vector-length" + +scmRef, scmSet :: [ScmValue] -> IO (ErrOr ScmValue) +scmRef [x, ScmInt i] = case x of + ScmVector s -> f (vLen s) (return . (s!)) + ScmMVector s -> f (mvLen s) (readArray s) + _ -> return$ notVector "vector-ref" + where + f len = tryToIdx "vector-ref" len i + +scmRef [_,_] = return$ notInt "vector-ref" +scmRef (_:_:_) = return$ tooManyArgs "vector-ref" +scmRef _ = return$ tooFewArgs "vector-ref" + +scmSet [v, ScmInt idx, x] = + case v of + ScmMVector v' -> do + tryToIdx "vector-set!" (mvLen v') idx (\i -> writeArray v' i x) + return (Right ScmVoid) + + ScmVector _ -> return$ immutable "vector-set!" + _ -> return$ notVector "vector-set!" + +scmSet [_, _, ScmChar _] = return$ notInt "vector-set!" +scmSet (_:_:_:_) = return$ tooManyArgs "vector-set!" +scmSet _ = return$ tooFewArgs "vector-set!" + +scmToList, scmFromList :: [ScmValue] -> IO (ErrOr ScmValue) +scmToList [x] = case x of + ScmVector v -> f (elems v) + ScmMVector v -> f =<< getElems v + _ -> return$ notVector "vector->list" + where + f = fmap (Right . fst) . listToPair + +scmToList [] = return$ tooFewArgs "vector->list" +scmToList _ = return$ tooManyArgs "vector->list" + +scmFromList [x] = + case x of + ScmList l -> Right <$> toScmMVector l + p@(ScmPair _ _) -> do + l <- pairToList p + case l of + Left _ -> return$ notList "list->vector" + Right (ScmList l') -> Right <$> toScmMVector l' + + _ -> error "list->vector :: the impossible happened" + + _ -> return$ notList "list->vector" + +scmFromList [] = return$ tooFewArgs "list->vector" +scmFromList _ = return$ tooManyArgs "list->vector" + +scmFill :: [ScmValue] -> IO (ErrOr ScmValue) +scmFill [v, x] = + case v of + ScmMVector v' -> do + (a,b) <- getBounds v' + mapM_ (\i -> writeArray v' i x) [a..b] + return (Right ScmVoid) + + ScmVector _ -> return$ immutable "vector-fill!" + _ -> return$ notVector "vector-fill!" + +scmFill (_:_:_) = return$ tooManyArgs "vector-fill!" +scmFill _ = return$ tooFewArgs "vector-fill!" + +------ + +notVector :: String -> ErrOr a +notVector = fail . ("Nonvector argument to " ++) + +toScmMVector :: [ScmValue] -> IO ScmValue +toScmMVector v = ScmMVector <$> newListArray (0, length v - 1) v + +tryToLen :: String -> Integer -> (Int -> IO a) -> IO (ErrOr a) +tryToLen = tryRange 0 (toInteger (maxBound :: Int)) + +tryToIdx :: String -> IO Int -> Integer -> (Int -> IO a) -> IO (ErrOr a) +tryToIdx s mlen i f = mlen >>= \len -> tryRange 0 (toInteger len - 1) s i f + +tryRange :: Integer -> Integer -> String -> Integer -> (Int -> IO a) + -> IO (ErrOr a) +tryRange a b s i f = if i >= a && i <= b + then Right <$> f (fromInteger i) + else return.Left $ "Out-of-range integer to " ++ s + +vLen :: Array Int ScmValue -> IO Int +vLen = return . (+1) . snd . bounds + +mvLen :: IOArray Int ScmValue -> IO Int +mvLen = fmap ((+1) . snd) . getBounds diff --git a/Haschoo/Evaluator/Utils.hs b/Haschoo/Evaluator/Utils.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Evaluator/Utils.hs @@ -0,0 +1,19 @@ +-- File created: 2009-07-19 18:41:22 + +{-# LANGUAGE FlexibleContexts #-} + +module Haschoo.Evaluator.Utils where + +import Control.Monad.Error (MonadError, throwError) + +tooFewArgs, tooManyArgs, immutable, + notList, notInt, notChar, notProcedure, notString + :: MonadError String m => String -> m a +tooFewArgs = throwError . ("Too few arguments to " ++) +tooManyArgs = throwError . ("Too many arguments to " ++) +immutable = throwError . ("Immutable argument to " ++) +notList = throwError . ("Nonlist argument to "++) +notInt = throwError . ("Noninteger argument to " ++) +notChar = throwError . ("Noncharacter argument to " ++) +notProcedure = throwError . ("Nonprocedural argument to "++) +notString = throwError . ("Nonstring argument to " ++) diff --git a/Haschoo/Main.hs b/Haschoo/Main.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Main.hs @@ -0,0 +1,31 @@ +-- File created: 2009-07-21 13:19:42 + +module Main (main, runOne) where + +import Prelude hiding (catch) + +import Control.Exception (catch) +import Data.IORef (newIORef, readIORef) +import System.Environment (getArgs) + +import Haschoo.Running (runRepl, runFile, run, RunError) +import Haschoo.Stdlib (toplevelContext) +import Haschoo.Utils (void, errPrint) + +main :: IO () +main = do + ctx <- toplevelContext + args <- getArgs + if null args + then runRepl ctx + else do + initCtx <- mapM readIORef ctx + mapM_ (\f -> do + ctx' <- mapM newIORef initCtx + runFile ctx' f + `catch` \e -> errPrint (e :: RunError)) + args + +-- For GHCi use +runOne :: String -> IO () +runOne s = toplevelContext >>= \ctx -> void (run ctx "runOne" s) diff --git a/Haschoo/Parser.hs b/Haschoo/Parser.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Parser.hs @@ -0,0 +1,312 @@ +-- File created: 2009-07-11 20:29:49 + +module Haschoo.Parser (runParser, programValue, value, number) where + +import Control.Applicative ((<$>)) +import Control.Arrow (first) +import Control.Monad (liftM2) +import Data.Char (digitToInt, toLower) +import Data.Complex (Complex((:+)), mkPolar) +import Data.Maybe (fromJust, fromMaybe, isJust) +import Data.Ratio ((%)) +import Numeric (readInt) +import Text.ParserCombinators.Parsec hiding (runParser) + +import Haschoo.Types (ScmValue(..), toScmString, toScmVector) +import Haschoo.Utils (void, (.:)) + +runParser :: Parser a -> SourceName -> String -> Either String a +runParser = (either (Left . show) Right .:) . parse + +programValue :: Maybe SourcePos -> Parser (Maybe (ScmValue, String, SourcePos)) +programValue pos = do + maybe (return ()) setPosition pos + optional atmosphere + v <- (Just <$> value) <|> (eof >> return Nothing) + case v of + Nothing -> return Nothing + Just v' -> liftM2 (Just .: (,,) v') getInput getPosition + +values :: Parser [ScmValue] +values = optional atmosphere >> (many $ value `discard` atmosphere) + +value :: Parser ScmValue +value = do + quotes <- + concat <$> many + (choice [ string "'" + , string "`" + , liftM2 (:) (char ',') (string "@" <|> return "") ] + `discard` atmosphere) + + val <- choice [ ident + , list + , vector + , bool + , number 10 + , character + , quotedString ] + + return $ quote quotes val + where + quote [] = id + quote ('\'' :qs) = quoteWith "quote" qs + quote ('`' :qs) = quoteWith "quasiquote" qs + quote (',' :'@':qs) = quoteWith "unquote-splicing" qs + quote (',' :qs) = quoteWith "unquote" qs + quote _ = error "Parser.quote :: the impossible happened" + + quoteWith s qs = ScmList . (ScmIdentifier s :) . (:[]) . quote qs + +ident :: Parser ScmValue +ident = do + -- peculiar needs the try due to negative numbers + x <- try $ choice [ peculiar `discard` try delimiter + , ordinary `discard` delimiter ] + return (ScmIdentifier $ map toLower x) + where + peculiar = choice [return <$> oneOf "+-", string "..."] + ordinary = do + x <- oneOf initial + xs <- many (oneOf (initial ++ "+-.@" ++ ['0'..'9'])) + return (x:xs) + where + initial = ['a'..'z'] ++ ['A'..'Z'] ++ "!$%&*/:<=>?^_~" + +bool :: Parser ScmValue +bool = ScmBool . (`elem` "tT") <$> try (char '#' >> oneOf "ftFT") + +character :: Parser ScmValue +character = do + try (string "#\\") + c <- try named <|> anyChar + delimiter + return (ScmChar c) + where + named = choice [ string "space" >> return ' ' + , string "newline" >> return '\n' ] + +quotedString :: Parser ScmValue +quotedString = + fmap toScmString + . between (try $ char '"') (char '"') + . many $ + (char '\\' >> (oneOf "\\\"" concat [show "\\"," or ",show "\""])) + <|> satisfy (/= '"') + +list :: Parser ScmValue +list = + between (try $ char '(') (optional atmosphere >> char ')') $ do + vals <- values + if null vals + then return$ ScmList vals + else do + optional atmosphere + dot <- optionMaybe (char '.') + if isJust dot + then do + atmosphere + end <- value + return$ case end of + ScmList l -> ScmList (vals ++ l) + _ -> mkDotted vals end + else return$ ScmList vals + where + -- Flatten (1 . (2 . 3)) to (1 2 . 3) + mkDotted xs (ScmDottedList ys z) = mkDotted (xs ++ ys) z + mkDotted xs x = ScmDottedList xs x + +vector :: Parser ScmValue +vector = do + try (char '#' >> char '(') + toScmVector <$> values `discard` (optional atmosphere >> char ')') + +number :: Int -> Parser ScmValue +number defRadix = do + (radix,exact) <- try prefix + + let p = if isJust radix || isJust exact then id else try + n <- p $ complex (fromMaybe False exact) (fromMaybe defRadix radix) + + delimiter + + return$ if fromMaybe True exact + then n + else case n of + ScmInt x -> ScmReal (fromInteger x) + ScmRat x -> ScmReal (fromRational x) + _ -> n + where + prefix = do + r <- radix + e <- exactness + -- They can be in either order + flip (,) e <$> if isJust r + then return r + else radix + where + radix = f [('B',2), ('O',8), ('D',10), ('X',16)] + exactness = f [('E',True), ('I',False)] + f xs = optionMaybe . try $ do + char '#' + let xs' = map (first toLower) xs ++ xs + fromJust . (`lookup` xs') <$> oneOf (map fst xs') + + complex exact radix = + choice [ try $ do n <- sreal False radix + ncChar 'i' + return (mkImaginary n) + + , try $ do a <- real exact radix + at <- optionMaybe (char '@') + if isJust at + then mkComplex mkPolar a <$> real False radix + else do + b <- optionMaybe $ try imaginaryUnit <|> + do n <- sreal False radix + ncChar 'i' + return n + + return $ case b of + Nothing -> a + Just n -> mkComplex (:+) a n + + , mkImaginary <$> imaginaryUnit ] + where + imaginaryUnit = do + neg <- sign + ncChar 'i' + return (ScmInt neg) + + mkImaginary = mkComplex (:+) (ScmInt 0) + mkComplex f a b = ScmComplex $ f (toDouble a) (toDouble b) + + toDouble (ScmInt i) = fromInteger i + toDouble (ScmRat r) = fromRational r + toDouble (ScmReal r) = r + toDouble _ = error "number.toDouble :: internal error" + + real exact radix = do + neg <- optionMaybe sign + applySign (fromMaybe 1 neg) <$> ureal exact radix + + sreal exact radix = do + neg <- sign + applySign neg <$> ureal exact radix + + applySign neg (ScmInt n) = ScmInt (fromIntegral neg * n) + applySign neg (ScmRat n) = ScmRat (fromIntegral neg * n) + applySign neg (ScmReal n) = ScmReal (fromIntegral neg * n) + applySign _ _ = error "number.applySign :: іnternal error" + + ureal exact radix = choice [ string "nan.#" >> return (ScmReal $ 0/0) + , string "inf.#" >> return (ScmReal $ 1/0) + , decimal exact radix + , do a <- uint radix + b <- optionMaybe $ char '/' >> uint radix + case b of + Nothing -> + if radix == 10 + then tryExponent exact a + else return a + Just n -> return (mkRatio a n) ] + + mkRatio (ScmInt a) (ScmInt b) = ScmRat (a % b) + mkRatio _ _ = error "number.mkRatio :: internal error" + + decimal exact radix | radix /= 10 = fail "Decimal outside radix 10" + | otherwise = + tryExponent exact =<< + (try . choice) [ do char '.' + n <- many1 (digitN 10) + skipMany (char '#') + return $ readDecimal exact "0" n + + , do a <- many1 (digitN 10) + char '.' + b <- many (digitN 10) + skipMany (char '#') + -- read doesn't like "123." so add a 0 if + -- necessary + return $ + readDecimal exact a (if null b then "0" else b) + + , do n <- many1 (digitN 10) + hashes <- map (const '0') <$> many1 (char '#') + char '.' + hashes2 <- many (char '#') + return . inexactHashes (hashes ++ hashes2) . + ScmInt $ readInteger 10 (n ++ hashes) + ] + + tryExponent exact n = do + ex <- optionMaybe $ do + oneOf "esfdlESFDL" -- Ignore the exponent: all Double + neg <- optionMaybe sign + xs <- many1 (digitN 10) + return$ fromMaybe 1 neg * readInteger 10 xs + + return$ + case ex of + Nothing -> n + Just e | not exact -> ScmReal (10^^e * toDouble n) + | otherwise -> + case n of + ScmInt x -> ScmRat (10^^e * fromInteger x) + ScmRat x -> ScmRat (10^^e * x) + _ -> + error$ "Parser.tryExponent :: " + ++ "the impossible happened" + + uint radix = do + n <- many1 (digitN radix) + hashes <- map (const '0') <$> many (char '#') + return . inexactHashes hashes . ScmInt $ readInteger radix (n ++ hashes) + + -- If any # were present, the value is inexact (R5RS 6.2.4) + inexactHashes :: String -> ScmValue -> ScmValue + inexactHashes [] = id + inexactHashes _ = ScmReal . toDouble + + digitN :: Int -> Parser Char + digitN 2 = oneOf "01" + digitN 8 = octDigit + digitN 10 = digit + digitN 16 = hexDigit + digitN _ = error "number.digitN :: internal error" + + sign = (\c -> if c == '+' then 1 else -1) <$> oneOf "+-" + + -- These read functions all assume correctly formed input + + readInteger :: Int -> String -> Integer + readInteger radix = + fst.head . readInt (fromIntegral radix) (const True) digitToInt + + readDecimal :: Bool -> String -> String -> ScmValue + readDecimal False as bs = ScmReal . read . concat $ [as, ".", bs] + readDecimal True as bs = + ScmRat $ fromInteger (readInteger 10 as) + + fromInteger (readInteger 10 bs) / 10 ^ length bs + +-- Pushes back anything relevant for other parsers +delimiter :: Parser () +delimiter = choice [ whitespaceOrComment + , void . lookAhead . try $ oneOf "()\"" + , try eof ] + +atmosphere :: Parser () +atmosphere = skipMany whitespaceOrComment + +whitespaceOrComment :: Parser () +whitespaceOrComment = + choice [ void newline + , char '\r' >> optional newline + , void space + , char ';' >> skipMany (noneOf "\n\r") ] + +ncChar :: Char -> Parser Char +ncChar c = toLower <$> satisfy ((== c) . toLower) + +discard :: Parser a -> Parser b -> Parser a +discard a b = a >>= \a' -> b >> return a' diff --git a/Haschoo/Running.hs b/Haschoo/Running.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Running.hs @@ -0,0 +1,68 @@ +-- File created: 2009-07-26 17:17:23 + +{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables #-} +module Haschoo.Running (RunError(..), runFile, runHandle, run, runRepl) where + +import Control.Exception (Exception, throw, catch) +import Control.Monad ((>=>), when) +import Data.IORef (IORef) +import Data.Typeable (Typeable) +import System.IO ( Handle, openFile, IOMode(ReadMode), hGetContents + , hPutStrLn, hFlush, stderr, stdout ) + +import Prelude hiding (catch) + +import Haschoo.Evaluator (evalToplevel) +import Haschoo.Parser (runParser, programValue) +import Haschoo.Types (Context, scmShow) + +data RunError = ParseError String | RuntimeError String + deriving Typeable + +instance Show RunError where + show (ParseError s) = "Parse error: " ++ s + show (RuntimeError s) = "Runtime error: " ++ s + +instance Exception RunError + +runFile :: [IORef Context] -> FilePath -> IO () +runFile ctx path = openFile path ReadMode >>= runHandle ctx path + +runHandle :: [IORef Context] -> FilePath -> Handle -> IO () +runHandle ctx name = hGetContents >=> run ctx name + +run :: [IORef Context] -> FilePath -> String -> IO () +run ctx name = go Nothing + where + go pos str = + case runParser (programValue pos) name str of + Left e -> throw (ParseError e) + Right (Just (v,s,p)) -> do + result <- evalToplevel ctx v + case result of + Left e -> throw (RuntimeError e) + Right _ -> go (Just p) s + + Right Nothing -> return () + +runRepl :: [IORef Context] -> IO () +runRepl ctx = do + putStr "Haschoo} " + hFlush stdout + line <- fmap Just getLine `catch` (\(_ :: IOError) -> return Nothing) + maybe (return ()) (\l -> handle (go l) >> runRepl ctx) line + where + handle = flip catch $ \e -> hPutStrLn stderr $ show (e :: RunError) + go str = + case runParser (programValue Nothing) "" str of + Left e -> throw (ParseError e) + Right (Just (v,s,_)) -> do + result <- evalToplevel ctx v + case result of + Left e -> throw (RuntimeError e) + Right r -> do + rs <- scmShow r + when (not $ null rs) (putStrLn rs) + go s + + Right Nothing -> return () diff --git a/Haschoo/Stdlib.hs b/Haschoo/Stdlib.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Stdlib.hs @@ -0,0 +1,69 @@ +-- File created: 2009-07-26 17:13:57 + +module Haschoo.Stdlib (toplevelContext) where + +import Prelude hiding (catch) + +import Control.Exception (catch, SomeException) +import Data.IORef (IORef, newIORef, readIORef) +import System.Exit (exitFailure) + +import Haschoo.Running (runFile) +import Haschoo.Types (Context, addToContext, ScmValue(..)) +import Haschoo.Utils (errPut, errPutLn, errPrint, ErrOr) +import Haschoo.Evaluator.Utils (tooFewArgs, tooManyArgs, notInt) + +import qualified Haschoo.Evaluator.Standard as Standard +import qualified Haschoo.Evaluator.Primitives as Primitives + +toplevelContext, primitiveContext :: IO [IORef Context] +toplevelContext = do + pc <- primitiveContext + load pc std "std-func.scm" + where + std = foldr (uncurry addToContext) Standard.context envFuncs + +primitiveContext = load [] Primitives.context "std-prim.scm" + +load :: [IORef Context] -> Context -> FilePath -> IO [IORef Context] +load ctx new path = (do + ctx' <- fmap (:ctx) $ newIORef new + runFile ctx' path + return ctx') + `catch` \e -> do + errPutLn.concat $ ["Failed to load standard library file '",path,"'!"] + errPut " " + errPrint (e :: SomeException) + exitFailure + +-- These are defined here because they depend on the above +envFuncs :: [(String, ScmValue)] +envFuncs = map (\(a,b) -> (a, ScmFunc a b)) + [ ("scheme-report-environment", fmap (fmap ScmContext) . scmStandardEnv) + , ("null-environment", fmap (fmap ScmContext) . scmNullEnv) + ] + +scmStandardEnv, scmNullEnv :: [ScmValue] -> IO (ErrOr [Context]) +scmStandardEnv [ScmInt n] = + if n == 5 + then do + ctx <- toplevelContext + ctx' <- mapM readIORef ctx + return$ Right ctx' + else return$ Left ("Nonfive integer to scheme-report-environment") + +scmStandardEnv [_] = return$ notInt "scheme-report-environment" +scmStandardEnv [] = return$ tooFewArgs "scheme-report-environment" +scmStandardEnv _ = return$ tooManyArgs "scheme-report-environment" + +scmNullEnv [ScmInt n] = + if n == 5 + then do + ctx <- primitiveContext + ctx' <- mapM readIORef ctx + return$ Right ctx' + else return$ Left ("Nonfive integer to scheme-report-environment") + +scmNullEnv [_] = return$ notInt "null-environment" +scmNullEnv [] = return$ tooFewArgs "null-environment" +scmNullEnv _ = return$ tooManyArgs "null-environment" diff --git a/Haschoo/Types.hs b/Haschoo/Types.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Types.hs @@ -0,0 +1,245 @@ +-- File created: 2009-07-11 21:47:19 + +-- ScmValue depends on Haschoo +-- Haschoo depends on Context +-- Context depends on ScmValue +-- +-- Thus they all have to be in the same module, to avoid circular dependencies. +{-# LANGUAGE BangPatterns, GeneralizedNewtypeDeriving #-} + +module Haschoo.Types + ( Haschoo, runHaschoo, withHaschoo + , ScmValue(..), MacroCall(..) + , isTrue, isAggregate + , toScmString, toScmMString + , toScmVector + , pairToList, listToPair + , Context, mkContext, addToContext, contextLookup, contextSize + , scmShow, scmShowWith + ) where + +import Control.Applicative ((<$>)) +import Control.Arrow (second) +import Control.Monad.Error (ErrorT, MonadError, runErrorT) +import Control.Monad.State.Strict (StateT, MonadState, evalStateT) +import Control.Monad.Trans (MonadIO, liftIO) +import Data.Array.IO (IOArray, IOUArray, newListArray, getElems) +import Data.Array.Unboxed (Array, UArray, elems, listArray) +import Data.Complex (Complex((:+))) +import Data.IORef (IORef, readIORef, newIORef) +import Data.List (intercalate) +import Data.Ratio (numerator, denominator) +import System.IO (Handle) +import System.IO.Unsafe (unsafeInterleaveIO) +import Text.Show.Functions () + +import qualified Data.ListTrie.Patricia.Map.Enum as TM +import Data.ListTrie.Patricia.Map.Enum (TrieMap) + +import Haschoo.Utils (ErrOr, lazyMapM) + +-- Our main monad +newtype Haschoo a = Haschoo (StateT HaschState (ErrorT String IO) a) + deriving (Functor, Monad, MonadIO, MonadState HaschState, MonadError String) + +runHaschoo :: HaschState -> Haschoo a -> IO (ErrOr a) +runHaschoo state (Haschoo h) = runErrorT $ evalStateT h state + +-- Like 'local' of the Reader monad +withHaschoo :: HaschState -> Haschoo a -> Haschoo a +withHaschoo state h = either fail return =<< liftIO (runHaschoo state h) + +type HaschState = [IORef Context] + +data ScmValue = ScmPrim String !([ScmValue] -> Haschoo ScmValue) + | ScmFunc String !([ScmValue] -> IO (ErrOr ScmValue)) + + | ScmMacro String + !(MacroCall -> + Haschoo (ScmValue, TrieMap Char [IORef Context])) + + | ScmBool !Bool + | ScmChar !Char + | ScmInt !Integer + | ScmRat !Rational + | ScmReal !Double + | ScmComplex !(Complex Double) + | ScmIdentifier !String + | ScmPair !(IORef ScmValue) !(IORef ScmValue) + | ScmString !( UArray Int Char) + | ScmMString !(IOUArray Int Char) + | ScmVector !( Array Int ScmValue) + | ScmMVector !( IOArray Int ScmValue) + + | ScmSyntax { patterns :: ![(ScmValue, ScmValue, [String])] + , literals :: ![(String, Maybe ScmValue)] } + + -- These two are only for literal lists, appearing only directly + -- from the parser + | ScmList ![ScmValue] + | ScmDottedList ![ScmValue] !ScmValue -- The list is never empty + + -- The "unspecified value" returned by IO procedures and such + | ScmVoid + + | ScmInput !Handle + | ScmOutput !Handle + | ScmEOF + + -- The "environment-specifier" used by eval-related procedures + | ScmContext ![Context] + +-- The form of the macro usage: +-- +-- (macro foo bar), (macro foo . bar), or #(macro foo bar) +-- +-- The macro keyword is not included regardless of constructor +data MacroCall = MCList ![ScmValue] + | MCDotted ![ScmValue] !ScmValue + +isTrue, isAggregate :: ScmValue -> Bool +isTrue (ScmBool False) = False +isTrue _ = True + +isAggregate (ScmList _) = True +isAggregate (ScmDottedList _ _) = True +isAggregate (ScmVector _) = True +isAggregate (ScmMVector _) = True +isAggregate (ScmPair _ _) = True +isAggregate _ = False + +-- From ScmPair to Left . ScmDottedList or Right . ScmList +pairToList :: ScmValue -> IO (Either ScmValue ScmValue) +pairToList = go [] + where + go xs (ScmList ys) = + return . Right $ ScmList (reverse xs ++ ys) + go xs (ScmDottedList ys z) = + return . Left $ ScmDottedList (reverse xs ++ ys) z + + go xs (ScmPair a b) = do + a' <- readIORef a + b' <- readIORef b + go (a':xs) b' + + go xs v = return . Left $ ScmDottedList (reverse xs) v + +-- ScmList -> ScmPair, returns the tail pointer if it wasn't empty +listToPair :: [ScmValue] -> IO (ScmValue, Maybe (IORef ScmValue)) +listToPair [] = return (ScmList [], Nothing) +listToPair (x:xs) = second Just <$> go x xs + where + go :: ScmValue -> [ScmValue] -> IO (ScmValue, IORef ScmValue) + go v [] = do + a <- newIORef v + b <- newIORef (ScmList []) + return (ScmPair a b, b) + + go v (y:ys) = do + a <- newIORef v + (zs, fin) <- go y ys + b <- newIORef zs + return (ScmPair a b, fin) + +toScmString :: String -> ScmValue +toScmString s = ScmString $ listArray (0, length s - 1) s + +toScmMString :: String -> IO ScmValue +toScmMString s = ScmMString <$> newListArray (0, length s - 1) s + +toScmVector :: [ScmValue] -> ScmValue +toScmVector v = ScmVector $ listArray (0, length v - 1) v + +newtype Context = Context (TrieMap Char ScmValue) + +mkContext :: [(String, ScmValue)] -> Context +mkContext = Context . TM.fromList + +addToContext :: String -> ScmValue -> Context -> Context +addToContext name val (Context c) = Context (TM.insert' name val c) + +contextLookup :: String -> Context -> Maybe ScmValue +contextLookup s (Context c) = TM.lookup s c + +contextSize :: Context -> Int +contextSize (Context c) = TM.size' c + +scmShow :: ScmValue -> IO String +scmShow ScmVoid = return "" -- Has no representation +scmShow (ScmBool b) = return$ '#' : if b then "t" else "f" +scmShow (ScmPrim s _) = return s +scmShow (ScmFunc s _) = return s +scmShow (ScmMacro s _) = return s +scmShow (ScmIdentifier s) = return s +scmShow (ScmInt n) = return$ show n +scmShow (ScmReal n) + | isNaN n = return "+nan.#" + | isInfinite n = return$ (if n < 0 then '-' else '+') : "inf.#" + | otherwise = return$ show n +scmShow (ScmRat n) = + if denominator n == 1 + then return$ show (numerator n) + else return$ concat [show (numerator n), "/", show (denominator n)] + +scmShow (ScmComplex (a :+ b)) = do + bs <- scmShow (ScmReal b) + as <- scmShow (ScmReal a) + return$ concat [ as + , if head bs `elem` "-+" then [] else "+" + , bs + , "i" ] + +scmShow (ScmChar c) | c == ' ' = return "#\\space" + | c == '\n' = return "#\\newline" + | otherwise = return$ "#\\" ++ [c] + +scmShow (ScmSyntax _ _) = return "" +scmShow (ScmContext _) = return "" +scmShow ScmEOF = return "" +scmShow (ScmInput _) = return "" +scmShow (ScmOutput _) = return "" + +scmShow (ScmString s) = return$ showScmString (elems s) +scmShow (ScmMString s) = showScmString <$> getElems s + +scmShow x | isAggregate x = scmShowWith scmShow x + | otherwise = error "scmShow :: the impossible happened" + +scmShowWith :: (ScmValue -> IO String) -> ScmValue -> IO String +scmShowWith f (ScmList xs) = showScmList f xs +scmShowWith f (ScmDottedList a b) = do + as <- showScmList f a + bs <- f b + return$ concat [init as, " . ", bs, ")"] + +scmShowWith f (ScmVector v) = ('#':) <$> showScmList f (elems v) +scmShowWith f (ScmMVector v) = ('#':) <$> (showScmList f =<< getElems v) + +scmShowWith f (ScmPair car cdr) = do + a <- readIORef car + as <- f a + ('(':) . (as ++) <$> unsafeInterleaveIO (readIORef cdr >>= go) + where + go (ScmList []) = return ")" + go x@(ScmList _) = (' ':) . tail <$> f x + go x@(ScmDottedList _ _) = (' ':) . tail <$> f x + + go (ScmPair x y) = do + a <- readIORef x + as <- f a + (' ':) . (as ++) <$> unsafeInterleaveIO (readIORef y >>= go) + + go x = (" . "++) . (++")") <$> f x + +scmShowWith _ _ = error "scmShowWith :: the impossible happened" + +showScmString :: String -> String +showScmString s = '"' : foldr ((.) . f) id s "\"" + where + f c | c == '\\' = showString "\\\\" + | c == '\"' = showString "\\\"" + | otherwise = showChar c + +showScmList :: (a -> IO String) -> [a] -> IO String +showScmList f xs = + ("("++) . (++")") . intercalate " " <$> lazyMapM f xs diff --git a/Haschoo/Utils.hs b/Haschoo/Utils.hs new file mode 100644 --- /dev/null +++ b/Haschoo/Utils.hs @@ -0,0 +1,108 @@ +-- File created: 2009-07-15 10:37:42 + +module Haschoo.Utils where + +import Control.Arrow (first, (***)) +import Control.Monad (liftM) +import Control.Monad.Error () -- Monad ErrOr +import Control.Monad.State (MonadState, get, put) +import Control.Monad.Trans (MonadIO, liftIO) +import System.IO (hPutStr, hPutStrLn, stderr) +import System.IO.Unsafe (unsafeInterleaveIO) +import System.Mem.StableName (makeStableName) + +type ErrOr = Either String + +swap :: (a,b) -> (b,a) +swap ~(a,b) = (b,a) + +fst3 :: (a,b,c) -> a +fst3 (a,_,_) = a + +-- Returns the length of the shorter of the two +compareLengths :: [a] -> [b] -> (Ordering, Int) +compareLengths = go 0 + where + go n [] [] = (EQ, n) + go n (_:_) [] = (GT, n) + go n [] (_:_) = (LT, n) + go n (_:as) (_:bs) = go (n+1) as bs + +compareLength :: [a] -> Int -> Ordering +compareLength _ n | n < 0 = GT +compareLength [] 0 = EQ +compareLength [] _ = LT +compareLength (_:_) 0 = GT +compareLength (_:as) n = compareLength as (n-1) + +initLast :: [a] -> ([a], a) +initLast [x] = ([], x) +initLast (x:xs) = first (x:) (initLast xs) +initLast [] = error "initLast :: empty list" + +initLast2Maybe :: [a] -> Maybe ([a], a, a) +initLast2Maybe [x,y] = Just ([], x, y) +initLast2Maybe (a:as) = fmap (\ ~(bs,x,y) -> (a:bs,x,y)) (initLast2Maybe as) +initLast2Maybe [] = Nothing + +fromRights :: [Either a b] -> Maybe [b] +fromRights [] = Just [] +fromRights (Left _ : _) = Nothing +fromRights (Right x : xs) = fmap (x:) (fromRights xs) + +-- eqWithM p xs ys is kind of like allM (uncurry p) (zip xs ys) but takes into +-- account the lengths of the lists (differing lengths aren't equal) +-- +-- Essentially, monadic list equality according to the given predicate +eqWithM :: Monad m => (a -> b -> m Bool) -> [a] -> [b] -> m Bool +eqWithM _ [] [] = return True +eqWithM _ _ [] = return False +eqWithM _ [] _ = return False +eqWithM p (x:xs) (y:ys) = do + b <- p x y + if b + then eqWithM p xs ys + else return False + +-- Applies the function on element pairs while there are enough elements to +-- form pairs +mapOnPairs :: (a -> b -> (a,b)) -> [a] -> [b] -> ([a],[b]) +mapOnPairs f (x:xs) (y:ys) = let (x',y') = f x y + in ((x':) *** (y':)) (mapOnPairs f xs ys) + +mapOnPairs _ xs ys = (xs, ys) + +void :: Functor f => f a -> f () +void = fmap (const ()) + +allM :: Monad m => (a -> m Bool) -> [a] -> m Bool +allM f = liftM and . mapM f + +lazyMapM :: MonadIO io => (a -> IO b) -> [a] -> io [b] +lazyMapM f = mapM (liftIO . unsafeInterleaveIO . f) + +modifyM :: (MonadState s m) => (s -> m s) -> m () +modifyM = (put =<<) . (get >>=) + +infixl 0 $< +($<) :: a -> (a -> b) -> b +($<) = flip ($) + +infixr 9 .: +(.:) :: (d -> c) -> (a -> b -> d) -> a -> b -> c +f .: g = \x y -> f (g x y) + +ptrEq :: a -> a -> IO Bool +ptrEq x y = do + nx <- makeStableName x + ny <- makeStableName y + return (nx == ny) + +errPut :: String -> IO () +errPut = hPutStr stderr + +errPutLn :: String -> IO () +errPutLn = hPutStrLn stderr + +errPrint :: Show a => a -> IO () +errPrint = errPutLn . show diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,24 @@ +Copyright (c) 2009, Matti Niemenmaa +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * 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. + * Neither the name of the project 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 AUTHORS ``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 AUTHORS 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.txt b/README.txt new file mode 100644 --- /dev/null +++ b/README.txt @@ -0,0 +1,95 @@ +Haschoo: the Scheme interpreter to be sneezed at +======= + +Haschoo is a little R5RS [1] interpreter written in Haskell for a university +course. The name, if it's not obvious, is a portmanteau of "Haskell", "Scheme", +and "achoo", the last of which is meant to signify something along the lines of +it being a sneeze's worth of code and not a particularly serious endeavour. + +For licensing information, see LICENSE.txt. + +Usage +----- + +Haschoo is quite spartan. It doesn't understand any command line options: if +given no parameters, it becomes a REPL which terminates on end-of-file, +otherwise it runs the file named by each argument as a standalone Scheme +program. + +Building +-------- + +Haschoo is not written in standard Haskell 98, but depends on GHC-only (at the +time of writing) compiler extensions, so you'll need GHC to build it. Get it at +http://www.haskell.org/ghc/; version 6.10.2 was used for testing, but later +6.10 versions should work as well. + +Nowadays you can also try the Haskell Platform, intended as a simple installer +to get you started quickly: http://hackage.haskell.org/platform/ + +If you have the cabal-install tool installed ([2] or the Haskell Platform), +installing Haschoo without downloading it manually should be as simple as: + +cabal install Haschoo + +If you've already got Haschoo downloaded, and you have cabal-install, try: + +cabal configure +cabal build +cabal install + +If you don't have cabal-install, the following commands, run from Haschoo's root +directory, should also work: + +runhaskell Setup.hs configure +runhaskell Setup.hs build +runhaskell Setup.hs install + +As a last resort: + +ghc --make Haschoo/Main.hs -o haschoo -O2 + +Goal +---- + +If Haschoo can be said to have had a goal, it is minimalism: it tries to be a +bit of a DeathStation 9000 (see e.g. [3]) for R5RS. Currently it achieves this +in the following ways: + +- No non-R5RS procedures are implemented or recognized. +- No extensions are made to existing R5RS procedures. +- Only two optional procedures are implemented: - and / for more than two + arguments. +- Literal lists, strings, and vectors are immutable, as allowed by R5RS 3.4. + +The basic idea was that if something works in Haschoo, it should work in any +R5RS system. That's not quite the current situation, but it seems to be mostly +true, at least based on my limited testing. + +Known bugs +---------- + +Due to time and energy constraints I didn't manage to iron out the following: + +- Continuations, regretfully, are not implemented at all. + +- Nested ellipses in macros don't always work correctly. + (e.g. tests/macros/nested-ellipses.scm) + +- The "read" procedure doesn't work very well: due to annoying technical + issues, it works by reading one character at a time and then trying to parse + the string gathered thus far, stopping on a successful parse. Hence reading + "-1" gives "-" followed by "1". + +- Quasiquotation has some silly bugs. For example, `(1 2 . ,(list 3 4)) results + in '(1 2 unquote (list 3 4)) instead of '(1 2 (list 3 4)). + +No doubt there are many other lurking bugs. Time and energy constraints tend to +limit testing as well. + +References +---------- + +[1]: http://schemers.org/Documents/Standards/R5RS/ +[2]: http://hackage.haskell.org/trac/hackage/wiki/CabalInstall +[3]: http://wikibin.org/articles/deathstation-9000.html diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/tests/macros/access-newvar.scm b/tests/macros/access-newvar.scm new file mode 100644 --- /dev/null +++ b/tests/macros/access-newvar.scm @@ -0,0 +1,4 @@ +(define-syntax m (syntax-rules () ((m x) x))) +(let ((x 'ok)) + (write (m x)) + (newline)) diff --git a/tests/macros/conflicting-bindings.scm b/tests/macros/conflicting-bindings.scm new file mode 100644 --- /dev/null +++ b/tests/macros/conflicting-bindings.scm @@ -0,0 +1,3 @@ +(define-syntax m (syntax-rules () ((m n1 n2) (let ((x n1)) n2)))) +(define (f x) (m x x)) +(write (if (= (f 2) 2) 'ok 'bad))(newline) diff --git a/tests/macros/define-syntax-set.scm b/tests/macros/define-syntax-set.scm new file mode 100644 --- /dev/null +++ b/tests/macros/define-syntax-set.scm @@ -0,0 +1,5 @@ +(define x 1) +(let-syntax ((m (syntax-rules () ((m) x)))) + (set! x 2) + (write (if (= (m) 1) 'bad 'ok))) +(newline) diff --git a/tests/macros/define-syntax.scm b/tests/macros/define-syntax.scm new file mode 100644 --- /dev/null +++ b/tests/macros/define-syntax.scm @@ -0,0 +1,4 @@ +(define-syntax m1 (syntax-rules () ((m1 x) (m2 x)))) +(define-syntax m2 (syntax-rules () ((m2 x) x))) +(write (m1 'ok)) +(newline) diff --git a/tests/macros/dottedlist-ellipsis.scm b/tests/macros/dottedlist-ellipsis.scm new file mode 100644 --- /dev/null +++ b/tests/macros/dottedlist-ellipsis.scm @@ -0,0 +1,6 @@ +(define-syntax m (syntax-rules () + ((m (x . y) ...) (append (list x ...) (list y ...))))) + +(letrec ((x (m (1 . 2) (3 . 4)))) + (if (equal? x '(1 3 2 4)) + (begin (write 'ok)(newline)))) diff --git a/tests/macros/ellipsis-is-zero.scm b/tests/macros/ellipsis-is-zero.scm new file mode 100644 --- /dev/null +++ b/tests/macros/ellipsis-is-zero.scm @@ -0,0 +1,4 @@ +(define-syntax m (syntax-rules () ((m (x ...)) 'ok))) +(write (m ()))(newline) +(define-syntax m (syntax-rules () ((m (x y ...)) 'x))) +(write (m (ok)))(newline) diff --git a/tests/macros/elliptic-aggregates.scm b/tests/macros/elliptic-aggregates.scm new file mode 100644 --- /dev/null +++ b/tests/macros/elliptic-aggregates.scm @@ -0,0 +1,6 @@ +(define-syntax m (syntax-rules () ((m (x #(a b) ...)) '((a b) ...)))) +(write (if (null? (m (x))) 'ok 'bad))(newline) + + +(define-syntax m (syntax-rules () ((m (x ...) y) '((x y)...)))) +(write (if (equal? (m (a b) x) '((a x) (b x))) 'ok 'bad))(newline) diff --git a/tests/macros/let-vs-letrec.scm b/tests/macros/let-vs-letrec.scm new file mode 100644 --- /dev/null +++ b/tests/macros/let-vs-letrec.scm @@ -0,0 +1,3 @@ +(letrec-syntax ((m (syntax-rules () ((m x) x) ((m x y ...) (m y ...))))) + (write (m 'bad 'ok)) + (newline)) diff --git a/tests/macros/list-ellipsis-2.scm b/tests/macros/list-ellipsis-2.scm new file mode 100644 --- /dev/null +++ b/tests/macros/list-ellipsis-2.scm @@ -0,0 +1,6 @@ +(define-syntax m + (syntax-rules () + ((m () b) b) + ((m ((_1 _2) (x y) ...) b) (m ((x y) ...) b)))) +(write (m ((1 2) (3 4)) 'ok)) +(newline) diff --git a/tests/macros/list-ellipsis.scm b/tests/macros/list-ellipsis.scm new file mode 100644 --- /dev/null +++ b/tests/macros/list-ellipsis.scm @@ -0,0 +1,6 @@ +(define-syntax m (syntax-rules () + ((m (x y) ...) (append (list x ...) (list y ...))))) + +(letrec ((x (m (1 2) (3 4)))) + (if (equal? x '(1 3 2 4)) + (begin (write 'ok)(newline)))) diff --git a/tests/macros/literal.scm b/tests/macros/literal.scm new file mode 100644 --- /dev/null +++ b/tests/macros/literal.scm @@ -0,0 +1,3 @@ +(define-syntax m (syntax-rules (x) ((m x) 'ok))) +(write (m x)) +(newline) diff --git a/tests/macros/multilet.scm b/tests/macros/multilet.scm new file mode 100644 --- /dev/null +++ b/tests/macros/multilet.scm @@ -0,0 +1,1 @@ +(write (if (= 3 (let ((a 1) (b 2)) (+ a b))) 'ok 'bad))(newline) diff --git a/tests/macros/multiletstar.scm b/tests/macros/multiletstar.scm new file mode 100644 --- /dev/null +++ b/tests/macros/multiletstar.scm @@ -0,0 +1,1 @@ +(write (if (= 3 (let* ((a 1) (b 2)) (+ a b))) 'ok 'bad))(newline) diff --git a/tests/macros/nested-ellipses.scm b/tests/macros/nested-ellipses.scm new file mode 100644 --- /dev/null +++ b/tests/macros/nested-ellipses.scm @@ -0,0 +1,3 @@ +(define-syntax m (syntax-rules () ((m (x ...) ...) '(#((x ...) (x ...)) ...)))) (m (a) (b)) +(write (if (equal? (m (a) (b)) '(#((a) (a)) #((b) (b)))) 'ok 'bad)) +(newline) diff --git a/tests/macros/nested-frees.scm b/tests/macros/nested-frees.scm new file mode 100644 --- /dev/null +++ b/tests/macros/nested-frees.scm @@ -0,0 +1,8 @@ +(define x 'ok) +(let-syntax ((m1 (syntax-rules () ((m1) x)))) + (define y 'ok) + (let ((x 'bad)) + (let-syntax ((m2 (syntax-rules () ((m2) y)))) + (let ((y 'bad)) + (write (m1))(newline) + (write (m2))(newline))))) diff --git a/tests/macros/r5rs/4.3.1.scm b/tests/macros/r5rs/4.3.1.scm new file mode 100644 --- /dev/null +++ b/tests/macros/r5rs/4.3.1.scm @@ -0,0 +1,15 @@ +(let-syntax ((when (syntax-rules () + ((when test stmt1 stmt2 ...) + (if test + (begin stmt1 + stmt2 ...) #f))))) + (let ((if #t)) + (when if (set! if 'ok)) + (write if))) +(newline) + +(let ((x 'ok)) + (let-syntax ((m (syntax-rules () ((m) x)))) + (let ((x 'bad)) + (write (m))))) +(newline) diff --git a/tests/macros/r5rs/4.3.2.scm b/tests/macros/r5rs/4.3.2.scm new file mode 100644 --- /dev/null +++ b/tests/macros/r5rs/4.3.2.scm @@ -0,0 +1,3 @@ +(write (let ((=> #f)) + (cond (#t => 'ok)))) +(newline) diff --git a/tests/macros/vec-ellipsis-2.scm b/tests/macros/vec-ellipsis-2.scm new file mode 100644 --- /dev/null +++ b/tests/macros/vec-ellipsis-2.scm @@ -0,0 +1,6 @@ +(define-syntax m + (syntax-rules () + ((m #() b) b) + ((m #((_1 _2) #(x y) ...) b) (m #(#(x y) ...) b)))) +(write (m #((1 2)) 'ok)) +(newline) diff --git a/tests/macros/vec-ellipsis.scm b/tests/macros/vec-ellipsis.scm new file mode 100644 --- /dev/null +++ b/tests/macros/vec-ellipsis.scm @@ -0,0 +1,6 @@ +(define-syntax m (syntax-rules () + ((m #(x y) ...) (append (list x ...) (list y ...))))) + +(letrec ((x (m #(1 2) #(3 4)))) + (if (equal? x '(1 3 2 4)) + (begin (write 'ok)(newline)))) diff --git a/tests/macros/xfail/access-newvar.scm b/tests/macros/xfail/access-newvar.scm new file mode 100644 --- /dev/null +++ b/tests/macros/xfail/access-newvar.scm @@ -0,0 +1,4 @@ +(define-syntax m (syntax-rules () ((m) x))) +(let ((x 'bad)) + (write (m)) + (newline)) diff --git a/tests/macros/xfail/bad-elliptic-aggregates.scm b/tests/macros/xfail/bad-elliptic-aggregates.scm new file mode 100644 --- /dev/null +++ b/tests/macros/xfail/bad-elliptic-aggregates.scm @@ -0,0 +1,3 @@ +(define-syntax m (syntax-rules () + ((m (x ...) (y ...))(begin(write 'BAD)(newline)'((x y) ...))))) +(m (a b) (x)) diff --git a/tests/macros/xfail/let-vs-letrec.scm b/tests/macros/xfail/let-vs-letrec.scm new file mode 100644 --- /dev/null +++ b/tests/macros/xfail/let-vs-letrec.scm @@ -0,0 +1,3 @@ +(let-syntax ((m (syntax-rules () ((m x) x) ((m x y ...) (m y ...))))) + (write (m 'BAD 'BAD)) + (newline)) diff --git a/tests/macros/xfail/literal.scm b/tests/macros/xfail/literal.scm new file mode 100644 --- /dev/null +++ b/tests/macros/xfail/literal.scm @@ -0,0 +1,4 @@ +(define-syntax m (syntax-rules (x) ((m x) 'ok))) +(let ((x 0)) + (write (m x)) + (newline)) diff --git a/tests/r5rstest.scm b/tests/r5rstest.scm new file mode 100644 --- /dev/null +++ b/tests/r5rstest.scm @@ -0,0 +1,31249 @@ +;;; R5RS test suite +;;; +;;; Edited for Haschoo... +;;; removed non-R5RS-stuff (interpreter-specific stuff etc) +;;; commented out stuff I disagree with or don't implement yet +;;; +;;; sources include +;;; clisp test suite +;;; Paul Dietz's CL test suite +;;; R Kelsey, W Clinger, and J Rees r5rs.html (and r6rs.html) +;;; A Jaffer's r4rstest.scm (the inspiration for this...) +;;; guile test suite +;;; gauche test suite +;;; gambit test suite +;;; Kent Dybvig's "The Scheme Programming Language" +;;; Brad Lucier (who also pointed out many bugs) +;;; Snd's numtst.c +;;; GSL tests +;;; Abramowitz and Stegun, "Handbook of Mathematical Functions" +;;; Weisstein, "Encyclopedia of Mathematics" +;;; the arprec package of David Bailey et al +;;; Maxima, William Schelter et al +;;; H Cohen, "A Course in Computational Algebraic Number Theory" +;;; various mailing lists + +(define with-bignums #t) ; scheme integer has any number of bits +(define with-bigfloats #f) ; scheme real has any number of bits +(define with-64-bit-ints #t) ; scheme integer has at least 64 bits +(define with-relational-ops-that-require-at-least-2-args #t) ; < et al min args = 2? +(define with-generic-modulo #f) ; #f is the Scheme norm +(define with-syntax-rules #t) ; only lightly tested +(define with-delay #t) ; delay and force +; Haschoo: breaks with stuff becoming NaN +(define with-error-data #f) ; collect numerical error info and report at end +(define with-error-checks #f) ; include checks for bad arg types etc +(define with-large-powers #t) ; for Gauche +(define with-rationalize #t) ; test rationalize + + +(define our-pi 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930382) + + +;;; -------------------------------------------------------------------------------- + +; we're assuming call/cc is defined +; (define call/cc call-with-current-continuation) +; +; (define-syntax defmacro +; (syntax-rules () +; ((_ name params . body) (define-macro (name . params) . body)))) +; +; we also assume there's a "catch" macro trapping all errors +; if you're not expecting any errors, catch can be: + (define (catch tag l1 l2) (l1)) + +;;;-------------------------------------------------------------------------------- + +(define (ok? tst result expected) + ;(write tst) (display #\space) (write result) (display #\space) (write expected) (newline) + (if (not (equal? result expected)) + (begin + (write tst) + (display " got ") + (write result) + (display " but expected ") + (write expected) + (newline) + ))) + + +;(defmacro test (tst expected) (begin +; (display tst) (display #\space) (display expected) (newline) +; `(let ((result (catch #t (lambda () ,tst) (lambda args 'error)))) +; (ok? ',tst result ,expected))) +(define-syntax test (syntax-rules () ((_ tst expected) (begin + (let ((result (catch #t (lambda () tst) (lambda args 'error)))) + (ok? 'tst result expected))) + ))) + + +;;; the error limits below are pretty expansive in some cases, so with-error-data +;;; tries to keep a record of the worst case error for each operator. error-data +;;; is a list: '(#(op worst-error worst-error-case) ...). + +(define error-data '()) + +(define (op-error op result expected) + + (define (conjugate n) + (make-rectangular (real-part n) (- (imag-part n)))) + + (if (and (real? result) + (real? expected)) + (/ (magnitude (- result expected)) (max 1.0 (magnitude expected))) + (case op + ((acosh) + (/ (magnitude (- (cosh result) (cosh expected))) + (max 0.001 (magnitude (cosh expected))))) + ((asin) + (/ (min (magnitude (- (sin result) (sin expected))) + (magnitude (- result expected))) + (max 0.001 (* 10 (magnitude (sin expected)))))) + ((acos) + (/ (min (magnitude (- (cos result) (cos expected))) + (magnitude (- result expected))) + (max 0.001 (magnitude (cos expected))))) + ((asinh) + (/ (magnitude (- (sinh result) (sinh expected))) + (max 0.001 (magnitude (sinh expected))))) + ((atanh) + (/ (min (magnitude (- (tanh result) (tanh expected))) + (magnitude (- result expected))) + (max 0.001 (magnitude (tanh expected))))) + ((atan) + (/ (min (magnitude (- (tan result) (tan expected))) + (magnitude (- result expected))) + (max 0.001 (magnitude (tan expected))))) + ((cosh) + (/ (min (magnitude (- result expected)) + (magnitude (- result (- expected)))) + (max 0.001 (magnitude expected)))) + (else (/ (magnitude (- result expected)) (max 0.001 (magnitude expected))))))) + + +(define (check-error tst result expected) + (if (and (number? result) + (number? expected)) + (let ((err (op-error (car tst) result expected))) + (if (> err 0.0) + (letrec ((find-if (lambda (pred l) + (cond ((null? l) #f) + ((pred (car l)) (car l)) + (else (find-if pred (cdr l))))))) + (let* ((op (car tst)) + (err-op (find-if (lambda (n) (eq? op (vector-ref n 0))) error-data))) + (if err-op + (if (> err (vector-ref err-op 1)) + (begin + (vector-set! err-op 1 err) + (vector-set! err-op 2 tst) + (vector-set! err-op 3 result) + (vector-set! err-op 4 expected))) + (set! error-data (cons (vector op err tst result expected) error-data))))))))) + + +(define (types-consistent? n) + (not (or (and (integer? n) + (or (not (= (denominator n) 1)) + (not (= n (numerator n))) + (not (= (imag-part n) 0)) + (not (= (floor n) (ceiling n) (truncate n) (round n) n)) + (not (= n (real-part n))))) + (and (rational? n) + (not (integer? n)) + (or (not (= (imag-part n) 0)) + (= (denominator n) 1) + (= (denominator n) 0) + (not (= n (real-part n))) + (not (= n (/ (numerator n) (denominator n)))))) + (and (real? n) + (not (rational? n)) + (or (not (= (imag-part n) 0)) + (not (= n (real-part n))))) + (and (complex? n) + (not (real? n)) + (or (= (imag-part n) 0) + (not (= n (+ (real-part n) (* 0+i (imag-part n)))))))))) + + +(define (our-nan? x) + (or (and (real? x) + (not (= 1 (+ (if (positive? x) 1 0) + (if (negative? x) 1 0) + (if (zero? x) 1 0))))) + (and (integer? x) + (not (= 1 (+ (if (even? x) 1 0) + (if (odd? x) 1 0))))) + (not (= 1 (+ (if (zero? x) 1 0) + (if (> (magnitude x) 0) 1 0)))) + (let ((type (+ (if (integer? x) 1 0) + (if (rational? x) 2 0) + (if (real? x) 4 0) + (if (complex? x) 8 0)))) + (and (not (= type 8)) + (not (= type 12)) + (not (= type 14)) + (not (= type 15)))) + (not (zero? (- x x))))) ; inf probably + + +(define (number-ok? tst result expected) + (if (and with-error-data + (number? result) + (number? expected)) + (check-error tst result expected)) + + ;; (number? +nan.0) returns #t in Guile and Gauche -- this strikes me as perverse + + (if (not (eq? result expected)) + (if (or (and (not (number? expected)) + (not (eq? result expected))) + (and (number? expected) + (or (not (number? result)) + (our-nan? result))) + (and (rational? expected) + (exact? expected) + (rational? result) + (exact? result) + (not (= result expected))) + (and (or (and (rational? expected) + (exact? expected)) + (and (rational? result) + (exact? result))) + (real? expected) + (real? result) + (> (magnitude (- result expected)) 1.0e-12)) + (> (op-error (car tst) result expected) 1.0e-6) + (and (number? result) + (not (types-consistent? result)))) + (begin + ;(display (and (not (number? expected)) + ; (not (eq? result expected)))) + ;(display(and (number? expected) + ; (or (not (number? result)) + ; (our-nan? result)))) + ;(display(and (rational? expected) + ; (exact? expected) + ; (rational? result) + ; (exact? result) + ; (not (= result expected)))) + ;(display(and (or (and (rational? expected) + ; (exact? expected)) + ; (and (rational? result) + ; (exact? result))) + ; (real? expected) + ; (real? result) + ; (> (magnitude (- result expected)) 1.0e-12))) + ;(display(> (op-error (car tst) result expected) 1.0e-6)) + ;(display (and (number? result) + ; (not (types-consistent? result)))) + (display tst) + (display " got ") + (display result) + (if (and (rational? result) (not (rational? expected))) + (begin + (display " (") + (display (exact->inexact result)) + (display ")" ))) + (display " but expected ") + (display expected) + +; (if (defined? 'format) +; (begin +; (if (and (not (number? expected)) +; (not (eq? result expected))) +; (format #t ", (eq? ~A ~A) -> #f" result expected) +; (if (and (number? expected) +; (or (not (number? result)) +; (our-nan? result))) +; (begin +; (if (not (number? result)) +; (format #t ", (number? ~A) but not (number? ~A)" expected result) +; (format #t ", (number? ~A) but (nan? ~A)" expected result))) +; (if (and (rational? expected) +; (exact? expected) +; (rational? result) +; (exact? result) +; (not (= result expected))) +; (format #t ", exact results but not (= ~A ~A): ~A" expected result (= result expected)) +; (if (and (or (and (rational? expected) +; (exact? expected)) +; (and (rational? result) +; (exact? result))) +; (real? expected) +; (real? result) +; (> (abs (- result expected)) 1.0e-12)) +; (format #t ", rational results but diff > 1e-12: ~A" (> (abs (- result expected)) 1.0e-12)) +; (if (> (op-error (car tst) result expected) 1.0e-6) +; (format #t ", op-error ~A is > 1e-6" (op-error (car tst) result expected)) +; (let ((n result)) +; (format #t ", result not internally consistent") +; (if (and (integer? n) +; (or (not (= (denominator n) 1)) +; (not (= n (numerator n))) +; (not (= (imag-part n) 0)) +; (not (= (floor n) (ceiling n) (truncate n) (round n) n)) +; (not (= n (real-part n))))) +; (format #t ", ~A integer but den: ~A, num: ~A, imag: ~A, real: ~A, floors: ~A ~A ~A ~A" +; n (denominator n) (numerator n) (imag-part n) (real-part n) +; (floor n) (ceiling n) (truncate n) (round n)) +; (if (and (rational? n) +; (not (integer? n)) +; (or (not (= (imag-part n) 0)) +; (= (denominator n) 1) +; (= (denominator n) 0) +; (not (= n (real-part n))) +; (not (= n (/ (numerator n) (denominator n)))))) +; (format #t ", ~A ratio but imag: ~A, den: ~A, real: ~A, ~A/~A=~A" +; n (imag-part n) (denominator n) (real-part n) +; (numerator n) (denominator n) (exact->inexact (/ (numerator n) (denominator n)))) +; (if (and (real? n) +; (not (rational? n)) +; (or (not (= (imag-part n) 0)) +; (not (= n (real-part n))))) +; (format #t ", ~A real but rational: ~A, imag: ~A, real: ~A" +; n (rational? n) (imag-part n) (real-part n)) +; (format #t ", ~A complex but real? ~A, imag: ~A, ~A+~A=~A" +; n (real? n) (imag-part n) (real-part n) (imag-part n) +; (+ (real-part n) (* 0+i (imag-part n))))))))))))))) + (newline))))) + +(define-syntax num-test (syntax-rules () ((_ tst expected) (begin + (let ((result (catch #t (lambda () tst) (lambda args 'error)))) + (number-ok? 'tst result expected) + )) + ))) + +;;; -------------------------------------------------------------------------------- +;;; GENERIC STUFF +;;; -------------------------------------------------------------------------------- + +(test (eq? 'a 3) #f) +(test (eq? #t 't) #f) +(test (eq? "abs" 'abc) #f) +(test (eq? "hi" '(hi)) #f) +(test (eq? "()" '()) #f) +(test (eq? #\a #\b) #f) +(test (eq? #t #t) #t) +(test (eq? #f #f) #t) +(test (eq? #f #t) #f) +(test (eq? (null? '()) #t) #t) +(test (eq? (null? '(a)) #f) #t) +(test (eq? (cdr '(a)) '()) #t) +(test (eq? 'a 'a) #t) +(test (eq? 'a 'b) #f) +(test (eq? 'a (string->symbol "a")) #t) +(test (eq? '(a) '(b)) #f) +(test (let ((x '(a . b))) (eq? x x)) #t) +(test (let ((x (cons 'a 'b))) (eq? x x)) #t) +(test (eq? (cons 'a 'b) (cons 'a 'b)) #f) +(test (eq? "abc" "cba") #f) +(test (let ((x "hi")) (eq? x x)) #t) +(test (eq? (string #\h #\i) (string #\h #\i)) #f) +(test (eq? '#(a) '#(b)) #f) +(test (let ((x (vector 'a))) (eq? x x)) #t) +(test (eq? (vector 'a) (vector 'a)) #f) +(test (eq? car car) #t) +(test (eq? car cdr) #f) +(test (let ((x (lambda () 1))) (eq? x x)) #t) +(test (eq? 'abc 'abc) #t) +(test (eq? eq? eq?) #t) +(test (eq? (if #f 1) 1) #f) +;(test (eq? call/cc call-with-current-continuation) #t) +; guile accepts (eq? #t #t #t) +(test (eq? 3/4 3) #f) +(test (eq? '() '()) #t) +(test (eq? '() (list)) #t) + +(let ((things (vector #t #f #\space '() "" 0 1 3/4 1+i 1.5 '(1 .2) '#() (vector) (vector 1) (list 1) 'f 't #\t))) + (do ((i 0 (+ i 1))) + ((= i (- (vector-length things) 1))) + (do ((j (+ i 1) (+ j 1))) + ((= j (vector-length things))) + (if (eq? (vector-ref things i) (vector-ref things j)) + (begin + (display "(eq? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #t?") (newline)))))) + + + +(test (eqv? 'a 3) #f) +(test (eqv? #t 't) #f) +(test (eqv? "abs" 'abc) #f) +(test (eqv? "hi" '(hi)) #f) +(test (eqv? "()" '()) #f) +(test (eqv? #\a #\b) #f) +(test (eqv? #\a #\a) #t) +(test (let ((x (string-ref "hi" 0))) (eqv? x x)) #t) +(test (eqv? #t #t) #t) +(test (eqv? #f #f) #t) +(test (eqv? #f #t) #f) +(test (eqv? (null? '()) #t) #t) +(test (eqv? (null? '(a)) #f) #t) +(test (eqv? (cdr '(a)) '()) #t) +(test (eqv? 'a 'a) #t) +(test (eqv? 'a 'b) #f) +(test (eqv? 'a (string->symbol "a")) #t) +(test (eqv? '(a) '(b)) #f) +(test (let ((x '(a . b))) (eqv? x x)) #t) +(test (let ((x (cons 'a 'b))) (eqv? x x)) #t) +(test (eqv? (cons 'a 'b) (cons 'a 'b)) #f) +(test (eqv? "abc" "cba") #f) +(test (let ((x "hi")) (eqv? x x)) #t) +(test (eqv? (string #\h #\i) (string #\h #\i)) #f) +(test (eqv? '#(a) '#(b)) #f) +(test (let ((x (vector 'a))) (eqv? x x)) #t) +(test (eqv? (vector 'a) (vector 'a)) #f) +(test (eqv? car car) #t) +(test (eqv? car cdr) #f) +(test (let ((x (lambda () 1))) (eqv? x x)) #t) +(test (eqv? 9/2 9/2) #t) +;(test (eqv? 3.4 (+ 3.0 0.4)) #t) ; can be fooled +(test (let ((x 3.141)) (eqv? x x)) #t) +(test (eqv? (cons 'a 'b) (cons 'a 'c)) #f) +(test (eqv? eqv? eqv?) #t) +;(test (let ((quote -)) (eqv? '1 1)) #f) +(test (eqv? '#(1) '#(1)) #f) +(test (eqv? '(1) '(1)) #f) +(test (eqv? '() '()) #t) +(test (eqv? '() (list)) #t) + +(let ((things (vector #t #f #\space '() "" 0 1 3/4 1+i 1.5 '(1 .2) '#() (vector) (vector 1) (list 1) 'f 't #\t))) + (do ((i 0 (+ i 1))) + ((= i (- (vector-length things) 1))) + (do ((j (+ i 1) (+ j 1))) + ((= j (vector-length things))) + (if (eqv? (vector-ref things i) (vector-ref things j)) + (begin + (display "(eqv? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #t?") (newline)))))) + + + +(test (equal? 'a 3) #f) +(test (equal? #t 't) #f) +(test (equal? "abs" 'abc) #f) +(test (equal? "hi" '(hi)) #f) +(test (equal? "()" '()) #f) +(test (equal? #\a #\b) #f) +(test (equal? #\a #\a) #t) +(test (let ((x (string-ref "hi" 0))) (equal? x x)) #t) +(test (equal? #t #t) #t) +(test (equal? #f #f) #t) +(test (equal? #f #t) #f) +(test (equal? (null? '()) #t) #t) +(test (equal? (null? '(a)) #f) #t) +(test (equal? (cdr '(a)) '()) #t) +(test (equal? 'a 'a) #t) +(test (equal? 'a 'b) #f) +(test (equal? 'a (string->symbol "a")) #t) +(test (equal? '(a) '(b)) #f) +(test (equal? '(a) '(a)) #t) +(test (let ((x '(a . b))) (equal? x x)) #t) +(test (let ((x (cons 'a 'b))) (equal? x x)) #t) +(test (equal? (cons 'a 'b) (cons 'a 'b)) #t) +(test (equal? "abc" "cba") #f) +(test (equal? "abc" "abc") #t) +(test (let ((x "hi")) (equal? x x)) #t) +(test (equal? (string #\h #\i) (string #\h #\i)) #t) +(test (equal? '#(a) '#(b)) #f) +(test (equal? '#(a) '#(a)) #t) +(test (let ((x (vector 'a))) (equal? x x)) #t) +(test (equal? (vector 'a) (vector 'a)) #t) +(test (equal? '#(1 2) (vector 1 2)) #t) +(test (equal? '#(1.0 2/3) (vector 1.0 2/3)) #t) +(test (equal? '#(1 2) (vector 1 2.0)) #f) ; 2 not equal 2.0! +(test (equal? '(1 . 2) (cons 1 2)) #t) +(test (equal? '#(1 "hi" #\a) (vector 1 "hi" #\a)) #t) +(test (equal? '#((1 . 2)) (vector (cons 1 2))) #t) +(test (equal? '#(1 "hi" #\a (1 . 2)) (vector 1 "hi" #\a (cons 1 2))) #t) +(test (equal? '#(#f hi (1 2) 1 "hi" #\a (1 . 2)) (vector #f 'hi (list 1 2) 1 "hi" #\a (cons 1 2))) #t) +(test (equal? '#(#(1) #(1)) (vector (vector 1) (vector 1))) #t) +(test (equal? '#(()) (vector '())) #t) +(test (equal? '#("hi" "ho") (vector "hi" '"ho")) #t) +(test (equal? (list 1 "hi" #\a) '(1 "hi" #\a)) #t) +(test (equal? (list 1.0 2/3) '(1.0 2/3)) #t) +(test (equal? (list 1 2) '(1 2.0)) #f) +(test (equal? '#(1.0+1.0i) (vector 1.0+1.0i)) #t) +(test (equal? (list 1.0+1.0i) '(1.0+1.0i)) #t) +(test (equal? '((())) (list (list (list)))) #t) +(test (equal? car car) #t) +(test (equal? car cdr) #f) +(test (let ((x (lambda () 1))) (equal? x x)) #t) +(test (equal? 9/2 9/2) #t) +;(test (equal? 3.4 (+ 3.0 0.4)) #t) +(test (let ((x 3.141)) (equal? x x)) #t) +(test (equal? 3 3) #t) +(test (equal? 3 3.0) #f) +(test (equal? 3.0 3.0) #t) +(test (equal? 3-4i 3-4i) #t) +(test (equal? (string #\c) "c") #t) +(test (equal? equal? equal?) #t) +(test (equal? (cons 1 (cons 2 3)) '(1 2 . 3)) #t) +(test (equal? '() '()) #t) +(test (equal? '() (list)) #t) + +(test (equal? "asd""asd") #t) ; is this the norm? +(let ((streq (lambda (a b) (equal? a b)))) (test (streq "asd""asd") #t)) + +(let ((things (vector #t #f #\space '() "" 0 1 3/4 1+i 1.5 '(1 .2) '#() (vector 1) (list 1) 'f 't #\t))) + (do ((i 0 (+ i 1))) + ((= i (- (vector-length things) 1))) + (do ((j (+ i 1) (+ j 1))) + ((= j (vector-length things))) + (if (equal? (vector-ref things i) (vector-ref things j)) + (begin + (display "(equal? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #t?") (newline)))))) + + + + +(test (boolean? #f) #t) +(test (boolean? #t) #t) +(test (boolean? 0) #f) +(test (boolean? 1) #f) +(test (boolean? "") #f) +(test (boolean? #\0) #f) +(test (boolean? '()) #f) +(test (boolean? '#()) #f) +(test (boolean? 't) #f) +(test (boolean? (list)) #f) + +(for-each + (lambda (arg) + (if (boolean? arg) + (begin + (display "(boolean? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f (lambda (a) (+ a 1)))) + + + +(test (not #f) #t) +(test (not #t) #f) +(test (not (not #t)) #t) +(test (not 0) #f) +(test (not 1) #f) +(test (not '()) #f) +(test (not 't) #f) +(test (not (list)) #f) +(test (not (list 3)) #f) +(test (not 'nil) #f) +(test (not not) #f) + +(for-each + (lambda (arg) + (if (not arg) + (begin + (display "(not ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f (lambda (a) (+ a 1)))) + + + +(test (symbol? 't) #t) +(test (symbol? "t") #f) +(test (symbol? '(t)) #f) +(test (symbol? #t) #f) +(test (symbol? 4) #f) +(test (symbol? 'foo) #t) +(test (symbol? (car '(a b))) #t) +(test (symbol? 'nil) #t) +(test (symbol? '()) #f) +(test (symbol? #f) #f) +(test (symbol? 'car) #t) +(test (symbol? '#f) #f) +(test (symbol? 'sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789) #t) ;M Gran +(test (symbol? (vector-ref '#(1 a 34) 1)) #t) + +(for-each + (lambda (arg) + (if (symbol? arg) + (begin + (display "(symbol? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f (lambda (a) (+ a 1)))) + + + +(test (procedure? car) #t) +(test (procedure? procedure?) #t) +(test (procedure? 'car) #f) +(test (procedure? (lambda (x) x)) #t) +(test (procedure? '(lambda (x) x)) #f) +;(test (call/cc procedure?) #t) ; ?? +(test (let ((a (lambda (x) x))) (procedure? a)) #t) +(test (letrec ((a (lambda () (procedure? a)))) (a)) #t) +(test (let ((a 1)) (let ((a (lambda () (procedure? a)))) (a))) #f) + +(for-each + (lambda (arg) + (if (procedure? arg) + (begin + (display "(procedure? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) 3.14 3/4 1.0+1.0i #\f)) + + + + +;;; -------------------------------------------------------------------------------- +;;; CHARACTERS +;;; -------------------------------------------------------------------------------- + +(test (eqv? '#\ #\space) #t) +(test (eqv? #\space '#\space) #t) + +(test (char? #\a) #t) +(test (char? #\() #t) +(test (char? #\space) #t) +(test (char? '#\newline) #t) +(test (char? #\1) #t) +(test (char? #\$) #t) +(test (char? #\.) #t) +(test (char? #\\) #t) +(test (char? #\)) #t) +(test (char? #\%) #t) +(test (char? '#\space) #t) +(test (char? '#\ ) #t) +(test (char? '#\newline) #t) +(test (char? '#\a) #t) +(test (char? '#\8) #t) +(test (char? #\-) #t) +(test (char? #\n) #t) +(test (char? #\() #t) +(test (char? #e1) #f) +(test (char? #\#) #t) +(test (char? #\x) #t) +(test (char? #\o) #t) +(test (char? #\b) #t) +(test (char? #b101) #f) +(test (char? #o73) #f) +(test (char? #x73) #f) +(test (char? 'a) #f) +(test (char? 97) #f) +(test (char? "a") #f) +(test (char? (string-ref "hi" 0)) #t) +(test (char? (string-ref (make-string 1) 0)) #t) +(test (char? #\") #t) +(test (char? #\') #t) +(test (char? #\`) #t) +(test (char? #\@) #t) + +(for-each + (lambda (arg) + (if (char? arg) + (begin + (display "(char? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1)))) + +(do ((i 0 (+ i 1))) + ((= i 256)) + (if (not (char? (integer->char i))) + (begin + (display "(char? (integer->char ") (display i) (display ")) returned #f?") (newline)))) + +(num-test (let ((str (make-string 258 #\space))) + (do ((i 1 (+ i 1))) + ((= i 256)) + (string-set! str i (integer->char i))) + (string-set! str 257 (integer->char 0)) + (string-length str)) + 258) + + +(let ((a-to-z (list #\a #\b #\c #\d #\e #\f #\g #\h #\i #\j #\k #\l #\m #\n #\o #\p #\q #\r #\s #\t #\u #\v #\x #\y #\z)) + (cap-a-to-z (list #\A #\B #\C #\D #\E #\F #\G #\H #\I #\J #\K #\L #\M #\N #\O #\P #\Q #\R #\S #\T #\U #\V #\X #\Y #\Z)) + (mixed-a-to-z (list #\a #\B #\c #\D #\e #\F #\g #\H #\I #\j #\K #\L #\m #\n #\O #\p #\Q #\R #\s #\t #\U #\v #\X #\y #\Z)) + (digits (list #\0 #\1 #\2 #\3 #\4 #\5 #\6 #\7 #\8 #\9))) + + + (test (char-upper-case? #\a) #f) + (test (char-upper-case? #\A) #t) + + (for-each + (lambda (arg) + (if (not (char-upper-case? arg)) + (begin + (display "(char-upper-case? ") (display arg) (display ") returned #f?") (newline)))) + cap-a-to-z) + + (for-each + (lambda (arg) + (if (char-upper-case? arg) + (begin + (display "(char-upper-case? ") (display arg) (display ") returned #t?") (newline)))) + a-to-z) + + ;; non-alpha chars are "unspecified" here + + + (test (char-lower-case? #\A) #f) + (test (char-lower-case? #\a) #t) + + (for-each + (lambda (arg) + (if (not (char-lower-case? arg)) + (begin + (display "(char-lower-case? ") (display arg) (display ") returned #f?") (newline)))) + a-to-z) + + (for-each + (lambda (arg) + (if (char-lower-case? arg) + (begin + (display "(char-lower-case? ") (display arg) (display ") returned #t?") (newline)))) + cap-a-to-z) + + + (test (char-upcase #\A) #\A) + (test (char-upcase #\a) #\A) + (test (char-upcase #\?) #\?) + (test (char-upcase #\$) #\$) + (test (char-upcase #\.) #\.) + (test (char-upcase #\\) #\\) + (test (char-upcase #\5) #\5) + (test (char-upcase #\)) #\)) + (test (char-upcase #\%) #\%) + (test (char-upcase #\0) #\0) + (test (char-upcase #\_) #\_) + (test (char-upcase #\space) #\space) + (test (char-upcase #\newline) #\newline) + + (for-each + (lambda (arg1 arg2) + (if (not (char=? (char-upcase arg1) arg2)) + (begin + (display "(char-upcase ") (display arg1) (display ") returned ") (display arg2) (display "?") (newline)))) + a-to-z + cap-a-to-z) + + (do ((i 1 (+ i 1))) + ((= i 128)) + (if (and (not (char=? (integer->char i) (char-upcase (integer->char i)))) + (not (char-alphabetic? (integer->char i)))) + (begin + (display "(char-upcase ") (display (integer->char i)) (display ") -> ") + (display (integer->char i)) (display ", but not alphabetic?") + (newline)))) + + (test (char-downcase #\A) #\a) + (test (char-downcase #\a) #\a) + (test (char-downcase #\?) #\?) + (test (char-downcase #\$) #\$) + (test (char-downcase #\.) #\.) + (test (char-downcase #\_) #\_) + (test (char-downcase #\\) #\\) + (test (char-downcase #\5) #\5) + (test (char-downcase #\)) #\)) + (test (char-downcase #\%) #\%) + (test (char-downcase #\0) #\0) + (test (char-downcase #\space) #\space) + + (for-each + (lambda (arg1 arg2) + (if (not (char=? (char-downcase arg1) arg2)) + (begin + (display "(char-downcase ") (display arg1) (display ") returned ") (display arg2) (display "?") (newline)))) + cap-a-to-z + a-to-z) + + + (test (char-numeric? #\a) #f) + (test (char-numeric? #\5) #t) + (test (char-numeric? #\A) #f) + (test (char-numeric? #\z) #f) + (test (char-numeric? #\Z) #f) + (test (char-numeric? #\0) #t) + (test (char-numeric? #\9) #t) + (test (char-numeric? #\space) #f) + (test (char-numeric? #\;) #f) + (test (char-numeric? #\.) #f) + (test (char-numeric? #\-) #f) + + (for-each + (lambda (arg) + (if (char-numeric? arg) + (begin + (display "(char-numeric? ") (display arg) (display ") returned #t?") (newline)))) + cap-a-to-z) + + (for-each + (lambda (arg) + (if (char-numeric? arg) + (begin + (display "(char-numeric? ") (display arg) (display ") returned #t?") (newline)))) + a-to-z) + + + (test (char-whitespace? #\a) #f) + (test (char-whitespace? #\A) #f) + (test (char-whitespace? #\z) #f) + (test (char-whitespace? #\Z) #f) + (test (char-whitespace? #\0) #f) + (test (char-whitespace? #\9) #f) + (test (char-whitespace? #\space) #t) + (test (char-whitespace? #\newline) #t) + (test (char-whitespace? #\;) #f) + + (for-each + (lambda (arg) + (if (char-whitespace? arg) + (begin + (display "(char-whitespace? ") (display arg) (display ") returned #t?") (newline)))) + mixed-a-to-z) + + (for-each + (lambda (arg) + (if (char-whitespace? arg) + (begin + (display "(char-whitespace? ") (display arg) (display ") returned #t?") (newline)))) + digits) + + + (test (char-alphabetic? #\a) #t) + (test (char-alphabetic? #\$) #f) + (test (char-alphabetic? #\A) #t) + (test (char-alphabetic? #\z) #t) + (test (char-alphabetic? #\Z) #t) + (test (char-alphabetic? #\0) #f) + (test (char-alphabetic? #\9) #f) + (test (char-alphabetic? #\space) #f) + (test (char-alphabetic? #\;) #f) + (test (char-alphabetic? #\.) #f) + (test (char-alphabetic? #\-) #f) + (test (char-alphabetic? #\_) #f) + (test (char-alphabetic? #\^) #f) + (test (char-alphabetic? #\[) #f) + + (for-each + (lambda (arg) + (if (char-alphabetic? arg) + (begin + (display "(char-alphabetic? ") (display arg) (display ") returned #t?") (newline)))) + digits) + + (for-each + (lambda (arg) + (if (not (char-alphabetic? arg)) + (begin + (display "(char-alphabetic? ") (display arg) (display ") returned #f?") (newline)))) + mixed-a-to-z) + + + (test (char=? #\d #\d) #t) + (test (char=? #\A #\a) #f) + (test (char=? #\d #\x) #f) + (test (char=? #\d #\D) #f) + (test (char=? #\a #\a) #t) + (test (char=? #\A #\B) #f) + (test (char=? #\a #\b) #f) + (test (char=? #\9 #\0) #f) + (test (char=? #\A #\A) #t) + (test (char=? #\ #\space) #t) + (let ((i (char->integer #\space))) + (test (char=? (integer->char i) #\space) #t)) + (test (char=? (integer->char (char->integer #\")) #\") #t) + + (test (char? #\e #\d) #t) + (test (char>? #\z #\a) #t) + (test (char>? #\A #\B) #f) + (test (char>? #\a #\b) #f) + (test (char>? #\9 #\0) #t) + (test (char>? #\A #\A) #f) + (test (char>? #\space #\space) #f) + + (test (char>=? #\e #\d) #t) + (test (char>=? #\A #\B) #f) + (test (char>=? #\a #\b) #f) + (test (char>=? #\9 #\0) #t) + (test (char>=? #\A #\A) #t) + (test (char>=? #\space #\space) #t) + + (test (char-ci=? #\A #\B) #f) + (test (char-ci=? #\a #\B) #f) + (test (char-ci=? #\A #\b) #f) + (test (char-ci=? #\a #\b) #f) + (test (char-ci=? #\9 #\0) #f) + (test (char-ci=? #\A #\A) #t) + (test (char-ci=? #\A #\a) #t) + (test (char-ci=? #\a #\A) #t) + (test (char-ci=? #\space #\space) #t) + + (test (char-cichar i)) +; (c2 (integer->char k))) +; (for-each +; (lambda (op1 op2) +; (if (not (eq? (op1 c1 c2) (op2 (string c1) (string c2)))) +; (format #t "(~A|~A ~A ~A) -> ~A|~A~%" op1 op2 c1 c2 (op1 c1 c2) (op2 (string c1) (string c2))))) +; (list char=? char? char>=? char-ci=? char-ci? char-ci>=?) +; (list string=? string? string>=? string-ci=? string-ci? string-ci>=?))))) + + + (test (char-ci>? #\A #\B) #f) + (test (char-ci>? #\a #\B) #f) + (test (char-ci>? #\A #\b) #f) + (test (char-ci>? #\a #\b) #f) + (test (char-ci>? #\9 #\0) #t) + (test (char-ci>? #\A #\A) #f) + (test (char-ci>? #\A #\a) #f) +; (test (char-ci>? #\^ #\a) #t) +; (test (char-ci>? #\_ #\e) #t) + (test (char-ci>? #\[ #\S) #t) +; (test (char-ci>? #\\ #\l) #t) +; (test (char-ci>? #\t #\_) #f) +; (test (char-ci>? #\a #\]) #f) +; (test (char-ci>? #\z #\^) #f) + (test (char-ci>? #\] #\X) #t) + + (test (char-ci<=? #\A #\B) #t) + (test (char-ci<=? #\a #\B) #t) + (test (char-ci<=? #\A #\b) #t) + (test (char-ci<=? #\a #\b) #t) + (test (char-ci<=? #\9 #\0) #f) + (test (char-ci<=? #\A #\A) #t) + (test (char-ci<=? #\A #\a) #t) + (test (char-ci<=? #\` #\H) #f) +; (test (char-ci<=? #\[ #\m) #f) +; (test (char-ci<=? #\j #\`) #t) + (test (char-ci<=? #\\ #\E) #f) +; (test (char-ci<=? #\t #\_) #t) +; (test (char-ci<=? #\a #\]) #t) +; (test (char-ci<=? #\z #\^) #t) + + (test (char-ci>=? #\A #\B) #f) + (test (char-ci>=? #\a #\B) #f) + (test (char-ci>=? #\A #\b) #f) + (test (char-ci>=? #\a #\b) #f) + (test (char-ci>=? #\9 #\0) #t) + (test (char-ci>=? #\A #\A) #t) + (test (char-ci>=? #\A #\a) #t) + (test (char-ci>=? #\Y #\_) #f) + (test (char-ci>=? #\` #\S) #t) + (test (char-ci>=? #\[ #\Y) #t) +; (test (char-ci>=? #\t #\_) #f) +; (test (char-ci>=? #\a #\]) #f) +; (test (char-ci>=? #\z #\^) #f) + ) ; end let with a-to-z + + +(test (integer->char (char->integer #\.)) #\.) +(test (integer->char (char->integer #\A)) #\A) +(test (integer->char (char->integer #\a)) #\a) +(test (integer->char (char->integer #\space)) #\space) + + + + +;;; -------------------------------------------------------------------------------- +;;; STRINGS +;;; -------------------------------------------------------------------------------- + +(test (string? "abc") #t) +(test (string? ':+*/-) #f) +(test (string? "das ist einer der teststrings") #t) +(test (string? '(das ist natuerlich falsch)) #f) +(test (string? "aaaaaa") #t) +(test (string? #\a) #f) +(test (string? "\"\\\"") #t) + +(for-each + (lambda (arg) + (test (string? arg) #f)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + +(test (string=? "foo" "foo") #t) +(test (string=? "foo" "FOO") #f) +(test (string=? "foo" "bar") #f) +(test (string=? "FOO" "FOO") #t) +(test (string=? "A" "B") #f) +(test (string=? "a" "b") #f) +(test (string=? "9" "0") #f) +(test (string=? "A" "A") #t) +(test (string=? "" "") #t) +(test (string=? (string #\newline) (string #\newline)) #t) + +(test (let ((str (string #\" #\1 #\\ #\2 #\"))) (string=? str "\"1\\2\"")) #t) +(test (let ((str (string #\\ #\\ #\\))) (string=? str "\\\\\\")) #t) +(test (let ((str (string #\"))) (string=? str "\"")) #t) +(test (let ((str (string #\\ #\"))) (string=? str "\\\"")) #t) +(test (let ((str (string #\space #\? #\)))) (string=? str " ?)")) #t) +(test (let ((str (string #\# #\\ #\t))) (string=? str "#\\t")) #t) +(test (let ((str (string #\# #\\ #\t))) (string-length str)) 3) + + +(test (string? "aaab" "aaaa") #t) +(test (string>? "aaaaa" "aaaa") #t) +(test (string>? "" "abcdefgh") #f) +(test (string>? "a" "abcdefgh") #f) +(test (string>? "abc" "abcdefgh") #f) +(test (string>? "cabc" "abcdefgh") #t) +(test (string>? "abcdefgh" "abcdefgh") #f) +(test (string>? "xyzabc" "abcdefgh") #t) +(test (string>? "abc" "xyzabcdefgh") #f) +(test (string>? "abcdefgh" "") #t) +(test (string>? "abcdefgh" "a") #t) +(test (string>? "abcdefgh" "abc") #t) +(test (string>? "abcdefgh" "cabc") #f) +(test (string>? "abcdefgh" "xyzabc") #f) +(test (string>? "xyzabcdefgh" "abc") #t) +(test (string>? "abcde" "bc") #f) +(test (string>? "bcdef" "abcde") #t) +(test (string>? "bcdef" "abcdef") #t) +(test (string>? "" "") #f) +(test (string>? "A" "B") #f) +(test (string>? "a" "b") #f) +(test (string>? "9" "0") #t) +(test (string>? "A" "A") #f) + +(test (string<=? "aaa" "aaaa") #t) +(test (string<=? "aaaaa" "aaaa") #f) +(test (string<=? "a" "abcdefgh") #t) +(test (string<=? "abc" "abcdefgh") #t) +(test (string<=? "aaabce" "aaabcdefgh") #f) +(test (string<=? "cabc" "abcdefgh") #f) +(test (string<=? "abcdefgh" "abcdefgh") #t) +(test (string<=? "xyzabc" "abcdefgh") #f) +(test (string<=? "abc" "xyzabcdefgh") #t) +(test (string<=? "abcdefgh" "") #f) +(test (string<=? "abcdefgh" "a") #f) +(test (string<=? "abcdefgh" "abc") #f) +(test (string<=? "abcdefgh" "cabc") #t) +(test (string<=? "abcdefgh" "xyzabc") #t) +(test (string<=? "xyzabcdefgh" "abc") #f) +(test (string<=? "abcdef" "bcdefgh") #t) +(test (string<=? "" "") #t) +(test (string<=? "A" "B") #t) +(test (string<=? "a" "b") #t) +(test (string<=? "9" "0") #f) +(test (string<=? "A" "A") #t) + +(test (string>=? "aaaaa" "aaaa") #t) +(test (string>=? "aaaa" "aaaa") #t) +(test (string>=? "aaa" "aaaa") #f) +(test (string>=? "" "abcdefgh") #f) +(test (string>=? "a" "abcdefgh") #f) +(test (string>=? "abc" "abcdefgh") #f) +(test (string>=? "cabc" "abcdefgh") #t) +(test (string>=? "abcdefgh" "abcdefgh") #t) +(test (string>=? "xyzabc" "abcdefgh") #t) +(test (string>=? "abc" "xyzabcdefgh") #f) +(test (string>=? "abcdefgh" "") #t) +(test (string>=? "abcdefgh" "a") #t) +(test (string>=? "abcdefgh" "abc") #t) +(test (string>=? "abcdefgh" "cabc") #f) +(test (string>=? "abcdefgh" "xyzabc") #f) +(test (string>=? "xyzabcdefgh" "abc") #t) +(test (string>=? "bcdef" "abcdef") #t) +(test (string>=? "A" "B") #f) +(test (string>=? "a" "b") #f) +(test (string>=? "9" "0") #t) +(test (string>=? "A" "A") #t) +(test (string>=? "" "") #t) + + +(test (string-ci=? "A" "B") #f) +(test (string-ci=? "a" "B") #f) +(test (string-ci=? "A" "b") #f) +(test (string-ci=? "a" "b") #f) +(test (string-ci=? "9" "0") #f) +(test (string-ci=? "A" "A") #t) +(test (string-ci=? "A" "a") #t) +(test (string-ci=? "" "") #t) +(test (string-ci=? "aaaa" "AAAA") #t) +(test (string-ci=? "aaaa" "Aaaa") #t) + + +(test (string-ci? "Aaa" "AA") #t) +(test (string-ci>? "A" "B") #f) +(test (string-ci>? "a" "B") #f) +(test (string-ci>? "A" "b") #f) +(test (string-ci>? "a" "b") #f) +(test (string-ci>? "9" "0") #t) +(test (string-ci>? "A" "A") #f) +(test (string-ci>? "A" "a") #f) +(test (string-ci>? "" "") #f) +(test (string-ci>? "Z" "DjNTl0") #t) +(test (string-ci>? "2399dt7BVN[,A" "^KHboHV") #f) + +;(test (string-ci>? "t" "_") #f) +;(test (string-ci>? "a" "]") #f) +;(test (string-ci>? "z" "^") #f) +(test (string-ci>? "R*95oG.k;?" "`2?J6LBbLG^alB[fMD") #f) +(test (string-ci>? "]" "X") #t) + +(test (string-ci<=? "A" "B") #t) +(test (string-ci<=? "a" "B") #t) +(test (string-ci<=? "A" "b") #t) +(test (string-ci<=? "a" "b") #t) +(test (string-ci<=? "9" "0") #f) +(test (string-ci<=? "A" "A") #t) +(test (string-ci<=? "A" "a") #t) +(test (string-ci<=? "" "") #t) +(test (string-ci<=? ":LPC`" ",O0>affA?(") #f) + +;(test (string-ci<=? "t" "_") #t) +;(test (string-ci<=? "a" "]") #t) +;(test (string-ci<=? "z" "^") #t) +(test (string-ci<=? "G888E>beF)*mwCNnagP" "`2uTd?h") #t) + +(test (string-ci>=? "A" "B") #f) +(test (string-ci>=? "a" "B") #f) +(test (string-ci>=? "A" "b") #f) +(test (string-ci>=? "a" "b") #f) +(test (string-ci>=? "9" "0") #t) +(test (string-ci>=? "A" "A") #t) +(test (string-ci>=? "A" "a") #t) +(test (string-ci>=? "" "") #t) +(test (string-ci>=? "5d7?[o[:hop=ktv;9)" "p^r9;TAXO=^") #f) + +;(test (string-ci>=? "t" "_") #f) +;(test (string-ci>=? "a" "]") #f) +;(test (string-ci>=? "z" "^") #f) +;(test (string-ci>=? "jBS" "`<+s[[:`l") #f) + + + +(test (string-length "abc") 3) +(test (string-length "") 0) +(test (string-length (string)) 0) +(test (string-length "\"\\\"") 3) +(test (string-length (string #\newline)) 1) +(test (string-length "hi there") 8) +(test (string-length "\"") 1) +(test (string-length (make-string 100 #\a)) 100) + + + + +(test (string) "") +(test (string #\a #\b #\c) "abc") +(test (string #\a) "a") + + + +(test (make-string 0) "") +(test (make-string 3 #\a) "aaa") +(test (make-string 0 #\a) "") +(test (make-string 3 #\space) " ") +(test (let ((hi (make-string 3 #\newline))) (string-length hi)) 3) + + + +(test (string-ref "abcdef-dg1ndh" 0) #\a) +(test (string-ref "abcdef-dg1ndh" 1) #\b) +(test (string-ref "abcdef-dg1ndh" 6) #\-) +(test (string-ref "\"\\\"" 1) #\\) +(test (string-ref "\"\\\"" 2) #\") + + + +(test (let ((hi (string-copy "hi"))) (string-set! hi 0 #\H) hi) "Hi") +(test (let ((hi (string-copy "hi"))) (string-set! hi 1 #\H) hi) "hH") +(test (let ((hi (string-copy "\"\\\""))) (string-set! hi 0 #\a) hi) "a\\\"") +(test (let ((hi (string-copy "\"\\\""))) (string-set! hi 1 #\a) hi) "\"a\"") +(test (let ((hi (string #\a #\newline #\b))) (string-set! hi 1 #\c) hi) "acb") + +(let ((str (make-string 10 #\x))) + (string-set! str 3 (integer->char 0)) +; (test (string=? str "xxx") #t) + (test (char=? (string-ref str 4) #\x) #t) + (string-set! str 4 #\a) +; (test (string=? str "xxx") #t) + (test (char=? (string-ref str 4) #\a) #t) + (string-set! str 3 #\x) + (test (string=? str "xxxxaxxxxx") #t)) + + + +(test (substring "ab" 0 0) "") +(test (substring "ab" 1 1) "") +(test (substring "ab" 2 2) "") +(test (substring "ab" 0 1) "a") +(test (substring "ab" 1 2) "b") +(test (substring "ab" 0 2) "ab") +(test (substring "hi there" 3 6) "the") +(test (substring "hi there" 0 (string-length "hi there")) "hi there") +(test (substring "" 0 0) "") +(test (let ((str "012345")) + (let ((str1 (substring str 2 4))) + (string-set! str1 1 #\x)) + (string=? str "012345")) + #t) + + +(test (string-append "hi" "ho") "hiho") +(test (string-append "hi") "hi") +(test (string-append "hi" "") "hi") +(test (string-append "hi" "" "ho") "hiho") +(test (string-append "" "hi") "hi") +(test (string-append) "") +(test (string-append "a" (string-append (string-append "b" "c") "d") "e") "abcde") +(test (string-append "a" "b" "c" "d" "e") "abcde") +(test (string-append (string-append) (string-append (string-append))) "") +(test (let ((hi "hi")) (let ((ho (string-append hi))) (eq? hi ho))) #f) +(test (let ((hi "hi")) (let ((ho (string-append hi))) (string-set! ho 0 #\a) hi)) "hi") +(test (let ((hi "hi")) (set! hi (string-append hi hi hi hi)) hi) "hihihihi") + +(num-test (letrec ((hi (lambda (str n) + (if (= n 0) + str + (hi (string-append str "a") (- n 1)))))) + (string-length (hi "" 100))) + 100) + +(test (let* ((str "hiho") + (str1 "ha") + (str2 (string-append str1 str))) + (string-set! str2 1 #\x) + (string-set! str2 4 #\x) + (and (string=? str "hiho") + (string=? str1 "ha") + (string=? str2 "hxhixo"))) + #t) + +(test (let* ((str (string-copy "hiho")) + (str1 (string-copy "ha")) + (str2 (string-append str1 str))) + (string-set! str1 1 #\x) + (string-set! str 2 #\x) + (and (string=? str "hixo") + (string=? str1 "hx") + (string=? str2 "hahiho"))) + #t) + + + +(test (let ((hi (string-copy "hi"))) (string-fill! hi #\s) hi) "ss") +(test (let ((hi (string-copy ""))) (string-fill! hi #\x) hi) "") +(test (let ((str (make-string 0))) (string-fill! str #\a) str) "") +(test (let ((hi (make-string 8 (integer->char 0)))) (string-fill! hi #\a) hi) "aaaaaaaa") ; is this result widely accepted? + + + +(test (string-copy "ab") "ab") +(test (string-copy "") "") +(test (string-copy "\"\\\"") "\"\\\"") +(test (let ((hi "abc")) (eq? hi (string-copy hi))) #f) +(test (let ((hi (string-copy (make-string 8 (integer->char 0))))) (string-fill! hi #\a) hi) "aaaaaaaa") ; is this result widely accepted? +(test (string-copy (string-copy (string-copy "a"))) "a") +(test (string-copy (string-copy (string-copy ""))) "") + + + +(test (string->list "abc") (list #\a #\b #\c)) +(test (string->list "") '()) +;(test (string->list (make-string 3 (integer->char 0))) '()) ; others return a list of #\nul or #\null +(test (string->list (list->string (list #\a #\b #\c))) (list #\a #\b #\c)) +(test (string->list (list->string '())) '()) +(test (list->string (string->list "abc")) "abc") +(test (list->string (string->list "hi there")) "hi there") +(test (list->string (string->list "&*#%^@%$)~@")) "&*#%^@%$)~@") +(test (list->string (string->list "")) "") +(test (let* ((str "abc") + (lst (string->list str))) + (and (string=? str "abc") + (equal? lst (list #\a #\b #\c)))) + #t) + +(test (list->string (list #\a #\b #\c)) "abc") +(test (list->string (list)) "") + +(test (list->string (list #\" #\# #\")) "\"#\"") +(test (list->string (list #\\ #\\ #\# #\\ #\# #\#)) "\\\\#\\##") +(test (list->string (list #\' #\' #\` #\")) '"''`\"") +(test (string #\" #\# #\") "\"#\"") +(test (string #\\ #\\ #\# #\\ #\# #\#) "\\\\#\\##") +(test (string #\' #\' #\` #\") '"''`\"") +;;; some schemes accept \' and other such sequences in a string, but the spec only mentions \\ and \" + + +(test (symbol->string 'hi) "hi") +(test (symbol->string (string->symbol "()")) "()") +(test (string->symbol (symbol->string 'hi)) 'hi) +(test (eq? (string->symbol "hi") 'hi) #t) +(test (eq? (string->symbol "hi") (string->symbol "hi")) #t) + +(test (string->symbol "hi") 'hi) + +(test (let ((str (symbol->string 'hi))) + ;(catch #t (lambda () (string-set! str 1 #\x)) (lambda args 'error)) ; can be disallowed + (symbol->string 'hi)) + "hi") + +(test (symbol->string 'sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789) + "sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789") +(test (string->symbol "sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789") + 'sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789) +(test (let ((sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 32)) + (+ sym0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 1)) + 33) + + + + +;;; -------------------------------------------------------------------------------- +;;; LISTS +;;; -------------------------------------------------------------------------------- + +(test (cons 'a '()) '(a)) +(test (cons '(a) '(b c d)) '((a) b c d)) +(test (cons "a" '(b c)) '("a" b c)) +(test (cons 'a 3) '(a . 3)) +(test (cons '(a b) 'c) '((a b) . c)) +(test (cons '() '()) '(())) +(test (cons '() 1) '(() . 1)) +(test (cons 1 2) '(1 . 2)) +(test (cons 1 '()) '(1)) +(test (cons '() 2) '(() . 2)) +(test (cons 1 (cons 2 (cons 3 (cons 4 '())))) '(1 2 3 4)) +(test (cons 'a 'b) '(a . b)) +(test (cons 'a (cons 'b (cons 'c '()))) '(a b c)) +(test (cons 'a (list 'b 'c 'd)) '(a b c d)) +(test (cons 'a (cons 'b (cons 'c 'd))) '(a b c . d)) +(test '(a b c d e) '(a . (b . (c . (d . (e . ())))))) +(test (cons (cons 1 2) (cons 3 4)) '((1 . 2) 3 . 4)) +(test (list (cons 1 2) (cons 3 4)) '((1 . 2) (3 . 4))) +(test (cons (cons 1 (cons 2 3)) 4) '((1 . (2 . 3)) . 4)) +(test (cons (cons 1 (cons 2 '())) (cons 1 2)) '((1 2) . (1 . 2))) +(test (let ((lst (list 1 2))) (list (apply cons lst) lst)) '((1 . 2) (1 2))) +(test (let ((lst (list 1 2))) (list lst (apply cons lst))) '((1 2) (1 . 2))) +(test (cdadr (let ((lst (list 1 2))) (list (apply cons lst) lst))) '(2)) + +(test (car (list 1 2 3)) 1) +(test (car (cons 1 2)) 1) +(test (car (list 1)) 1) +(test (car '(1 2 3)) 1) +(test (car '(1)) 1) +(test (car '(1 . 2)) 1) +(test (car '((1 2) 3)) '(1 2)) +(test (car '(((1 . 2) . 3) 4)) '((1 . 2) . 3)) +(test (car (list (list) (list 1 2))) '()) +(test (car '(a b c)) 'a) +(test (car '((a) b c d)) '(a)) +(test (car (reverse (list 1 2 3 4))) 4) +(test (car (list 'a 'b 'c 'd 'e 'f 'g)) 'a) +(test (car '(a b c d e f g)) 'a) +(test (car '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((((1 2 3) 4) 5) (6 7))) +(test (car '(a)) 'a) +(test (car '(1 ^ 2)) 1) +;(test (car '(1 .. 2)) 1) +(test (car ''foo) 'quote) +(test (car '(1 2 . 3)) 1) + +(for-each + (lambda (arg) + (if (not (equal? (car (cons arg '())) arg)) + (begin + (display "(car '(") (display arg) (display ")) returned ") (display (car (cons arg '()))) (display "?") (newline)))) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + +(test (cdr (list 1 2 3)) '(2 3)) +(test (cdr (cons 1 2)) 2) +(test (cdr (list 1)) '()) +(test (cdr '(1 2 3)) '(2 3)) +(test (cdr '(1)) '()) +(test (cdr '(1 . 2)) 2) +(test (cdr '((1 2) 3)) '(3)) +(test (cdr '(((1 . 2) . 3) 4)) '(4)) +(test (cdr (list (list) (list 1 2))) '((1 2))) +(test (cdr '(a b c)) '(b c)) +(test (cdr '((a) b c d)) '(b c d)) +(test (equal? (cdr (reverse (list 1 2 3 4))) 4) #f) +(test (equal? (cdr (list 'a 'b 'c 'd 'e 'f 'g)) 'a) #f) +(test (cdr '((((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f) g)) '(g)) +(test (cdr '(a)) '()) +(test (cdr '(a b c d e f g)) '(b c d e f g)) +(test (cdr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((((u v w) x) y) ((q w e) r) (a b c) e f g)) +(test (cdr ''foo) '(foo)) +(test (cdr (cons (cons 1 2) (cons 3 4))) '(3 . 4)) +(test (cdr '(1 2 . 3)) '(2 . 3)) + +(for-each + (lambda (arg) + (if (not (equal? (cdr (cons '() arg)) arg)) + (begin + (display "(cdr '(() ") (display arg) (display ")) returned ") (display (cdr (cons '() arg))) (display "?") (newline)))) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + +(define (cons-r a b n) (if (= 0 n) (cons a b) (cons (cons-r (+ a 1) (+ b 1) (- n 1)) (cons-r (- a 1) (- b 1) (- n 1))))) +(define (list-r a b n) (if (= 0 n) (list a b) (list (list-r (+ a 1) (+ b 1) (- n 1)) (list-r (- a 1) (- b 1) (- n 1))))) + +(define lists (list (list 1 2 3) + (cons 1 2) + (list 1) + (list) + (list (list 1 2) (list 3 4)) + (list (list 1 2) 3) + '(1 . 2) + '(a b c) + '((a) b (c)) + '((1 2) (3 4)) + '((1 2 3) (4 5 6) (7 8 9)) + '(((1) (2) (3)) ((4) (5) (6)) ((7) (8) (9))) + '((((1 123) (2 124) (3 125) (4 126)) ((5) (6) (7) (8)) ((9) (10) (11) (12)) ((13) (14) (15) (16))) + (((21 127) (22 128) (23 129) (24 130)) ((25) (26) (27) (28)) ((29) (30) (31) (32)) ((33) (34) (35) (36))) + (((41 131) (42 132) (43 133) (44 134)) ((45) (46) (47) (48)) ((49) (50) (51) (52)) ((53) (54) (55) (56))) + (((61 135) (62 136) (63 137) (64 138)) ((65) (66) (67) (68)) ((69) (70) (71) (72)) ((73) (74) (75) (76))) + 321) + (cons 1 (cons 2 (cons 3 4))) + (cons (cons 2 (cons 3 4)) 5) + (cons '() 1) + (cons 1 '()) + (cons '() '()) + (list 1 2 (cons 3 4) 5 (list (list 6) 7)) + (cons-r 0 0 4) + (cons-r 0 0 5) + (cons-r 0 0 10) + (list-r 0 0 3) + (list-r 0 0 7) + (list-r 0 0 11) + ''a + )) +(define (caar-1 x) (car (car x))) +(define (cadr-1 x) (car (cdr x))) +(define (cdar-1 x) (cdr (car x))) +(define (cddr-1 x) (cdr (cdr x))) +(define (caaar-1 x) (car (car (car x)))) +(define (caadr-1 x) (car (car (cdr x)))) +(define (cadar-1 x) (car (cdr (car x)))) +(define (caddr-1 x) (car (cdr (cdr x)))) +(define (cdaar-1 x) (cdr (car (car x)))) +(define (cdadr-1 x) (cdr (car (cdr x)))) +(define (cddar-1 x) (cdr (cdr (car x)))) +(define (cdddr-1 x) (cdr (cdr (cdr x)))) +(define (caaaar-1 x) (car (car (car (car x))))) +(define (caaadr-1 x) (car (car (car (cdr x))))) +(define (caadar-1 x) (car (car (cdr (car x))))) +(define (caaddr-1 x) (car (car (cdr (cdr x))))) +(define (cadaar-1 x) (car (cdr (car (car x))))) +(define (cadadr-1 x) (car (cdr (car (cdr x))))) +(define (caddar-1 x) (car (cdr (cdr (car x))))) +(define (cadddr-1 x) (car (cdr (cdr (cdr x))))) +(define (cdaaar-1 x) (cdr (car (car (car x))))) +(define (cdaadr-1 x) (cdr (car (car (cdr x))))) +(define (cdadar-1 x) (cdr (car (cdr (car x))))) +(define (cdaddr-1 x) (cdr (car (cdr (cdr x))))) +(define (cddaar-1 x) (cdr (cdr (car (car x))))) +(define (cddadr-1 x) (cdr (cdr (car (cdr x))))) +(define (cdddar-1 x) (cdr (cdr (cdr (car x))))) +(define (cddddr-1 x) (cdr (cdr (cdr (cdr x))))) + +;(for-each +; (lambda (name op1 op2) +; (for-each +; (lambda (lst) +; (let ((val1 (catch #t (lambda () (op1 lst)) (lambda args 'error))) +; (val2 (catch #t (lambda () (op2 lst)) (lambda args 'error)))) +; (if (not (equal? val1 val2)) +; (begin +; (display "(") (display name) (display " ") (display lst) (display ")) returned ") (display val1) (display " ") (display val2) (newline))))) +; lists)) +; (list 'caar 'cadr 'cdar 'cddr 'caaar 'caadr 'cadar 'cdaar 'caddr 'cdddr 'cdadr 'cddar +; 'caaaar 'caaadr 'caadar 'cadaar 'caaddr 'cadddr 'cadadr 'caddar 'cdaaar +; 'cdaadr 'cdadar 'cddaar 'cdaddr 'cddddr 'cddadr 'cdddar) +; +; (list caar cadr cdar cddr caaar caadr cadar cdaar caddr cdddr cdadr cddar +; caaaar caaadr caadar cadaar caaddr cadddr cadadr caddar cdaaar +; cdaadr cdadar cddaar cdaddr cddddr cddadr cdddar) +; +; (list caar-1 cadr-1 cdar-1 cddr-1 caaar-1 caadr-1 cadar-1 cdaar-1 caddr-1 cdddr-1 cdadr-1 cddar-1 +; caaaar-1 caaadr-1 caadar-1 cadaar-1 caaddr-1 cadddr-1 cadadr-1 caddar-1 cdaaar-1 +; cdaadr-1 cdadar-1 cddaar-1 cdaddr-1 cddddr-1 cddadr-1 cdddar-1)) + + + +(test (equal? (cadr (list 'a 'b 'c 'd 'e 'f 'g)) 'b) #t) +(test (equal? (cddr (list 'a 'b 'c 'd 'e 'f 'g)) '(c d e f g)) #t) +(test (equal? (caddr (list 'a 'b 'c 'd 'e 'f 'g)) 'c) #t) +(test (equal? (cdddr (list 'a 'b 'c 'd 'e 'f 'g)) '(d e f g)) #t) +(test (equal? (cadddr (list 'a 'b 'c 'd 'e 'f 'g)) 'd) #t) +(test (equal? (cddddr (list 'a 'b 'c 'd 'e 'f 'g)) '(e f g)) #t) +(test (equal? (caadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '((u v w) x)) #t) +(test (equal? (cadar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(6 7)) #t) +(test (equal? (cdaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(5)) #t) +(test (equal? (cdadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(y)) #t) +(test (equal? (cddar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '()) #t) +(test (equal? (caaaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(1 2 3)) #t) +(test (equal? (caadar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 6) #t) +(test (equal? (caaddr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(q w e)) #t) +(test (equal? (cadaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 5) #t) +(test (equal? (cadadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 'y) #t) +(test (equal? (caddar (list (list (list (list (list 1 2 3) 4) 5) 1 6 (list 5 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) 6) #t) +(test (equal? (cadddr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(a b c)) #t) +(test (equal? (cdaaar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(4)) #t) +(test (equal? (cdaadr (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(x)) #t) +(test (equal? (cdadar (list (list (list (list (list 1 2 3) 4) 5) (list 6 7)) (list (list (list 'u 'v 'w) 'x) 'y) (list (list 'q 'w 'e) 'r) (list 'a 'b 'c) 'e 'f 'g)) '(7)) #t) + +(test (caar '((a) b c d e f g)) 'a) +(test (cadr '(a b c d e f g)) 'b) +(test (cdar '((a b) c d e f g)) '(b)) +(test (cddr '(a b c d e f g)) '(c d e f g)) +(test (caaar '(((a)) b c d e f g)) 'a) +(test (caadr '(a (b) c d e f g)) 'b) +(test (cadar '((a b) c d e f g)) 'b) +(test (caddr '(a b c d e f g)) 'c) +(test (cdaar '(((a b)) c d e f g)) '(b)) +(test (cdadr '(a (b c) d e f g)) '(c)) +(test (cddar '((a b c) d e f g)) '(c)) +(test (cdddr '(a b c d e f g)) '(d e f g)) +(test (caaaar '((((a))) b c d e f g)) 'a) +(test (caaadr '(a ((b)) c d e f g)) 'b) +(test (caadar '((a (b)) c d e f g)) 'b) +(test (caaddr '(a b (c) d e f g)) 'c) +(test (cadaar '(((a b)) c d e f g)) 'b) +(test (cadadr '(a (b c) d e f g)) 'c) +(test (caddar '((a b c) d e f g)) 'c) +(test (cadddr '(a b c d e f g)) 'd) +(test (cdaaar '((((a b))) c d e f g)) '(b)) +(test (cdaadr '(a ((b c)) d e f g)) '(c)) +(test (cdadar '((a (b c)) d e f g)) '(c)) +(test (cdaddr '(a b (c d) e f g)) '(d)) +(test (cddaar '(((a b c)) d e f g)) '(c)) +(test (cddadr '(a (b c d) e f g)) '(d)) +(test (cdddar '((a b c d) e f g)) '(d)) +(test (cddddr '(a b c d e f g)) '(e f g)) +(test (cadr '(1 2 . 3)) 2) +(test (cddr '(1 2 . 3)) 3) + +(test (caar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(((1 2 3) 4) 5)) +(test (cadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(((u v w) x) y)) +(test (cdar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((6 7))) +(test (cddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(((q w e) r) (a b c) e f g)) +(test (caaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((1 2 3) 4)) +(test (caadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((u v w) x)) +(test (cadar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(6 7)) +(test (caddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((q w e) r)) +(test (cdaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(5)) +(test (cdadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(y)) +(test (cddar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '()) +(test (cdddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '((a b c) e f g)) +(test (caaaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(1 2 3)) +(test (caaadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(u v w)) +(test (caadar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 6) +(test (caaddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(q w e)) +(test (cadaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 5) +(test (cadadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 'y) +(test (cadddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(a b c)) +(test (cdaaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(4)) +(test (cdaadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(x)) +(test (cdadar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(7)) +(test (cdaddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(r)) +(test (cddaar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '()) +(test (cddadr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '()) +(test (cddddr '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) '(e f g)) + +(test (cadr '(a b c d e f g)) 'b) +(test (cddr '(a b c d e f g)) '(c d e f g)) +(test (caddr '(a b c d e f g)) 'c) +(test (cdddr '(a b c d e f g)) '(d e f g)) +(test (cadddr '(a b c d e f g)) 'd) +(test (cddddr '(a b c d e f g)) '(e f g)) + +(test (caar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((a . b) c . d)) +(test (caar '(((a . b) c . d) (e . f) g . h)) '(a . b)) +(test (caar '((a . b) c . d)) 'a) +(test (cadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((i . j) k . l)) +(test (cadr '(((a . b) c . d) (e . f) g . h)) '(e . f)) +(test (cadr '((a . b) c . d)) 'c) +(test (cdar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((e . f) g . h)) +(test (cdar '(((a . b) c . d) (e . f) g . h)) '(c . d)) +(test (cdar '((a . b) c . d)) 'b) +(test (cddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '((m . n) o . p)) +(test (cddr '(((a . b) c . d) (e . f) g . h)) '(g . h)) +(test (cddr '((a . b) c . d)) 'd) +(test (caaar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(a . b)) +(test (caaar '(((a . b) c . d) (e . f) g . h)) 'a) +(test (caadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(i . j)) +(test (caadr '(((a . b) c . d) (e . f) g . h)) 'e) +(test (cddar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(g . h)) +(test (cddar '(((a . b) c . d) (e . f) g . h)) 'd) +(test (cdddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) '(o . p)) +(test (cdddr '(((a . b) c . d) (e . f) g . h)) 'h) +(test (caaaar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'a) +(test (caaadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'i) +(test (caddar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'g) +(test (cadddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'o) +(test (cdaaar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'b) +(test (cdaadr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'j) +(test (cdddar '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'h) +(test (cddddr '((((a . b) c . d) (e . f) g . h) ((i . j) k . l) (m . n) o . p)) 'p) + +(test (cadr ''foo) 'foo) + + +(test (length (list 'a 'b 'c 'd 'e 'f)) 6) +(test (length (list 'a 'b 'c 'd)) 4) +(test (length (list 'a (list 'b 'c) 'd)) 3) +(test (length '()) 0) +(test (length '(this-that)) 1) +(test (length '(this - that)) 3) +(test (length '(a b)) 2) +(test (length '(a b c)) 3) +(test (length '(a (b) (c d e))) 3) +(test (length (list 1 (cons 1 2))) 2) +(test (length (list 1 (cons 1 '()))) 2) + + +(test (reverse '(a b c d)) '(d c b a)) +(test (reverse '(a b c)) '(c b a)) +(test (reverse '(a (b c) d (e (f)))) '((e (f)) d (b c) a)) +(test (reverse '()) '()) +(test (reverse (list 1 2 3)) '(3 2 1)) +(test (reverse (list 1)) '(1)) +(test (reverse (list)) (list)) +(test (reverse '(1 2 3)) (list 3 2 1)) +(test (reverse '(1)) '(1)) +(test (reverse '((1 2) 3)) '(3 (1 2))) +(test (reverse '(((1 . 2) . 3) 4)) '(4 ((1 . 2) . 3))) +(test (reverse (list (list) (list 1 2))) '((1 2) ())) +(test (reverse '((a) b c d)) '(d c b (a))) +(test (reverse (reverse (list 1 2 3 4))) (list 1 2 3 4)) +(test (reverse ''foo) '(foo quote)) +(test (let ((x (list 1 2 3 4))) + (let ((y (reverse x))) + (and (equal? x (list 1 2 3 4)) + (equal? y (list 4 3 2 1))))) + #t) +(test (letrec ((hi (lambda (lst n) + (if (= n 0) + lst + (hi (reverse lst) (- n 1)))))) + (hi (list 1 2 3) 100)) + (list 1 2 3)) +(test (let ((var (list 1 2 3))) (reverse (cdr var)) var) (list 1 2 3)) +(test (let ((var '(1 2 3))) (reverse (cdr var)) var) '(1 2 3)) +(test (let ((var (list 1 (list 2 3)))) (reverse (cdr var)) var) (list 1 (list 2 3))) +(test (let ((var '(1 (2 3)))) (reverse (cdr var)) var) '(1 (2 3))) +(test (let ((var (list (list 1 2) (list 3 4 5)))) (reverse (car var)) var) '((1 2) (3 4 5))) +(test (let ((x '(1 2 3))) (list (reverse x) x)) '((3 2 1) (1 2 3))) + +(for-each + (lambda (lst) + (if (list? lst) + (if (not (equal? lst (reverse (reverse lst)))) + (begin + (display "(reverse (reverse ") (display lst) (display ")) returned ") (display (reverse (reverse lst))) (newline))))) + lists) + +(for-each + (lambda (lst) + (if (list? lst) + (if (not (equal? lst (reverse (reverse (reverse (reverse lst)))))) + (begin + (display "(reverse...(4x) ") (display lst) (display ")) returned ") (display (reverse (reverse (reverse (reverse lst))))) (newline))))) + lists) + + + +(test (pair? 'a) #f) +(test (pair? '()) #f) +(test (pair? '(a b c)) #t) +(test (pair? (cons 1 2)) #t) +(test (pair? ''()) #t) +(test (pair? #f) #f) +(test (pair? (make-vector 6)) #f) +(test (pair? #t) #f) +(test (pair? '(a . b)) #t) +(test (pair? '#(a b)) #f) +(test (pair? (list 1 2)) #t) +(test (pair? (list)) #f) +(test (pair? ''foo) #t) +(test (pair? (list 'a 'b 'c 'd 'e 'f)) #t) +(test (pair? '(this-that)) #t) +(test (pair? '(this - that)) #t) +(let ((x (list 1 2))) + (set-cdr! x x) + (test (pair? x) #t)) +(test (pair? (list 1 (cons 1 2))) #t) +(test (pair? (list 1 (cons 1 '()))) #t) +(test (pair? (cons 1 '())) #t) +(test (pair? (cons '() '())) #t) +(test (pair? (cons '() 1)) #t) +(test (pair? (list (list))) #t) +(test (pair? '(())) #t) +(test (pair? (cons 1 (cons 2 3))) #t) + +(for-each + (lambda (arg) + (if (pair? arg) + (begin + (display "(pair? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + + +(test (list? 'a) #f) +(test (list? '()) #t) +(test (list? '(a b c)) #t) +(test (list? (cons 1 2)) #f) +(test (list? ''()) #t) +(test (list? #f) #f) +(test (list? (make-vector 6)) #f) +(test (list? #t) #f) +(test (list? '(a . b)) #f) +(test (list? '#(a b)) #f) +(test (list? (list 1 2)) #t) +(test (list? (list)) #t) +(test (list? ''foo) #t) +(test (list? (list 'a 'b 'c 'd 'e 'f)) #t) +(test (list? '(this-that)) #t) +(test (list? '(this - that)) #t) +(let ((x (list 1 2))) + (set-cdr! x x) + (test (list? x) #f)) +(test (list? (list 1 (cons 1 2))) #t) +(test (list? (list 1 (cons 1 '()))) #t) +(test (list? (cons 1 '())) #t) +(test (list? (cons '() '())) #t) +(test (list? (cons '() 1)) #f) +(test (list? (list (list))) #t) +(test (list? '(())) #t) +(test (list? '(1 2 . 3)) #f) +(test (list? (cons 1 (cons 2 3))) #f) + +(for-each + (lambda (arg) + (if (list? arg) + (begin + (display "(list? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + + +(test (null? 'a) '#f) +(test (null? '()) #t) +(test (null? '(a b c)) #f) +(test (null? (cons 1 2)) #f) +(test (null? ''()) #f) +(test (null? #f) #f) +(test (null? (make-vector 6)) #f) +(test (null? #t) #f) +(test (null? '(a . b)) #f) +(test (null? '#(a b)) #f) +(test (null? (list 1 2)) #f) +(test (null? (list)) #t) +(test (null? ''foo) #f) +(test (null? (list 'a 'b 'c 'd 'e 'f)) #f) +(test (null? '(this-that)) #f) +(test (null? '(this - that)) #f) +(let ((x (list 1 2))) + (set-cdr! x x) + (test (null? x) #f)) +(test (null? (list 1 (cons 1 2))) #f) +(test (null? (list 1 (cons 1 '()))) #f) +(test (null? (cons 1 '())) #f) +(test (null? (cons '() '())) #f) +(test (null? (cons '() 1)) #f) +(test (null? (list (list))) #f) +(test (null? '(())) #f) +(test (null? '#()) #f) + +(for-each + (lambda (arg) + (if (null? arg) + (begin + (display "(null? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + +(test (let ((x (cons 1 2))) (set-car! x 3) x) (cons 3 2)) +(test (let ((x (list 1 2))) (set-car! x 3) x) (list 3 2)) +(test (let ((x (list (list 1 2) 3))) (set-car! x 22) x) (list 22 3)) +(test (let ((x (cons 1 2))) (set-car! x '()) x) (cons '() 2)) +(test (let ((x (list 1 (list 2 3 4)))) (set-car! x (list 5 (list 6))) x) (list (list 5 (list 6)) (list 2 3 4))) +;(test (let ((x '(((1) 2) (3)))) (set-car! x '((2) 1)) x) '(((2) 1) (3))) +;(test (let ((x ''foo)) (set-car! x "hi") x) (list "hi" 'foo)) +;(test (let ((x '((1 . 2) . 3))) (set-car! x 4) x) '(4 . 3)) +;(test (let ((x '(1 . 2))) (set-car! x (cdr x)) x) '(2 . 2)) +;(test (let ((x '(1 . 2))) (set-car! x x) (list? x)) #f) +(test (let ((x (list 1))) (set-car! x '()) x) '(())) +;(test (let ((x '(((1 2) . 3) 4))) (set-car! x 1) x) '(1 4)) + + +(test (let ((x (cons 1 2))) (set-cdr! x 3) x) (cons 1 3)) +(test (let ((x (list 1 2))) (set-cdr! x 3) x) (cons 1 3)) +(test (let ((x (list (list 1 2) 3))) (set-cdr! x 22) x) '((1 2) . 22)) +(test (let ((x (cons 1 2))) (set-cdr! x '()) x) (list 1)) +(test (let ((x (list 1 (list 2 3 4)))) (set-cdr! x (list 5 (list 6))) x) '(1 5 (6))) +;(test (let ((x '(((1) 2) (3)))) (set-cdr! x '((2) 1)) x) '(((1) 2) (2) 1)) +;(test (let ((x ''foo)) (set-cdr! x "hi") x) (cons 'quote "hi")) +;(test (let ((x '((1 . 2) . 3))) (set-cdr! x 4) x) '((1 . 2) . 4)) +;(test (let ((x '(1 . 2))) (set-cdr! x (cdr x)) x) '(1 . 2)) +;(test (let ((x '(1 . 2))) (set-cdr! x x) (list? x)) #f) +(test (let ((x (list 1))) (set-cdr! x '()) x) (list 1)) +;(test (let ((x '(1 . (2 . (3 (4 5)))))) (set-cdr! x 4) x) '(1 . 4)) + + + +(test (list-ref (list 1 2) 1) 2) +(test (list-ref '(a b c d) 2) 'c) +(test (list-ref (cons 1 2) 0) 1) ; !! +(test (list-ref ''foo 0) 'quote) +(test (list-ref '((1 2) (3 4)) 1) '(3 4)) +(test (list-ref (list-ref (list (list 1 2) (list 3 4)) 1) 1) 4) +(test (let ((x (list 1 2 3))) (list-ref x (list-ref x 1))) 3) +; (list-ref '(1 2 . 3) 0) -- why is this acceptable? + +;(for-each +; (lambda (name op1 op2) +; (for-each +; (lambda (lst) +; (let ((val1 (catch #t (lambda () (op1 lst)) (lambda args 'error))) +; (val2 (catch #t (lambda () (op2 lst)) (lambda args 'error)))) +; (if (not (equal? val1 val2)) +; (begin +; (display "(") (display name) (display " ") (display lst) (display ")) returned ") (display val1) (display " ") (display val2) (newline))))) +; lists)) +; (list 'list-ref:0 'list-ref:1 'list-ref:2 'list-ref:3) +; (list car cadr caddr cadddr) +; (list (lambda (l) (list-ref l 0)) (lambda (l) (list-ref l 1)) (lambda (l) (list-ref l 2)) (lambda (l) (list-ref l 3)))) + +(for-each + (lambda (arg) + (test (list-ref (list 1 arg) 1) arg)) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + +;(test (let ((x '(1 . 2))) (set-cdr! x x) (list-ref x 0)) 1) +;(test (let ((x '(1 . 2))) (set-cdr! x x) (list-ref x 1)) 1) +;(test (let ((x '(1 . 2))) (set-cdr! x x) (list-ref x 100)) 1) + + + +(test (let ((tree1 (list 1 (list 1 2) (list (list 1 2 3)) (list (list (list 1 2 3 4)))))) tree1) '(1 (1 2) ((1 2 3)) (((1 2 3 4))))) +(test (let ((tree2 (list "one" (list "one" "two") (list (list "one" "two" "three"))))) tree2) '("one" ("one" "two") (("one" "two" "three")))) +(test (let ((tree1 (list 1 (list 1 2) (list 1 2 3) (list 1 2 3 4)))) tree1) '(1 (1 2) (1 2 3) (1 2 3 4))) +(test (let ((tree1 (list 1 (list 1 2))) (tree2 (list 1 (list 1 2)))) tree2) '(1 (1 2))) +(test (let ((tree1 (list 1 (list 1 2))) (tree2 (list 1 (list 1 2)))) (eqv? tree1 tree2)) #f) +(test (let ((tree1 (list ''a (list ''b ''c))) (tree2 (list ''a (list ''b ''c)))) tree2) '('a ('b 'c))) +(test (let ((lst (list 1 (list 2 3)))) lst) '(1 (2 3))) +(test (let* ((lst (list 1 (list 2 3))) (slst lst)) slst) '(1 (2 3))) +(test (list 1) '(1)) +(test (let ((a 1)) (list a 2)) '(1 2)) +(test (let ((a 1)) (list 'a '2)) '(a 2)) +(test (let ((a 1)) (list 'a 2)) '(a 2)) +(test (list) '()) +(test (let ((a (list 1 2))) a) '(1 2)) +(test (let ((a (list 1 2))) (list 3 4 'a (car (cons 'b 'c)) (+ 6 -2))) '(3 4 a b 4)) +(test (list) '()) +;(test (length (list quote do map call/cc lambda define if begin set! let let* cond and or for-each)) 15) +(test (length (list quote do map lambda if begin set! let let* cond and or for-each)) 13) + + +(test (list-tail '(1 2 3) 0) '(1 2 3)) +(test (list-tail '(1 2 3) 2) '(3)) +(test (list-tail '(1 2 3) 3) '()) +(test (list-tail '(1 2 3 . 4) 2) '(3 . 4)) +(test (list-tail '(1 2 3 . 4) 3) 4) +(test (let ((x (list 1 2 3))) (eq? (list-tail x 2) (cddr x))) #t) +(test (list-tail '() 0) '()) +(test (list-tail (list 1 2) 2) '()) +(test (list-tail (cons 1 2) 0) '(1 . 2)) +(test (list-tail (cons 1 2) 1) 2) +(test (list-tail ''foo 1) '(foo)) +(test (list-tail '((1 2) (3 4)) 1) '((3 4))) +(test (list-tail (list-tail (list-tail '(1 2 3 4) 1) 1) 1) '(4)) + +;(let ((x '(1 . 2))) (set-cdr! x x) (test (list-tail x 0) x)) +;(let ((x '(1 . 2))) (set-cdr! x x) (test (list-tail x 1) (cdr x))) +;(let ((x '(1 . 2))) (set-cdr! x x) (test (list-tail x 100) x)) + +;(for-each +; (lambda (name op1 op2) +; (for-each +; (lambda (lst) +; (let ((val1 (catch #t (lambda () (op1 lst)) (lambda args 'error))) +; (val2 (catch #t (lambda () (op2 lst)) (lambda args 'error)))) +; (if (not (equal? val1 val2)) +; (begin +; (display "(") (display name) (display " ") (display lst) (display ")) returned ") (display val1) (display " ") (display val2) (newline))))) +; lists)) +; (list 'list-tail:0 'list-tail:1 'list-tail:2 'list-tail:3 'list-tail:4) +; (list (lambda (l) l) cdr cddr cdddr cddddr) +; (list (lambda (l) (list-tail l 0)) (lambda (l) (list-tail l 1)) (lambda (l) (list-tail l 2)) (lambda (l) (list-tail l 3)) (lambda (l) (list-tail l 4)))) + + + +(let ((e '((a 1) (b 2) (c 3)))) + (test (assq 'a e) '(a 1)) + (test (assq 'b e) '(b 2)) + (test (assq 'd e) #f)) +(test (assq (list 'a) '(((a)) ((b)) ((c)))) #f) + +(let ((xcons (cons 1 2)) + (xvect (vector 1 2)) + (xlambda (lambda () 1)) + (xstr "abs")) + (let ((e (list (list #t 1) (list #f 2) (list 'a 3) (list xcons 4) (list xvect 5) (list xlambda 6) (list xstr 7) (list car 8)))) + (test (assq #t e) (list #t 1)) + (test (assq #f e) (list #f 2)) + (test (assq 'a e) (list 'a 3)) + (test (assq xcons e) (list xcons 4)) + (test (assq xvect e) (list xvect 5)) + (test (assq xlambda e) (list xlambda 6)) + (test (assq xstr e) (list xstr 7)) + (test (assq car e) (list car 8)))) + +(let ((e '((1+i 1) (3.0 2) (5/3 3)))) + (test (assq 1+i e) #f) + (test (assq 3.0 e) #f) + (test (assq 5/3 e) #f)) + + + +(let ((e '((a 1) (b 2) (c 3)))) + (test (assv 'a e) '(a 1)) + (test (assv 'b e) '(b 2)) + (test (assv 'd e) #f)) +(test (assv (list 'a) '(((a)) ((b)) ((c)))) #f) + +(let ((xcons (cons 1 2)) + (xvect (vector 1 2)) + (xlambda (lambda () 1)) + (xstr "abs")) + (let ((e (list (list #t 1) (list #f 2) (list 'a 3) (list xcons 4) (list xvect 5) (list xlambda 6) (list xstr 7) (list car 8)))) + (test (assv #t e) (list #t 1)) + (test (assv #f e) (list #f 2)) + (test (assv 'a e) (list 'a 3)) + (test (assv xcons e) (list xcons 4)) + (test (assv xvect e) (list xvect 5)) + (test (assv xlambda e) (list xlambda 6)) + (test (assv xstr e) (list xstr 7)) + (test (assv car e) (list car 8)))) + +(let ((e '((1+i 1) (3.0 2) (5/3 3) (#\a 4) ("hiho" 5)))) + (test (assv 1+i e) '(1+i 1)) + (test (assv 3.0 e) '(3.0 2)) + (test (assv 5/3 e) '(5/3 3)) + (test (assv #\a e) '(#\a 4)) + (test (assv "hiho" e) #f)) + +(let ((e '(((a) 1) (#(a) 2) ("c" 3)))) + (test (assv '(a) e) #f) + (test (assv '#(a) e) #f) + (test (assv (string #\c) e) #f)) + +;(let ((lst '((2 . a) (3 . b)))) +; (set-cdr! (assv 3 lst) 'c) +; (test lst '((2 . a) (3 . c)))) + + +(let ((e '((a 1) (b 2) (c 3)))) + (test (assoc 'a e) '(a 1)) + (test (assoc 'b e) '(b 2)) + (test (assoc 'd e) #f)) +(test (assoc (list 'a) '(((a)) ((b)) ((c)))) '((a))) + +(let ((xcons (cons 1 2)) + (xvect (vector 1 2)) + (xlambda (lambda () 1)) + (xstr "abs")) + (let ((e (list (list #t 1) (list #f 2) (list 'a 3) (list xcons 4) (list xvect 5) (list xlambda 6) (list xstr 7) (list car 8)))) + (test (assoc #t e) (list #t 1)) + (test (assoc #f e) (list #f 2)) + (test (assoc 'a e) (list 'a 3)) + (test (assoc xcons e) (list xcons 4)) + (test (assoc xvect e) (list xvect 5)) + (test (assoc xlambda e) (list xlambda 6)) + (test (assoc xstr e) (list xstr 7)) + (test (assoc car e) (list car 8)))) + +(let ((e '((1+i 1) (3.0 2) (5/3 3) (#\a 4) ("hiho" 5)))) + (test (assoc 1+i e) '(1+i 1)) + (test (assoc 3.0 e) '(3.0 2)) + (test (assoc 5/3 e) '(5/3 3)) + (test (assoc #\a e) '(#\a 4)) + (test (assoc "hiho" e) '("hiho" 5))) + +(let ((e '(((a) 1) (#(a) 2) ("c" 3)))) + (test (assoc '(a) e) '((a) 1)) + (test (assoc '#(a) e) '(#(a) 2)) + (test (assoc (string #\c) e) '("c" 3))) + +(test (assoc 'a '((b c) (a u) (a i))) '(a u)) +(test (assoc 'a '((b c) ((a) u) (a i))) '(a i)) +(test (assoc (list 'a) '(((a)) ((b)) ((c)))) '((a))) +(test (assoc 5 '((2 3) (5 7) (11 13))) '(5 7)) + + +(test (append '(a b c) '()) '(a b c)) +(test (append '() '(a b c)) '(a b c)) +(test (append '(a b) '(c d)) '(a b c d)) +(test (append '(a b) 'c) '(a b . c)) +(test (equal? (append (list 'a 'b 'c) (list 'd 'e 'f) '() '(g)) '(a b c d e f g)) #t) +(test (append (list 'a 'b 'c) (list 'd 'e 'f) '() (list 'g)) '(a b c d e f g)) +(test (append (list 'a 'b 'c) 'd) '(a b c . d)) +(test (append '() '()) '()) +(test (append '() (list 'a 'b 'c)) '(a b c)) +(test (append) '()) +(test (append 'a) 'a) +(test (append '(x) '(y)) '(x y)) +(test (append '(a) '(b c d)) '(a b c d)) +(test (append '(a (b)) '((c))) '(a (b) (c))) +(test (append '(a b) '(c . d)) '(a b c . d)) +(test (append '() 'a) 'a) +(test (append '(a b) (append (append '(c)) '(e) 'f)) '(a b c e . f)) +(test (append ''foo 'foo) '(quote foo . foo)) +(test (append '() (cons 1 2)) '(1 . 2)) +(test (append '() '() '()) '()) +(test (append (cons 1 2)) '(1 . 2)) + +(test (append #f) #f) +(test (append '() #f) #f) +(test (append '(1 2) #f) '(1 2 . #f)) +(test (append '() '() #f) #f) +(test (append '() '(1 2) #f) '(1 2 . #f)) +(test (append '(1 2) '() #f) '(1 2 . #f)) +(test (append '(1 2) '(3 4) #f) '(1 2 3 4 . #f)) +(test (append '() '() '() #f) #f) +(test (append '(1 2) '(3 4) '(5 6) #f) '(1 2 3 4 5 6 . #f)) + + +(test (memq 'a '(a b c)) '(a b c)) +(test (memq 'b '(a b c)) '(b c)) +(test (memq 'a '(b c d)) #f) +(test (memq (list 'a) '(b (a) c)) #f) +(test (memq 'a '(b a c a d a)) '(a c a d a)) +(let ((v (vector 'a))) (test (memq v (list 'a 1.2 v "hi")) (list v "hi"))) + + +(test (memv 101 '(100 101 102)) '(101 102)) +(test (memv 3.4 '(1.2 2.3 3.4 4.5)) '(3.4 4.5)) +(test (memv 3.4 '(1.3 2.5 3.7 4.9)) #f) +(let ((ls (list 'a 'b 'c))) + (set-car! (memv 'b ls) 'z) + (test ls '(a z c))) + + +(test (member (list 'a) '(b (a) c)) '((a) c)) +(test (member "b" '("a" "c" "b")) '("b")) +(test (member 1 '(3 2 1 4)) '(1 4)) +(test (member car (list abs car modulo)) (list car modulo)) +(test (member do (list quote map do)) (list do)) +(test (member 5/2 (list 1/3 2/4 5/2)) '(5/2)) + + + + + +;;; -------------------------------------------------------------------------------- +;;; VECTORS +;;; -------------------------------------------------------------------------------- + +(test (vector? (make-vector 6)) #t) +(test (vector? (make-vector 6 #\a)) #t) +(test (vector? (make-vector 0)) #t) +;; (test (vector? #*1011) #f) +(test (vector? '#(0 (2 2 2 2) "Anna")) #t) +(test (vector? '#()) #t) +(test (vector? '#("hi")) #t) +(test (vector? (vector 1)) #t) +(test (let ((v (vector 1 2 3))) (vector? v)) #t) + +(for-each + (lambda (arg) + (test (vector? arg) #f)) + (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + +(test (let ((v (make-vector 3 #f))) (and (vector? v) (= (vector-length v) 3) (eq? (vector-ref v 1) #f))) #t) +(test (let ((v (make-vector 1 1))) (and (vector? v) (= (vector-length v) 1) (vector-ref v 0))) 1) +(test (let ((v (make-vector 0 1))) (and (vector? v) (= (vector-length v) 0))) #t) +(test (do ((vec (make-vector 5)) (i 0 (+ i 1))) ((= i 5) vec) (vector-set! vec i i)) '#(0 1 2 3 4)) +(test (let ((v (make-vector 5))) (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4)) v) '#(0 1 4 9 16)) +(test (make-vector 2 'hi) '#(hi hi)) +(test (make-vector 0) '#()) +(test (make-vector 0 'hi) '#()) +(test (make-vector 3 (make-vector 1 'hi)) '#(#(hi) #(hi) #(hi))) +(test (make-vector 3 '#(hi)) '#(#(hi) #(hi) #(hi))) +(test (make-vector 3 (list)) '#(() () ())) +(test (make-vector 3 (make-vector 1 (make-vector 1 'hi))) '#(#(#(hi)) #(#(hi)) #(#(hi)))) + +(for-each + (lambda (arg) + (test (vector-ref (make-vector 1 arg) 0) arg)) + (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1)))) + +(test (vector 1 2 3) '#(1 2 3)) +(test (vector 1 '(2) 3) '#(1 (2) 3)) +(test (vector) '#()) +(test (vector (vector (vector))) '#(#(#()))) +(test (vector (vector) (vector) (vector)) '#(#() #() #())) +(test (vector (list)) '#(())) +(test '#(1 #\a "hi" hi) (vector 1 #\a "hi" 'hi)) +(test (let ((v (make-vector 4 "hi"))) + (vector-set! v 0 1) + (vector-set! v 1 #\a) + (vector-set! v 3 'hi) + v) + '#(1 #\a "hi" hi)) +(let ((x 34)) + (test (vector x 'x) '#(34 x))) + +(for-each + (lambda (arg) + (test (vector-ref (vector arg) 0) arg)) + (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1)))) + + + +(test (vector->list '#(0)) (list 0)) +(test (vector->list (vector)) '()) +(test (vector->list '#(a b c)) '(a b c)) +(test (vector->list '#(#(0) #(1))) '(#(0) #(1))) +(test (vector? (list-ref (let ((v (vector 1 2))) (vector-set! v 1 v) (vector->list v)) 1)) #t) + +(test (list->vector '()) '#()) +(test (list->vector '(a b c)) '#(a b c)) +(test (list->vector (list (list 1 2) (list 3 4))) '#((1 2) (3 4))) +(test (list->vector ''foo) '#(quote foo)) +(test (list->vector (list)) '#()) +(test (list->vector (list 1)) '#(1)) +(test (list->vector (list (list))) '#(())) +(test (list->vector (list 1 #\a "hi" 'hi)) '#(1 #\a "hi" hi)) + +(for-each + (lambda (arg) + (if (list? arg) + (test (vector->list (list->vector arg)) arg))) + lists) + +(test (list->vector (vector->list (vector))) '#()) +(test (list->vector (vector->list (vector 1))) '#(1)) +(test (vector->list (list->vector (list))) '()) +(test (vector->list (list->vector (list 1))) '(1)) + + + +(test (vector-length (vector)) 0) +(test (vector-length (vector 1)) 1) +(test (vector-length (make-vector 128)) 128) +(test (vector-length '#(a b c d e f)) 6) +(test (vector-length '#()) 0) +(test (vector-length (vector #\a (list 1 2) (vector 1 2))) 3) +(test (vector-length '#(#(#(hi)) #(#(hi)) #(#(hi)))) 3) +(test (vector-length (vector 1 2 3 4)) 4) +(test (vector-length (let ((v (vector 1 2))) (vector-set! v 1 v) v)) 2) +(test (vector-length (let ((v (vector 1 2))) (vector-set! v 1 v) (vector-ref v 1))) 2) + + +(test (vector-ref '#(1 1 2 3 5 8 13 21) 5) 8) +(test (vector-ref '#(1 1 2 3 5 8 13 21) (let ((i (round (* 2 (acos -1))))) (if (inexact? i) (inexact->exact i) i))) 13) +(test (let ((v (make-vector 1 0))) (vector-ref v 0)) 0) +(test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref v 1)) (list 2)) +(test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref v 2)) '#(#\a #\a #\a)) +(test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref (vector-ref v 2) 1)) #\a) +(test (vector-ref '#(a b c) 1) 'b) +(test (vector-ref '#(()) 0) '()) +(test (vector-ref '#(#()) 0) '#()) +(test (vector-ref (vector-ref (vector-ref '#(1 (2) #(3 (4) #(5))) 2) 2) 0) 5) +(test (let ((v (vector 1 2))) (vector-set! v 1 v) (eq? (vector-ref v 1) v)) #t) + + +(test (let ((vec (vector 0 '(2 2 2 2) "Anna"))) (vector-set! vec 1 '("Sue" "Sue")) vec) '#(0 ("Sue" "Sue") "Anna")) +(test (let ((v (vector 1 2 3))) (vector-set! v 1 32) v) '#(1 32 3)) +(let ((v (make-vector 8 #f))) + (for-each + (lambda (arg) + (vector-set! v 1 arg) + (test (vector-ref v 1) arg)) + (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1))))) +(test (let ((v (vector 1 2 3))) (vector-set! v 1 0) v) '#(1 0 3)) +(test (let ((v (vector #f))) (vector-set! v 0 (vector)) v) '#(#())) +(test (let ((v (vector 1 (list 2) (vector 1 2 3)))) (vector-set! (vector-ref v 2) 0 21) v) '#(1 (2) #(21 2 3))) + + + +(test (let ((v (vector 1 2 3))) (vector-fill! v 0) v) '#(0 0 0)) +(test (let ((v (vector))) (vector-fill! v #f) v) '#()) +(let ((v (make-vector 8 #f))) + (for-each + (lambda (arg) + (vector-fill! v arg) + (test (vector-ref v 1) arg)) + (list #\a 1 '() (list 1) '(1 . 2) #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1))))) + +;(let ((str "hi") (v (make-vector 3))) (vector-fill! v str) (string-set! (vector-ref v 0) 1 #\a) str) -> mutable string error +;(let ((lst (list 1 2)) (v (make-vector 3))) (vector-fill! v lst) (list-set! (vector-ref v 0) 1 #\a) lst) -> '(1 #\a) + + +;(if (provided? 'multidimensional-vectors) +; (let ((v1 (make-vector 3 1))) +; (num-test (v1 1) 1) +; (set! (v1 1) 2) +; (num-test (v1 1) 2) +; (let ((i0 0) +; (i2 2)) +; (num-test (v1 i0) 1) +; (num-test (vector-ref v1 i2) 1) +; (set! (v1 i0) 0) +; (num-test (v1 0) 0) +; (set! (v1 i0) i2) +; (num-test (v1 i0) i2)) +; (test (vector-dimensions v1) '(3)) +; (set! v1 (make-vector '(3 2))) +; (test (vector-dimensions v1) '(3 2)) +; (vector-set! v1 1 1 0) +; (num-test (vector-ref v1 1 1) 0) +; (let ((i0 1) +; (i1 1) +; (i2 32)) +; (set! (v1 i0 i1) i2) +; (num-test (vector-ref v1 1 1) 32) +; (num-test (v1 i0 i1) i2) +; (vector-set! v1 0 1 3) +; (num-test (v1 0 1) 3) +; (num-test (v1 1 1) 32)) +; (set! v1 (make-vector '(2 4 3) 1)) +; (test (vector-dimensions v1) '(2 4 3)) +; (num-test (vector-ref v1 1 1 1) 1) +; (vector-set! v1 0 0 0 32) +; (num-test (v1 0 0 0) 32) +; (set! (v1 0 1 1) 3) +; (num-test (v1 0 1 1) 3))) + + +(set! lists '()) + + + +;;; -------------------------------------------------------------------------------- +;;; PORTS +;;; -------------------------------------------------------------------------------- + +(define start-input-port (current-input-port)) +(define start-output-port (current-output-port)) + +(test (input-port? (current-input-port)) #t) + +(for-each + (lambda (arg) + (if (input-port? arg) + (begin + (display "(input-port? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" #f (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) 3.14 3/4 1.0+1.0i #\f)) + +(test (call-with-input-file "r5rstest.scm" input-port?) #t) +(if (not (eq? start-input-port (current-input-port))) + (begin (display "call-with-input-file did not restore current-input-port? ") (display start-input-port) (display " ") (display (current-input-port)) (newline))) + +(test (let ((this-file (open-input-file "r5rstest.scm"))) (let ((res (input-port? this-file))) (close-input-port this-file) res)) #t) +(if (not (eq? start-input-port (current-input-port))) + (begin (display "open-input-file clobbered current-input-port? ") (display start-input-port) (display " ") (display (current-input-port)) (newline))) + +(test (output-port? (current-output-port)) #t) +(write-char #\space (current-output-port)) +(write " " (current-output-port)) +(newline (current-output-port)) + + +(for-each + (lambda (arg) + (if (output-port? arg) + (begin + (display "(output-port? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" #f (integer->char 65) 1 (list 1 2) '#t '3 (make-vector 3) 3.14 3/4 1.0+1.0i #\f)) + +(test (call-with-output-file "tmp1.r5rs" output-port?) #t) +(if (not (eq? start-output-port (current-output-port))) + (begin (display "call-with-output-file did not restore current-output-port? ") (display start-output-port) (display " ") (display (current-output-port)) (newline))) + +(test (let ((this-file (open-output-file "tmp1.r5rs"))) (let ((res (output-port? this-file))) (close-output-port this-file) res)) #t) +(if (not (eq? start-output-port (current-output-port))) + (begin (display "open-output-file clobbered current-output-port? ") (display start-output-port) (display " ") (display (current-output-port)) (newline))) + +(for-each + (lambda (arg) + (if (eof-object? arg) + (begin + (display "(eof-object? ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" -1 #\a 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1)))) + +(call-with-output-file "tmp1.r5rs" (lambda (p) (display "3.14" p))) +(test (call-with-input-file "tmp1.r5rs" (lambda (p) (read p) (let ((val (read p))) (eof-object? val)))) #t) + + +(test (call-with-input-file "tmp1.r5rs" (lambda (p) (read-char p))) #\3) +(test (call-with-input-file "tmp1.r5rs" (lambda (p) (peek-char p))) #\3) +(test (call-with-input-file "tmp1.r5rs" (lambda (p) (peek-char p) (read-char p))) #\3) +(test (call-with-input-file "tmp1.r5rs" (lambda (p) (list->string (list (read-char p) (read-char p) (read-char p) (read-char p))))) "3.14") +(test (call-with-input-file "tmp1.r5rs" (lambda (p) (list->string (list (read-char p) (peek-char p) (read-char p) (read-char p) (peek-char p) (read-char p))))) "3..144") + +(for-each + (lambda (arg) + (call-with-output-file "tmp1.r5rs" (lambda (p) (write arg p))) + (test (call-with-input-file "tmp1.r5rs" (lambda (p) (read p))) arg)) + (list "hi" -1 #\a 1 'a-symbol (make-vector 3 0) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) (cons 1 2))) + +;;; r4rstest +(let* ((write-test-obj '(#t #f a () 9739 -3 . #((test) "te \" \" st" "" test #() b c))) + (load-test-obj (list 'define 'foo (list 'quote write-test-obj)))) + + (define (check-test-file name) + (let ((val (call-with-input-file + name + (lambda (test-file) + (test (read test-file) load-test-obj) + (test (eof-object? (peek-char test-file)) #t) + (test (eof-object? (read-char test-file)) #t) + (input-port? test-file))))) + (if (not (eq? val #t)) + (begin (display "input-port? in call-with-input-file? returned ") (display val) (newline))))) + + (test (call-with-output-file + "tmp1.r5rs" + (lambda (test-file) + (write-char #\; test-file) + (display #\; test-file) + (display ";" test-file) + (write write-test-obj test-file) + (newline test-file) + (write load-test-obj test-file) + (output-port? test-file))) #t) + (check-test-file "tmp1.r5rs") + + (let ((test-file (open-output-file "tmp2.r5rs"))) + (write-char #\; test-file) + (display #\; test-file) + (display ";" test-file) + (write write-test-obj test-file) + (newline test-file) + (write load-test-obj test-file) + (test (output-port? test-file) #t) + (close-output-port test-file) + (check-test-file "tmp2.r5rs"))) + + +(call-with-output-file "tmp1.r5rs" (lambda (p) (display "3.14" p))) +;(test (with-input-from-file "tmp1.r5rs" (lambda () (read))) 3.14) +(if (not (eq? start-input-port (current-input-port))) + (begin (display "with-input-from-file did not restore current-input-port? ") (display start-input-port) (display " ") (display (current-input-port)) (newline))) + +;(test (with-input-from-file "tmp1.r5rs" (lambda () (eq? (current-input-port) start-input-port))) #f) + +;(test (with-output-to-file "tmp1.r5rs" (lambda () (eq? (current-output-port) start-output-port))) #f) +(if (not (eq? start-output-port (current-output-port))) + (begin (display "with-output-to-file did not restore current-output-port? ") (display start-output-port) (display " ") (display (current-output-port)) (newline))) + + +;(let ((newly-found-sonnet-probably-by-shakespeare +; "This is the story, a sad tale but true Of a programmer who had far too little to do. One day as he sat in his hut swilling stew, He cried \"CLM takes forever, it's stuck in a slough!, Its C code is slow, too slow by a few. Why, with just a small effort, say one line or two, It could outpace a no-op, you could scarcely say 'boo'\"! So he sat in his kitchen and worked like a dog. He typed and he typed 'til his mind was a fog. Now 6000 lines later, what wonders we see! CLM is much faster, and faster still it will be! In fact, for most cases, C beats the DSP! But bummed is our coder; he grumbles at night. That DSP code took him a year to write. He was paid many dollars, and spent them with glee, But his employer might mutter, this result were he to see.")) +; (call-with-output-file "tmp1.r5rs" +; (lambda (p) +; (write newly-found-sonnet-probably-by-shakespeare p))) +; (let ((sonnet (with-input-from-file "tmp1.r5rs" +; (lambda () +; (read))))) +; (if (or (not (string? sonnet)) +; (not (string=? sonnet newly-found-sonnet-probably-by-shakespeare))) +; (begin (display "write/read long string returned: ") (display sonnet) (newline)))) +; +; (let ((file (open-output-file "tmp1.r5rs"))) +; (let ((len (string-length newly-found-sonnet-probably-by-shakespeare))) +; (write-char #\" file) +; (do ((i 0 (+ i 1))) +; ((= i len)) +; (let ((chr (string-ref newly-found-sonnet-probably-by-shakespeare i))) +; (if (char=? chr #\") +; (write-char #\\ file)) +; (write-char chr file))) +; (write-char #\" file) +; (close-output-port file))) +; (let ((file (open-input-file "tmp1.r5rs"))) +; (let ((sonnet (read file))) +; (close-input-port file) +; (if (or (not (string? sonnet)) +; (not (string=? sonnet newly-found-sonnet-probably-by-shakespeare))) +; (begin (display "write-char/read long string returned: ") (display sonnet) (newline)))))) + +(let ((file (open-output-file "tmp1.r5rs"))) + (for-each + (lambda (arg) + (write arg file) + (write-char #\space file)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + (close-output-port file)) +(let ((file (open-input-file "tmp1.r5rs"))) + (for-each + (lambda (arg) + (let ((val (read file))) + (if (not (equal? val arg)) + (begin (display "read/write ") (display arg) (display " returned ") (display val) (newline))))) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + (close-input-port file)) + +;(with-output-to-file "tmp1.r5rs" +; (lambda () +; (write lists))) +;(let ((val (with-input-from-file "tmp1.r5rs" +; (lambda () +; (read))))) +; (if (not (equal? val lists)) +; (begin (display "read/write lists returned ") (display val) (newline)))) + +;(let ((badfile "tmp1.r5rs")) +; (let ((p (open-output-file "tmp1.r5rs"))) +; (close-output-port p)) +; (load "tmp1.r5rs")) + + + +;;; -------------------------------------------------------------------------------- +;;; CONTROL OPS +;;; -------------------------------------------------------------------------------- + +;(define control-ops (list lambda define quote if begin set! let let* letrec cond case and or do +; call/cc eval apply for-each map values call-with-values dynamic-wind +; quasiquote)) +(define control-ops (list lambda quote if begin set! let let* letrec cond case and or do + eval apply for-each map + quasiquote)) +(for-each + (lambda (op) + (if (not (eq? op op)) + (begin (display op) (display " not eq? to itself?") (newline)))) + control-ops) + +(for-each + (lambda (op) + (if (not (eqv? op op)) + (begin (display op) (display " not eqv? to itself?") (newline)))) + control-ops) + +(for-each + (lambda (op) + (if (not (equal? op op)) + (begin (display op) (display " not equal? to itself?") (newline)))) + control-ops) + +(define question-ops (list boolean? eof-object? string? + number? integer? real? rational? complex? char? + list? vector? pair? null?)) + +(for-each + (lambda (ques) + (for-each + (lambda (op) + (if (ques op) + (begin (display ques) (display " ") (display op) (display " returned #t?") (newline)))) + control-ops)) + question-ops) + + +(for-each + (lambda (s) + (if (not (symbol? s)) + (begin (display "(symbol? ") (display s) (display " returned #f?") (newline)))) + '(+ - ... !.. $.+ %.- &.! *.: /:. <-. =. >. ?. ~. _. ^.)) + + + +;;; -------- if -------- + +(test ((if #f + *) 3 4) 12) +(test (if (> 3 2) 'yes 'no) 'yes) +(test (if (> 2 3) 'yes 'no) 'no) +(test (if (> 3 2) (- 3 2) (+ 3 2)) 1) +(test (if (> 3 2) 1) 1) +(test (if '() 1 2) 1) +(test (if 't 1 2) 1) +(test (if #t 1 2) 1) +(test (if '#() 1 2) 1) +(test (if 1 2 3) 2) +(test (if 0 2 3) 2) +(test (if (list) 2 3) 2) +(test (if "" 2 3) 2) + +(test (let ((a #t) (b #f) (c #t) (d #f)) (if (if (if (if d d c) d b) d a) 'a 'd)) 'a) +(test (let ((a #t) (b #f) (c #t) (d #f)) (if a (if b (if c (if d d c) c) 'b) 'a)) 'b) +;(test (let ((a #t) (b #f) (c #t) (d #f)) (((if a if 'gad) c if 'gad) (not d) 'a 'gad)) 'a) +(test (let ((a #t) (b #f) (c #t) (d #f)) (if b (if a (if d 'gad) 'gad) (if d 'gad 'a))) 'a) + +(let ((a #t)) + (for-each + (lambda (arg) + (test (if a arg 'gad) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))) + +(let ((a #t)) + (for-each + (lambda (arg) + (test (if (not a) 'gad arg) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2)))) + +(test (let ((ctr 0) (a #t)) (if a (let ((b ctr)) (set! ctr (+ ctr 1)) (list b ctr)) (let ((c ctr)) (set! ctr (+ ctr 100)) (list c ctr)))) (list 0 1)) + +(test (if if if if) if) +;(test (((if if if) if if) if if 'gad) if) +(test (if if (if if if) if) if) +;(test (let ((car if)) (car #t 0 1)) 0) +;(test ((car (list if)) #t 0 1) 0) +(test (symbol->string 'if) "if") +(test (if (and if (if if if)) if 'gad) if) +;(test (let ((if #t)) (or if)) #t) +;(test (let ((if +)) (if 1 2 3)) 6) +(test (let ((ctr 0)) (if (let () (set! ctr (+ ctr 1)) (= ctr 1)) 0 1)) 0) +(test (let ((ctr 0)) (if (let () (set! ctr (+ ctr 1)) (if (= ctr 1) (> 3 2) (< 3 2))) 0 1)) 0) +(test ( if (> 3 2) 1 2) 1) +(test (let ((alist (list (list map 1) (list car 2) (list if 3) (list do 4)))) (assoc if alist)) (list if 3)) +(test (let ((alist (list (list map 1) (list car 2) (list if 3) (list do 4)))) (assv if alist)) (list if 3)) +(test (let ((alist (list (list map 1) (list car 2) (list if 3) (list do 4)))) (assq if alist)) (list if 3)) +(test (let ((alist (list map car if do))) (member if alist)) (list if do)) +(test (let ((alist (list map car if do))) (memv if alist)) (list if do)) +(test (let ((alist (list map car if do))) (memq if alist)) (list if do)) +;(test ((vector-ref (vector if) 0) #t 1 2) 1) +;(test ((vector-ref (make-vector 1 if) 0) #t 1 2) 1) +(test ((if #t + -) 3 4) 7) +(test (list (if 0 1 2)) (list 1)) +;(test ((car (list if map)) #f 1 2) 2) +(test (let ((ctr 0)) (if (= ctr 0) (let () (set! ctr (+ ctr 1)) (if (= ctr 1) 2 3)) (let () (set! ctr (+ ctr 1)) (if (= ctr 1) 4 5)))) 2) +(test (let ((x (cons 1 2))) (set-cdr! x x) (if x 1 2)) 1) +(test (let ((ctr 0)) (if (let ((ctr 123)) (set! ctr (+ ctr 1)) (= ctr 124)) (let () (set! ctr (+ ctr 100)) ctr) (let () (set! ctr (+ ctr 1000)) ctr)) ctr) 100) +(test (if (let ((if 3)) (> 2 if)) 4 5) 5) + +;(test (test-eval '(if (> 3 2) 1 2)) 1) + +;(test (let ((ctr 0)) (call/cc (lambda (exit) (if (> 3 2) (let () (exit ctr) (set! ctr 100) ctr) #f)))) 0) +;(test (let ((ctr 0)) (call/cc (lambda (exit) (if (< 3 2) #f (let () (exit ctr) (set! ctr 100) ctr))))) 0) +;(test (let ((ctr 0)) (call/cc (lambda (exit) (if (let () (exit ctr) (set! ctr 100) ctr) 123 321)))) 0) +;(test (let ((ctr 0)) (if (> 3 2) (call/cc (lambda (exit) (set! ctr (+ ctr 1)) (exit ctr))) #f) ctr) 1) + + + + +;;; -------- quote -------- + +(test (quote a) 'a) +(test 'a (quote a)) +(test '1 1) +(test '(+ 2 3) '(+ 2 3)) +(test '"hi" "hi") +(test '#\a #\a) +(test '#f #f) +(test '#t #t) +(test '#b1 1) +(test '() '()) +(test (+ '1 '2) 3) +(test (+ '1 '2) '3) +(test (+ ' 1 ' 2) ' 3) +(test (char? '#\a) #t) +(test (string? '"hi") #t) +(test (boolean? '#t) #t) +(test (if '#f 2 3) 3) +(test (if '#t 2 3) 2) +(test (vector? '#()) #t) +(test (char? (quote #\a)) #t) +(test (string? (quote "hi")) #t) +(test (boolean? (quote #t)) #t) +(test (if (quote #f) 2 3) 3) +(test (if (quote #t) 2 3) 2) +(test (vector? (quote #())) #t) +(test (+ (quote 1) (quote 2)) (quote 3)) +(test (list? (quote ())) #t) +(test (pair? (quote (1 . 2))) #t) +(test (+ '1.0 '2.0) 3.0) +(test (+ '1/2 '3/2) 2) +(test (+ '1.0+1.0i '-2.0) -1.0+1.0i) +(test (let ((hi 2)) (equal? hi 'hi)) #f) +(test ''1 (quote (quote 1))) +(test ''a (quote (quote a))) +(test (symbol? '#f) #f) +(test ''quote (quote (quote quote))) +(test (+ (cadr ''3) (cadadr '''4) (cadr (cadr (cadr ''''5)))) 12) + +;(test (eq? '() ()) #t) ; not sure about this -- Gauche, SCM, stklos say #t; Guile says error; clisp, cmucl, and sbcl say T + + + + +;;; -------- for-each -------- + +(test (let ((v (make-vector 5))) (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4)) v) '#(0 1 4 9 16)) +(test (let ((ctr 0) (v (make-vector 5))) (for-each (lambda (i) (vector-set! v ctr (* i i)) (set! ctr (+ ctr 1))) '(0 1 2 3 4)) v) '#(0 1 4 9 16)) +(for-each (lambda (x) (display "for-each should not have called this")) '()) +(test (let ((ctr 0)) (for-each (lambda (x y) (if (= x y) (set! ctr (+ ctr 1)))) '(1 2 3 4 5 6) '(2 3 3 4 7 6)) ctr) 3) +(test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(0 1) '(2 3) '(4 5)) ctr) 15) +(test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(1) '(3) '(5)) ctr) 9) +(test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '() '() '()) ctr) 0) +(test (let () (for-each abs '(1 2)) 1) 1) +(test (let ((ctr 0)) (for-each (lambda (a) (for-each (lambda (b) (set! ctr (+ ctr 1))) '(0 1))) '(2 3 4)) ctr) 6) +(test (let ((sum 0)) (for-each (lambda args (set! sum (+ sum (apply + args)))) '(0 1 2) '(2 1 0) '(3 4 5) '(5 4 3) '(6 7 8) '(8 7 6)) sum) 72) +(test (let ((sum 0)) (for-each (lambda (a b . args) (set! sum (+ sum a b (apply + args)))) '(0 1 2) '(2 1 0) '(3 4 5) '(5 4 3) '(6 7 8) '(8 7 6)) sum) 72) +(test (let ((sum 0)) (for-each (lambda (a b . args) (set! sum (+ sum a b (apply + args)))) '(0 1 2) '(2 1 0)) sum) 6) +(test (let () (for-each + '(0 1 2) '(2 1 0)) 0) 0) +(test (let ((d 0)) + (for-each (let ((a 0)) + (for-each (lambda (b) (set! a (+ a b))) (list 1 2)) + (lambda (c) (set! d (+ d c a)))) + (list 3 4 5)) + d) + 21) +(test (let ((d 0)) + (for-each (lambda (c) + (let ((a 0)) + (for-each (lambda (b) (set! a (+ a b))) (list 1 2)) + (set! d (+ d a c)))) + (list 3 4 5)) + d) + 21) + +;(test (let ((ctr 0)) +; (let ((val (call/cc +; (lambda (exit) +; (for-each (lambda (a) +; (if (> a 3) (exit a)) +; (set! ctr (+ ctr 1))) +; (list 0 1 2 3 4 5)))))) +; (list ctr val))) +; (list 4 4)) +; +;(test (call-with-current-continuation +; (lambda (exit) +; (for-each +; (lambda (x) +; (if (negative? x) (exit x))) +; '(54 0 37 -3 245 19)) +; #t)) +; -3) +; +;(test (let ((ctr 0) +; (cont #f) +; (lst '())) +; (let ((val (call/cc +; (lambda (exit) +; (for-each (lambda (a) +; (if (and (not cont) (= a 2)) +; (exit a)) +; (if (and cont (= a 5)) +; (exit a)) +; (call/cc (lambda (c) (set! cont c))) +; (set! lst (cons ctr lst)) +; (set! ctr (+ ctr 1))) +; (list 0 1 2 3 4 5)))))) +; (if (< val 5) +; (cont)) +; (list ctr val lst))) +; (list 5 5 (list 4 3 2 1 0))) + +(test (let ((lst '())) + (for-each (lambda (a) (set! lst (cons a lst))) + (let ((lst '())) + (for-each (lambda (b) (set! lst (cons b lst))) + (list 1 2 3)) + lst)) + lst) + (list 1 2 3)) + +;;; this is an infinite loop? +; (let ((cont #f)) (call/cc (lambda (x) (set! cont x))) (for-each cont (list 1 2 3))) +;(test (call/cc (lambda (x) (for-each x (list 1 2 3)))) 1) ; map also gives 1 ... perhaps not actually legal? + + + + +;;; -------- map -------- + +(test (map cadr '((a b) (d e) (g h))) '(b e h)) +(test (map (lambda (n) (expt n n)) '(1 2 3 4 5)) '(1 4 27 256 3125)) +(test (map + '(1 2 3) '(4 5 6)) '(5 7 9)) + +(test (apply vector (map (lambda (i) (* i i)) '(0 1 2 3 4))) '#(0 1 4 9 16)) +(map (lambda (x) (display "map should not have called this")) '()) +(test (let ((ctr 0)) (map (lambda (x y) (if (= x y) (set! ctr (+ ctr 1))) ctr) '(1 2 3 4 5 6) '(2 3 3 4 7 6))) (list 0 0 1 2 2 3)) +(test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(0 1) '(2 3) '(4 5))) (list 6 15)) +(test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(1) '(3) '(5))) (list 9)) +(test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '() '() '())) '()) +(test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2)) (list 2 4)) +(test (map abs '(1 -2)) (list 1 2)) +(test (map + '(0 1 2) '(2 1 0) '(3 4 5) '(5 4 3) '(6 7 8) '(8 7 6)) (list 24 24 24)) +(test (map (lambda (a) (cons a (map (lambda (b) (+ b 1)) (list 0 1 2)))) (list 3 4 5)) '((3 1 2 3) (4 1 2 3) (5 1 2 3))) +(test (map (lambda (a) (+ a 1)) (map (lambda (b) (+ b 1)) (map (lambda (c) (+ c 1)) (list 0 1 2)))) '(3 4 5)) +(test (map (lambda args (apply + args)) '(0 1 2) '(3 4 5) '(6 7 8) '(9 10 11) '(12 13 14)) '(30 35 40)) +(test (map (lambda (a b . args) (+ a b (apply + args))) '(0 1 2) '(3 4 5) '(6 7 8) '(9 10 11) '(12 13 14)) '(30 35 40)) +(test (map (lambda (a b . args) (+ a b (apply + args))) '(0 1 2) '(3 4 5)) '(3 5 7)) + +(test (let ((d 0)) + (map (let ((a 0)) + (map (lambda (b) (set! a (+ a b))) (list 1 2)) + (lambda (c) (set! d (+ d c a)) d)) + (list 3 4 5))) + (list 6 13 21)) +(test (let ((d 0)) + (map (lambda (c) + (let ((a 0)) + (map (lambda (b) (set! a (+ a b))) (list 1 2)) + (set! d (+ d a c)) + d)) + (list 3 4 5))) + (list 6 13 21)) + +;(test (let ((ctr 0)) +; (let ((val (call/cc +; (lambda (exit) +; (map (lambda (a) +; (if (> a 3) (exit a)) +; (set! ctr (+ ctr 1)) +; ctr) +; (list 0 1 2 3 4 5)))))) +; (list ctr val))) +; (list 4 4)) +; +;(test (call-with-current-continuation +; (lambda (exit) +; (map +; (lambda (x) +; (if (negative? x) (exit x)) +; x) +; '(54 0 37 -3 245 19)))) +; -3) +; +;(test (let ((ctr 0) +; (cont #f) +; (lst '())) +; (let ((val (call/cc +; (lambda (exit) +; (map (lambda (a) +; (if (and (not cont) (= a 2)) +; (exit a)) +; (if (and cont (= a 5)) +; (exit a)) +; (call/cc (lambda (c) (set! cont c))) +; (set! lst (cons ctr lst)) +; (set! ctr (+ ctr 1)) +; ctr) +; (list 0 1 2 3 4 5)))))) +; (if (< val 5) +; (cont)) +; (list ctr val lst))) +; (list 5 5 (list 4 3 2 1 0))) + +(test (map (lambda (a) a) (map (lambda (b) b) (list 1 2 3))) (list 1 2 3)) + + + + +;;; --------- do -------- + +(test (do () (#t 1)) 1) +(for-each + (lambda (arg) + (test (do () (#t arg)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + +(for-each + (lambda (arg) + (test (do ((i arg)) (#t i)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + +(test (do ((i 0 (+ i 1))) ((= i 3) #f)) #f) +(test (do ((i 0 (+ i 1))) ((= i 3) i)) 3) +(test (do ((vec (make-vector 5)) (i 0 (+ i 1))) ((= i 5) vec) (vector-set! vec i i)) '#(0 1 2 3 4)) +(test (let ((x '(1 3 5 7 9))) (do ((x x (cdr x)) (sum 0 (+ sum (car x)))) ((null? x) sum))) 25) +(test (do ((i 4 (- i 1)) (a 1 (* a i))) ((zero? i) a)) 24) + +;(test (do () (() ()) ()) '()) ; ?? -- is '() the same as ()? -- scheme bboard sez not necessarily +(test (do () ('() '())) '()) + +(test (let ((x 0) (y 0)) (set! y (do () (#t (set! x 32) 123))) (list x y)) (list 32 123)) +(test (let ((i 32)) (do ((i 0 (+ i 1)) (j i (+ j 1))) ((> j 33) i))) 2) +(test (let ((i 0)) (do () ((> i 1)) (set! i (+ i 1))) i) 2) +(test (let ((i 0) (j 0)) (do ((k #\a)) (#t i) (set! i (char->integer k)) (set! j (+ j i)))) 0) +(test (let ((i 0) (j 0)) (do ((k #\a)) ((> i 1) j) (set! i (char->integer k)) (set! j (+ j i)))) (char->integer #\a)) +(test (let ((x 0)) (do ((i 0 (+ i 2)) (j 1 (* j 2))) ((= i 4) x) (set! x (+ x i j)))) 5) +(test (let ((sum 0)) (do ((lst '(1 2 3 4) (cdr lst))) ((null? lst) sum) (set! sum (+ sum (car lst))))) 10) +(test (do ((i 0 (+ 1 i))) ((= i 4) (do ((i 0 (+ i 2))) ((= i 10) i)))) 10) +(test (let ((i 0)) (do ((i 1 (+ i 1))) ((= i 3) i))) 3) +(test (let ((j 0)) (do ((i 0 (+ i 1))) ((= i 3) (+ i j)) (do ((j 0 (+ j i 1))) ((> j 3) j)))) 3) +(test (let ((add1 (lambda (a) (+ a 1)))) (do ((i 0 (add1 i))) ((= i 10) (add1 i)))) 11) +(test (do ((i 0 (do ((j 0 (+ j 1))) ((= j i) (+ i 1))))) ((= i 3) i)) 3) +(test (do ((i 0 (do ((i 0 (+ i 1))) ((= i 3) i)))) ((= i 3) i)) 3) +(test (let ((i 123)) (do ((i 0 (+ i 1)) (j i (+ j i))) ((> j 200) i))) 13) +(test (do ((i 0 (+ i 1))) ((> i 3) i) (set! i (* i 10))) 11) +(test (do ((i 123) (j 0 (+ j i))) ((= j 246) i)) 123) +(test (do ((i 123 i) (j 0 (+ j i))) ((= j 246) i)) 123) +(test (do ((i 0 i)) (i i)) 0) +(test (do ((i 1 i)) (i i (+ i i) (+ i i i))) 3) +(test (do ((i 1)) (#t 1) 123) 1) +(test (do ((i 0 (+ i j)) (j 0 (+ j 1))) (#t 1)) 1) +(test (do ((i 0 j) (j 0 (+ j 1))) ((= j 3) i)) 2) ; uh, lessee... lexical scoping... +(test (do ((i 1 j) (j 0 k) (k 0 m) (m 0 (+ i j k))) ((> m 10) (list i j k m))) (list 4 5 8 11)) +(test (do ((do 1 (+ do do))) ((> do 3) do)) 4) +(test (do ((do 1 do) (j do do)) (do do)) 1) +(test (do ((do do do)) (do do)) do) +(test (do ((do do do)) (do do do)) do) ; ok ok! +(test (let ((i 10) (j 11) (k 12)) (do ((i i j) (j j k) (k k m) (m (+ i j k) (+ i j k))) ((> m 100) (list i j k m)))) (list 33 56 78 122)) +(test (do ((i 0 (let () (set! j 3) (+ i 1))) (j 0 (+ j 1))) ((= i 3) j)) 4) +(test (let ((i 0)) (do () ((= i 3) (* i 2)) (set! i (+ i 1)))) 6) +(num-test (do ((i 0 (- i 1))) ((= i -3) i)) -3) +(num-test (do ((i 1/2 (+ i 1/2))) ((> i 2) i)) 5/2) +(num-test (do ((i 0.0 (+ i 0.1))) ((>= i 0.9999) i)) 1.0) +(num-test (do ((i 0 (- i 1/2))) ((< i -2) i)) -5/2) +(num-test (do ((i 0+i (+ i 0+i))) ((> (magnitude i) 2) i)) 0+3i) + +(if with-bignums + (begin + (num-test (do ((i 24444516448431392447461 (+ i 1)) + (j 0 (+ j 1))) + ((>= i 24444516448431392447471) j)) + 10) + (num-test (do ((i 0 (+ i 24444516448431392447461)) + (j 0 (+ j 1))) + ((>= i 244445164484313924474610) j)) + 10) + (num-test (do ((i 4096 (* i 2)) + (j 0 (+ j 1))) + ((= i 4722366482869645213696) j)) + 60))) + +(num-test (do ((x (list 1 2 3) (cdr x)) (j -1)) ((null? x) j) (set! j (car x))) 3) + +(test (let ((x 0)) + (do ((i 0 (+ i 1))) + ((= i (do ((j 0 (+ j 1))) ((= j 2) (+ j 1))))) + (set! x (+ x i))) + x) + 3) +(test (let ((x 0)) + (do ((i 0 (+ i (do ((j 0 (+ j 1))) ((= j 2) 1))))) + ((= i 3) x) + (set! x (+ x i)))) + 3) +(test (let ((x 0)) + (do ((i 0 (+ i (do ((j 0 (+ j 1))) ((= j 2) 1))))) + ((= i 3) (do ((j 0 (+ j 1))) ((= j 5) x) (set! x j))) + (set! x (+ x i)))) + 4) + +;(test (call/cc (lambda (exit) (do ((i 0 (+ i 1))) ((= i 100) i) (if (= i 2) (exit 321))))) 321) +;(test (call/cc (lambda (exit) (do ((i 0 (if (= i 3) (exit 321) (+ i 1)))) ((= i 100) i)))) 321) +;(test (call/cc (lambda (exit) (do ((i 0 (+ i 1))) ((= i 10) (exit 321))))) 321) +;(test (call/cc (lambda (exit) (do ((i 0 (+ i 1))) ((= i 10) i) (if (= i -2) (exit 321))))) 10) +;(test (do ((x 0 (+ x 1)) (y 0 (call/cc (lambda (c) c)))) ((> x 5) x) #f) 6) +(test (let ((happy #f)) (do ((i 0 (+ i 1))) (happy happy) (if (> i 3) (set! happy i)))) 4) + +(test (+ (do ((i 0 (+ i 1))) ((= i 3) i)) (do ((j 0 (+ j 1))) ((= j 4) j))) 7) +(test (let ((do 1) (map 2) (for-each 3) (quote 4)) (+ do map for-each quote)) 10) + +;(test (let ((cont #f) +; (j 0) +; (k 0)) +; (call/cc (lambda (exit) +; (do ((i 0 (+ i 1))) +; ((= i 100) i) +; (set! j i) +; (call/cc (lambda (r) (set! cont r))) +; (if (= j 2) (exit)) +; (set! k i)))) +; (if (= j 2) +; (begin +; (set! j 3) +; (cont)) +; (list j k))) +; (list 99 99)) + +;(test (call/cc (lambda (r) (do () (#f) (r 1)))) 1) +(test (let ((hi (lambda (x) (+ x 1)))) (do ((i 0 (hi i))) ((= i 3) i))) 3) +(test (do ((i 0 (+ i 1))) (list 1) ((= i 3) #t)) 1) ; a typo originally -- Guile and Gauche are happy with it + + + +;;; -------- set! -------- + +(test (let ((a 1)) (set! a 2) a) 2) +(for-each + (lambda (arg) + (test (let ((a 0)) (set! a arg) a) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + +;(test (let ((a 1)) (call/cc (lambda (r) (set! a (let () (if (= a 1) (r 123)) 321)))) a) 1) +(test (let ((a (lambda (b) (+ b 1)))) (set! a (lambda (b) (+ b 2))) (a 3)) 5) +(test (let ((a (lambda (x) (set! x 3) x))) (a 1)) 3) + + + +;;; -------- or -------- + +(test (or (= 2 2) (> 2 1)) #t) +(test (or (= 2 2) (< 2 1)) #t) +(test (or #f #f #f) #f) +(test (or) #f) +(test (or (memq 'b '(a b c)) (+ 3 0)) '(b c)) +(test (or 3 9) 3) +(test (or #f 3 asdf) 3) ; "evaluation stops immediately" +(test (or 3 (/ 1 0) (display "or is about to exit!") (exit)) 3) + +(for-each + (lambda (arg) + (test (or arg) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(test (call-with-input-file "r5rstest.scm" + (lambda (p) + (let ((loc 0)) + (let loop ((val (read p))) + (or (eof-object? val) + (> loc 10000) ; try to avoid the read-error stuff + (begin + (set! loc (+ 1 loc)) + (loop (read p))))) + (> loc 10000)))) + #t) + +(test (or (and (or (> 3 2) (> 3 4)) (> 2 3)) 4) 4) +(test (or or) or) +(test (or (or (or))) #f) +(test (or (or (or) (and))) #t) +(test (let ((a 1)) (or (let () (set! a 2) #f) (= a 1) (let () (set! a 3) #f) (and (= a 3) a) (let () (set! a 4) #f) a)) 3) +(test (or (let ((or #t)) or)) #t) +(test (or '#f '()) '()) +;(test (call/cc (lambda (r) (or #f (> 3 2) (r 123) 321))) #t) +;(test (call/cc (lambda (r) (or #f (< 3 2) (r 123) 321))) 123) +(test (+ (or #f (not (null? '())) 3) (or (zero? 1) 2)) 5) +(test (or 0) 0) +(test (if (or) 1 2) 2) + + + +;;; -------- and -------- + +(test (and (= 2 2) (> 2 1)) #t) +(test (and (= 2 2) (< 2 1)) #f) +(test (and 1 2 'c '(f g)) '(f g)) +(test (and) #t) +(test (and 3) 3) +(test (and (memq 'b '(a b c)) (+ 3 0)) 3) +(test (and 3 9) 9) +(test (and #f 3 asdf) #f) ; "evaluation stops immediately" +(test (and 3 (zero? 1) (/ 1 0) (display "and is about to exit!") (exit)) #f) +(test (if (and) 1 2) 1) +(test (if (+) 1 2) 1) +(test (if (*) 1 2) 1) + +(for-each + (lambda (arg) + (test (and arg) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(test (call-with-input-file "r5rstest.scm" + (lambda (p) + (let ((loc 0)) + (let loop ((val (read p))) + (and (not (eof-object? val)) + (< loc 10000) + (begin + (set! loc (+ 1 loc)) + (loop (read p))))) + (>= loc 10000)))) + #t) + +(test (and (or (and (> 3 2) (> 3 4)) (> 2 3)) 4) #f) +(test (and and) and) +(test (and (and (and))) #t) +(test (and (and (and (and (or))))) #f) +(test (let ((a 1)) (and (let () (set! a 2) #t) (= a 1) (let () (set! a 3) #f) (and (= a 3) a) (let () (set! a 4) #f) a)) #f) +(test (and (let ((and #t)) and)) #t) +(test (and '#t '()) '()) +;(test (call/cc (lambda (r) (and #t (> 3 2) (r 123) 321))) 123) +;(test (call/cc (lambda (r) (and #t (< 3 2) (r 123) 321))) #f) +(test (+ (and (null? '()) 3) (and (zero? 0) 2)) 5) + + + + +;;; -------- cond -------- + +(test (cond ('a)) 'a) +(test (cond (#f 'a) ('b)) 'b) +(test (cond (#t 'a) (#t 'b)) 'a) +(test (cond ((> 3 2) 'greater) ((< 3 2) 'less)) 'greater) +(test (cond ((> 3 3) 'greater) ((< 3 3) 'less) (else 'equal)) 'equal) +(test (cond ((assv 'b '((a 1) (b 2))) => cadr) (else #f)) 2) +(test (cond (#f 2) (else 5)) 5) +(test (cond (1 2) (else 5)) 2) +(test (cond (1 => (lambda (x) (+ x 2))) (else 8)) 3) +(test (cond ((+ 1 2))) 3) +(test (cond ((zero? 1) 123) ((= 1 1) 321)) 321) +(test (cond ('() 1)) 1) +;(test (cond (1 2) '()) 2) +(test (cond (1 2 3)) 3) +(test (cond ((= 1 2) 3) ((+ 3 4))) 7) +(test (cond ((= 1 1) (abs -1) (+ 2 3) (* 10 2)) (else 123)) 20) +(test (let ((a 1)) (cond ((= a 1) (set! a 2) (+ a 3)))) 5) +(test (let ((a 1)) (cond ((= a 2) (+ a 2)) (else (set! a 3) (+ a 3)))) 6) +(test (cond ((= 1 1))) #t) +(test (cond ((= 1 2) #f) (#t)) #t) +(test (cond ((+ 1 2))) 3) +(test (cond ((cons 1 2))) '(1 . 2)) +(test (cond (#f #t) ((string-append "hi" "ho"))) "hiho") +(test (cond ('() 3) (#t 4)) 3) +(test (cond ((list) 3) (#t 4)) 3) +;;; (cond (1 1) (asdf 3)) -- should this be an error? + +(for-each + (lambda (arg) + (test (cond ((or arg) => (lambda (x) x))) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + + +(test (cond ((+ 1 2) => (lambda (x) (+ 1 x)))) 4) +(test (cond ((cons 1 2) => car)) 1) +; (cond ((values 1 2) => +)) -- seems like it ought to work +;(test (cond ((values -1) => abs)) 1) + +(test (cond (else 1)) 1) +;(test (call/cc (lambda (r) (cond ((r 4) 3) (else 1)))) 4) +(test (cond ((cond (#t 1)))) 1) + +(for-each + (lambda (arg) + (test (cond (#t arg)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(for-each + (lambda (arg) + (test (cond (arg)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(for-each + (lambda (arg) + (test (cond (#f 1) (else arg)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(for-each + (lambda (arg) + (test (cond (arg => (lambda (x) x))) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(test (let ((=> 3) (cond 4)) (+ => cond)) 7) +(test (cond (cond 'cond)) 'cond) + +;(test (and (defined? 'else) (boolean? else)) #f) + + + +;;; -------- case -------- + +(test (case (* 2 3) ((2 3 5 7) 'prime) ((1 4 6 8 9) 'composite)) 'composite) +(test (case (car '(c d)) ((a e i o u) 'vowel) ((w y) 'semivowel) (else 'consonant)) 'consonant) +(test (case 3.1 ((1.3 2.4) 1) ((4.1 3.1 5.4) 2) (else 3)) 2) +(test (case 3/2 ((3/4 1/2) 1) ((3/2) 2) (else 3)) 2) +(test (case 3 ((1) 1 2 3) ((2) 2 3 4) ((3) 3 4 5)) 5) +(test (case 1+i ((1) 1) ((1/2) 1/2) ((1.0) 1.0) ((1+i) 1+i)) 1+i) +(test (case 'abs ((car cdr) 1) ((+ cond) 2) ((abs) 3) (else 4)) 3) +(test (case #\a ((#\b) 1) ((#\a) 2) ((#\c) 3)) 2) +(test (case (boolean? 1) ((#t) 2) ((#f) 1) (else 0)) 1) +(test (case 1 ((1 2 3) (case 2 ((1 2 3) 3)))) 3) +(test (case 1 ((1 2) 1) ((3.14 2/3) 2)) 1) +(test (case 1 ((1 2) 1) ((#\a) 2)) 1) +(test (case 1 ((1 2) 1) ((#\a) 2) ((car cdr) 3) ((#f #t) 4)) 1) +(test (case #f ((1 2) 1) ((#\a) 2) ((car cdr) 3) ((#f #t) 4)) 4) +(test (case 1 ((#t) 2) ((#f) 1) (else 0)) 0) +(test (let ((x 1)) (case x ((x) "hi") (else "ho"))) "ho") +(test (let ((x 1)) (case x ((1) "hi") (else "ho"))) "hi") +(test (let ((x 1)) (case x (('x) "hi") (else "ho"))) "ho") +(test (let ((x 1)) (case 'x ((x) "hi") (else "ho"))) "hi") + +(test (let ((x 1)) (case (+ 1 x) ((0 "hi" #f) 3/4) ((#\a 1+3i '(1 . 2)) "3") ((-1 'hi 2 2.0) #\f))) #\f) +(test (case (case 1 ((0 2) 3) (else 2)) ((0 1) 2) ((4 2) 3) (else 45)) 3) +(test (case 3/4 ((0 1.0 5/6) 1) (("hi" 'hi 3/4) 2) (else 3)) 2) +(test (case (case (+ 1 2) (else 3)) ((3) (case (+ 2 2) ((2 3) 32) ((4) 33) ((5) 0)))) 33) +(test (let ((x 1)) (case x ((0) (set! x 12)) ((2) (set! x 32))) x) 1) + +(test (case 1 (else #f)) #f) +(test (case 1 ((1 2) (let ((case 3)) (+ case 1))) ((3 4) 0)) 4) + +(for-each + (lambda (arg) + (test (case 1 ((0) 'gad) ((1 2 3) arg) (else 'gad)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(for-each + (lambda (arg) + (test (case arg ((0) 'gad) ((1 2 3) arg) (else 'gad)) 'gad)) + (list "hi" -1 #\a 0 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +;(test (call/cc (lambda (r) (case 1 ((1) (r 123) #t) (else #f)))) 123) +;(test (call/cc (lambda (r) (case 1 ((0) 0) (else (r 123) #f)))) 123) + +(test (case '() ((1) 1) ('() 2)) 2) +(test (case (list) ((1) 1) ('() 2)) 2) +(test (case '() ((1) 1) ((()) 2)) 2) +(test (case (list) ((1) 1) ((()) 2)) 2) + + + +;;; -------- lambda -------- + +(test (procedure? (lambda (x) x)) #t) +(test ((lambda (x) (+ x x)) 4) 8) +(test (let ((reverse-subtract (lambda (x y) (- y x)))) (reverse-subtract 7 10)) 3) +(test (let ((add4 (let ((x 4)) (lambda (y) (+ x y))))) (add4 6)) 10) +(test ((lambda x x) 3 4 5 6) (list 3 4 5 6)) +(test ((lambda (x y . z) z) 3 4 5 6) (list 5 6)) +(test ((lambda (a b c d e f) (+ a b c d e f)) 1 2 3 4 5 6) 21) +(test (let ((foo (lambda () 9))) (+ (foo) 1)) 10) +(test (let ((a 1)) (let ((f (lambda (x) (set! a x) a))) (let ((c (f 123))) (list c a)))) (list 123 123)) +(test (let ((a 1) (b (lambda (a) a))) (b 3)) 3) +(test (let ((ctr 0)) (letrec ((f (lambda (x) (if (> x 0) (begin (set! ctr (+ ctr 1)) (f (- x 1))) 0)))) (f 10) ctr)) 10) +(test (let ((f (lambda (x) (car x)))) (f '(4 5 6))) 4) +(test ((lambda () ((lambda (x y) ((lambda (z) (* (car z) (cdr z))) (cons x y))) 3 4))) 12) +(test (let ((ctr 0)) (define (f) (set! ctr (+ ctr 1)) ctr) (let ((x (f))) (let ((y (f))) (list x y ctr)))) (list 1 2 2)) + +(test (let ((x 5)) (define foo (lambda (y) (bar1 x y))) (define bar1 (lambda (a b) (+ (* a b) a))) (foo (+ x 3))) 45) +(test (let ((x 5)) (letrec ((foo (lambda (y) (bar2 x y))) (bar2 (lambda (a b) (+ (* a b) a)))) (foo (+ x 3)))) 45) +(num-test (let () (define compose (lambda (f g) (lambda args (f (apply g args))))) ((compose sqrt *) 12 75)) 30.0) +(test (let ((f (lambda () (lambda (x y) (+ x y))))) ((f) 1 2)) 3) +(test ((lambda (x) (define y 4) (+ x y)) 1) 5) +(test ((lambda () (define (y x) (+ x 1)) (y 1))) 2) +(test ((lambda (x) 123 (let ((a (+ x 1))) a)) 2) 3) +(test ((lambda (x) "documentation" (let ((a (+ x 1))) a)) 2) 3) +(test ((lambda (x) (x 1)) (lambda (y) (+ y 1))) 2) +(test (let ((a 1)) (let ((b (lambda (x) (define y 1) (define z 2) (define a 3) (+ x y z a)))) (b a))) 7) +(test ((lambda (f x) (f x x)) + 11) 22) +(test ((lambda () (+ 2 3))) 5) + +(for-each + (lambda (arg) + (test ((lambda (x) x) arg) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +;(let ((list-length + ;(lambda (obj) + ;(call-with-current-continuation + ;(lambda (return) + ;(letrec ((r (lambda (obj) (cond ((null? obj) 0) + ;((pair? obj) (+ (r (cdr obj)) 1)) + ;(else (return #f)))))) + ;(r obj))))))) + ;(test (list-length '(1 2 3 4)) 4) + ;(test (list-length '(a b . c)) #f)) + +(test (let ((samples (vector 0 1 2 3 4 5 6 7 8 9 10))) + (let ((make-scaler + (lambda (start end) + (letrec ((ctr start) + (us (lambda (them) + (vector-set! samples ctr (* 2 (vector-ref samples ctr))) + (set! ctr (+ ctr 2)) + (if (<= ctr end) + (them us))))) + us)))) + ((make-scaler 0 11) + (make-scaler 1 11))) + samples) + (vector 0 2 4 6 8 10 12 14 16 18 20)) + +(test ((lambda (x . y) y) 1 2 '(3 . 4)) '(2 (3 . 4))) +(test ((lambda (x . y) y) 1) '()) +(test ((lambda x x) '()) '(())) +(test ((lambda x x)) '()) ; ?? +(test ((lambda (x) x) '()) '()) +(test (let ((lambda 4)) (+ lambda 1)) 5) +(test ((lambda (x) (+ x ((lambda (x) (+ x 1)) 2))) 3) 6) +(test ((lambda (x) (define y 1) (+ x y)) 2) 3) +(test ((lambda (a) "this is a doc string" a) 1) 1) +;;; ideally ((lambda (a) "hiho" (define x 1) x) 1) -> 1 but I'm not sure it's r5rs-ish + + +(test ((lambda lambda lambda) 'x) '(x)) +;(test ((lambda (begin) (begin 1 2 3)) (lambda lambda lambda)) '(1 2 3)) + +(test (let ((funcs (make-vector 3 #f))) + (do ((i 0 (+ i 1))) + ((= i 3)) + (vector-set! funcs i (lambda () (+ i 1)))) + (+ ((vector-ref funcs 0)) + ((vector-ref funcs 1)) + ((vector-ref funcs 2)))) + 6) + +(test (let ((i 1)) + (let ((func1 (lambda () i))) + (let ((i 2)) + (let ((func2 (lambda () i))) + (+ (func1) (func2)))))) + 3) + +(test (let ((funcs (make-vector 3 #f))) + (map + (lambda (i) + (vector-set! funcs i (lambda () (+ i 1)))) + (list 0 1 2)) + (+ ((vector-ref funcs 0)) + ((vector-ref funcs 1)) + ((vector-ref funcs 2)))) + 6) + +(test (let ((func #f)) + (define (func1 x) + (set! func (lambda () (+ x 1)))) + (func1 1) + (+ (func) + (let () + (func1 2) + (func)))) + 5) + +(test (((lambda (x) (lambda () (+ x 1))) 32)) 33) + +(test (let ((func #f)) + (define (func1 x) + (set! func (lambda () (string-append x "-")))) + (func1 "hi") + (string-append (func) + (let () + (func1 "ho") + (func)))) + "hi-ho-") + +(test (let ((func1 #f) + (func2 #f)) + (let ((x 1)) + (set! func1 (lambda () x)) + (set! func2 (lambda (y) (set! x y) y))) + (+ (func1) + (let () + (func2 32) + (func1)))) + 33) + +(test (let ((funcs (make-vector 3))) + (let ((hi (lambda (a) (vector-set! funcs (- a 1) (lambda () a))))) + (hi 1) (hi 2) (hi 3) + (+ ((vector-ref funcs 0)) + ((vector-ref funcs 1)) + ((vector-ref funcs 2))))) + 6) + +(test (let ((hi (lambda (a) (+ a 1))) + (ho (lambda (a) (a 32)))) + (+ (hi (hi (hi 1))) + (ho hi))) + 37) + +(test ((if (> 3 2) + -) 3 2) 5) +(test (let ((op +)) (op 3 2)) 5) +(test (((lambda () +)) 3 2) 5) +(test ((car (cons + -)) 3 2) 5) +(test ((do ((i 0 (+ i 1))) ((= i 3) +) ) 3 2) 5) +(test (((lambda (x) x) (lambda (x) x)) 3) 3) +(test ((((lambda (x) x) (lambda (x) x)) (lambda (x) x)) 3) 3) +(test (((lambda (x) (lambda (y) x)) 3) 4) 3) +(test (((lambda (x) (lambda (x) x)) 3) 4) 4) +(test (let ((x 32)) (((lambda (x) (lambda (y) x)) 3) x)) 3) +;(test ((call/cc (lambda (return) (return +))) 3 2) 5) +;(test ((call-with-values (lambda () (values +)) (lambda (x) x)) 3 2) 5) +(test ((case '+ ((+) +)) 3 2) 5) +(test ((case '+ ((-) -) (else +)) 3 2) 5) +;(test ((call/cc (lambda (return) (dynamic-wind (lambda () #f) (lambda () (return +)) (lambda () #f)))) 3 2) 5) +;(test (+ 1 ((call/cc (lambda (return) (dynamic-wind (lambda () #f) (lambda () (return +)) (lambda () #f)))) 3 2) 2) 8) + + + +;;; -------- begin -------- + +(test (let () (begin) #f) #f) +(test (let () (begin (begin (begin (begin)))) #f) #f) +(test (let () (begin (define x 2) (define y 1)) (+ x y)) 3) +(test (let () (begin (define x 0)) (begin (set! x 5) (+ x 1))) 6) +(test (let () (begin (define first car)) (first '(1 2))) 1) +(test (let () (begin (define x 3)) (begin (set! x 4) (+ x x))) 8) + +(if (equal? (begin 1) 1) + (begin + (test (let () (begin (define x 0)) (set! x (begin (begin 5))) (begin ((begin +) (begin x) (begin (begin 1))))) 6) + + (test (let ((x 5)) + (begin (begin (begin) + (begin (begin (begin) (define foo (lambda (y) (bar3 x y))) + (begin))) + (begin)) + (begin) + (begin) + (begin (define bar3 (lambda (a b) (+ (* a b) a)))) + (begin)) + (begin) + (begin (foo (+ x 3)))) + 45) + + (for-each + (lambda (arg) + (test (begin arg) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + + (test (if (= 1 1) (begin 2) (begin 3)) 2) + )) + +(test (let ((begin 3)) (+ begin 1)) 4) +(test ((lambda (x) (begin (set! x 1) (let ((a x)) (+ a 1)))) 2) 2) +;;; apparently these can be considered errors or not (guile says error, stklos and gauche do not) +;(test (begin (define x 0) (+ x 1)) 1) +;(test ((lambda () (begin (define x 0) (+ x 1)))) 1) +;(test (let ((f (lambda () (begin (define x 0) (+ x 1))))) (f)) 1) + +(test ((lambda () (begin (define x 0)) (+ x 1))) 1) +(test (let ((f (lambda () (begin (define x 0)) (+ x 1)))) (f)) 1) +(test (let ((x 32)) (begin (define x 3)) x) 3) +(test ((lambda (x) (begin (define x 3)) x) 32) 3) +(test (let* ((x 32) (y x)) (define x 3) y) 32) + +;(test (let ((z 0)) (begin (define x 32)) (begin (define y x)) (set! z y) z) 32) ; so begin is like let*? -- guile uses letrec here = error +;(test (let ((z 0)) (begin (define x 32) (define y x)) (set! z y) z) 32) ; similarly here +;;; I can't find anything in r5rs.html that mandates letrec here, or that says it's in error + + + + +;;; -------- apply -------- + +(test (apply (lambda (a b) (+ a b)) (list 3 4)) 7) +(test (apply + 10 (list 3 4)) 17) +(test (apply list '()) '()) +(test (apply + '(1 2)) 3) +(test (apply - '(1 2)) -1) +(test (apply max 3 5 '(2 7 3)) 7) +(test (apply cons '((+ 2 3) 4)) '((+ 2 3) . 4)) +(test (apply + '()) 0) +(test (apply + (list 3 4)) 7) +(test (apply + '()) 0) +(test (apply + 2 '(3)) 5) +(test (apply + 2 3 '()) 5) +(test (apply + '(2 3)) 5) +(test (apply list 1 '(2 3)) (list 1 2 3)) +(test (apply apply (list list 1 2 '(3))) (list 1 2 3)) +(test (vector? (apply make-vector '(1))) #t) +(test (apply make-vector '(1 1)) '#(1)) +(test (let* ((x '(1 2 3)) (y (apply list x))) (not (eq? x y))) #t) ; is this standard? +(test (apply min '(1 2 3 5 4 0 9)) 0) +(test (apply min 1 2 4 3 '(4 0 9)) 0) +(test (apply vector 1 2 '(3)) '#(1 2 3)) +(test (apply (lambda (x . y) x) (list 1 2 3)) 1) +(test (apply * (list 2 (apply + 1 2 '(3)))) 12) +(test (apply (if (> 3 2) + -) '(3 2)) 5) + +(for-each + (lambda (arg) + (test (apply (lambda (x) x) (list arg)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(test (apply cadadr (list '''4)) 4) +(test (apply string-ref "hi" '(0)) #\h) +(test (let ((x (string-copy "hi"))) (apply string-set! x 0 '(#\c)) x) "ci") +(test (apply apply (list + '(3 2))) 5) +(test (apply apply apply apply (list (list (list + '(3 2))))) 5) +(test (apply + 1 2 (list 3 4)) 10) + + + +;;; -------- define -------- +;;; +;;; trying to avoid top-level definitions here + +(let () + (define x 2) + (test (+ x 1) 3) + (set! x 4) + (test (+ x 1) 5) + (let () + (define (tprint x) #t) + (test (tprint 56) #t) + (let () + (define first car) + (test (first '(1 2)) 1) + (let () + (define foo (lambda () (define x 5) x)) + (test (foo) 5) + (let () + (define (foo x) ((lambda () (define x 5) x)) x) + (test (foo 88) 88)))))) + + +(test (letrec ((foo (lambda (arg) (or arg (and (procedure? foo) (foo 99)))))) (define bar4 (foo #f)) (foo #f)) 99) +(test (letrec ((foo 77) (bar5 #f) (retfoo (lambda () foo))) (define baz (retfoo)) (retfoo)) 77) + +;(test (let () (define .. 1) ..) 1) + +(test (let () (define (hi a) (+ a 1)) (hi 2)) 3) +(test (let () (define (hi a . b) (+ a (cadr b) 1)) (hi 2 3 4)) 7) +(test (let () (define (hi) 1) (hi)) 1) +(test (let () (define (hi . a) (apply + a)) (hi 1 2 3)) 6) + +(for-each + (lambda (arg) + (test (let () (define x arg) x) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +(test ((lambda (x) (define (hi a) (+ a 1)) (hi x)) 1) 2) +(test (let ((x 2)) (define f (lambda (y) (+ y x))) (f 3)) 5) +(begin (define r5rstest-plus (lambda (x y) (+ x y))) (define r5rstest-x 32)) +(test (r5rstest-plus r5rstest-x 3) 35) + + + + + +;;; -------- values, call-with-values -------- + +;(test (call-with-values (lambda () (values 1 2 3)) +) 6) +;(test (call-with-values (lambda () (values 4 5)) (lambda (a b) b)) 5) +;(test (call-with-values (lambda () (values 4 5)) (lambda (a b) (+ a b))) 9) +;(test (call-with-values * -) -1) ; right... +;(test (values 1) 1) +;(test (call-with-values (lambda () (values 1 2 3 4)) list) (list 1 2 3 4)) +;(test (+ (values 1) (values 2)) 3) +;(test (+ (values '1) (values '2)) 3) +;(test (if (values #t) 1 2) 1) +;(test (if (values '#t) 1 2) 1) +;(test (values 1 2 3) (values 1 2 3)) +;;(test (call-with-values (lambda () (values)) list) '()) +;(test (call-with-values (lambda () 4) (lambda (x) x)) 4) +;(test (let () (values 1 2 3) 4) 4) +;(test (apply + (values '())) 0) +; +;(for-each +; (lambda (arg) +; (test (values arg) arg)) +; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) +; +;(for-each +; (lambda (arg) +; (test (call-with-values (lambda () (values arg arg)) (lambda (a b) b)) arg)) +; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) +; +;(test (call-with-values (lambda () (values "hi" 1 3/2 'a)) (lambda (a b c d) (+ b c))) 5/2) +;;(test (call-with-values values (lambda arg arg)) '()) +;(test (string-ref (values "hi") 1) #\i) +; +;(test (letrec ((split (lambda (ls) +; (if (or (null? ls) (null? (cdr ls))) +; (values ls '()) +; (call-with-values +; (lambda () (split (cddr ls))) +; (lambda (odds evens) +; (values (cons (car ls) odds) +; (cons (cadr ls) evens)))))))) +; (split '(a b c d e f))) +; (values '(a c e) '(b d f))) +; +;;(test (call-with-values (lambda () (call/cc (lambda (k) (k 2 3)))) (lambda (x y) (list x y))) '(2 3)) +; ;;; s7: (lambda (x y) (list x y)): not enough arguments: (2) +; +;(test (let ((values 3)) (+ 2 values)) 5) +;(test (apply values (list 1 2)) (values 1 2)) +;(test (let ((a (values 1 2))) a) (values 1 2)) +;(test (let ((a (values 1))) a) 1) +; +;(test (call-with-values (lambda () 2) (lambda (x) x)) 2) + + + +;;; -------- let, let*, letrec -------- + +(test (let ((x 2) (y 3)) (* x y)) 6) +(test (let ((x 32)) (let ((x 3) (y x)) y)) 32) +(test (let ((x 32)) (let* ((x 3) (y x)) y)) 3) +(test (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x))) 35) +(test (let ((x 2) (y 3)) (let* ((x 7) (z (+ x y))) (* z x))) 70) +(test (letrec ((even? (lambda (n) (if (zero? n) #t (odd? (- n 1))))) (odd? (lambda (n) (if (zero? n) #f (even? (- n 1)))))) (even? 88)) #t) +(test (let loop ((numbers '(3 -2 1 6 -5)) + (nonneg '()) + (neg '())) + (cond ((null? numbers) + (list nonneg neg)) + ((>= (car numbers) 0) + (loop (cdr numbers) (cons (car numbers) nonneg) neg)) + ((< (car numbers) 0) + (loop (cdr numbers) nonneg (cons (car numbers) neg))))) + '((6 1 3) (-5 -2))) + +(test (let ((x 3)) (define x 5) x) 5) +(test (let* () (define x 8) x) 8) +(test (letrec () (define x 9) x) 9) +(test (letrec ((x 3)) (define x 10) x) 10) +(test (let foo () 1) 1) +(test (let ((f -)) (let f ((n (f 1))) n)) -1) +(test (let () 1 2 3 4) 4) + +(test (let ((x 1)) (let ((x 32) (y x)) y)) 1) +(test (let ((x 1)) (letrec ((y (if #f x 1)) (x 32)) 1)) 1) +(test (let ((x 1)) (letrec ((y (lambda () (+ 1 x))) (x 32)) (y))) 33) ; good grief! -- (let ((x 1)) (letrec ((y (* 0 x)) (x 32)) y)) +(test (let* ((x 1) (f (letrec ((y (lambda () (+ 1 x))) (x 32)) y))) (f)) 33) +(test (letrec ((x 1) (y (let ((x 2)) x))) (+ x y)) 3) +(test (letrec ((f (lambda () (+ x 3))) (x 2)) (f)) 5) +(test (let* ((x 1) (x 2)) x) 2) +(test (let* ((x 1) (y x)) y) 1) +(test (let ((x 1)) (let ((x 32) (y x)) (+ x y))) 33) +(test (let ((x 1)) (let* ((x 32) (y x)) (+ x y))) 64) +(test (let ((x 'a) (y '(b c))) (cons x y)) '(a b c)) +(test (let ((x 0) (y 1)) (let ((x y) (y x)) (list x y))) (list 1 0)) +(test (let ((x 0) (y 1)) (let* ((x y) (y x)) (list x y))) (list 1 1)) +(test (letrec ((sum (lambda (x) (if (zero? x) 0 (+ x (sum (- x 1))))))) (sum 5)) 15) +(test (let ((divisors (lambda (n) (let f ((i 2)) (cond ((>= i n) '()) ((integer? (/ n i)) (cons i (f (+ i 1)))) (else (f (+ i 1)))))))) (divisors 32)) '(2 4 8 16)) +(test (let ((a -1)) (let loop () (if (not (positive? a)) (begin (set! a (+ a 1)) (loop)))) a) 1) +;(test (let* ((let 3) (x let)) (+ x let)) 6) ; Commented out for Haschoo: since let* uses let in its definition, this can't work +(test (let () (let () (let () '()))) '()) +(test (let ((x 1)) (let ((y 0)) (begin (let ((x (* 2 x))) (set! y x))) y)) 2) +(test (let* ((x 1) (x (+ x 1)) (x (+ x 2))) x) 4) +; (test (let ((.. 2) (.... 4) (..... +)) (..... .. ....)) 6) + +(for-each + (lambda (arg) + (test (let ((x arg)) x) arg)) + (list "hi" -1 #\a "" '() '#() (current-output-port) 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t abs (list 1 2 3) '(1 . 2))) + +(test (let ((x 1)) (= 1 (let ((y 2)) (set! x y) x)) (+ x 1)) 3) +(test (let ((x 1)) (let ((xx (lambda (a) (set! x a) a))) (= 1 (xx 2))) (+ x 1)) 3) + + +;(let ((initial-chars "aA!$%&*/:<=>?^_~") +; (subsequent-chars "9aA!$%&*+-./:<=>?@^_~") +; (ctr 0)) +; (display (format #f "(let (")) +; (do ((i 0 (+ i 1))) +; ((= i (string-length initial-chars))) +; (display (format #f "(~A ~D) " (string (string-ref initial-chars i)) ctr)) +; (set! ctr (+ ctr 1))) +; +; (do ((i 0 (+ i 1))) +; ((= i (string-length initial-chars))) +; (do ((k 0 (+ k 1))) +; ((= k (string-length subsequent-chars))) +; (display (format #f "(~A ~D) " (string (string-ref initial-chars i) (string-ref subsequent-chars k)) ctr)) +; (set! ctr (+ ctr 1)))) +; +; (display (format #f ")~% (+ ")) +; (do ((i 0 (+ i 1))) +; ((= i (string-length initial-chars))) +; (display (format #f "~A " (string (string-ref initial-chars i))))) +; +; (do ((i 0 (+ i 1))) +; ((= i (string-length initial-chars))) +; (do ((k 0 (+ k 1))) +; ((= k (string-length subsequent-chars))) +; (display (format #f "~A " (string (string-ref initial-chars i) (string-ref subsequent-chars k)))))) +; +; (display (format #f "))~%"))) + +;(num-test (let ((a 0) (A 1) (! 2) ($ 3) (% 4) (& 5) (* 6) (/ 7) (: 8) (< 9) (= 10) (> 11) (? 12) (^ 13) (_ 14) (~ 15) (a9 16) (aa 17) (aA 18) (a! 19) (a$ 20) (a% 21) (a& 22) (a* 23) (a+ 24) (a- 25) (a. 26) (a/ 27) (a: 28) (a< 29) (a= 30) (a> 31) (a? 32) (a@ 33) (a^ 34) (a_ 35) (a~ 36) (A9 37) (Aa 38) (AA 39) (A! 40) (A$ 41) (A% 42) (A& 43) (A* 44) (A+ 45) (A- 46) (A. 47) (A/ 48) (A: 49) (A< 50) (A= 51) (A> 52) (A? 53) (A@ 54) (A^ 55) (A_ 56) (A~ 57) (!9 58) (!a 59) (!A 60) (!! 61) (!$ 62) (!% 63) (!& 64) (!* 65) (!+ 66) (!- 67) (!. 68) (!/ 69) (!: 70) (!< 71) (!= 72) (!> 73) (!? 74) (!@ 75) (!^ 76) (!_ 77) (!~ 78) ($9 79) ($a 80) ($A 81) ($! 82) ($$ 83) ($% 84) ($& 85) ($* 86) ($+ 87) ($- 88) ($. 89) ($/ 90) ($: 91) ($< 92) ($= 93) ($> 94) ($? 95) ($@ 96) ($^ 97) ($_ 98) ($~ 99) (%9 100) (%a 101) (%A 102) (%! 103) (%$ 104) (%% 105) (%& 106) (%* 107) (%+ 108) (%- 109) (%. 110) (%/ 111) (%: 112) (%< 113) (%= 114) (%> 115) (%? 116) (%@ 117) (%^ 118) (%_ 119) (%~ 120) (&9 121) (&a 122) (&A 123) (&! 124) (&$ 125) (&% 126) (&& 127) (&* 128) (&+ 129) (&- 130) (&. 131) (&/ 132) (&: 133) (&< 134) (&= 135) (&> 136) (&? 137) (&@ 138) (&^ 139) (&_ 140) (&~ 141) (*9 142) (*a 143) (*A 144) (*! 145) (*$ 146) (*% 147) (*& 148) (** 149) (*+ 150) (*- 151) (*. 152) (*/ 153) (*: 154) (*< 155) (*= 156) (*> 157) (*? 158) (*@ 159) (*^ 160) (*_ 161) (*~ 162) (/9 163) (/a 164) (/A 165) (/! 166) (/$ 167) (/% 168) (/& 169) (/* 170) (/+ 171) (/- 172) (/. 173) (// 174) (/: 175) (/< 176) (/= 177) (/> 178) (/? 179) (/@ 180) (/^ 181) (/_ 182) (/~ 183) (:9 184) (:a 185) (:A 186) (:! 187) (:$ 188) (:% 189) (:& 190) (:* 191) (:+ 192) (:- 193) (:. 194) (:/ 195) (:: 196) (:< 197) (:= 198) (:> 199) (:? 200) (:@ 201) (:^ 202) (:_ 203) (:~ 204) (<9 205) ( 220) ( 241) (=? 242) (=@ 243) (=^ 244) (=_ 245) (=~ 246) (>9 247) (>a 248) (>A 249) (>! 250) (>$ 251) (>% 252) (>& 253) (>* 254) (>+ 255) (>- 256) (>. 257) (>/ 258) (>: 259) (>< 260) (>= 261) (>> 262) (>? 263) (>@ 264) (>^ 265) (>_ 266) (>~ 267) (?9 268) (?a 269) (?A 270) (?! 271) (?$ 272) (?% 273) (?& 274) (?* 275) (?+ 276) (?- 277) (?. 278) (?/ 279) (?: 280) (?< 281) (?= 282) (?> 283) (?? 284) (?@ 285) (?^ 286) (?_ 287) (?~ 288) (^9 289) (^a 290) (^A 291) (^! 292) (^$ 293) (^% 294) (^& 295) (^* 296) (^+ 297) (^- 298) (^. 299) (^/ 300) (^: 301) (^< 302) (^= 303) (^> 304) (^? 305) (^@ 306) (^^ 307) (^_ 308) (^~ 309) (_9 310) (_a 311) (_A 312) (_! 313) (_$ 314) (_% 315) (_& 316) (_* 317) (_+ 318) (_- 319) (_. 320) (_/ 321) (_: 322) (_< 323) (_= 324) (_> 325) (_? 326) (_@ 327) (_^ 328) (__ 329) (_~ 330) (~9 331) (~a 332) (~A 333) (~! 334) (~$ 335) (~% 336) (~& 337) (~* 338) (~+ 339) (~- 340) (~. 341) (~/ 342) (~: 343) (~< 344) (~= 345) (~> 346) (~? 347) (~@ 348) (~^ 349) (~_ 350) (~~ 351) ) +; (+ a A ! $ % & * / : < = > ? ^ _ ~ a9 aa aA a! a$ a% a& a* a+ a- a. a/ a: a< a= a> a? a@ a^ a_ a~ A9 Aa AA A! A$ A% A& A* A+ A- A. A/ A: A< A= A> A? A@ A^ A_ A~ !9 !a !A !! !$ !% !& !* !+ !- !. !/ !: !< != !> !? !@ !^ !_ !~ $9 $a $A $! $$ $% $& $* $+ $- $. $/ $: $< $= $> $? $@ $^ $_ $~ %9 %a %A %! %$ %% %& %* %+ %- %. %/ %: %< %= %> %? %@ %^ %_ %~ &9 &a &A &! &$ &% && &* &+ &- &. &/ &: &< &= &> &? &@ &^ &_ &~ *9 *a *A *! *$ *% *& ** *+ *- *. */ *: *< *= *> *? *@ *^ *_ *~ /9 /a /A /! /$ /% /& /* /+ /- /. // /: /< /= /> /? /@ /^ /_ /~ :9 :a :A :! :$ :% :& :* :+ :- :. :/ :: :< := :> :? :@ :^ :_ :~ <9 =? =@ =^ =_ =~ >9 >a >A >! >$ >% >& >* >+ >- >. >/ >: >< >= >> >? >@ >^ >_ >~ ?9 ?a ?A ?! ?$ ?% ?& ?* ?+ ?- ?. ?/ ?: ?< ?= ?> ?? ?@ ?^ ?_ ?~ ^9 ^a ^A ^! ^$ ^% ^& ^* ^+ ^- ^. ^/ ^: ^< ^= ^> ^? ^@ ^^ ^_ ^~ _9 _a _A _! _$ _% _& _* _+ _- _. _/ _: _< _= _> _? _@ _^ __ _~ ~9 ~a ~A ~! ~$ ~% ~& ~* ~+ ~- ~. ~/ ~: ~< ~= ~> ~? ~@ ~^ ~_ ~~ )) +; 61776) + +(test (let ()(+ (let ((x 0) (y 1) (z 2) )(+ x y (let ((x 3) )(+ x (let ()(+ (let () + (+ (let ((x 0) (y 1) (z 2) )(+ x y z (let ((x 3) )(+ x (let ((x 4) (y 5) (z 6) ) + (+ x y z (let ()(+ (let ((x 7) )(+ x (let ()(+ (let ((x 8) (y 9) ) + (+ x (let ((x 10) (y 11) (z 12) )(+ x )))))))))))))))))))))))))) + 50) +(test (let* ((x 0) (y x) )(+ x y (let ()(+ (let ((x 2) )(+ x (let ()(+ (let ((x 4) ) + (+ x (let ((x 5) )(+ x (let ((x 6) (y x) (z y) )(+ x (let ((x 7) (y x) ) + (+ x (let ((x 8) (y x) )(+ x y (let ((x 9) (y x) (z y) )(+ x )))))))))))))))))))) + 48) +(test (let* ((x 0) (y x) )(+ x y (let* ()(+ (let* ((x 2) )(+ x (let* ()(+ (let* ((x 4) ) + (+ x (let* ((x 5) )(+ x (let* ((x 6) (y x) (z y) )(+ x (let* ((x 7) (y x) ) + (+ x (let* ((x 8) (y x) )(+ x y (let* ((x 9) (y x) (z y) )(+ x )))))))))))))))))))) + 49) + + + + +;;; -------- call/cc -------- +;;; +;;; some of these were originally from Al Petrovsky, Scott G Miller, Matthias Radestock, J H Brown, Dorai Sitaram, +;;; and probably others. + +;(let* ((next-leaf-generator (lambda (obj eot) +; (letrec ((return #f) +; (cont (lambda (x) +; (recur obj) +; (set! cont (lambda (x) (return eot))) +; (cont #f))) +; (recur (lambda (obj) +; (if (pair? obj) +; (for-each recur obj) +; (call-with-current-continuation +; (lambda (c) +; (set! cont c) +; (return obj))))))) +; (lambda () (call-with-current-continuation +; (lambda (ret) (set! return ret) (cont #f))))))) +; (leaf-eq? (lambda (x y) +; (let* ((eot (list 'eot)) +; (xf (next-leaf-generator x eot)) +; (yf (next-leaf-generator y eot))) +; (letrec ((loop (lambda (x y) +; (cond ((not (eq? x y)) #f) +; ((eq? eot x) #t) +; (else (loop (xf) (yf))))))) +; (loop (xf) (yf))))))) +; +; (test (leaf-eq? '(a (b (c))) '((a) b c)) #t) +; (test (leaf-eq? '(a (b (c))) '((a) b c d)) #f)) +; +;(test (let ((r #f) +; (a #f) +; (b #f) +; (c #f) +; (i 0)) +; (let () +; (set! r (+ 1 (+ 2 (+ 3 (call/cc (lambda (k) (set! a k) 4)))) +; (+ 5 (+ 6 (call/cc (lambda (k) (set! b k) 7)))))) +; (if (not c) +; (set! c a)) +; (set! i (+ i 1)) +; (case i +; ((1) (a 5)) +; ((2) (b 8)) +; ((3) (a 6)) +; ((4) (c 4))) +; r)) +; 28) +; +;(test (let ((r #f) +; (a #f) +; (b #f) +; (c #f) +; (i 0)) +; (let () +; (set! r (+ 1 (+ 2 (+ 3 (call/cc (lambda (k) (set! a k) 4)))) +; (+ 5 (+ 6 (call/cc (lambda (k) (set! b k) 7)))))) +; (if (not c) +; (set! c a)) +; (set! i (+ i 1)) +; (case i +; ((1) (b 8)) +; ((2) (a 5)) +; ((3) (b 7)) +; ((4) (c 4))) +; r)) +; 28) +; +; (test (let ((k1 #f) +; (k2 #f) +; (k3 #f) +; (state 0)) +; (define (identity x) x) +; (define (fn) +; ((identity (if (= state 0) +; (call/cc (lambda (k) (set! k1 k) +)) +; +)) +; (identity (if (= state 0) +; (call/cc (lambda (k) (set! k2 k) 1)) +; 1)) +; (identity (if (= state 0) +; (call/cc (lambda (k) (set! k3 k) 2)) +; 2)))) +; (define (check states) +; (set! state 0) +; (let* ((res '()) +; (r (fn))) +; (set! res (cons r res)) +; (if (null? states) +; res +; (begin (set! state (car states)) +; (set! states (cdr states)) +; (case state +; ((1) (k3 4)) +; ((2) (k2 2)) +; ((3) (k1 -))))))) +; (map check '((1 2 3) (1 3 2) (2 1 3) (2 3 1) (3 1 2) (3 2 1)))) +; '((-1 4 5 3) (4 -1 5 3) (-1 5 4 3) (5 -1 4 3) (4 5 -1 3) (5 4 -1 3))) +; +;(test (let ((x '()) +; (y 0)) +; (call/cc +; (lambda (escape) +; (let* ((yin ((lambda (foo) +; (set! x (cons y x)) +; (if (= y 10) +; (escape x) +; (begin +; (set! y 0) +; foo))) +; (call/cc (lambda (bar) bar)))) +; (yang ((lambda (foo) +; (set! y (+ y 1)) +; foo) +; (call/cc (lambda (baz) baz))))) +; (yin yang))))) +; '(10 9 8 7 6 5 4 3 2 1 0)) +; +;(test (let ((c #f)) +; (let ((r '())) +; (let ((w (let ((v 1)) +; (set! v (+ (call-with-current-continuation +; (lambda (c0) (set! c c0) v)) +; v)) +; (set! r (cons v r)) +; v))) +; (if (<= w 1024) (c w) r)))) +; '(2048 1024 512 256 128 64 32 16 8 4 2)) +; +;(test (let ((cc #f) +; (r '())) +; (let ((s (list 1 2 3 4 (call/cc (lambda (c) (set! cc c) 5)) 6 7 8))) +; (if (null? r) +; (begin (set! r s) (cc -1)) +; (list r s)))) +; '((1 2 3 4 5 6 7 8) (1 2 3 4 -1 6 7 8))) +; +;(test (call/cc (lambda (c) (0 (c 1)))) 1) +;(test (call/cc (lambda (k) (k "foo"))) "foo") +;(test (call/cc (lambda (k) "foo")) "foo") +;(test (call/cc (lambda (k) (k "foo") "oops")) "foo") +; +;(test (let ((listindex (lambda (e l) +; (call/cc (lambda (not_found) +; (letrec ((loop +; (lambda (l) +; (cond +; ((null? l) (not_found #f)) +; ((equal? e (car l)) 0) +; (else (+ 1 (loop (cdr l)))))))) +; (loop l))))))) +; (listindex 1 '(0 3 2 4 8))) +; #f) +; +;(test (let ((product (lambda (li) +; (call/cc (lambda (break) +; (let loop ((l li)) +; (cond +; ((null? l) 1) +; ((= (car l) 0) (break 0)) +; (else (* (car l) (loop (cdr l))))))))))) +; (product '(1 2 3 0 4 5 6))) +; 0) +; +;(test (let ((lst '())) +; ((call/cc +; (lambda (goto) +; (letrec ((start (lambda () (set! lst (cons "start" lst)) (goto next))) +; (next (lambda () (set! lst (cons "next" lst)) (goto last))) +; (last (lambda () (set! lst (cons "last" lst)) (reverse lst)))) +; start))))) +; '("start" "next" "last")) +; +;(test (let ((cont #f)) +; (letrec ((x (call-with-current-continuation (lambda (c) (set! cont c) 0))) +; (y (call-with-current-continuation (lambda (c) (set! cont c) 0)))) +; (if cont +; (let ((c cont)) +; (set! cont #f) +; (set! x 1) +; (set! y 1) +; (c 0)) +; (+ x y)))) +; 0) +; +;(test (letrec ((x (call/cc list)) +; (y (call/cc list))) +; (cond ((procedure? x) (x (pair? y))) +; ((procedure? y) (y (pair? x)))) +; (let ((x (car x)) (y (car y))) +; (and (call/cc x) (call/cc y) (call/cc x)))) +; #t) +; +;(test (letrec ((x (call-with-current-continuation +; (lambda (c) +; (list #t c))))) +; (if (car x) +; ((cadr x) (list #f (lambda () x))) +; (eq? x ((cadr x))))) +; #t) +; +;(test (call/cc (lambda (c) (0 (c 1)))) 1) +; +;(test (let ((member (lambda (x ls) +; (call/cc +; (lambda (break) +; (do ((ls ls (cdr ls))) +; ((null? ls) #f) +; (if (equal? x (car ls)) +; (break ls)))))))) +; (list (member 'd '(a b c)) +; (member 'b '(a b c)))) +; '(#f (b c))) +; +;(test (+ 2 (call/cc (lambda (k) (* 5 (k 4))))) 6) +; +;(test (let ((x (call/cc (lambda (k) k)))) +; (x (lambda (y) "hi"))) +; "hi") +; +;(test (((call/cc (lambda (k) k)) (lambda (x) x)) "hi") "hi") +; +;(test (let ((return #f) +; (lst '())) +; (let ((val (+ 1 (call/cc +; (lambda (cont) +; (set! return cont) +; 1))))) +; (set! lst (cons val lst))) +; (if (= (length lst) 1) +; (return 10) +; (if (= (length lst) 2) +; (return 20))) +; (reverse lst)) +; '(2 11 21)) +; +;(test (let ((r1 #f) +; (r2 #f) +; (lst '())) +; (define (somefunc x y) +; (+ (* 2 (expt x 2)) (* 3 y) 1)) +; (let ((val (somefunc (call/cc +; (lambda (c1) +; (set! r1 c1) +; (c1 1))) +; (call/cc +; (lambda (c2) +; (set! r2 c2) +; (c2 1)))))) +; (set! lst (cons val lst))) +; (if (= (length lst) 1) +; (r1 2) +; (if (= (length lst) 2) +; (r2 3))) +; (reverse lst)) +; '(6 12 18)) +; +;(let ((tree->generator +; (lambda (tree) +; (let ((caller '*)) +; (letrec +; ((generate-leaves +; (lambda () +; (let loop ((tree tree)) +; (cond ((null? tree) 'skip) +; ((pair? tree) +; (loop (car tree)) +; (loop (cdr tree))) +; (else +; (call/cc +; (lambda (rest-of-tree) +; (set! generate-leaves +; (lambda () +; (rest-of-tree 'resume))) +; (caller tree)))))) +; (caller '())))) +; (lambda () +; (call/cc +; (lambda (k) +; (set! caller k) +; (generate-leaves))))))))) +; (let ((same-fringe? +; (lambda (tree1 tree2) +; (let ((gen1 (tree->generator tree1)) +; (gen2 (tree->generator tree2))) +; (let loop () +; (let ((leaf1 (gen1)) +; (leaf2 (gen2))) +; (if (eqv? leaf1 leaf2) +; (if (null? leaf1) #t (loop)) +; #f))))))) +; +; (test (same-fringe? '(1 (2 3)) '((1 2) 3)) #t) +; (test (same-fringe? '(1 2 3) '(1 (3 2))) #f))) +; +; +;(for-each +; (lambda (arg) +; (test (let ((ctr 0)) +; (let ((val (call/cc (lambda (exit) +; (do ((i 0 (+ i 1))) +; ((= i 10) 'gad) +; (set! ctr (+ ctr 1)) +; (if (= i 1) +; (exit arg))))))) +; (and (equal? val arg) +; (= ctr 2)))) +; #t)) +; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) +; +;(for-each +; (lambda (arg) +; (test (let ((ctr 0)) +; (let ((val (call/cc (lambda (exit) +; (do ((i 0 (+ i 1))) +; ((= i 10) arg) +; (set! ctr (+ ctr 1)) +; (if (= i 11) +; (exit 'gad))))))) +; (and (equal? val arg) +; (= ctr 10)))) +; #t)) +; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) +; +;(test (let ((c #f) +; (r (string-copy "testing-hiho"))) +; (let ((v (call/cc (lambda (c0) (set! c c0) (list #\a 0))))) +; (let ((chr (car v)) +; (index (cadr v))) +; (string-set! r index chr) +; (set! index (+ index 1)) +; (if (<= index 8) +; (c (list (integer->char (+ 1 (char->integer chr))) index)) +; r)))) +; "abcdefghiiho") +; +;(test (let ((x 0) +; (again #f)) +; (call/cc (lambda (r) (set! again r))) +; (set! x (+ x 1)) +; (if (< x 3) (again)) +; x) +; 3) +; +;(test (let* ((x 0) +; (again #f) +; (func (lambda (r) (set! again r)))) +; (call/cc func) +; (set! x (+ x 1)) +; (if (< x 3) (again)) +; x) +; 3) +; +;(test (let* ((x 0) +; (again #f)) +; (call/cc (let () +; (lambda (r) (set! again r)))) +; (set! x (+ x 1)) +; (if (< x 3) (again)) +; x) +; 3) +; +;(test (call/cc procedure?) #t) +;(test (procedure? (call/cc (lambda (a) a))) #t) +; +;(for-each +; (lambda (arg) +; (test (call/cc (lambda (a) arg)) arg)) +; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) +; +;(let ((a (call/cc (lambda (a) a)))) +; (test (eq? a a) #t) +; (test (eqv? a a) #t) +; (test (equal? a a) #t) +; (for-each +; (lambda (ques) +; (if (ques a) +; (begin (display ques) (display " ") (display a) (display " returned #t?") (newline)))) +; question-ops)) +; +;(test (let ((conts (make-vector 4 #f))) +; (let ((lst '())) +; (set! lst (cons (+ (call/cc (lambda (a) (vector-set! conts 0 a) 0)) +; (call/cc (lambda (a) (vector-set! conts 1 a) 0)) +; (call/cc (lambda (a) (vector-set! conts 2 a) 0)) +; (call/cc (lambda (a) (vector-set! conts 3 a) 0))) +; lst)) +; (let ((len (length lst))) +; (if (< len 4) +; ((vector-ref conts (- len 1)) (+ len 1)) +; (reverse lst))))) +; '(0 2 5 9)) +; +;(test (let ((conts '())) +; (let ((lst '())) +; (set! lst (cons (+ (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1)) +; (* (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1)) +; (+ (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1)) +; (* (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) 1)) 2)))) +; lst)) +; (let ((len (length lst))) +; (if (<= len 4) +; ((list-ref conts (- len 1)) (+ len 1)) +; (reverse lst))))) +; ; (+ 1 (* 1 (+ 1 (* 1 2)))) to start +; ; (+ 1 ... 2 ) +; ; (+ 1 ... 3 [1] ) +; ; (+ 1 ...4 [1] ) +; ; (+ 5 [1] ) +; '(4 6 6 13 8)) +; +;(test (let ((conts (make-vector 4 #f))) +; (let ((lst '())) +; (set! lst (cons (+ (call/cc (lambda (a) (if (not (vector-ref conts 0)) (vector-set! conts 0 a)) 0)) +; (call/cc (lambda (a) (if (not (vector-ref conts 1)) (vector-set! conts 1 a)) 0)) +; (call/cc (lambda (a) (if (not (vector-ref conts 2)) (vector-set! conts 2 a)) 0)) +; (call/cc (lambda (a) (if (not (vector-ref conts 3)) (vector-set! conts 3 a)) 0))) +; lst)) +; (let ((len (length lst))) +; (if (< len 4) +; ((vector-ref conts (- len 1)) (+ len 1)) +; (reverse lst))))) +; '(0 2 3 4)) +; +;(test (let ((conts '())) +; (let ((lst '())) +; (set! lst (cons (+ (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 1 0) +; (* (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 2 1) +; (+ (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 1 0) +; (* (if (call/cc (lambda (a) (if (< (length conts) 4) (set! conts (cons a conts))) #f)) 2 1) 2)))) +; lst)) +; (let ((len (length lst))) +; (if (<= len 4) +; ((list-ref conts (- len 1)) #t) +; (reverse lst))))) +; ; (+ 0 (* 1 (+ 0 (* 1 2)))) to start +; ; (+ 0 ... 2 ) +; ; (+ 0 ... 1 [1] ) +; ; (+ 0 ...2 [0] ) +; ; (+ 1 [1] ) +; '(2 4 3 4 3)) +; +;(test (let ((call/cc 2)) (+ call/cc 1)) 3) +; +; +;(let ((r5rs-ratify (lambda (ux err) +; (if (= ux 0.0) +; 0 +; (let ((tt 1) +; (a1 0) +; (b2 0) +; (a2 1) +; (b1 1) +; (a 0) +; (b 0) +; (ctr 0) +; (x (/ 1 ux))) +; (call-with-current-continuation +; (lambda (return) +; (do () +; (#f) +; (set! a (+ (* a1 tt) a2)) +; (set! b (+ (* tt b1) b2)) +; ;(display (format #f "~A ~A~%" a (- b a))) +; (if (or (<= (abs (- ux (/ a b))) err) +; (> ctr 1000)) +; (return (/ a b))) +; (set! ctr (+ 1 ctr)) +; (if (= x tt) (return)) +; (set! x (/ 1 (- x tt))) +; (set! tt (inexact->exact (floor x))) +; (set! a2 a1) +; (set! b2 b1) +; (set! a1 a) +; (set! b1 b))))))))) +; +; (test (r5rs-ratify (/ (log 2.0) (log 3.0)) 1/10000000) 665/1054) +; (if (positive? 2147483648) +; (test (r5rs-ratify (/ (log 2.0) (log 3.0)) 1/100000000000) 190537/301994))) +; +;(for-each +; (lambda (arg) +; (test (let ((ctr 0)) +; (let ((val (call/cc +; (lambda (exit) +; (for-each (lambda (a) +; (if (equal? a arg) (exit arg)) +; (set! ctr (+ ctr 1))) +; (list 0 1 2 3 arg 5)))))) +; (list ctr val))) +; (list 4 arg))) +; (list "hi" -1 #\a 11 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t '(1 . 2))) +; +;(test (+ 2 (call/cc (lambda (rtn) (+ 1 (let () (begin (define x (+ 1 (rtn 3)))) x))))) 5) +; +; +; +; +;;;; -------- dynamic-wind -------- +; +;(test (let ((ctr1 0) +; (ctr2 0) +; (ctr3 0)) +; (let ((ctr4 (dynamic-wind +; (lambda () (set! ctr1 (+ ctr1 1))) +; (lambda () (set! ctr2 (+ ctr2 1)) ctr2) +; (lambda () (set! ctr3 (+ ctr3 1)))))) +; (= ctr1 ctr2 ctr3 ctr4 1))) +; #t) +; +;(test (let ((ctr1 0) +; (ctr2 0) +; (ctr3 0)) +; (let ((ctr4 (call/cc (lambda (exit) +; (dynamic-wind +; (lambda () (set! ctr1 (+ ctr1 1))) +; (lambda () (exit ctr2) (set! ctr2 (+ ctr2 1)) ctr2) +; (lambda () (set! ctr3 (+ ctr3 1)) 123)))))) +; (and (= ctr1 ctr3 1) +; (= ctr2 ctr4 0)))) +; #t) +; +;(test (let ((ctr1 0) +; (ctr2 0) +; (ctr3 0)) +; (let ((ctr4 (call/cc (lambda (exit) +; (dynamic-wind +; (lambda () (exit ctr1) (set! ctr1 (+ ctr1 1))) +; (lambda () (set! ctr2 (+ ctr2 1)) ctr2) +; (lambda () (set! ctr3 (+ ctr3 1)))))))) +; (= ctr1 ctr2 ctr3 ctr4 0))) +; #t) +; +;(test (let ((ctr1 0) +; (ctr2 0) +; (ctr3 0)) +; (let ((ctr4 (call/cc (lambda (exit) +; (dynamic-wind +; (lambda () (set! ctr1 (+ ctr1 1))) +; (lambda () (set! ctr2 (+ ctr2 1)) ctr2) +; (lambda () (exit ctr3) (set! ctr3 (+ ctr3 1)))))))) +; (and (= ctr1 ctr2 1) +; (= ctr3 ctr4 0)))) +; #t) +; +;(test (let ((path '()) +; (c #f)) +; (let ((add (lambda (s) +; (set! path (cons s path))))) +; (dynamic-wind +; (lambda () (add 'connect)) +; (lambda () (add (call-with-current-continuation +; (lambda (c0) (set! c c0) 'talk1)))) +; (lambda () (add 'disconnect))) +; (if (< (length path) 4) +; (c 'talk2) +; (reverse path)))) +; '(connect talk1 disconnect connect talk2 disconnect)) +; +; +;(for-each +; (lambda (arg) +; (test (dynamic-wind (lambda () #f) (lambda () arg) (lambda () #f)) arg)) +; (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) +; +;(test (dynamic-wind (lambda () #f) (lambda () #f) (lambda () #f)) #f) +; +;(test (let ((identity (lambda (a) a))) +; (let ((x '()) +; (c #f)) +; (dynamic-wind +; (lambda () (set! x (cons 'a x))) +; (lambda () +; (dynamic-wind +; (lambda () (set! x (cons 'b x))) +; (lambda () +; (dynamic-wind +; (lambda () (set! x (cons 'c x))) +; (lambda () (set! c (call/cc identity))) +; (lambda () (set! x (cons 'd x))))) +; (lambda () (set! x (cons 'e x)))) +; (dynamic-wind +; (lambda () (set! x (cons 'f x))) +; (lambda () (if c (c #f))) +; (lambda () (set! x (cons 'g x))))) +; (lambda () (set! x (cons 'h x)))) +; (reverse x))) +; '(a b c d e f g b c d e f g h)) +; +;(test (dynamic-wind +; (lambda () #f) +; (lambda () (values 'a 'b 'c)) +; (lambda () #f)) +; (values 'a 'b 'c)) +; +;(test (let ((dynamic-wind 1)) (+ dynamic-wind 2)) 3) +; +;(test (let ((ctr1 0) +; (ctr2 0) +; (ctr3 0)) +; (let ((val (dynamic-wind +; (lambda () #f) +; (lambda () +; (set! ctr1 1) +; (call/cc +; (lambda (exit) +; (exit 123) +; (set! ctr2 2) +; 321))) +; (lambda () +; (set! ctr3 3))))) +; (and (= ctr1 1) (= ctr2 0) (= ctr3 3) (= val 123)))) +; #t) +; +;(test (let ((ctr1 0)) +; (let ((val (dynamic-wind +; (let ((a 1)) +; (lambda () +; (set! ctr1 a))) +; (let ((a 10)) +; (lambda () +; (set! ctr1 (+ ctr1 a)) +; ctr1)) +; (let ((a 100)) +; (lambda () +; (set! ctr1 (+ ctr1 a))))))) +; (and (= ctr1 111) (= val 11)))) +; #t) +; +;(test (let ((ctr1 0)) +; (let ((val (+ 3 (dynamic-wind +; (let ((a 1)) +; (lambda () +; (set! ctr1 a))) +; (let ((a 10)) +; (lambda () +; (set! ctr1 (+ ctr1 a)) +; ctr1)) +; (let ((a 100)) +; (lambda () +; (set! ctr1 (+ ctr1 a))))) +; 1000))) +; (and (= ctr1 111) (= val 1014)))) +; #t) +; +;(test (let ((n 0)) +; (call-with-current-continuation +; (lambda (k) +; (dynamic-wind +; (lambda () +; (set! n (+ n 1)) +; (k)) +; (lambda () +; (set! n (+ n 2))) +; (lambda () +; (set! n (+ n 4)))))) +; n) +; 1) +; +;(test (let ((n 0)) +; (call-with-current-continuation +; (lambda (k) +; (dynamic-wind +; (lambda () #f) +; (lambda () +; (dynamic-wind +; (lambda () #f) +; (lambda () +; (set! n (+ n 1)) +; (k)) +; (lambda () +; (set! n (+ n 2)) +; ;(k) +; ))) +; (lambda () +; (set! n (+ n 4)))))) +; n) +; 7) +; +;(test (let ((n 0)) +; (call-with-current-continuation +; (lambda (k) +; (dynamic-wind +; (lambda () #f) +; (lambda () +; (dynamic-wind +; (lambda () #f) +; (lambda () +; (dynamic-wind +; (lambda () #f) +; (lambda () +; (set! n (+ n 1)) +; (k)) +; (lambda () +; (if (= n 1) +; (set! n (+ n 2)))))) +; (lambda () +; (if (= n 3) +; (set! n (+ n 4)))))) +; (lambda () +; (if (= n 7) +; (set! n (+ n 8))))))) +; n) +; 15) + + + +;;; -------- delay and force -------- + +(if with-delay + (begin + + (test (let ((stream-car (lambda (s) (car (force s)))) + (stream-cdr (lambda (s) (cdr (force s)))) + (counters (let next ((n 1)) (delay (cons n (next (+ n 1))))))) + (let* ((val1 (stream-car counters)) + (val2 (stream-car (stream-cdr counters)))) + (letrec ((stream-add (lambda (s1 s2) + (delay (cons + (+ (stream-car s1) (stream-car s2)) + (stream-add (stream-cdr s1) (stream-cdr s2))))))) + (let ((even-counters (stream-add counters counters))) + (let* ((val3 (stream-car even-counters)) + (val4 (stream-car (stream-cdr even-counters)))) + (list val1 val2 val3 val4)))))) + (list 1 2 2 4)) + + (test (force (delay (+ 1 2))) 3) + (test (let ((p (delay (+ 1 2)))) (list (force p) (force p))) (list 3 3)) + (test (letrec ((a-stream (letrec ((next (lambda (n) + (cons n (delay (next (+ n 1))))))) + (next 0))) + (head car) + (tail (lambda (stream) (force (cdr stream))))) + (head (tail (tail a-stream)))) + 2) + + (letrec ((count 0) + (p (delay (begin (set! count (+ count 1)) + (if (> count x) + count + (force p))))) + (x 5)) + (test (force p) 6) + (set! x 10) + (test (force p) 6)) + +; (test (let ((generate (lambda (use-it) +; (let loop ((i 0)) +; (if (< i 10) (begin (use-it i) (loop (+ i 1))))))) +; (generator->lazy-list (lambda (generator) +; (delay +; (call/cc (lambda (k-main) +; (generator +; (lambda (e) +; (call/cc (lambda (k-reenter) +; (k-main (cons e +; (delay +; (call/cc (lambda (k-new-main) +; (set! k-main k-new-main) +; (k-reenter #f)))))))))) +; (k-main '())))))) +; (fnull? (lambda (x) (null? (force x)))) +; (fcar (lambda (x) (car (force x)))) +; (fcdr (lambda (x) (cdr (force x))))) +; (letrec ((lazy-list->list (lambda (lz) +; (if (fnull? lz) '() +; (cons (fcar lz) (lazy-list->list (fcdr lz))))))) +; (lazy-list->list (generator->lazy-list generate)))) +; '(0 1 2 3 4 5 6 7 8 9)) + + (test (let* ((x 1) + (p (delay (+ x 1)))) + (force p) + (set! x (+ x 1)) + (force p)) + 2) + + (test (let* ((x 1) + (p #f)) + (let* ((x 2)) + (set! p (delay (+ x 1)))) + (force p)) + 3) + + (test (letrec ((count 0) + (x 5) + (p (delay (begin (set! count (+ count 1)) + (if (> count x) + count + (force p)))))) + (force p) + (set! x 10) + (force p)) + 6) + + (test (let ((count 0)) + (define s (delay (begin (set! count (+ count 1)) 1))) + (+ (force s) (force s)) + count) + 1) + + (test (let () + (define f + (let ((first? #t)) + (delay + (if first? + (begin + (set! first? #f) + (force f)) + 'second)))) + (force f)) + 'second) + + (test (let () + (define q + (let ((count 5)) + (define (get-count) count) + (define p (delay (if (<= count 0) + count + (begin (set! count (- count 1)) + (force p) + (set! count (+ count 2)) + count)))) + (list get-count p))) + (let* ((get-count (car q)) + (p (cadr q)) + (a (get-count)) + (b (force p)) + (c (get-count))) + (list a b c))) + (list 5 0 10)) + + (for-each + (lambda (arg) + (test (force (delay arg)) arg)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + + )) + + +;;; -------- quasiquote -------- + +(test `(1 2 3) '(1 2 3)) +(test `() '()) +(test `(list ,(+ 1 2) 4) '(list 3 4)) +(test `(1 ,@(list 1 2) 4) '(1 1 2 4)) +(test `#(1 ,@(list 1 2) 4) '#(1 1 2 4)) +(test `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b) '(a 3 4 5 6 b)) +(if (eqv? 2 (sqrt 4)) + (test `#(10 5 ,(sqrt 4) ,@(map sqrt '(16 9)) 8) '#(10 5 2 4 3 8))) ; inexactness foolishness +(test `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f) '(a `(b ,(+ 1 2) ,(foo 4 d) e) f)) +(test (let ((name1 'x) (name2 'y)) `(a `(b ,,name1 ,',name2 d) e)) '(a `(b ,x ,'y d) e)) +(test `(,@'() . foo) 'foo) +(test `(1 2 ,(* 9 9) 3 4) '(1 2 81 3 4)) +(test `(1 ,(+ 1 1) 3) '(1 2 3)) +;#; `(,(+ 1 2)) -> infinite loop? +(test `(,'a . ,'b) (cons 'a 'b)) + +;; from gauche +(let ((quasi0 99) + (quasi1 101) + (quasi2 '(a b)) + (quasi3 '(c d))) + (test `,quasi0 99) + (test `,quasi1 101) + (test `(,(cons 1 2)) '((1 . 2))) + (test `(,(cons 1 2) 3) '((1 . 2) 3)) + (test `(,quasi0 3) '(99 3)) + (test `(3 ,quasi0) '(3 99)) + (test `(,(+ quasi0 1) 3) '(100 3)) + (test `(3 ,(+ quasi0 1)) '(3 100)) + (test `(,quasi1 3) '(101 3)) + (test `(3 ,quasi1) '(3 101)) + (test `(,(+ quasi1 1) 3) '(102 3)) + (test `(3 ,(+ quasi1 1)) '(3 102)) + (test `(1 ,@(list 2 3) 4) '(1 2 3 4)) + (test `(1 2 ,@(list 3 4)) '(1 2 3 4)) + (test `(,@quasi2 ,@quasi3) '(a b c d)) + (test `(1 2 . ,(list 3 4)) '(1 2 3 4)) + (test `(,@quasi2 . ,quasi3) '(a b c d)) + (test `#(,(cons 1 2) 3) '#((1 . 2) 3)) + (test `#(,quasi0 3) '#(99 3)) + (test `#(,(+ quasi0 1) 3) '#(100 3)) + (test `#(3 ,quasi1) '#(3 101)) + (test `#(3 ,(+ quasi1 1)) '#(3 102)) + (test `#(1 ,@(list 2 3) 4) '#(1 2 3 4)) + (test `#(1 2 ,@(list 3 4)) '#(1 2 3 4)) + (test `#(,@quasi2 ,@quasi3) '#(a b c d)) + (test `#(,@quasi2 ,quasi3) '#(a b (c d))) + (test `#(,quasi2 ,@quasi3) '#((a b) c d)) + (test `#() '#()) + (test `#(,@(list)) '#()) + (test `(,@(list 1 2) ,@(list 1 2)) '(1 2 1 2)) + (test `(,@(list 1 2) a ,@(list 1 2)) '(1 2 a 1 2)) + (test `(a ,@(list 1 2) ,@(list 1 2)) '(a 1 2 1 2)) + (test `(,@(list 1 2) ,@(list 1 2) a) '(1 2 1 2 a)) + (test `(,@(list 1 2) ,@(list 1 2) a b) '(1 2 1 2 a b)) + (test `(,@(list 1 2) ,@(list 1 2) . a) '(1 2 1 2 . a)) + (test `(,@(list 1 2) ,@(list 1 2) . ,(cons 1 2)) '(1 2 1 2 1 . 2)) + (test `(,@(list 1 2) ,@(list 1 2) . ,quasi2) '(1 2 1 2 a b)) + (test `(,@(list 1 2) ,@(list 1 2) a . ,(cons 1 2)) '(1 2 1 2 a 1 . 2)) + (test `(,@(list 1 2) ,@(list 1 2) a . ,quasi3) '(1 2 1 2 a c d)) + (test `#(,@(list 1 2) ,@(list 1 2)) '#(1 2 1 2)) + (test `#(,@(list 1 2) a ,@(list 1 2)) '#(1 2 a 1 2)) + (test `#(a ,@(list 1 2) ,@(list 1 2)) '#(a 1 2 1 2)) + (test `#(,@(list 1 2) ,@(list 1 2) a) '#(1 2 1 2 a)) + (test `#(,@(list 1 2) ,@(list 1 2) a b) '#(1 2 1 2 a b)) + (test `(1 `(1 ,2 ,,(+ 1 2)) 1) '(1 `(1 ,2 ,3) 1)) + (test `(1 `(1 ,,quasi0 ,,quasi1) 1) '(1 `(1 ,99 ,101) 1)) + (test `(1 `(1 ,@2 ,@,(list 1 2))) '(1 `(1 ,@2 ,@(1 2)))) + (test `(1 `(1 ,@,quasi2 ,@,quasi3)) '(1 `(1 ,@(a b) ,@(c d)))) + (test `(1 `(1 ,(,@quasi2 x) ,(y ,@quasi3))) '(1 `(1 ,(a b x) ,(y c d)))) + (test `#(1 `(1 ,2 ,,(+ 1 2)) 1) '#(1 `(1 ,2 ,3) 1)) + (test `#(1 `(1 ,,quasi0 ,,quasi1) 1) '#(1 `(1 ,99 ,101) 1)) + (test `#(1 `(1 ,@2 ,@,(list 1 2))) '#(1 `(1 ,@2 ,@(1 2)))) + (test `#(1 `(1 ,@,quasi2 ,@,quasi3)) '#(1 `(1 ,@(a b) ,@(c d)))) + (test `#(1 `(1 ,(,@quasi2 x) ,(y ,@quasi3))) '#(1 `(1 ,(a b x) ,(y c d)))) + (test `(1 `#(1 ,(,@quasi2 x) ,(y ,@quasi3))) '(1 `#(1 ,(a b x) ,(y c d))))) + +(test (let ((hi (lambda (a) `(+ 1 ,a)))) + (hi 2)) + '(+ 1 2)) + +(test (let ((hi (lambda (a) `(+ 1 ,@a)))) + (hi (list 2 3))) + '(+ 1 2 3)) + +(test (let ((hi (lambda (a) `(let ((b ,a)) ,(+ 1 a))))) + (hi 3)) + '(let ((b 3)) 4)) + +(test (let ((x '(a b c))) + `(x ,x ,@x foo ,(cadr x) bar ,(cdr x) baz ,@(cdr x))) + '(x (a b c) a b c foo b bar (b c) baz b c)) + +(test (let ((x '(a b c))) + `(,(car `(,x)))) + '((a b c))) + +(test (let ((x '(a b c))) + `(,@(car `(,x)))) + '(a b c)) + +(test (let ((x '(a b c))) + `(,(car `(,@x)))) + '(a)) + +(test (let ((x '(a b c))) + (cadadr ``,,x)) + '(a b c)) + +(test (let ((x '(a b c))) + `,(car `,x)) + 'a) + +(test (let ((x '(2 3))) + `(1 ,@x 4)) + '(1 2 3 4)) + +(test (let ((x '(2 3))) + `#(9 ,@x 9)) + '#(9 2 3 9)) + +(test `#(1 ,(/ 12 2)) '#(1 6)) +(test ((lambda () `#(1 ,(/ 12 2)))) '#(1 6)) + +(test (let ((x '(2 3))) + `(1 ,@(map (lambda (a) (+ a 1)) x))) + '(1 3 4)) + +;;; these are from the scheme bboard +(test (let ((x '(1 2 3))) `(0 . ,x)) '(0 1 2 3)) +(test (let ((x '(1 2 3))) `(0 ,x)) '(0 (1 2 3))) +(test (let ((x '(1 2 3))) `#(0 ,x)) '#(0 (1 2 3))) +;(test (let ((x '(1 2 3))) `#(0 . ,x)) '#(0 1 2 3)) + + + + +;;; -------- syntax-rules -------- + +(if with-syntax-rules + (begin + + (test (let-syntax ((foo + (syntax-rules () + ((_ expr) (+ expr 1))))) + (let ((+ *)) + (foo 3))) + 4) + + (test (let-syntax ((foo (syntax-rules () + ((_ var) (define var 1))))) + (let ((x 2)) + (begin (define foo +)) + (cond (else (foo x))) + x)) + 2) + + (test (let ((x 1)) + (let-syntax + ((foo (syntax-rules () + ((_ y) (let-syntax + ((bar (syntax-rules () + ((_) (let ((x 2)) y))))) + (bar)))))) + (foo x))) + 1) + )) + +;;; -------------------------------------------------------------------------------- +;;; NUMBERS +;;; -------------------------------------------------------------------------------- + + +;; -------- sin +(num-test (sin 0) 0.0) +(num-test (sin 1) 0.84147098480790) +(num-test (sin -1) -0.84147098480790) +(num-test (sin 2) 0.90929742682568) +(num-test (sin -2) -0.90929742682568) +(num-test (sin 0/1) 0.0) +(num-test (sin 0/2) 0.0) +(num-test (sin 0/3) 0.0) +(num-test (sin 0/10) 0.0) +(num-test (sin 0/1234) 0.0) +(num-test (sin 0/1234000000) 0.0) +(num-test (sin 0/500029) 0.0) +(num-test (sin 0/362880) 0.0) +(num-test (sin 1/1) 0.84147098480790) +(num-test (sin -1/1) -0.84147098480790) +(num-test (sin 1/2) 0.47942553860420) +(num-test (sin -1/2) -0.47942553860420) +(num-test (sin 1/3) 0.32719469679615) +(num-test (sin -1/3) -0.32719469679615) +(num-test (sin 1/10) 0.09983341664683) +(num-test (sin -1/10) -0.09983341664683) +(num-test (sin 1/1234) 0.00081037268278) +(num-test (sin -1/1234) -0.00081037268278) +(num-test (sin 1/1234000000) 0.00000000081037) +(num-test (sin -1/1234000000) -0.00000000081037) +(num-test (sin 1/500029) 0.00000199988401) +(num-test (sin -1/500029) -0.00000199988401) +(num-test (sin 1/362880) 0.00000275573192) +(num-test (sin -1/362880) -0.00000275573192) +(num-test (sin 2/1) 0.90929742682568) +(num-test (sin -2/1) -0.90929742682568) +(num-test (sin 2/2) 0.84147098480790) +(num-test (sin -2/2) -0.84147098480790) +(num-test (sin 2/3) 0.61836980306974) +(num-test (sin -2/3) -0.61836980306974) +(num-test (sin 2/10) 0.19866933079506) +(num-test (sin -2/10) -0.19866933079506) +(num-test (sin 2/1234) 0.00162074483338) +(num-test (sin -2/1234) -0.00162074483338) +(num-test (sin 2/1234000000) 0.00000000162075) +(num-test (sin -2/1234000000) -0.00000000162075) +(num-test (sin 2/500029) 0.00000399976801) +(num-test (sin -2/500029) -0.00000399976801) +(num-test (sin 2/362880) 0.00000551146384) +(num-test (sin -2/362880) -0.00000551146384) +(num-test (sin 3/2) 0.99749498660405) +(num-test (sin -3/2) -0.99749498660405) +(num-test (sin 3/3) 0.84147098480790) +(num-test (sin -3/3) -0.84147098480790) +(num-test (sin 3/10) 0.29552020666134) +(num-test (sin -3/10) -0.29552020666134) +(num-test (sin 3/1234) 0.00243111591964) +(num-test (sin -3/1234) -0.00243111591964) +(num-test (sin 3/1234000000) 0.00000000243112) +(num-test (sin -3/1234000000) -0.00000000243112) +(num-test (sin 3/500029) 0.00000599965202) +(num-test (sin -3/500029) -0.00000599965202) +(num-test (sin 3/362880) 0.00000826719577) +(num-test (sin -3/362880) -0.00000826719577) +(num-test (sin 10/10) 0.84147098480790) +(num-test (sin -10/10) -0.84147098480790) +(num-test (sin 10/1234) 0.00810363901920) +(num-test (sin -10/1234) -0.00810363901920) +(num-test (sin 10/1234000000) 0.00000000810373) +(num-test (sin -10/1234000000) -0.00000000810373) +(num-test (sin 10/500029) 0.00001999884007) +(num-test (sin -10/500029) -0.00001999884007) +(num-test (sin 10/362880) 0.00002755731922) +(num-test (sin -10/362880) -0.00002755731922) +(num-test (sin 1234/1234) 0.84147098480790) +(num-test (sin -1234/1234) -0.84147098480790) +(num-test (sin 1234/1234000000) 0.00000100000000) +(num-test (sin -1234/1234000000) -0.00000100000000) +(num-test (sin 1234/500029) 0.00246785435930) +(num-test (sin -1234/500029) -0.00246785435930) +(num-test (sin 1234/362880) 0.00340056663826) +(num-test (sin -1234/362880) -0.00340056663826) +(num-test (sin 1234000000/1234000000) 0.84147098480790) +(num-test (sin -1234000000/1234000000) -0.84147098480790) +(num-test (sin 500029/1234000000) 0.00040520987546) +(num-test (sin -500029/1234000000) -0.00040520987546) +(num-test (sin 500029/500029) 0.84147098480790) +(num-test (sin -500029/500029) -0.84147098480790) +(num-test (sin 500029/362880) 0.98146191370834) +(num-test (sin -500029/362880) -0.98146191370834) +(num-test (sin 362880/1234000000) 0.00029406806707) +(num-test (sin -362880/1234000000) -0.00029406806707) +(num-test (sin 362880/500029) 0.66367262572318) +(num-test (sin -362880/500029) -0.66367262572318) +(num-test (sin 362880/362880) 0.84147098480790) +(num-test (sin -362880/362880) -0.84147098480790) +(num-test (sin 0.0) 0.0) +(num-test (sin 0.00000001) 0.00000001) +(num-test (sin -0.00000001) -0.00000001) +(num-test (sin 1.0) 0.84147098480790) +(num-test (sin -1.0) -0.84147098480790) +(num-test (sin 0.0+0.0i) 0.0) +(num-test (sin -0.0+0.0i) 0.0) +(num-test (sin 0.0-0.0i) 0.0) +(num-test (sin -0.0-0.0i) -0.0) +(num-test (sin 0.0+0.00000001i) 0.0+0.00000001i) +(num-test (sin -0.0+0.00000001i) 0.0+0.00000001i) +(num-test (sin 0.0-0.00000001i) 0.0-0.00000001i) +(num-test (sin -0.0-0.00000001i) -0.0-0.00000001i) +(num-test (sin 0.0+1.0i) 0.0+1.17520119364380i) +(num-test (sin -0.0+1.0i) 0.0+1.17520119364380i) +(num-test (sin 0.0-1.0i) 0.0-1.17520119364380i) +(num-test (sin -0.0-1.0i) -0.0-1.17520119364380i) +(num-test (sin 0.0+3.14159265358979i) 0.0+11.54873935725775i) +(num-test (sin -0.0+3.14159265358979i) 0.0+11.54873935725775i) +(num-test (sin 0.0-3.14159265358979i) 0.0-11.54873935725775i) +(num-test (sin -0.0-3.14159265358979i) -0.0-11.54873935725775i) +(num-test (sin 0.0+2.71828182845905i) 0.0+7.54413710281697i) +(num-test (sin -0.0+2.71828182845905i) 0.0+7.54413710281697i) +(num-test (sin 0.0-2.71828182845905i) 0.0-7.54413710281697i) +(num-test (sin -0.0-2.71828182845905i) -0.0-7.54413710281697i) +(num-test (sin 0.00000001+0.0i) 0.00000001) +(num-test (sin -0.00000001+0.0i) -0.00000001) +(num-test (sin 0.00000001-0.0i) 0.00000001) +(num-test (sin -0.00000001-0.0i) -0.00000001) +(num-test (sin 0.00000001+0.00000001i) 0.00000001+0.00000001i) +(num-test (sin -0.00000001+0.00000001i) -0.00000001+0.00000001i) +(num-test (sin 0.00000001-0.00000001i) 0.00000001-0.00000001i) +(num-test (sin -0.00000001-0.00000001i) -0.00000001-0.00000001i) +(num-test (sin 0.00000001+1.0i) 0.00000001543081+1.17520119364380i) +(num-test (sin -0.00000001+1.0i) -0.00000001543081+1.17520119364380i) +(num-test (sin 0.00000001-1.0i) 0.00000001543081-1.17520119364380i) +(num-test (sin -0.00000001-1.0i) -0.00000001543081-1.17520119364380i) +(num-test (sin 0.00000001+3.14159265358979i) 0.00000011591953+11.54873935725775i) +(num-test (sin -0.00000001+3.14159265358979i) -0.00000011591953+11.54873935725775i) +(num-test (sin 0.00000001-3.14159265358979i) 0.00000011591953-11.54873935725775i) +(num-test (sin -0.00000001-3.14159265358979i) -0.00000011591953-11.54873935725775i) +(num-test (sin 0.00000001+2.71828182845905i) 0.00000007610125+7.54413710281697i) +(num-test (sin -0.00000001+2.71828182845905i) -0.00000007610125+7.54413710281697i) +(num-test (sin 0.00000001-2.71828182845905i) 0.00000007610125-7.54413710281697i) +(num-test (sin -0.00000001-2.71828182845905i) -0.00000007610125-7.54413710281697i) +(num-test (sin 1.0+0.0i) 0.84147098480790) +(num-test (sin -1.0+0.0i) -0.84147098480790) +(num-test (sin 1.0-0.0i) 0.84147098480790) +(num-test (sin -1.0-0.0i) -0.84147098480790) +(num-test (sin 1.0+0.00000001i) 0.84147098480790+0.00000000540302i) +(num-test (sin -1.0+0.00000001i) -0.84147098480790+0.00000000540302i) +(num-test (sin 1.0-0.00000001i) 0.84147098480790-0.00000000540302i) +(num-test (sin -1.0-0.00000001i) -0.84147098480790-0.00000000540302i) +(num-test (sin 1.0+1.0i) 1.29845758141598+0.63496391478474i) +(num-test (sin -1.0+1.0i) -1.29845758141598+0.63496391478474i) +(num-test (sin 1.0-1.0i) 1.29845758141598-0.63496391478474i) +(num-test (sin -1.0-1.0i) -1.29845758141598-0.63496391478474i) +(num-test (sin 1.0+3.14159265358979i) 9.75429233860021+6.23981050459650i) +(num-test (sin -1.0+3.14159265358979i) -9.75429233860021+6.23981050459650i) +(num-test (sin 1.0-3.14159265358979i) 9.75429233860021-6.23981050459650i) +(num-test (sin -1.0-3.14159265358979i) -9.75429233860021-6.23981050459650i) +(num-test (sin 1.0+2.71828182845905i) 6.40369949494148+4.07611467243740i) +(num-test (sin -1.0+2.71828182845905i) -6.40369949494148+4.07611467243740i) +(num-test (sin 1.0-2.71828182845905i) 6.40369949494148-4.07611467243740i) +(num-test (sin -1.0-2.71828182845905i) -6.40369949494148-4.07611467243740i) +(num-test (sin 10/3) -0.1905679628754527) +(num-test (sin 1234/3) 0.213644699569724) +(num-test (sin 1234/10) -0.7693905459455223) +(num-test (sin 1234000000/3) 9.98585468017658e-1) +(num-test (sin 1234000000/500029) -0.9907886154453116) +(num-test (sin 1234000000/362880) .9798963032808383) +(num-test (sin 500029/2) 0.270047165973401) +(num-test (sin 500029/3) 7.610322596690986e-1) +(num-test (sin 500029/10) .9665258739436294) +(num-test (sin 500029/1234) .05553717596791147) +(num-test (sin 362880/1234) -0.9463147870254296) +(num-test (sin our-pi) -6.982889851335445E-15) +(num-test (sin 2.71828182845905) .4107812905029501) +(num-test (sin 3.14159265358979+0.0i) -6.982889851335445E-15) +(num-test (sin 3.14159265358979+0.00000001i) -6.982889851335445E-15-1.0E-8i) +(num-test (sin 3.14159265358979+1.0i) -1.077516210464362E-14-1.175201193643801i) +(num-test (sin 3.14159265358979+3.14159265358979i) -8.094533288479446E-14-11.54873935725783i) +(num-test (sin 3.14159265358979+2.71828182845905i) -5.314066559815525E-14-7.54413710281663i) +(num-test (sin 2.71828182845905+0.0i) .4107812905029501) +(num-test (sin 2.71828182845905+0.00000001i) .4107812905029501-9.117339147869465E-9i) +(num-test (sin 2.71828182845905+1.0i) .6338686545195173-1.071470784943156i) +(num-test (sin 2.71828182845905+3.14159265358979i) 4.761757525968664-10.52937734504676i) +(num-test (sin 2.71828182845905+2.71828182845905i) 3.126097025348496-6.878245654440458i) +(num-test (sin 1234.0+0.00000001i) .6019276547624973-7.985506235875843E-9i) +(num-test (sin 1234.0+3.14159265358979i) 6.977517249251167-9.222253015388718i) +(num-test (sin 1234.0+2.71828182845905i) 4.58074477716391-6.024375387884452i) +(num-test (sin 1234000000.0+0.00000001i) -0.9872932128398908+1.5890913089022285E-9i) +(num-test (sin 1234000000.0+3.14159265358979i) -11.44465679247962+1.835200134139553i) +(num-test (sin 1234000000.0+2.71828182845905i) -7.513424898263172+1.198832270325275i) +(num-test (sin 1234.0+12.0i) 48983.30495194942-64983.97008730317i) +(num-test (sin -3.45266983001243932001e-04+0.0e+00i) -3.4526697614140534807e-4+0.0i) +(num-test (sin 3.45266983001243932001e-04+0.0e+00i) 3.4526697614140534807e-4+0.0i) +(num-test (sin -3.45266983001243932001e-04+1.19209289550781250e-07i) -3.4526697614140780134e-4+1.1920928244535424533e-7i) +(num-test (sin -3.45266983001243932001e-04-1.19209289550781250e-07i) -3.4526697614140780134e-4-1.1920928244535424533e-7i) +(num-test (sin 3.45266983001243932001e-04+1.19209289550781250e-07i) 3.4526697614140780134e-4+1.1920928244535424533e-7i) +(num-test (sin 3.45266983001243932001e-04-1.19209289550781250e-07i) 3.4526697614140780134e-4-1.1920928244535424533e-7i) +(num-test (sin -3.45266983001243932001e-04+5.0e-01i) -3.8933200722534065172e-4+5.2109527443404709209e-1i) +(num-test (sin -3.45266983001243932001e-04-5.0e-01i) -3.8933200722534065172e-4-5.2109527443404709209e-1i) +(num-test (sin 3.45266983001243932001e-04+5.0e-01i) 3.8933200722534065172e-4+5.2109527443404709209e-1i) +(num-test (sin 3.45266983001243932001e-04-5.0e-01i) 3.8933200722534065172e-4-5.2109527443404709209e-1i) +(num-test (sin -3.45266983001243932001e-04+1.0e+00i) -5.3277478472501939236e-4+1.1752011235963524660e0i) +(num-test (sin -3.45266983001243932001e-04-1.0e+00i) -5.3277478472501939236e-4-1.1752011235963524660e0i) +(num-test (sin 3.45266983001243932001e-04+1.0e+00i) 5.3277478472501939236e-4+1.1752011235963524660e0i) +(num-test (sin 3.45266983001243932001e-04-1.0e+00i) 5.3277478472501939236e-4-1.1752011235963524660e0i) +(num-test (sin -3.45266983001243932001e-04+2.0e+00i) -1.2989619299126701883e-3+3.6268601916692946556e0i) +(num-test (sin -3.45266983001243932001e-04-2.0e+00i) -1.2989619299126701883e-3-3.6268601916692946556e0i) +(num-test (sin 3.45266983001243932001e-04+2.0e+00i) 1.2989619299126701883e-3+3.6268601916692946556e0i) +(num-test (sin 3.45266983001243932001e-04-2.0e+00i) 1.2989619299126701883e-3-3.6268601916692946556e0i) +(num-test (sin 1.57045105981189525579e+00+0.0e+00i) 9.9999994039535581669e-1+0.0i) +(num-test (sin -1.57045105981189525579e+00+0.0e+00i) -9.9999994039535581669e-1+0.0i) +(num-test (sin 1.57045105981189525579e+00+1.19209289550781250e-07i) 9.9999994039536292211e-1+4.1159030931177815679e-11i) +(num-test (sin 1.57045105981189525579e+00-1.19209289550781250e-07i) 9.9999994039536292211e-1-4.1159030931177815679e-11i) +(num-test (sin -1.57045105981189525579e+00+1.19209289550781250e-07i) -9.9999994039536292211e-1+4.1159030931177815679e-11i) +(num-test (sin -1.57045105981189525579e+00-1.19209289550781250e-07i) -9.9999994039536292211e-1-4.1159030931177815679e-11i) +(num-test (sin 1.57045105981189525579e+00+5.0e-01i) 1.1276258979946363572e0+1.7991700040937027667e-4i) +(num-test (sin 1.57045105981189525579e+00-5.0e-01i) 1.1276258979946363572e0-1.7991700040937027667e-4i) +(num-test (sin -1.57045105981189525579e+00+5.0e-01i) -1.1276258979946363572e0+1.7991700040937027667e-4i) +(num-test (sin -1.57045105981189525579e+00-5.0e-01i) -1.1276258979946363572e0-1.7991700040937027667e-4i) +(num-test (sin 1.57045105981189525579e+00+1.0e+00i) 1.5430805428404715942e0+4.0575816248730593018e-4i) +(num-test (sin 1.57045105981189525579e+00-1.0e+00i) 1.5430805428404715942e0-4.0575816248730593018e-4i) +(num-test (sin -1.57045105981189525579e+00+1.0e+00i) -1.5430805428404715942e0+4.0575816248730593018e-4i) +(num-test (sin -1.57045105981189525579e+00-1.0e+00i) -1.5430805428404715942e0-4.0575816248730593018e-4i) +(num-test (sin 1.57045105981189525579e+00+2.0e+00i) 3.7621954668392959445e0+1.2522351259047577385e-3i) +(num-test (sin 1.57045105981189525579e+00-2.0e+00i) 3.7621954668392959445e0-1.2522351259047577385e-3i) +(num-test (sin -1.57045105981189525579e+00+2.0e+00i) -3.7621954668392959445e0+1.2522351259047577385e-3i) +(num-test (sin -1.57045105981189525579e+00-2.0e+00i) -3.7621954668392959445e0-1.2522351259047577385e-3i) +(num-test (sin 1.57114159377789786021e+00+0.0e+00i) 9.9999994039535581673e-1+0.0i) +(num-test (sin -1.57114159377789786021e+00+0.0e+00i) -9.9999994039535581673e-1+0.0i) +(num-test (sin 1.57114159377789786021e+00+1.19209289550781250e-07i) 9.9999994039536292216e-1-4.1159030931163216752e-11i) +(num-test (sin 1.57114159377789786021e+00-1.19209289550781250e-07i) 9.9999994039536292216e-1+4.1159030931163216752e-11i) +(num-test (sin -1.57114159377789786021e+00+1.19209289550781250e-07i) -9.9999994039536292216e-1-4.1159030931163216752e-11i) +(num-test (sin -1.57114159377789786021e+00-1.19209289550781250e-07i) -9.9999994039536292216e-1+4.1159030931163216752e-11i) +(num-test (sin 1.57114159377789786021e+00+5.0e-01i) 1.1276258979946363573e0-1.7991700040930646090e-4i) +(num-test (sin 1.57114159377789786021e+00-5.0e-01i) 1.1276258979946363573e0+1.7991700040930646090e-4i) +(num-test (sin -1.57114159377789786021e+00+5.0e-01i) -1.1276258979946363573e0-1.7991700040930646090e-4i) +(num-test (sin -1.57114159377789786021e+00-5.0e-01i) -1.1276258979946363573e0+1.7991700040930646090e-4i) +(num-test (sin 1.57114159377789786021e+00+1.0e+00i) 1.5430805428404715942e0-4.0575816248716200955e-4i) +(num-test (sin 1.57114159377789786021e+00-1.0e+00i) 1.5430805428404715942e0+4.0575816248716200955e-4i) +(num-test (sin -1.57114159377789786021e+00+1.0e+00i) -1.5430805428404715942e0-4.0575816248716200955e-4i) +(num-test (sin -1.57114159377789786021e+00-1.0e+00i) -1.5430805428404715942e0+4.0575816248716200955e-4i) +(num-test (sin 1.57114159377789786021e+00+2.0e+00i) 3.7621954668392959447e0-1.2522351259043135762e-3i) +(num-test (sin 1.57114159377789786021e+00-2.0e+00i) 3.7621954668392959447e0+1.2522351259043135762e-3i) +(num-test (sin -1.57114159377789786021e+00+2.0e+00i) -3.7621954668392959447e0-1.2522351259043135762e-3i) +(num-test (sin -1.57114159377789786021e+00-2.0e+00i) -3.7621954668392959447e0+1.2522351259043135762e-3i) +(num-test (sin 3.14124738660679181379e+00+0.0e+00i) 3.4526697614158608860e-4+0.0i) +(num-test (sin -3.14124738660679181379e+00+0.0e+00i) -3.4526697614158608860e-4+0.0i) +(num-test (sin 3.14124738660679181379e+00+1.19209289550781250e-07i) 3.4526697614158854187e-4-1.1920928244535424532e-7i) +(num-test (sin 3.14124738660679181379e+00-1.19209289550781250e-07i) 3.4526697614158854187e-4+1.1920928244535424532e-7i) +(num-test (sin -3.14124738660679181379e+00+1.19209289550781250e-07i) -3.4526697614158854187e-4-1.1920928244535424532e-7i) +(num-test (sin -3.14124738660679181379e+00-1.19209289550781250e-07i) -3.4526697614158854187e-4+1.1920928244535424532e-7i) +(num-test (sin 3.14124738660679181379e+00+5.0e-01i) 3.8933200722554445944e-4-5.2109527443404709206e-1i) +(num-test (sin 3.14124738660679181379e+00-5.0e-01i) 3.8933200722554445944e-4+5.2109527443404709206e-1i) +(num-test (sin -3.14124738660679181379e+00+5.0e-01i) -3.8933200722554445944e-4-5.2109527443404709206e-1i) +(num-test (sin -3.14124738660679181379e+00-5.0e-01i) -3.8933200722554445944e-4+5.2109527443404709206e-1i) +(num-test (sin 3.14124738660679181379e+00+1.0e+00i) 5.3277478472529828958e-4-1.1752011235963524659e0i) +(num-test (sin 3.14124738660679181379e+00-1.0e+00i) 5.3277478472529828958e-4+1.1752011235963524659e0i) +(num-test (sin -3.14124738660679181379e+00+1.0e+00i) -5.3277478472529828958e-4-1.1752011235963524659e0i) +(num-test (sin -3.14124738660679181379e+00-1.0e+00i) -5.3277478472529828958e-4+1.1752011235963524659e0i) +(num-test (sin 3.14124738660679181379e+00+2.0e+00i) 1.2989619299133501696e-3-3.6268601916692946553e0i) +(num-test (sin 3.14124738660679181379e+00-2.0e+00i) 1.2989619299133501696e-3+3.6268601916692946553e0i) +(num-test (sin -3.14124738660679181379e+00+2.0e+00i) -1.2989619299133501696e-3-3.6268601916692946553e0i) +(num-test (sin -3.14124738660679181379e+00-2.0e+00i) -1.2989619299133501696e-3+3.6268601916692946553e0i) +(num-test (sin 3.14193792057279441821e+00+0.0e+00i) -3.4526697614134115926e-4+0.0i) +(num-test (sin -3.14193792057279441821e+00+0.0e+00i) 3.4526697614134115926e-4+0.0i) +(num-test (sin 3.14193792057279441821e+00+1.19209289550781250e-07i) -3.4526697614134361253e-4-1.1920928244535424533e-7i) +(num-test (sin 3.14193792057279441821e+00-1.19209289550781250e-07i) -3.4526697614134361253e-4+1.1920928244535424533e-7i) +(num-test (sin -3.14193792057279441821e+00+1.19209289550781250e-07i) 3.4526697614134361253e-4-1.1920928244535424533e-7i) +(num-test (sin -3.14193792057279441821e+00-1.19209289550781250e-07i) 3.4526697614134361253e-4+1.1920928244535424533e-7i) +(num-test (sin 3.14193792057279441821e+00+5.0e-01i) -3.8933200722526827075e-4-5.2109527443404709211e-1i) +(num-test (sin 3.14193792057279441821e+00-5.0e-01i) -3.8933200722526827075e-4+5.2109527443404709211e-1i) +(num-test (sin -3.14193792057279441821e+00+5.0e-01i) 3.8933200722526827075e-4-5.2109527443404709211e-1i) +(num-test (sin -3.14193792057279441821e+00-5.0e-01i) 3.8933200722526827075e-4+5.2109527443404709211e-1i) +(num-test (sin 3.14193792057279441821e+00+1.0e+00i) -5.3277478472492034385e-4-1.1752011235963524660e0i) +(num-test (sin 3.14193792057279441821e+00-1.0e+00i) -5.3277478472492034385e-4+1.1752011235963524660e0i) +(num-test (sin -3.14193792057279441821e+00+1.0e+00i) 5.3277478472492034385e-4-1.1752011235963524660e0i) +(num-test (sin -3.14193792057279441821e+00-1.0e+00i) 5.3277478472492034385e-4+1.1752011235963524660e0i) +(num-test (sin 3.14193792057279441821e+00+2.0e+00i) -1.2989619299124286975e-3-3.6268601916692946556e0i) +(num-test (sin 3.14193792057279441821e+00-2.0e+00i) -1.2989619299124286975e-3+3.6268601916692946556e0i) +(num-test (sin -3.14193792057279441821e+00+2.0e+00i) 1.2989619299124286975e-3-3.6268601916692946556e0i) +(num-test (sin -3.14193792057279441821e+00-2.0e+00i) 1.2989619299124286975e-3+3.6268601916692946556e0i) +(num-test (sin 4.71204371340168837179e+00+0.0e+00i) -9.9999994039535581664e-1+0.0i) +(num-test (sin -4.71204371340168837179e+00+0.0e+00i) 9.9999994039535581664e-1+0.0i) +(num-test (sin 4.71204371340168837179e+00+1.19209289550781250e-07i) -9.9999994039536292207e-1-4.1159030931192414605e-11i) +(num-test (sin 4.71204371340168837179e+00-1.19209289550781250e-07i) -9.9999994039536292207e-1+4.1159030931192414605e-11i) +(num-test (sin -4.71204371340168837179e+00+1.19209289550781250e-07i) 9.9999994039536292207e-1-4.1159030931192414605e-11i) +(num-test (sin -4.71204371340168837179e+00-1.19209289550781250e-07i) 9.9999994039536292207e-1+4.1159030931192414605e-11i) +(num-test (sin 4.71204371340168837179e+00+5.0e-01i) -1.1276258979946363572e0-1.7991700040943409243e-4i) +(num-test (sin 4.71204371340168837179e+00-5.0e-01i) -1.1276258979946363572e0+1.7991700040943409243e-4i) +(num-test (sin -4.71204371340168837179e+00+5.0e-01i) 1.1276258979946363572e0-1.7991700040943409243e-4i) +(num-test (sin -4.71204371340168837179e+00-5.0e-01i) 1.1276258979946363572e0+1.7991700040943409243e-4i) +(num-test (sin 4.71204371340168837179e+00+1.0e+00i) -1.5430805428404715941e0-4.0575816248744985081e-4i) +(num-test (sin 4.71204371340168837179e+00-1.0e+00i) -1.5430805428404715941e0+4.0575816248744985081e-4i) +(num-test (sin -4.71204371340168837179e+00+1.0e+00i) 1.5430805428404715941e0-4.0575816248744985081e-4i) +(num-test (sin -4.71204371340168837179e+00-1.0e+00i) 1.5430805428404715941e0+4.0575816248744985081e-4i) +(num-test (sin 4.71204371340168837179e+00+2.0e+00i) -3.7621954668392959444e0-1.2522351259052019007e-3i) +(num-test (sin 4.71204371340168837179e+00-2.0e+00i) -3.7621954668392959444e0+1.2522351259052019007e-3i) +(num-test (sin -4.71204371340168837179e+00+2.0e+00i) 3.7621954668392959444e0-1.2522351259052019007e-3i) +(num-test (sin -4.71204371340168837179e+00-2.0e+00i) 3.7621954668392959444e0+1.2522351259052019007e-3i) +(num-test (sin 4.71273424736769097620e+00+0.0e+00i) -9.9999994039535581677e-1+0.0i) +(num-test (sin -4.71273424736769097620e+00+0.0e+00i) 9.9999994039535581677e-1+0.0i) +(num-test (sin 4.71273424736769097620e+00+1.19209289550781250e-07i) -9.9999994039536292220e-1+4.1159030931148617825e-11i) +(num-test (sin 4.71273424736769097620e+00-1.19209289550781250e-07i) -9.9999994039536292220e-1-4.1159030931148617825e-11i) +(num-test (sin -4.71273424736769097620e+00+1.19209289550781250e-07i) 9.9999994039536292220e-1+4.1159030931148617825e-11i) +(num-test (sin -4.71273424736769097620e+00-1.19209289550781250e-07i) 9.9999994039536292220e-1-4.1159030931148617825e-11i) +(num-test (sin 4.71273424736769097620e+00+5.0e-01i) -1.1276258979946363573e0+1.7991700040924264514e-4i) +(num-test (sin 4.71273424736769097620e+00-5.0e-01i) -1.1276258979946363573e0-1.7991700040924264514e-4i) +(num-test (sin -4.71273424736769097620e+00+5.0e-01i) 1.1276258979946363573e0+1.7991700040924264514e-4i) +(num-test (sin -4.71273424736769097620e+00-5.0e-01i) 1.1276258979946363573e0-1.7991700040924264514e-4i) +(num-test (sin 4.71273424736769097620e+00+1.0e+00i) -1.5430805428404715943e0+4.0575816248701808892e-4i) +(num-test (sin 4.71273424736769097620e+00-1.0e+00i) -1.5430805428404715943e0-4.0575816248701808892e-4i) +(num-test (sin -4.71273424736769097620e+00+1.0e+00i) 1.5430805428404715943e0+4.0575816248701808892e-4i) +(num-test (sin -4.71273424736769097620e+00-1.0e+00i) 1.5430805428404715943e0-4.0575816248701808892e-4i) +(num-test (sin 4.71273424736769097620e+00+2.0e+00i) -3.7621954668392959448e0+1.2522351259038694139e-3i) +(num-test (sin 4.71273424736769097620e+00-2.0e+00i) -3.7621954668392959448e0-1.2522351259038694139e-3i) +(num-test (sin -4.71273424736769097620e+00+2.0e+00i) 3.7621954668392959448e0+1.2522351259038694139e-3i) +(num-test (sin -4.71273424736769097620e+00-2.0e+00i) 3.7621954668392959448e0-1.2522351259038694139e-3i) +(num-test (sin 6.28284004019658492979e+00+0.0e+00i) -3.4526697614170855328e-4+0.0i) +(num-test (sin -6.28284004019658492979e+00+0.0e+00i) 3.4526697614170855328e-4+0.0i) +(num-test (sin 6.28284004019658492979e+00+1.19209289550781250e-07i) -3.4526697614171100655e-4+1.1920928244535424532e-7i) +(num-test (sin 6.28284004019658492979e+00-1.19209289550781250e-07i) -3.4526697614171100655e-4-1.1920928244535424532e-7i) +(num-test (sin -6.28284004019658492979e+00+1.19209289550781250e-07i) 3.4526697614171100655e-4+1.1920928244535424532e-7i) +(num-test (sin -6.28284004019658492979e+00-1.19209289550781250e-07i) 3.4526697614171100655e-4-1.1920928244535424532e-7i) +(num-test (sin 6.28284004019658492979e+00+5.0e-01i) -3.8933200722568255379e-4+5.2109527443404709204e-1i) +(num-test (sin 6.28284004019658492979e+00-5.0e-01i) -3.8933200722568255379e-4-5.2109527443404709204e-1i) +(num-test (sin -6.28284004019658492979e+00+5.0e-01i) 3.8933200722568255379e-4+5.2109527443404709204e-1i) +(num-test (sin -6.28284004019658492979e+00-5.0e-01i) 3.8933200722568255379e-4-5.2109527443404709204e-1i) +(num-test (sin 6.28284004019658492979e+00+1.0e+00i) -5.3277478472548726245e-4+1.1752011235963524659e0i) +(num-test (sin 6.28284004019658492979e+00-1.0e+00i) -5.3277478472548726245e-4-1.1752011235963524659e0i) +(num-test (sin -6.28284004019658492979e+00+1.0e+00i) 5.3277478472548726245e-4+1.1752011235963524659e0i) +(num-test (sin -6.28284004019658492979e+00-1.0e+00i) 5.3277478472548726245e-4-1.1752011235963524659e0i) +(num-test (sin 6.28284004019658492979e+00+2.0e+00i) -1.2989619299138109057e-3+3.6268601916692946552e0i) +(num-test (sin 6.28284004019658492979e+00-2.0e+00i) -1.2989619299138109057e-3-3.6268601916692946552e0i) +(num-test (sin -6.28284004019658492979e+00+2.0e+00i) 1.2989619299138109057e-3+3.6268601916692946552e0i) +(num-test (sin -6.28284004019658492979e+00-2.0e+00i) 1.2989619299138109057e-3-3.6268601916692946552e0i) +(num-test (sin 6.28353057416258753420e+00+0.0e+00i) 3.4526697614121869459e-4+0.0i) +(num-test (sin -6.28353057416258753420e+00+0.0e+00i) -3.4526697614121869459e-4+0.0i) +(num-test (sin 6.28353057416258753420e+00+1.19209289550781250e-07i) 3.4526697614122114786e-4+1.1920928244535424534e-7i) +(num-test (sin 6.28353057416258753420e+00-1.19209289550781250e-07i) 3.4526697614122114786e-4-1.1920928244535424534e-7i) +(num-test (sin -6.28353057416258753420e+00+1.19209289550781250e-07i) -3.4526697614122114786e-4+1.1920928244535424534e-7i) +(num-test (sin -6.28353057416258753420e+00-1.19209289550781250e-07i) -3.4526697614122114786e-4-1.1920928244535424534e-7i) +(num-test (sin 6.28353057416258753420e+00+5.0e-01i) 3.8933200722513017641e-4+5.2109527443404709213e-1i) +(num-test (sin 6.28353057416258753420e+00-5.0e-01i) 3.8933200722513017641e-4-5.2109527443404709213e-1i) +(num-test (sin -6.28353057416258753420e+00+5.0e-01i) -3.8933200722513017641e-4+5.2109527443404709213e-1i) +(num-test (sin -6.28353057416258753420e+00-5.0e-01i) -3.8933200722513017641e-4-5.2109527443404709213e-1i) +(num-test (sin 6.28353057416258753420e+00+1.0e+00i) 5.3277478472473137099e-4+1.1752011235963524661e0i) +(num-test (sin 6.28353057416258753420e+00-1.0e+00i) 5.3277478472473137099e-4-1.1752011235963524661e0i) +(num-test (sin -6.28353057416258753420e+00+1.0e+00i) -5.3277478472473137099e-4+1.1752011235963524661e0i) +(num-test (sin -6.28353057416258753420e+00-1.0e+00i) -5.3277478472473137099e-4-1.1752011235963524661e0i) +(num-test (sin 6.28353057416258753420e+00+2.0e+00i) 1.2989619299119679614e-3+3.6268601916692946558e0i) +(num-test (sin 6.28353057416258753420e+00-2.0e+00i) 1.2989619299119679614e-3-3.6268601916692946558e0i) +(num-test (sin -6.28353057416258753420e+00+2.0e+00i) -1.2989619299119679614e-3+3.6268601916692946558e0i) +(num-test (sin -6.28353057416258753420e+00-2.0e+00i) -1.2989619299119679614e-3-3.6268601916692946558e0i) +(num-test (sin 9.42443269378637893396e+00+0.0e+00i) 3.4526697614094283958e-4+0.0i) +(num-test (sin -9.42443269378637893396e+00+0.0e+00i) -3.4526697614094283958e-4+0.0i) +(num-test (sin 9.42443269378637893396e+00+1.19209289550781250e-07i) 3.4526697614094529285e-4-1.1920928244535424535e-7i) +(num-test (sin 9.42443269378637893396e+00-1.19209289550781250e-07i) 3.4526697614094529285e-4+1.1920928244535424535e-7i) +(num-test (sin -9.42443269378637893396e+00+1.19209289550781250e-07i) -3.4526697614094529285e-4-1.1920928244535424535e-7i) +(num-test (sin -9.42443269378637893396e+00-1.19209289550781250e-07i) -3.4526697614094529285e-4+1.1920928244535424535e-7i) +(num-test (sin 9.42443269378637893396e+00+5.0e-01i) 3.8933200722481911514e-4-5.2109527443404709218e-1i) +(num-test (sin 9.42443269378637893396e+00-5.0e-01i) 3.8933200722481911514e-4+5.2109527443404709218e-1i) +(num-test (sin -9.42443269378637893396e+00+5.0e-01i) -3.8933200722481911514e-4-5.2109527443404709218e-1i) +(num-test (sin -9.42443269378637893396e+00-5.0e-01i) -3.8933200722481911514e-4+5.2109527443404709218e-1i) +(num-test (sin 9.42443269378637893396e+00+1.0e+00i) 5.3277478472430570447e-4-1.1752011235963524662e0i) +(num-test (sin 9.42443269378637893396e+00-1.0e+00i) 5.3277478472430570447e-4+1.1752011235963524662e0i) +(num-test (sin -9.42443269378637893396e+00+1.0e+00i) -5.3277478472430570447e-4-1.1752011235963524662e0i) +(num-test (sin -9.42443269378637893396e+00-1.0e+00i) -5.3277478472430570447e-4+1.1752011235963524662e0i) +(num-test (sin 9.42443269378637893396e+00+2.0e+00i) 1.2989619299109301409e-3-3.6268601916692946561e0i) +(num-test (sin 9.42443269378637893396e+00-2.0e+00i) 1.2989619299109301409e-3+3.6268601916692946561e0i) +(num-test (sin -9.42443269378637893396e+00+2.0e+00i) -1.2989619299109301409e-3-3.6268601916692946561e0i) +(num-test (sin -9.42443269378637893396e+00-2.0e+00i) -1.2989619299109301409e-3+3.6268601916692946561e0i) +(num-test (sin 9.42512322775237976202e+00+0.0e+00i) -3.4526697614020805155e-4+0.0i) +(num-test (sin -9.42512322775237976202e+00+0.0e+00i) 3.4526697614020805155e-4+0.0i) +(num-test (sin 9.42512322775237976202e+00+1.19209289550781250e-07i) -3.4526697614021050482e-4-1.1920928244535424538e-7i) +(num-test (sin 9.42512322775237976202e+00-1.19209289550781250e-07i) -3.4526697614021050482e-4+1.1920928244535424538e-7i) +(num-test (sin -9.42512322775237976202e+00+1.19209289550781250e-07i) 3.4526697614021050482e-4-1.1920928244535424538e-7i) +(num-test (sin -9.42512322775237976202e+00-1.19209289550781250e-07i) 3.4526697614021050482e-4+1.1920928244535424538e-7i) +(num-test (sin 9.42512322775237976202e+00+5.0e-01i) -3.8933200722399054908e-4-5.2109527443404709231e-1i) +(num-test (sin 9.42512322775237976202e+00-5.0e-01i) -3.8933200722399054908e-4+5.2109527443404709231e-1i) +(num-test (sin -9.42512322775237976202e+00+5.0e-01i) 3.8933200722399054908e-4-5.2109527443404709231e-1i) +(num-test (sin -9.42512322775237976202e+00-5.0e-01i) 3.8933200722399054908e-4+5.2109527443404709231e-1i) +(num-test (sin 9.42512322775237976202e+00+1.0e+00i) -5.3277478472317186729e-4-1.1752011235963524665e0i) +(num-test (sin 9.42512322775237976202e+00-1.0e+00i) -5.3277478472317186729e-4+1.1752011235963524665e0i) +(num-test (sin -9.42512322775237976202e+00+1.0e+00i) 5.3277478472317186729e-4-1.1752011235963524665e0i) +(num-test (sin -9.42512322775237976202e+00-1.0e+00i) 5.3277478472317186729e-4+1.1752011235963524665e0i) +(num-test (sin 9.42512322775237976202e+00+2.0e+00i) -1.2989619299081657245e-3-3.6268601916692946571e0i) +(num-test (sin 9.42512322775237976202e+00-2.0e+00i) -1.2989619299081657245e-3+3.6268601916692946571e0i) +(num-test (sin -9.42512322775237976202e+00+2.0e+00i) 1.2989619299081657245e-3-3.6268601916692946571e0i) +(num-test (sin -9.42512322775237976202e+00-2.0e+00i) 1.2989619299081657245e-3+3.6268601916692946571e0i) + + +;; -------- cos +(num-test (cos 0) 1.0) +(num-test (cos 1) 0.54030230586814) +(num-test (cos 2) -0.41614683654714) +(num-test (cos 3) -0.98999249660045) +(num-test (cos 0/1) 1.0) +(num-test (cos 0/2) 1.0) +(num-test (cos 0/3) 1.0) +(num-test (cos 0/10) 1.0) +(num-test (cos 0/1234) 1.0) +(num-test (cos 0/1234000000) 1.0) +(num-test (cos 0/500029) 1.0) +(num-test (cos 0/362880) 1.0) +(num-test (cos 1/1) 0.54030230586814) +(num-test (cos 1/2) 0.87758256189037) +(num-test (cos -1/2) 0.87758256189037) +(num-test (cos 1/3) 0.94495694631474) +(num-test (cos -1/3) 0.94495694631474) +(num-test (cos 1/10) 0.99500416527803) +(num-test (cos -1/10) 0.99500416527803) +(num-test (cos 1/1234) 0.99999967164800) +(num-test (cos -1/1234) 0.99999967164800) +(num-test (cos 1/1234000000) 1.0) +(num-test (cos -1/1234000000) 1.0) +(num-test (cos 1/500029) 0.99999999999800) +(num-test (cos -1/500029) 0.99999999999800) +(num-test (cos 1/362880) 0.99999999999620) +(num-test (cos -1/362880) 0.99999999999620) +(num-test (cos 2/1) -0.41614683654714) +(num-test (cos 2/2) 0.54030230586814) +(num-test (cos 2/3) 0.78588726077695) +(num-test (cos 2/10) 0.98006657784124) +(num-test (cos -2/10) 0.98006657784124) +(num-test (cos 2/1234) 0.99999868659223) +(num-test (cos -2/1234) 0.99999868659223) +(num-test (cos 2/1234000000) 1.0) +(num-test (cos -2/1234000000) 1.0) +(num-test (cos 2/500029) 0.99999999999200) +(num-test (cos -2/500029) 0.99999999999200) +(num-test (cos 2/362880) 0.99999999998481) +(num-test (cos -2/362880) 0.99999999998481) +(num-test (cos 3/1) -0.98999249660045) +(num-test (cos 3/2) 0.07073720166770) +(num-test (cos 3/3) 0.54030230586814) +(num-test (cos 3/10) 0.95533648912561) +(num-test (cos -3/10) 0.95533648912561) +(num-test (cos 3/1234) 0.99999704483333) +(num-test (cos -3/1234) 0.99999704483333) +(num-test (cos 3/1234000000) 1.0) +(num-test (cos -3/1234000000) 1.0) +(num-test (cos 3/500029) 0.99999999998200) +(num-test (cos -3/500029) 0.99999999998200) +(num-test (cos 3/362880) 0.99999999996583) +(num-test (cos -3/362880) 0.99999999996583) +(num-test (cos 10/3) -0.98167400471108) +(num-test (cos 10/10) 0.54030230586814) +(num-test (cos 10/1234) 0.99996716497825) +(num-test (cos -10/1234) 0.99996716497825) +(num-test (cos 10/1234000000) 1.0) +(num-test (cos -10/1234000000) 1.0) +(num-test (cos 10/500029) 0.99999999980002) +(num-test (cos -10/500029) 0.99999999980002) +(num-test (cos 10/362880) 0.99999999962030) +(num-test (cos -10/362880) 0.99999999962030) +(num-test (cos 1234/1234) 0.54030230586814) +(num-test (cos 1234/1234000000) 0.99999999999950) +(num-test (cos -1234/1234000000) 0.99999999999950) +(num-test (cos 1234/500029) 0.99999695484279) +(num-test (cos -1234/500029) 0.99999695484279) +(num-test (cos 1234/362880) 0.99999421805655) +(num-test (cos -1234/362880) 0.99999421805655) +(num-test (cos 1234000000/1234000000) 0.54030230586814) +(num-test (cos 500029/1234000000) 0.99999991790247) +(num-test (cos -500029/1234000000) 0.99999991790247) +(num-test (cos 500029/500029) 0.54030230586814) +(num-test (cos 500029/362880) 0.19165727729458) +(num-test (cos 362880/1234000000) 0.99999995676199) +(num-test (cos -362880/1234000000) 0.99999995676199) +(num-test (cos 362880/500029) 0.74802315864263) +(num-test (cos 362880/362880) 0.54030230586814) +(num-test (cos 0.0) 1.0) +(num-test (cos 0.00000001) 1.0) +(num-test (cos -0.00000001) 1.0) +(num-test (cos 1.0) 0.54030230586814) +(num-test (cos our-pi) -1.0) +(num-test (cos 2.71828182845905) -0.91173391478697) +(num-test (cos 0.0+0.0i) 1.0) +(num-test (cos -0.0+0.0i) 1.0) +(num-test (cos 0.0-0.0i) 1.0) +(num-test (cos -0.0-0.0i) 1.0) +(num-test (cos 0.0+0.00000001i) 1.0) +(num-test (cos -0.0+0.00000001i) 1.0) +(num-test (cos 0.0-0.00000001i) 1.0) +(num-test (cos -0.0-0.00000001i) 1.0) +(num-test (cos 0.0+1.0i) 1.54308063481524) +(num-test (cos -0.0+1.0i) 1.54308063481524) +(num-test (cos 0.0-1.0i) 1.54308063481524) +(num-test (cos 0.0+3.14159265358979i) 11.59195327552152) +(num-test (cos -0.0+3.14159265358979i) 11.59195327552152) +(num-test (cos 0.0-3.14159265358979i) 11.59195327552152) +(num-test (cos 0.0+2.71828182845905i) 7.61012513866229) +(num-test (cos -0.0+2.71828182845905i) 7.61012513866229) +(num-test (cos 0.0-2.71828182845905i) 7.61012513866229) +(num-test (cos 0.00000001+0.0i) 1.0) +(num-test (cos -0.00000001+0.0i) 1.0) +(num-test (cos 0.00000001-0.0i) 1.0) +(num-test (cos -0.00000001-0.0i) 1.0) +(num-test (cos 0.00000001+0.00000001i) 1.0-1e-16i) ; maxima +(num-test (cos -0.00000001+0.00000001i) 1.0+1e-16i) +(num-test (cos 0.00000001-0.00000001i) 1.0+1e-16i) +(num-test (cos -0.00000001-0.00000001i) 1.0-1e-16i) +(num-test (cos 0.00000001+1.0i) 1.54308063481524-0.00000001175201i) +(num-test (cos 0.00000001-1.0i) 1.54308063481524+0.00000001175201i) +(num-test (cos 0.00000001+3.14159265358979i) 11.59195327552152-0.00000011548739i) +(num-test (cos 0.00000001-3.14159265358979i) 11.59195327552152+0.00000011548739i) +(num-test (cos 0.00000001+2.71828182845905i) 7.61012513866229-0.00000007544137i) +(num-test (cos 0.00000001-2.71828182845905i) 7.61012513866229+0.00000007544137i) +(num-test (cos 1.0+0.0i) 0.54030230586814) +(num-test (cos 1.0-0.0i) 0.54030230586814) +(num-test (cos 1.0+0.00000001i) 0.54030230586814-0.00000000841471i) +(num-test (cos 1.0-0.00000001i) 0.54030230586814+0.00000000841471i) +(num-test (cos 1.0+1.0i) 0.83373002513115-0.98889770576287i) +(num-test (cos 1.0-1.0i) 0.83373002513115+0.98889770576287i) +(num-test (cos 1.0+3.14159265358979i) 6.26315908428001-9.71792908024139i) +(num-test (cos 1.0-3.14159265358979i) 6.26315908428001+9.71792908024139i) +(num-test (cos 1.0+2.71828182845905i) 4.11176816036433-6.34817247743319i) +(num-test (cos 1.0-2.71828182845905i) 4.11176816036433+6.34817247743319i) +(num-test (cos 3.14159265358979+0.0i) -1.0) +(num-test (cos 3.14159265358979-0.0i) -1.0) +(num-test (cos 3.14159265358979+0.00000001i) -1.0-3.23121723694911E-23i) ; maxima +(num-test (cos 3.14159265358979-0.00000001i) -1.0+3.23121723694911E-23i) ; maxima +(num-test (cos 3.14159265358979+1.0i) -1.54308063481524-0.0i) +(num-test (cos 3.14159265358979-1.0i) -1.54308063481524+0.0i) +(num-test (cos 3.14159265358979+3.14159265358979i) -11.5919532755216+8.064357485351393E-14i) ; maxima +(num-test (cos 3.14159265358979-3.14159265358979i) -11.59195327552152+3.73164856762037E-14i) +(num-test (cos 3.14159265358979+2.71828182845905i) -7.61012513866229-2.437674584452965E-14i) +(num-test (cos 3.14159265358979-2.71828182845905i) -7.61012513866229+2.437674584452965E-14i) +(num-test (cos 2.71828182845905+0.0i) -0.91173391478697) +(num-test (cos 2.71828182845905-0.0i) -0.91173391478697) +(num-test (cos 2.71828182845905+0.00000001i) -0.91173391478697-0.00000000410781i) +(num-test (cos 2.71828182845905-0.00000001i) -0.91173391478697+0.00000000410781i) +(num-test (cos 2.71828182845905+1.0i) -1.40687894801206-0.48275066292556i) +(num-test (cos 2.71828182845905-1.0i) -1.40687894801206+0.48275066292556i) +(num-test (cos 2.71828182835905+3.14159265358979i) -10.56877693991882-4.74400605685607i) +(num-test (cos 2.71828182845905-3.14159265358979i) -10.56877693991882+4.74400605685607i) +(num-test (cos 2.71828182845905+2.71828182845905i) -6.93840918469126-3.09899037482603i) +(num-test (cos 2.71828182845905-2.71828182845905i) -6.93840918469126+3.09899037482603i) +(num-test (cos -2/3) .7858872607769459) +(num-test (cos -3/2) 0.0707372016677029) +(num-test (cos -10/3) -0.9816740047110853) +(num-test (cos 1234/3) -0.9769114301438807) +(num-test (cos 1234/10) -0.6387786688749486) +(num-test (cos 1234000000/3) -5.317013319482049e-2) +(num-test (cos 1234000000/500029) .1354175745756898) +(num-test (cos 1234000000/362880) .1995074806029773) +(num-test (cos 500029/2) 0.962847094896035) +(num-test (cos 500029/3) -0.6487140328750399) +(num-test (cos 500029/10) .2565691622107056) +(num-test (cos 500029/1234) -0.9984566200318916) +(num-test (cos -500029/362880) .1916572772946199) +(num-test (cos 362880/1234) .3232465372699541) +(num-test (cos -362880/500029) .7480231586426291) +(num-test (cos -3.14159265358979) -1.0) +(num-test (cos -2.71828182845905) -0.9117339147869464) +(num-test (cos 0.0+3.14159265358979i) 11.5919532755216) +(num-test (cos 0.0+2.71828182845905i) 7.610125138661946) +(num-test (cos 0.00000001+1.0i) 1.543080634815244-1.1752011936438014E-8i) +(num-test (cos 0.00000001+3.14159265358979i) 11.5919532755216-1.154873935725783E-7i) +(num-test (cos 0.00000001+2.71828182845905i) 7.610125138661945-7.54413710281663E-8i) +(num-test (cos 1.0+0.00000001i) .5403023058681398-8.414709848078964E-9i) +(num-test (cos 1.0+3.14159265358979i) 6.263159084280057-9.71792908024146i) +(num-test (cos 1.0+2.71828182845905i) 4.111768160364146-6.348172477432901i) +(num-test (cos 3.14159265358979+0.0i) -1.0) +(num-test (cos 3.14159265358979+0.00000001i) -1.0+6.982889851335445E-23i) +(num-test (cos 3.14159265358979+1.0i) -1.543080634815244+8.206300488372603E-15i) +(num-test (cos 3.14159265358979+3.14159265358979i) -11.5919532755216+8.064357485351393E-14i) +(num-test (cos 3.14159265358979+2.71828182845905i) -7.610125138661946+5.267987841234144E-14i) +(num-test (cos 2.71828182845905+0.0i) -0.9117339147869464) +(num-test (cos 2.71828182845905+0.00000001i) -0.9117339147869464-4.1078129050295015E-9i) +(num-test (cos 2.71828182845905+1.0i) -1.406878948012029-0.4827506629256081i) +(num-test (cos 2.71828182845905+3.14159265358979i) -10.56877693991868-4.744006056856582i) +(num-test (cos 2.71828182845905+2.71828182845905i) -6.93840918469081-3.098990374826203i) +(num-test (cos 1234.0+0.00000001i) -0.7985506235875843-6.019276547624973E-9i) +(num-test (cos 1234.0+3.14159265358979i) -9.256761516765916-6.951505596777556i) +(num-test (cos 1234.0+2.71828182845905i) -6.077070175058048-4.541024753505155i) +(num-test (cos 1234000000.0+0.00000001i) +0.1589091308902228+9.872932128398908E-9i) +(num-test (cos 1234000000.0+3.14159265358979i) +1.84206722033321+11.40199198427758i) +(num-test (cos 1234000000.0+2.71828182845905i) +1.209318371750606+7.448275358344457i) +(num-test (cos 1234.0+12.0i) -64983.97009220963-48983.30494825104i) +(num-test (cos -3.45266983001243932001e-04+0.0e+00i) 9.9999994039535581673e-1+0.0i) +(num-test (cos 3.45266983001243932001e-04+0.0e+00i) 9.9999994039535581673e-1+0.0i) +(num-test (cos -3.45266983001243932001e-04+1.19209289550781250e-07i) 9.9999994039536292216e-1+4.1159030931163569191e-11i) +(num-test (cos -3.45266983001243932001e-04-1.19209289550781250e-07i) 9.9999994039536292216e-1-4.1159030931163569191e-11i) +(num-test (cos 3.45266983001243932001e-04+1.19209289550781250e-07i) 9.9999994039536292216e-1-4.1159030931163569191e-11i) +(num-test (cos 3.45266983001243932001e-04-1.19209289550781250e-07i) 9.9999994039536292216e-1+4.1159030931163569191e-11i) +(num-test (cos -3.45266983001243932001e-04+5.0e-01i) 1.1276258979946363573e0+1.7991700040930800151e-4i) +(num-test (cos -3.45266983001243932001e-04-5.0e-01i) 1.1276258979946363573e0-1.7991700040930800151e-4i) +(num-test (cos 3.45266983001243932001e-04+5.0e-01i) 1.1276258979946363573e0-1.7991700040930800151e-4i) +(num-test (cos 3.45266983001243932001e-04-5.0e-01i) 1.1276258979946363573e0+1.7991700040930800151e-4i) +(num-test (cos -3.45266983001243932001e-04+1.0e+00i) 1.5430805428404715942e0+4.057581624871654840e-4i) +(num-test (cos -3.45266983001243932001e-04-1.0e+00i) 1.5430805428404715942e0-4.057581624871654840e-4i) +(num-test (cos 3.45266983001243932001e-04+1.0e+00i) 1.5430805428404715942e0-4.057581624871654840e-4i) +(num-test (cos 3.45266983001243932001e-04-1.0e+00i) 1.5430805428404715942e0+4.057581624871654840e-4i) +(num-test (cos -3.45266983001243932001e-04+2.0e+00i) 3.7621954668392959447e0+1.2522351259043242989e-3i) +(num-test (cos -3.45266983001243932001e-04-2.0e+00i) 3.7621954668392959447e0-1.2522351259043242989e-3i) +(num-test (cos 3.45266983001243932001e-04+2.0e+00i) 3.7621954668392959447e0-1.2522351259043242989e-3i) +(num-test (cos 3.45266983001243932001e-04-2.0e+00i) 3.7621954668392959447e0+1.2522351259043242989e-3i) +(num-test (cos 1.57045105981189525579e+00+0.0e+00i) 3.4526697614152485627e-4+0.0i) +(num-test (cos -1.57045105981189525579e+00+0.0e+00i) 3.4526697614152485627e-4+0.0i) +(num-test (cos 1.57045105981189525579e+00+1.19209289550781250e-07i) 3.4526697614152730954e-4-1.1920928244535424532e-7i) +(num-test (cos 1.57045105981189525579e+00-1.19209289550781250e-07i) 3.4526697614152730954e-4+1.1920928244535424532e-7i) +(num-test (cos -1.57045105981189525579e+00+1.19209289550781250e-07i) 3.4526697614152730954e-4+1.1920928244535424532e-7i) +(num-test (cos -1.57045105981189525579e+00-1.19209289550781250e-07i) 3.4526697614152730954e-4-1.1920928244535424532e-7i) +(num-test (cos 1.57045105981189525579e+00+5.0e-01i) 3.8933200722547541227e-4-5.2109527443404709207e-1i) +(num-test (cos 1.57045105981189525579e+00-5.0e-01i) 3.8933200722547541227e-4+5.2109527443404709207e-1i) +(num-test (cos -1.57045105981189525579e+00+5.0e-01i) 3.8933200722547541227e-4+5.2109527443404709207e-1i) +(num-test (cos -1.57045105981189525579e+00-5.0e-01i) 3.8933200722547541227e-4-5.2109527443404709207e-1i) +(num-test (cos 1.57045105981189525579e+00+1.0e+00i) 5.3277478472520380315e-4-1.1752011235963524659e0i) +(num-test (cos 1.57045105981189525579e+00-1.0e+00i) 5.3277478472520380315e-4+1.1752011235963524659e0i) +(num-test (cos -1.57045105981189525579e+00+1.0e+00i) 5.3277478472520380315e-4+1.1752011235963524659e0i) +(num-test (cos -1.57045105981189525579e+00-1.0e+00i) 5.3277478472520380315e-4-1.1752011235963524659e0i) +(num-test (cos 1.57045105981189525579e+00+2.0e+00i) 1.2989619299131198016e-3-3.6268601916692946554e0i) +(num-test (cos 1.57045105981189525579e+00-2.0e+00i) 1.2989619299131198016e-3+3.6268601916692946554e0i) +(num-test (cos -1.57045105981189525579e+00+2.0e+00i) 1.2989619299131198016e-3+3.6268601916692946554e0i) +(num-test (cos -1.57045105981189525579e+00-2.0e+00i) 1.2989619299131198016e-3-3.6268601916692946554e0i) +(num-test (cos 1.57114159377789786021e+00+0.0e+00i) -3.4526697614140239160e-4+0.0i) +(num-test (cos -1.57114159377789786021e+00+0.0e+00i) -3.4526697614140239160e-4+0.0i) +(num-test (cos 1.57114159377789786021e+00+1.19209289550781250e-07i) -3.4526697614140484486e-4-1.1920928244535424533e-7i) +(num-test (cos 1.57114159377789786021e+00-1.19209289550781250e-07i) -3.4526697614140484486e-4+1.1920928244535424533e-7i) +(num-test (cos -1.57114159377789786021e+00+1.19209289550781250e-07i) -3.4526697614140484486e-4+1.1920928244535424533e-7i) +(num-test (cos -1.57114159377789786021e+00-1.19209289550781250e-07i) -3.4526697614140484486e-4-1.1920928244535424533e-7i) +(num-test (cos 1.57114159377789786021e+00+5.0e-01i) -3.8933200722533731792e-4-5.2109527443404709209e-1i) +(num-test (cos 1.57114159377789786021e+00-5.0e-01i) -3.8933200722533731792e-4+5.2109527443404709209e-1i) +(num-test (cos -1.57114159377789786021e+00+5.0e-01i) -3.8933200722533731792e-4+5.2109527443404709209e-1i) +(num-test (cos -1.57114159377789786021e+00-5.0e-01i) -3.8933200722533731792e-4-5.2109527443404709209e-1i) +(num-test (cos 1.57114159377789786021e+00+1.0e+00i) -5.3277478472501483029e-4-1.1752011235963524660e0i) +(num-test (cos 1.57114159377789786021e+00-1.0e+00i) -5.3277478472501483029e-4+1.1752011235963524660e0i) +(num-test (cos -1.57114159377789786021e+00+1.0e+00i) -5.3277478472501483029e-4+1.1752011235963524660e0i) +(num-test (cos -1.57114159377789786021e+00-1.0e+00i) -5.3277478472501483029e-4-1.1752011235963524660e0i) +(num-test (cos 1.57114159377789786021e+00+2.0e+00i) -1.2989619299126590655e-3-3.6268601916692946556e0i) +(num-test (cos 1.57114159377789786021e+00-2.0e+00i) -1.2989619299126590655e-3+3.6268601916692946556e0i) +(num-test (cos -1.57114159377789786021e+00+2.0e+00i) -1.2989619299126590655e-3+3.6268601916692946556e0i) +(num-test (cos -1.57114159377789786021e+00-2.0e+00i) -1.2989619299126590655e-3-3.6268601916692946556e0i) +(num-test (cos 3.14124738660679181379e+00+0.0e+00i) -9.9999994039535581667e-1+0.0i) +(num-test (cos -3.14124738660679181379e+00+0.0e+00i) -9.9999994039535581667e-1+0.0i) +(num-test (cos 3.14124738660679181379e+00+1.19209289550781250e-07i) -9.9999994039536292209e-1-4.1159030931185115142e-11i) +(num-test (cos 3.14124738660679181379e+00-1.19209289550781250e-07i) -9.9999994039536292209e-1+4.1159030931185115142e-11i) +(num-test (cos -3.14124738660679181379e+00+1.19209289550781250e-07i) -9.9999994039536292209e-1+4.1159030931185115142e-11i) +(num-test (cos -3.14124738660679181379e+00-1.19209289550781250e-07i) -9.9999994039536292209e-1-4.1159030931185115142e-11i) +(num-test (cos 3.14124738660679181379e+00+5.0e-01i) -1.1276258979946363572e0-1.7991700040940218455e-4i) +(num-test (cos 3.14124738660679181379e+00-5.0e-01i) -1.1276258979946363572e0+1.7991700040940218455e-4i) +(num-test (cos -3.14124738660679181379e+00+5.0e-01i) -1.1276258979946363572e0+1.7991700040940218455e-4i) +(num-test (cos -3.14124738660679181379e+00-5.0e-01i) -1.1276258979946363572e0-1.7991700040940218455e-4i) +(num-test (cos 3.14124738660679181379e+00+1.0e+00i) -1.5430805428404715941e0-4.0575816248737789049e-4i) +(num-test (cos 3.14124738660679181379e+00-1.0e+00i) -1.5430805428404715941e0+4.0575816248737789049e-4i) +(num-test (cos -3.14124738660679181379e+00+1.0e+00i) -1.5430805428404715941e0+4.0575816248737789049e-4i) +(num-test (cos -3.14124738660679181379e+00-1.0e+00i) -1.5430805428404715941e0-4.0575816248737789049e-4i) +(num-test (cos 3.14124738660679181379e+00+2.0e+00i) -3.7621954668392959444e0-1.2522351259049798196e-3i) +(num-test (cos 3.14124738660679181379e+00-2.0e+00i) -3.7621954668392959444e0+1.2522351259049798196e-3i) +(num-test (cos -3.14124738660679181379e+00+2.0e+00i) -3.7621954668392959444e0+1.2522351259049798196e-3i) +(num-test (cos -3.14124738660679181379e+00-2.0e+00i) -3.7621954668392959444e0-1.2522351259049798196e-3i) +(num-test (cos 3.14193792057279441821e+00+0.0e+00i) -9.9999994039535581675e-1+0.0i) +(num-test (cos -3.14193792057279441821e+00+0.0e+00i) -9.9999994039535581675e-1+0.0i) +(num-test (cos 3.14193792057279441821e+00+1.19209289550781250e-07i) -9.9999994039536292218e-1+4.1159030931155917289e-11i) +(num-test (cos 3.14193792057279441821e+00-1.19209289550781250e-07i) -9.9999994039536292218e-1-4.1159030931155917289e-11i) +(num-test (cos -3.14193792057279441821e+00+1.19209289550781250e-07i) -9.9999994039536292218e-1-4.1159030931155917289e-11i) +(num-test (cos -3.14193792057279441821e+00-1.19209289550781250e-07i) -9.9999994039536292218e-1+4.1159030931155917289e-11i) +(num-test (cos 3.14193792057279441821e+00+5.0e-01i) -1.1276258979946363573e0+1.7991700040927455302e-4i) +(num-test (cos 3.14193792057279441821e+00-5.0e-01i) -1.1276258979946363573e0-1.7991700040927455302e-4i) +(num-test (cos -3.14193792057279441821e+00+5.0e-01i) -1.1276258979946363573e0-1.7991700040927455302e-4i) +(num-test (cos -3.14193792057279441821e+00-5.0e-01i) -1.1276258979946363573e0+1.7991700040927455302e-4i) +(num-test (cos 3.14193792057279441821e+00+1.0e+00i) -1.5430805428404715943e0+4.0575816248709004923e-4i) +(num-test (cos 3.14193792057279441821e+00-1.0e+00i) -1.5430805428404715943e0-4.0575816248709004923e-4i) +(num-test (cos -3.14193792057279441821e+00+1.0e+00i) -1.5430805428404715943e0-4.0575816248709004923e-4i) +(num-test (cos -3.14193792057279441821e+00-1.0e+00i) -1.5430805428404715943e0+4.0575816248709004923e-4i) +(num-test (cos 3.14193792057279441821e+00+2.0e+00i) -3.7621954668392959448e0+1.2522351259040914950e-3i) +(num-test (cos 3.14193792057279441821e+00-2.0e+00i) -3.7621954668392959448e0-1.2522351259040914950e-3i) +(num-test (cos -3.14193792057279441821e+00+2.0e+00i) -3.7621954668392959448e0-1.2522351259040914950e-3i) +(num-test (cos -3.14193792057279441821e+00-2.0e+00i) -3.7621954668392959448e0+1.2522351259040914950e-3i) +(num-test (cos 4.71204371340168837179e+00+0.0e+00i) -3.4526697614164732094e-4+0.0i) +(num-test (cos -4.71204371340168837179e+00+0.0e+00i) -3.4526697614164732094e-4+0.0i) +(num-test (cos 4.71204371340168837179e+00+1.19209289550781250e-07i) -3.4526697614164977421e-4+1.1920928244535424532e-7i) +(num-test (cos 4.71204371340168837179e+00-1.19209289550781250e-07i) -3.4526697614164977421e-4-1.1920928244535424532e-7i) +(num-test (cos -4.71204371340168837179e+00+1.19209289550781250e-07i) -3.4526697614164977421e-4-1.1920928244535424532e-7i) +(num-test (cos -4.71204371340168837179e+00-1.19209289550781250e-07i) -3.4526697614164977421e-4+1.1920928244535424532e-7i) +(num-test (cos 4.71204371340168837179e+00+5.0e-01i) -3.8933200722561350661e-4+5.2109527443404709205e-1i) +(num-test (cos 4.71204371340168837179e+00-5.0e-01i) -3.8933200722561350661e-4-5.2109527443404709205e-1i) +(num-test (cos -4.71204371340168837179e+00+5.0e-01i) -3.8933200722561350661e-4-5.2109527443404709205e-1i) +(num-test (cos -4.71204371340168837179e+00-5.0e-01i) -3.8933200722561350661e-4+5.2109527443404709205e-1i) +(num-test (cos 4.71204371340168837179e+00+1.0e+00i) -5.3277478472539277601e-4+1.1752011235963524659e0i) +(num-test (cos 4.71204371340168837179e+00-1.0e+00i) -5.3277478472539277601e-4-1.1752011235963524659e0i) +(num-test (cos -4.71204371340168837179e+00+1.0e+00i) -5.3277478472539277601e-4-1.1752011235963524659e0i) +(num-test (cos -4.71204371340168837179e+00-1.0e+00i) -5.3277478472539277601e-4+1.1752011235963524659e0i) +(num-test (cos 4.71204371340168837179e+00+2.0e+00i) -1.2989619299135805376e-3+3.6268601916692946552e0i) +(num-test (cos 4.71204371340168837179e+00-2.0e+00i) -1.2989619299135805376e-3-3.6268601916692946552e0i) +(num-test (cos -4.71204371340168837179e+00+2.0e+00i) -1.2989619299135805376e-3-3.6268601916692946552e0i) +(num-test (cos -4.71204371340168837179e+00-2.0e+00i) -1.2989619299135805376e-3+3.6268601916692946552e0i) +(num-test (cos 4.71273424736769097620e+00+0.0e+00i) 3.4526697614127992692e-4+0.0i) +(num-test (cos -4.71273424736769097620e+00+0.0e+00i) 3.4526697614127992692e-4+0.0i) +(num-test (cos 4.71273424736769097620e+00+1.19209289550781250e-07i) 3.4526697614128238019e-4+1.1920928244535424533e-7i) +(num-test (cos 4.71273424736769097620e+00-1.19209289550781250e-07i) 3.4526697614128238019e-4-1.1920928244535424533e-7i) +(num-test (cos -4.71273424736769097620e+00+1.19209289550781250e-07i) 3.4526697614128238019e-4-1.1920928244535424533e-7i) +(num-test (cos -4.71273424736769097620e+00-1.19209289550781250e-07i) 3.4526697614128238019e-4+1.1920928244535424533e-7i) +(num-test (cos 4.71273424736769097620e+00+5.0e-01i) 3.8933200722519922358e-4+5.2109527443404709212e-1i) +(num-test (cos 4.71273424736769097620e+00-5.0e-01i) 3.8933200722519922358e-4-5.2109527443404709212e-1i) +(num-test (cos -4.71273424736769097620e+00+5.0e-01i) 3.8933200722519922358e-4-5.2109527443404709212e-1i) +(num-test (cos -4.71273424736769097620e+00-5.0e-01i) 3.8933200722519922358e-4+5.2109527443404709212e-1i) +(num-test (cos 4.71273424736769097620e+00+1.0e+00i) 5.3277478472482585742e-4+1.1752011235963524660e0i) +(num-test (cos 4.71273424736769097620e+00-1.0e+00i) 5.3277478472482585742e-4-1.1752011235963524660e0i) +(num-test (cos -4.71273424736769097620e+00+1.0e+00i) 5.3277478472482585742e-4-1.1752011235963524660e0i) +(num-test (cos -4.71273424736769097620e+00-1.0e+00i) 5.3277478472482585742e-4+1.1752011235963524660e0i) +(num-test (cos 4.71273424736769097620e+00+2.0e+00i) 1.2989619299121983294e-3+3.6268601916692946557e0i) +(num-test (cos 4.71273424736769097620e+00-2.0e+00i) 1.2989619299121983294e-3-3.6268601916692946557e0i) +(num-test (cos -4.71273424736769097620e+00+2.0e+00i) 1.2989619299121983294e-3-3.6268601916692946557e0i) +(num-test (cos -4.71273424736769097620e+00-2.0e+00i) 1.2989619299121983294e-3+3.6268601916692946557e0i) +(num-test (cos 6.28284004019658492979e+00+0.0e+00i) 9.9999994039535581662e-1+0.0i) +(num-test (cos -6.28284004019658492979e+00+0.0e+00i) 9.9999994039535581662e-1+0.0i) +(num-test (cos 6.28284004019658492979e+00+1.19209289550781250e-07i) 9.9999994039536292205e-1+4.1159030931199714069e-11i) +(num-test (cos 6.28284004019658492979e+00-1.19209289550781250e-07i) 9.9999994039536292205e-1-4.1159030931199714069e-11i) +(num-test (cos -6.28284004019658492979e+00+1.19209289550781250e-07i) 9.9999994039536292205e-1-4.1159030931199714069e-11i) +(num-test (cos -6.28284004019658492979e+00-1.19209289550781250e-07i) 9.9999994039536292205e-1+4.1159030931199714069e-11i) +(num-test (cos 6.28284004019658492979e+00+5.0e-01i) 1.1276258979946363572e0+1.7991700040946600032e-4i) +(num-test (cos 6.28284004019658492979e+00-5.0e-01i) 1.1276258979946363572e0-1.7991700040946600032e-4i) +(num-test (cos -6.28284004019658492979e+00+5.0e-01i) 1.1276258979946363572e0-1.7991700040946600032e-4i) +(num-test (cos -6.28284004019658492979e+00-5.0e-01i) 1.1276258979946363572e0+1.7991700040946600032e-4i) +(num-test (cos 6.28284004019658492979e+00+1.0e+00i) 1.5430805428404715941e0+4.0575816248752181112e-4i) +(num-test (cos 6.28284004019658492979e+00-1.0e+00i) 1.5430805428404715941e0-4.0575816248752181112e-4i) +(num-test (cos -6.28284004019658492979e+00+1.0e+00i) 1.5430805428404715941e0-4.0575816248752181112e-4i) +(num-test (cos -6.28284004019658492979e+00-1.0e+00i) 1.5430805428404715941e0+4.0575816248752181112e-4i) +(num-test (cos 6.28284004019658492979e+00+2.0e+00i) 3.7621954668392959443e0+1.2522351259054239819e-3i) +(num-test (cos 6.28284004019658492979e+00-2.0e+00i) 3.7621954668392959443e0-1.2522351259054239819e-3i) +(num-test (cos -6.28284004019658492979e+00+2.0e+00i) 3.7621954668392959443e0-1.2522351259054239819e-3i) +(num-test (cos -6.28284004019658492979e+00-2.0e+00i) 3.7621954668392959443e0+1.2522351259054239819e-3i) +(num-test (cos 6.28353057416258753420e+00+0.0e+00i) 9.9999994039535581679e-1+0.0i) +(num-test (cos -6.28353057416258753420e+00+0.0e+00i) 9.9999994039535581679e-1+0.0i) +(num-test (cos 6.28353057416258753420e+00+1.19209289550781250e-07i) 9.9999994039536292222e-1-4.1159030931141318362e-11i) +(num-test (cos 6.28353057416258753420e+00-1.19209289550781250e-07i) 9.9999994039536292222e-1+4.1159030931141318362e-11i) +(num-test (cos -6.28353057416258753420e+00+1.19209289550781250e-07i) 9.9999994039536292222e-1+4.1159030931141318362e-11i) +(num-test (cos -6.28353057416258753420e+00-1.19209289550781250e-07i) 9.9999994039536292222e-1-4.1159030931141318362e-11i) +(num-test (cos 6.28353057416258753420e+00+5.0e-01i) 1.1276258979946363574e0-1.7991700040921073725e-4i) +(num-test (cos 6.28353057416258753420e+00-5.0e-01i) 1.1276258979946363574e0+1.7991700040921073725e-4i) +(num-test (cos -6.28353057416258753420e+00+5.0e-01i) 1.1276258979946363574e0+1.7991700040921073725e-4i) +(num-test (cos -6.28353057416258753420e+00-5.0e-01i) 1.1276258979946363574e0-1.7991700040921073725e-4i) +(num-test (cos 6.28353057416258753420e+00+1.0e+00i) 1.5430805428404715943e0-4.0575816248694612861e-4i) +(num-test (cos 6.28353057416258753420e+00-1.0e+00i) 1.5430805428404715943e0+4.0575816248694612861e-4i) +(num-test (cos -6.28353057416258753420e+00+1.0e+00i) 1.5430805428404715943e0+4.0575816248694612861e-4i) +(num-test (cos -6.28353057416258753420e+00-1.0e+00i) 1.5430805428404715943e0-4.0575816248694612861e-4i) +(num-test (cos 6.28353057416258753420e+00+2.0e+00i) 3.7621954668392959449e0-1.2522351259036473328e-3i) +(num-test (cos 6.28353057416258753420e+00-2.0e+00i) 3.7621954668392959449e0+1.2522351259036473328e-3i) +(num-test (cos -6.28353057416258753420e+00+2.0e+00i) 3.7621954668392959449e0+1.2522351259036473328e-3i) +(num-test (cos -6.28353057416258753420e+00-2.0e+00i) 3.7621954668392959449e0-1.2522351259036473328e-3i) +(num-test (cos 9.42443269378637893396e+00+0.0e+00i) -9.9999994039535581689e-1+0.0i) +(num-test (cos -9.42443269378637893396e+00+0.0e+00i) -9.9999994039535581689e-1+0.0i) +(num-test (cos 9.42443269378637893396e+00+1.19209289550781250e-07i) -9.9999994039536292231e-1-4.1159030931108433883e-11i) +(num-test (cos 9.42443269378637893396e+00-1.19209289550781250e-07i) -9.9999994039536292231e-1+4.1159030931108433883e-11i) +(num-test (cos -9.42443269378637893396e+00+1.19209289550781250e-07i) -9.9999994039536292231e-1+4.1159030931108433883e-11i) +(num-test (cos -9.42443269378637893396e+00-1.19209289550781250e-07i) -9.9999994039536292231e-1-4.1159030931108433883e-11i) +(num-test (cos 9.42443269378637893396e+00+5.0e-01i) -1.1276258979946363575e0-1.7991700040906699050e-4i) +(num-test (cos 9.42443269378637893396e+00-5.0e-01i) -1.1276258979946363575e0+1.7991700040906699050e-4i) +(num-test (cos -9.42443269378637893396e+00+5.0e-01i) -1.1276258979946363575e0+1.7991700040906699050e-4i) +(num-test (cos -9.42443269378637893396e+00-5.0e-01i) -1.1276258979946363575e0-1.7991700040906699050e-4i) +(num-test (cos 9.42443269378637893396e+00+1.0e+00i) -1.5430805428404715945e0-4.0575816248662194348e-4i) +(num-test (cos 9.42443269378637893396e+00-1.0e+00i) -1.5430805428404715945e0+4.0575816248662194348e-4i) +(num-test (cos -9.42443269378637893396e+00+1.0e+00i) -1.5430805428404715945e0+4.0575816248662194348e-4i) +(num-test (cos -9.42443269378637893396e+00-1.0e+00i) -1.5430805428404715945e0-4.0575816248662194348e-4i) +(num-test (cos 9.42443269378637893396e+00+2.0e+00i) -3.7621954668392959453e0-1.2522351259026468452e-3i) +(num-test (cos 9.42443269378637893396e+00-2.0e+00i) -3.7621954668392959453e0+1.2522351259026468452e-3i) +(num-test (cos -9.42443269378637893396e+00+2.0e+00i) -3.7621954668392959453e0+1.2522351259026468452e-3i) +(num-test (cos -9.42443269378637893396e+00-2.0e+00i) -3.7621954668392959453e0-1.2522351259026468452e-3i) +(num-test (cos 9.42512322775237976202e+00+0.0e+00i) -9.9999994039535581714e-1+0.0i) +(num-test (cos -9.42512322775237976202e+00+0.0e+00i) -9.9999994039535581714e-1+0.0i) +(num-test (cos 9.42512322775237976202e+00+1.19209289550781250e-07i) -9.9999994039536292257e-1+4.1159030931020840323e-11i) +(num-test (cos 9.42512322775237976202e+00-1.19209289550781250e-07i) -9.9999994039536292257e-1-4.1159030931020840323e-11i) +(num-test (cos -9.42512322775237976202e+00+1.19209289550781250e-07i) -9.9999994039536292257e-1-4.1159030931020840323e-11i) +(num-test (cos -9.42512322775237976202e+00-1.19209289550781250e-07i) -9.9999994039536292257e-1+4.1159030931020840323e-11i) +(num-test (cos 9.42512322775237976202e+00+5.0e-01i) -1.1276258979946363577e0+1.7991700040868409591e-4i) +(num-test (cos 9.42512322775237976202e+00-5.0e-01i) -1.1276258979946363577e0-1.7991700040868409591e-4i) +(num-test (cos -9.42512322775237976202e+00+5.0e-01i) -1.1276258979946363577e0-1.7991700040868409591e-4i) +(num-test (cos -9.42512322775237976202e+00-5.0e-01i) -1.1276258979946363577e0+1.7991700040868409591e-4i) +(num-test (cos 9.42512322775237976202e+00+1.0e+00i) -1.5430805428404715949e0+4.0575816248575841970e-4i) +(num-test (cos 9.42512322775237976202e+00-1.0e+00i) -1.5430805428404715949e0-4.0575816248575841970e-4i) +(num-test (cos -9.42512322775237976202e+00+1.0e+00i) -1.5430805428404715949e0-4.0575816248575841970e-4i) +(num-test (cos -9.42512322775237976202e+00-1.0e+00i) -1.5430805428404715949e0+4.0575816248575841970e-4i) +(num-test (cos 9.42512322775237976202e+00+2.0e+00i) -3.7621954668392959462e0+1.2522351258999818715e-3i) +(num-test (cos 9.42512322775237976202e+00-2.0e+00i) -3.7621954668392959462e0-1.2522351258999818715e-3i) +(num-test (cos -9.42512322775237976202e+00+2.0e+00i) -3.7621954668392959462e0-1.2522351258999818715e-3i) +(num-test (cos -9.42512322775237976202e+00-2.0e+00i) -3.7621954668392959462e0+1.2522351258999818715e-3i) +(num-test (cos 0) 1.0) + + +;; -------- tan +(num-test (tan 0) 0.0) +(num-test (tan 1) 1.55740772465490) +(num-test (tan -1) -1.55740772465490) +(num-test (tan 0/1) 0.0) +(num-test (tan 0/2) 0.0) +(num-test (tan 0/3) 0.0) +(num-test (tan 0/10) 0.0) +(num-test (tan 0/1234) 0.0) +(num-test (tan 0/1234000000) 0.0) +(num-test (tan 0/500029) 0.0) +(num-test (tan 0/362880) 0.0) +(num-test (tan 1/1) 1.55740772465490) +(num-test (tan -1/1) -1.55740772465490) +(num-test (tan 1/2) 0.54630248984379) +(num-test (tan -1/2) -0.54630248984379) +(num-test (tan 1/3) 0.34625354951058) +(num-test (tan -1/3) -0.34625354951058) +(num-test (tan 1/10) 0.10033467208545) +(num-test (tan -1/10) -0.10033467208545) +(num-test (tan 1/1234) 0.00081037294887) +(num-test (tan -1/1234) -0.00081037294887) +(num-test (tan 1/1234000000) 0.00000000081037) +(num-test (tan -1/1234000000) -0.00000000081037) +(num-test (tan 1/500029) 0.00000199988401) +(num-test (tan -1/500029) -0.00000199988401) +(num-test (tan 1/362880) 0.00000275573192) +(num-test (tan -1/362880) -0.00000275573192) +(num-test (tan 2/2) 1.55740772465490) +(num-test (tan -2/2) -1.55740772465490) +(num-test (tan 2/3) 0.78684288947298) +(num-test (tan -2/3) -0.78684288947298) +(num-test (tan 2/10) 0.20271003550867) +(num-test (tan -2/10) -0.20271003550867) +(num-test (tan 2/1234) 0.00162074696208) +(num-test (tan -2/1234) -0.00162074696208) +(num-test (tan 2/1234000000) 0.00000000162075) +(num-test (tan -2/1234000000) -0.00000000162075) +(num-test (tan 2/500029) 0.00000399976801) +(num-test (tan -2/500029) -0.00000399976801) +(num-test (tan 2/362880) 0.00000551146384) +(num-test (tan -2/362880) -0.00000551146384) +(num-test (tan 3/2) 14.10141994717166) +(num-test (tan -3/2) -14.10141994717166) +(num-test (tan 3/3) 1.55740772465490) +(num-test (tan -3/3) -1.55740772465490) +(num-test (tan 3/10) 0.30933624960962) +(num-test (tan -3/10) -0.30933624960962) +(num-test (tan 3/1234) 0.00243112310401) +(num-test (tan -3/1234) -0.00243112310401) +(num-test (tan 3/1234000000) 0.00000000243112) +(num-test (tan -3/1234000000) -0.00000000243112) +(num-test (tan 3/500029) 0.00000599965202) +(num-test (tan -3/500029) -0.00000599965202) +(num-test (tan 3/362880) 0.00000826719577) +(num-test (tan -3/362880) -0.00000826719577) +(num-test (tan 10/10) 1.55740772465490) +(num-test (tan -10/10) -1.55740772465490) +(num-test (tan 10/1234) 0.00810390511110) +(num-test (tan -10/1234) -0.00810390511110) +(num-test (tan 10/1234000000) 0.00000000810373) +(num-test (tan -10/1234000000) -0.00000000810373) +(num-test (tan 10/500029) 0.00001999884007) +(num-test (tan -10/500029) -0.00001999884007) +(num-test (tan 10/362880) 0.00002755731923) +(num-test (tan -10/362880) -0.00002755731923) +(num-test (tan 1234/1234) 1.55740772465490) +(num-test (tan -1234/1234) -1.55740772465490) +(num-test (tan 1234/1234000000) 0.00000100000000) +(num-test (tan -1234/1234000000) -0.00000100000000) +(num-test (tan 1234/500029) 0.00246786187432) +(num-test (tan -1234/500029) -0.00246786187432) +(num-test (tan 1234/362880) 0.00340058630026) +(num-test (tan -1234/362880) -0.00340058630026) +(num-test (tan 1234000000/1234000000) 1.55740772465490) +(num-test (tan -1234000000/1234000000) -1.55740772465490) +(num-test (tan 500029/1234000000) 0.00040520990873) +(num-test (tan -500029/1234000000) -0.00040520990873) +(num-test (tan 500029/500029) 1.55740772465490) +(num-test (tan -500029/500029) -1.55740772465490) +(num-test (tan 500029/362880) 5.12092171798848) +(num-test (tan -500029/362880) -5.12092171798848) +(num-test (tan 362880/1234000000) 0.00029406807979) +(num-test (tan -362880/1234000000) -0.00029406807979) +(num-test (tan 362880/500029) 0.88723539913856) +(num-test (tan -362880/500029) -0.88723539913856) +(num-test (tan 362880/362880) 1.55740772465490) +(num-test (tan -362880/362880) -1.55740772465490) +(num-test (tan 0.0) 0.0) +(num-test (tan 0.00000001) 0.00000001) +(num-test (tan -0.00000001) -0.00000001) +(num-test (tan 1.0) 1.55740772465490) +(num-test (tan -1.0) -1.55740772465490) +(num-test (tan 0.0+0.0i) 0.0) +(num-test (tan -0.0+0.0i) 0.0) +(num-test (tan 0.0-0.0i) 0.0) +(num-test (tan -0.0-0.0i) -0.0) +(num-test (tan 0.0+0.00000001i) 0.0+0.00000001i) +(num-test (tan -0.0+0.00000001i) 0.0+0.00000001i) +(num-test (tan 0.0-0.00000001i) 0.0-0.00000001i) +(num-test (tan -0.0-0.00000001i) -0.0-0.00000001i) +(num-test (tan 0.0+1.0i) 0.0+0.76159415595576i) +(num-test (tan -0.0+1.0i) 0.0+0.76159415595576i) +(num-test (tan 0.0-1.0i) 0.0-0.76159415595576i) +(num-test (tan -0.0-1.0i) -0.0-0.76159415595576i) +(num-test (tan 0.0+3.14159265358979i) 0.0+0.99627207622075i) +(num-test (tan -0.0+3.14159265358979i) 0.0+0.99627207622075i) +(num-test (tan 0.0-3.14159265358979i) 0.0-0.99627207622075i) +(num-test (tan -0.0-3.14159265358979i) -0.0-0.99627207622075i) +(num-test (tan 0.0+2.71828182845905i) 0.0+0.99132891580060i) +(num-test (tan -0.0+2.71828182845905i) 0.0+0.99132891580060i) +(num-test (tan 0.0-2.71828182845905i) 0.0-0.99132891580060i) +(num-test (tan -0.0-2.71828182845905i) -0.0-0.99132891580060i) +(num-test (tan 0.00000001+0.0i) 0.00000001) +(num-test (tan -0.00000001+0.0i) -0.00000001) +(num-test (tan 0.00000001-0.0i) 0.00000001) +(num-test (tan -0.00000001-0.0i) -0.00000001) +(num-test (tan 0.00000001+0.00000001i) 0.00000001+0.00000001i) +(num-test (tan -0.00000001+0.00000001i) -0.00000001+0.00000001i) +(num-test (tan 0.00000001-0.00000001i) 0.00000001-0.00000001i) +(num-test (tan -0.00000001-0.00000001i) -0.00000001-0.00000001i) +(num-test (tan 0.00000001+1.0i) 0.00000000419974+0.76159415595576i) +(num-test (tan -0.00000001+1.0i) -0.00000000419974+0.76159415595576i) +(num-test (tan 0.00000001-1.0i) 0.00000000419974-0.76159415595576i) +(num-test (tan -0.00000001-1.0i) -0.00000000419974-0.76159415595576i) +(num-test (tan 0.00000001+3.14159265358979i) 0.00000000007442+0.99627207622075i) +(num-test (tan -0.00000001+3.14159265358979i) -0.00000000007442+0.99627207622075i) +(num-test (tan 0.00000001-3.14159265358979i) 0.00000000007442-0.99627207622075i) +(num-test (tan -0.00000001-3.14159265358979i) -0.00000000007442-0.99627207622075i) +(num-test (tan 0.00000001+2.71828182845905i) 0.00000000017267+0.99132891580060i) +(num-test (tan -0.00000001+2.71828182845905i) -0.00000000017267+0.99132891580060i) +(num-test (tan 0.00000001-2.71828182845905i) 0.00000000017267-0.99132891580060i) +(num-test (tan -0.00000001-2.71828182845905i) -0.00000000017267-0.99132891580060i) +(num-test (tan 1.0+0.0i) 1.55740772465490) +(num-test (tan -1.0+0.0i) -1.55740772465490) +(num-test (tan 1.0-0.0i) 1.55740772465490) +(num-test (tan -1.0-0.0i) -1.55740772465490) +(num-test (tan 1.0+0.00000001i) 1.55740772465490+0.00000003425519i) +(num-test (tan -1.0+0.00000001i) -1.55740772465490+0.00000003425519i) +(num-test (tan 1.0-0.00000001i) 1.55740772465490-0.00000003425519i) +(num-test (tan -1.0-0.00000001i) -1.55740772465490-0.00000003425519i) +(num-test (tan 1.0+1.0i) 0.27175258531951+1.08392332733869i) +(num-test (tan -1.0+1.0i) -0.27175258531951+1.08392332733869i) +(num-test (tan 1.0-1.0i) 0.27175258531951-1.08392332733869i) +(num-test (tan -1.0-1.0i) -0.27175258531951-1.08392332733869i) +(num-test (tan 1.0+3.14159265358979i) 0.00340139653674+1.00154968930275i) +(num-test (tan -1.0+3.14159265358979i) -0.00340139653674+1.00154968930275i) +(num-test (tan 1.0-3.14159265358979i) 0.00340139653674-1.00154968930275i) +(num-test (tan -1.0-3.14159265358979i) -0.00340139653674-1.00154968930275i) +(num-test (tan 1.0+2.71828182845905i) 0.00794757997665+1.00359921084211i) +(num-test (tan -1.0+2.71828182845905i) -0.00794757997665+1.00359921084211i) +(num-test (tan 1.0-2.71828182845905i) 0.00794757997665-1.00359921084211i) +(num-test (tan -1.0-2.71828182845905i) -0.00794757997665-1.00359921084211i) +(num-test (tan 1234.0+1234.0i) 2.7e-20+1.0i) +(num-test (tan 1234.0-1234.0i) 2.7e-20-1.0i) +(num-test (tan 10/3) .1941255059835657) +(num-test (tan 1234/3) -0.2186940320047828) +(num-test (tan 1234/10) 1.204471256531804) +(num-test (tan 1234000000/3) -18.78094727276203) ; -18.78094815124064721190472 according to arprec's mathtool +(num-test (tan 1234000000/500029) -7.31654379832009) +(num-test (tan 1234000000/362880) 4.911576750502133) +(num-test (tan 500029/2) .2804673425353792) +(num-test (tan 500029/3) -1.173139817032177) +(num-test (tan 500029/10) 3.767116303516932) +(num-test (tan 500029/1234) -0.05562302342803592) +(num-test (tan 362880/1234) -2.927532635052267) +(num-test (tan our-pi) 6.982889851335445E-15) +(num-test (tan 2.71828182845905) -0.4505495340698621) +(num-test (tan 0.00000001+1234.0i) +8.077935669463161E-28+1.0i) +(num-test (tan 0.00000001+1234000000.0i) 0.0+1.0i) +(num-test (tan 3.14159265358979+0.0i) 6.982889851335445E-15) +(num-test (tan 3.14159265358979+0.00000001i) +6.982889851335444E-15+1.0E-8i) +(num-test (tan 3.14159265358979+1.0i) +2.932634567877868E-15+0.7615941559557649i) +(num-test (tan 3.14159265358979+3.14159265358979i) +5.196631812627532E-17+0.99627207622075i) +(num-test (tan 3.14159265358979+2.71828182845905i) +1.205734242765375E-16+0.991328915800599i) +(num-test (tan 3.14159265358979+1234.0i) 0.0+1.0i) +(num-test (tan 3.14159265358979+1234000000.0i) -7.703719777548943E-34+1.0i) +(num-test (tan 2.71828182845905+0.0i) -0.4505495340698621) +(num-test (tan 2.71828182845905+0.00000001i) -0.4505495340698621+1.2029948826505699E-8i) +(num-test (tan 2.71828182845905+1.0i) -0.1692870118766369+0.8196826057997404i) +(num-test (tan 2.71828182845905+3.14159265358979i) -0.002790687681003331+0.9975247319761639i) +(num-test (tan 2.71828182845905+2.71828182845905i) -0.00648578276962794+0.9942257438545914i) +(num-test (tan 2.71828182845905+1234.0i) +2.710505431213761E-20+1.0i) +(num-test (tan 2.71828182845905+1234000000.0i) +2.710505431213761E-20+1.0i) +(num-test (tan 1234.0+0.00000001i) -0.7537751984442328+1.5681770497896427E-8i) +(num-test (tan 1234.0+3.14159265358979i) -0.003586791196867043+0.9989656315245496i) +(num-test (tan 1234.0+2.71828182845905i) -0.008351965390936033+0.9975698313220817i) +(num-test (tan 1234000000.0+0.00000001i) -6.212941995900324+3.9600648244422054E-7i) +(num-test (tan 1234000000.0+3.14159265358979i) -0.001176098307980411+1.003551866736695i) +(num-test (tan 1234000000.0+2.71828182845905i) -0.002755390838840499+1.008299558244272i) +;(num-test (tan 1.5707963259845+2.0630965522972e-18i) 1.234000079689074E+9+3.141593059344448i) +(num-test (tan -3.45266983001243932001e-04+0.0e+00i) -3.4526699672092183585e-4+0.0i) +(num-test (tan 3.45266983001243932001e-04+0.0e+00i) 3.4526699672092183585e-4+0.0i) +(num-test (tan -3.45266983001243932001e-04+1.19209289550781250e-07i) -3.4526699672091692931e-4+1.1920930376163652989e-7i) +(num-test (tan -3.45266983001243932001e-04-1.19209289550781250e-07i) -3.4526699672091692931e-4-1.1920930376163652989e-7i) +(num-test (tan 3.45266983001243932001e-04+1.19209289550781250e-07i) 3.4526699672091692931e-4+1.1920930376163652989e-7i) +(num-test (tan 3.45266983001243932001e-04-1.19209289550781250e-07i) 3.4526699672091692931e-4-1.1920930376163652989e-7i) +(num-test (tan -3.45266983001243932001e-04+5.0e-01i) -2.7153443992655805934e-4+4.6211720058436229979e-1i) +(num-test (tan -3.45266983001243932001e-04-5.0e-01i) -2.7153443992655805934e-4-4.6211720058436229979e-1i) +(num-test (tan 3.45266983001243932001e-04+5.0e-01i) 2.7153443992655805934e-4+4.6211720058436229979e-1i) +(num-test (tan 3.45266983001243932001e-04-5.0e-01i) 2.7153443992655805934e-4-4.6211720058436229979e-1i) +(num-test (tan -3.45266983001243932001e-04+1.0e+00i) -1.4500326960274960880e-4+7.6159419408485704836e-1i) +(num-test (tan -3.45266983001243932001e-04-1.0e+00i) -1.4500326960274960880e-4-7.6159419408485704836e-1i) +(num-test (tan 3.45266983001243932001e-04+1.0e+00i) 1.4500326960274960880e-4+7.6159419408485704836e-1i) +(num-test (tan 3.45266983001243932001e-04-1.0e+00i) 1.4500326960274960880e-4-7.6159419408485704836e-1i) +(num-test (tan -3.45266983001243932001e-04+2.0e+00i) -2.4393395410435306874e-5+9.6402758819508310556e-1i) +(num-test (tan -3.45266983001243932001e-04-2.0e+00i) -2.4393395410435306874e-5-9.6402758819508310556e-1i) +(num-test (tan 3.45266983001243932001e-04+2.0e+00i) 2.4393395410435306874e-5+9.6402758819508310556e-1i) +(num-test (tan 3.45266983001243932001e-04-2.0e+00i) 2.4393395410435306874e-5-9.6402758819508310556e-1i) +(num-test (tan 1.57045105981189525579e+00+0.0e+00i) 2.8963092606501007060e3+0.0i) +(num-test (tan -1.57045105981189525579e+00+0.0e+00i) -2.8963092606501007060e3+0.0i) +(num-test (tan 1.57045105981189525579e+00+1.19209289550781250e-07i) 2.8963089153831588642e3+9.9999992052646305569e-1i) +(num-test (tan 1.57045105981189525579e+00-1.19209289550781250e-07i) 2.8963089153831588642e3-9.9999992052646305569e-1i) +(num-test (tan -1.57045105981189525579e+00+1.19209289550781250e-07i) -2.8963089153831588642e3+9.9999992052646305569e-1i) +(num-test (tan -1.57045105981189525579e+00-1.19209289550781250e-07i) -2.8963089153831588642e3-9.9999992052646305569e-1i) +(num-test (tan 1.57045105981189525579e+00+5.0e-01i) 1.2715121175455623363e-3+2.1639524637389325996e0i) +(num-test (tan 1.57045105981189525579e+00-5.0e-01i) 1.2715121175455623363e-3-2.1639524637389325996e0i) +(num-test (tan -1.57045105981189525579e+00+5.0e-01i) -1.2715121175455623363e-3+2.1639524637389325996e0i) +(num-test (tan -1.57045105981189525579e+00-5.0e-01i) -1.2715121175455623363e-3-2.1639524637389325996e0i) +(num-test (tan 1.57045105981189525579e+00+1.0e+00i) 2.4999454374276273814e-4+1.3130351721648674823e0i) +(num-test (tan 1.57045105981189525579e+00-1.0e+00i) 2.4999454374276273814e-4-1.3130351721648674823e0i) +(num-test (tan -1.57045105981189525579e+00+1.0e+00i) -2.4999454374276273814e-4+1.3130351721648674823e0i) +(num-test (tan -1.57045105981189525579e+00-1.0e+00i) -2.4999454374276273814e-4-1.3130351721648674823e0i) +(num-test (tan 1.57045105981189525579e+00+2.0e+00i) 2.6247825506572821595e-5+1.0373147113268752620e0i) +(num-test (tan 1.57045105981189525579e+00-2.0e+00i) 2.6247825506572821595e-5-1.0373147113268752620e0i) +(num-test (tan -1.57045105981189525579e+00+2.0e+00i) -2.6247825506572821595e-5+1.0373147113268752620e0i) +(num-test (tan -1.57045105981189525579e+00-2.0e+00i) -2.6247825506572821595e-5-1.0373147113268752620e0i) +(num-test (tan 1.57114159377789786021e+00+0.0e+00i) -2.8963092606511280143e3+0.0i) +(num-test (tan -1.57114159377789786021e+00+0.0e+00i) 2.8963092606511280143e3+0.0i) +(num-test (tan 1.57114159377789786021e+00+1.19209289550781250e-07i) -2.8963089153841861720e3+9.9999992052717244672e-1i) +(num-test (tan 1.57114159377789786021e+00-1.19209289550781250e-07i) -2.8963089153841861720e3-9.9999992052717244672e-1i) +(num-test (tan -1.57114159377789786021e+00+1.19209289550781250e-07i) 2.8963089153841861720e3+9.9999992052717244672e-1i) +(num-test (tan -1.57114159377789786021e+00-1.19209289550781250e-07i) 2.8963089153841861720e3-9.9999992052717244672e-1i) +(num-test (tan 1.57114159377789786021e+00+5.0e-01i) -1.2715121175451113370e-3+2.1639524637389326002e0i) +(num-test (tan 1.57114159377789786021e+00-5.0e-01i) -1.2715121175451113370e-3-2.1639524637389326002e0i) +(num-test (tan -1.57114159377789786021e+00+5.0e-01i) 1.2715121175451113370e-3+2.1639524637389326002e0i) +(num-test (tan -1.57114159377789786021e+00-5.0e-01i) 1.2715121175451113370e-3-2.1639524637389326002e0i) +(num-test (tan 1.57114159377789786021e+00+1.0e+00i) -2.4999454374267406620e-4+1.3130351721648674824e0i) +(num-test (tan 1.57114159377789786021e+00-1.0e+00i) -2.4999454374267406620e-4-1.3130351721648674824e0i) +(num-test (tan -1.57114159377789786021e+00+1.0e+00i) 2.4999454374267406620e-4+1.3130351721648674824e0i) +(num-test (tan -1.57114159377789786021e+00-1.0e+00i) 2.4999454374267406620e-4-1.3130351721648674824e0i) +(num-test (tan 1.57114159377789786021e+00+2.0e+00i) -2.6247825506563511609e-5+1.0373147113268752620e0i) +(num-test (tan 1.57114159377789786021e+00-2.0e+00i) -2.6247825506563511609e-5-1.0373147113268752620e0i) +(num-test (tan -1.57114159377789786021e+00+2.0e+00i) 2.6247825506563511609e-5+1.0373147113268752620e0i) +(num-test (tan -1.57114159377789786021e+00-2.0e+00i) 2.6247825506563511609e-5-1.0373147113268752620e0i) +(num-test (tan 3.14124738660679181379e+00+0.0e+00i) -3.4526699672110257641e-4+0.0i) +(num-test (tan -3.14124738660679181379e+00+0.0e+00i) 3.4526699672110257641e-4+0.0i) +(num-test (tan 3.14124738660679181379e+00+1.19209289550781250e-07i) -3.4526699672109766987e-4+1.1920930376163652991e-7i) +(num-test (tan 3.14124738660679181379e+00-1.19209289550781250e-07i) -3.4526699672109766987e-4-1.1920930376163652991e-7i) +(num-test (tan -3.14124738660679181379e+00+1.19209289550781250e-07i) 3.4526699672109766987e-4+1.1920930376163652991e-7i) +(num-test (tan -3.14124738660679181379e+00-1.19209289550781250e-07i) 3.4526699672109766987e-4-1.1920930376163652991e-7i) +(num-test (tan 3.14124738660679181379e+00+5.0e-01i) -2.7153443992670020234e-4+4.6211720058436229984e-1i) +(num-test (tan 3.14124738660679181379e+00-5.0e-01i) -2.7153443992670020234e-4-4.6211720058436229984e-1i) +(num-test (tan -3.14124738660679181379e+00+5.0e-01i) 2.7153443992670020234e-4+4.6211720058436229984e-1i) +(num-test (tan -3.14124738660679181379e+00-5.0e-01i) 2.7153443992670020234e-4-4.6211720058436229984e-1i) +(num-test (tan 3.14124738660679181379e+00+1.0e+00i) -1.4500326960282551519e-4+7.6159419408485704840e-1i) +(num-test (tan 3.14124738660679181379e+00-1.0e+00i) -1.4500326960282551519e-4-7.6159419408485704840e-1i) +(num-test (tan -3.14124738660679181379e+00+1.0e+00i) 1.4500326960282551519e-4+7.6159419408485704840e-1i) +(num-test (tan -3.14124738660679181379e+00-1.0e+00i) 1.4500326960282551519e-4-7.6159419408485704840e-1i) +(num-test (tan 3.14124738660679181379e+00+2.0e+00i) -2.4393395410448076340e-5+9.6402758819508310557e-1i) +(num-test (tan 3.14124738660679181379e+00-2.0e+00i) -2.4393395410448076340e-5-9.6402758819508310557e-1i) +(num-test (tan -3.14124738660679181379e+00+2.0e+00i) 2.4393395410448076340e-5+9.6402758819508310557e-1i) +(num-test (tan -3.14124738660679181379e+00-2.0e+00i) 2.4393395410448076340e-5-9.6402758819508310557e-1i) +(num-test (tan 3.14193792057279441821e+00+0.0e+00i) 3.4526699672085764703e-4+0.0i) +(num-test (tan -3.14193792057279441821e+00+0.0e+00i) -3.4526699672085764703e-4+0.0i) +(num-test (tan 3.14193792057279441821e+00+1.19209289550781250e-07i) 3.4526699672085274049e-4+1.1920930376163652989e-7i) +(num-test (tan 3.14193792057279441821e+00-1.19209289550781250e-07i) 3.4526699672085274049e-4-1.1920930376163652989e-7i) +(num-test (tan -3.14193792057279441821e+00+1.19209289550781250e-07i) -3.4526699672085274049e-4+1.1920930376163652989e-7i) +(num-test (tan -3.14193792057279441821e+00-1.19209289550781250e-07i) -3.4526699672085274049e-4-1.1920930376163652989e-7i) +(num-test (tan 3.14193792057279441821e+00+5.0e-01i) 2.7153443992650757820e-4+4.6211720058436229978e-1i) +(num-test (tan 3.14193792057279441821e+00-5.0e-01i) 2.7153443992650757820e-4-4.6211720058436229978e-1i) +(num-test (tan -3.14193792057279441821e+00+5.0e-01i) -2.7153443992650757820e-4+4.6211720058436229978e-1i) +(num-test (tan -3.14193792057279441821e+00-5.0e-01i) -2.7153443992650757820e-4-4.6211720058436229978e-1i) +(num-test (tan 3.14193792057279441821e+00+1.0e+00i) 1.4500326960272265115e-4+7.6159419408485704835e-1i) +(num-test (tan 3.14193792057279441821e+00-1.0e+00i) 1.4500326960272265115e-4-7.6159419408485704835e-1i) +(num-test (tan -3.14193792057279441821e+00+1.0e+00i) -1.4500326960272265115e-4+7.6159419408485704835e-1i) +(num-test (tan -3.14193792057279441821e+00-1.0e+00i) -1.4500326960272265115e-4-7.6159419408485704835e-1i) +(num-test (tan 3.14193792057279441821e+00+2.0e+00i) 2.4393395410430771882e-5+9.6402758819508310556e-1i) +(num-test (tan 3.14193792057279441821e+00-2.0e+00i) 2.4393395410430771882e-5-9.6402758819508310556e-1i) +(num-test (tan -3.14193792057279441821e+00+2.0e+00i) -2.4393395410430771882e-5+9.6402758819508310556e-1i) +(num-test (tan -3.14193792057279441821e+00-2.0e+00i) -2.4393395410430771882e-5-9.6402758819508310556e-1i) +(num-test (tan 4.71204371340168837179e+00+0.0e+00i) 2.8963092606490733978e3+0.0i) +(num-test (tan -4.71204371340168837179e+00+0.0e+00i) -2.8963092606490733978e3+0.0i) +(num-test (tan 4.71204371340168837179e+00+1.19209289550781250e-07i) 2.8963089153821315563e3+9.9999992052575366466e-1i) +(num-test (tan 4.71204371340168837179e+00-1.19209289550781250e-07i) 2.8963089153821315563e3-9.9999992052575366466e-1i) +(num-test (tan -4.71204371340168837179e+00+1.19209289550781250e-07i) -2.8963089153821315563e3+9.9999992052575366466e-1i) +(num-test (tan -4.71204371340168837179e+00-1.19209289550781250e-07i) -2.8963089153821315563e3-9.9999992052575366466e-1i) +(num-test (tan 4.71204371340168837179e+00+5.0e-01i) 1.2715121175460133355e-3+2.1639524637389325989e0i) +(num-test (tan 4.71204371340168837179e+00-5.0e-01i) 1.2715121175460133355e-3-2.1639524637389325989e0i) +(num-test (tan -4.71204371340168837179e+00+5.0e-01i) -1.2715121175460133355e-3+2.1639524637389325989e0i) +(num-test (tan -4.71204371340168837179e+00-5.0e-01i) -1.2715121175460133355e-3-2.1639524637389325989e0i) +(num-test (tan 4.71204371340168837179e+00+1.0e+00i) 2.4999454374285141007e-4+1.3130351721648674822e0i) +(num-test (tan 4.71204371340168837179e+00-1.0e+00i) 2.4999454374285141007e-4-1.3130351721648674822e0i) +(num-test (tan -4.71204371340168837179e+00+1.0e+00i) -2.4999454374285141007e-4+1.3130351721648674822e0i) +(num-test (tan -4.71204371340168837179e+00-1.0e+00i) -2.4999454374285141007e-4-1.3130351721648674822e0i) +(num-test (tan 4.71204371340168837179e+00+2.0e+00i) 2.6247825506582131582e-5+1.0373147113268752620e0i) +(num-test (tan 4.71204371340168837179e+00-2.0e+00i) 2.6247825506582131582e-5-1.0373147113268752620e0i) +(num-test (tan -4.71204371340168837179e+00+2.0e+00i) -2.6247825506582131582e-5+1.0373147113268752620e0i) +(num-test (tan -4.71204371340168837179e+00-2.0e+00i) -2.6247825506582131582e-5-1.0373147113268752620e0i) +(num-test (tan 4.71273424736769097620e+00+0.0e+00i) -2.8963092606521553225e3+0.0i) +(num-test (tan -4.71273424736769097620e+00+0.0e+00i) 2.8963092606521553225e3+0.0i) +(num-test (tan 4.71273424736769097620e+00+1.19209289550781250e-07i) -2.8963089153852134799e3+9.9999992052788183776e-1i) +(num-test (tan 4.71273424736769097620e+00-1.19209289550781250e-07i) -2.8963089153852134799e3-9.9999992052788183776e-1i) +(num-test (tan -4.71273424736769097620e+00+1.19209289550781250e-07i) 2.8963089153852134799e3+9.9999992052788183776e-1i) +(num-test (tan -4.71273424736769097620e+00-1.19209289550781250e-07i) 2.8963089153852134799e3-9.9999992052788183776e-1i) +(num-test (tan 4.71273424736769097620e+00+5.0e-01i) -1.2715121175446603377e-3+2.1639524637389326009e0i) +(num-test (tan 4.71273424736769097620e+00-5.0e-01i) -1.2715121175446603377e-3-2.1639524637389326009e0i) +(num-test (tan -4.71273424736769097620e+00+5.0e-01i) 1.2715121175446603377e-3+2.1639524637389326009e0i) +(num-test (tan -4.71273424736769097620e+00-5.0e-01i) 1.2715121175446603377e-3-2.1639524637389326009e0i) +(num-test (tan 4.71273424736769097620e+00+1.0e+00i) -2.4999454374258539427e-4+1.3130351721648674825e0i) +(num-test (tan 4.71273424736769097620e+00-1.0e+00i) -2.4999454374258539427e-4-1.3130351721648674825e0i) +(num-test (tan -4.71273424736769097620e+00+1.0e+00i) 2.4999454374258539427e-4+1.3130351721648674825e0i) +(num-test (tan -4.71273424736769097620e+00-1.0e+00i) 2.4999454374258539427e-4-1.3130351721648674825e0i) +(num-test (tan 4.71273424736769097620e+00+2.0e+00i) -2.6247825506554201622e-5+1.0373147113268752620e0i) +(num-test (tan 4.71273424736769097620e+00-2.0e+00i) -2.6247825506554201622e-5-1.0373147113268752620e0i) +(num-test (tan -4.71273424736769097620e+00+2.0e+00i) 2.6247825506554201622e-5+1.0373147113268752620e0i) +(num-test (tan -4.71273424736769097620e+00-2.0e+00i) 2.6247825506554201622e-5-1.0373147113268752620e0i) +(num-test (tan 6.28284004019658492979e+00+0.0e+00i) -3.4526699672122504111e-4+0.0i) +(num-test (tan -6.28284004019658492979e+00+0.0e+00i) 3.4526699672122504111e-4+0.0i) +(num-test (tan 6.28284004019658492979e+00+1.19209289550781250e-07i) -3.4526699672122013457e-4+1.1920930376163652992e-7i) +(num-test (tan 6.28284004019658492979e+00-1.19209289550781250e-07i) -3.4526699672122013457e-4-1.1920930376163652992e-7i) +(num-test (tan -6.28284004019658492979e+00+1.19209289550781250e-07i) 3.4526699672122013457e-4+1.1920930376163652992e-7i) +(num-test (tan -6.28284004019658492979e+00-1.19209289550781250e-07i) 3.4526699672122013457e-4-1.1920930376163652992e-7i) +(num-test (tan 6.28284004019658492979e+00+5.0e-01i) -2.7153443992679651442e-4+4.6211720058436229987e-1i) +(num-test (tan 6.28284004019658492979e+00-5.0e-01i) -2.7153443992679651442e-4-4.6211720058436229987e-1i) +(num-test (tan -6.28284004019658492979e+00+5.0e-01i) 2.7153443992679651442e-4+4.6211720058436229987e-1i) +(num-test (tan -6.28284004019658492979e+00-5.0e-01i) 2.7153443992679651442e-4-4.6211720058436229987e-1i) +(num-test (tan 6.28284004019658492979e+00+1.0e+00i) -1.4500326960287694721e-4+7.6159419408485704843e-1i) +(num-test (tan 6.28284004019658492979e+00-1.0e+00i) -1.4500326960287694721e-4-7.6159419408485704843e-1i) +(num-test (tan -6.28284004019658492979e+00+1.0e+00i) 1.4500326960287694721e-4+7.6159419408485704843e-1i) +(num-test (tan -6.28284004019658492979e+00-1.0e+00i) 1.4500326960287694721e-4-7.6159419408485704843e-1i) +(num-test (tan 6.28284004019658492979e+00+2.0e+00i) -2.4393395410456728569e-5+9.6402758819508310558e-1i) +(num-test (tan 6.28284004019658492979e+00-2.0e+00i) -2.4393395410456728569e-5-9.6402758819508310558e-1i) +(num-test (tan -6.28284004019658492979e+00+2.0e+00i) 2.4393395410456728569e-5+9.6402758819508310558e-1i) +(num-test (tan -6.28284004019658492979e+00-2.0e+00i) 2.4393395410456728569e-5-9.6402758819508310558e-1i) +(num-test (tan 6.28353057416258753420e+00+0.0e+00i) 3.4526699672073518233e-4+0.0i) +(num-test (tan -6.28353057416258753420e+00+0.0e+00i) -3.4526699672073518233e-4+0.0i) +(num-test (tan 6.28353057416258753420e+00+1.19209289550781250e-07i) 3.4526699672073027579e-4+1.1920930376163652988e-7i) +(num-test (tan 6.28353057416258753420e+00-1.19209289550781250e-07i) 3.4526699672073027579e-4-1.1920930376163652988e-7i) +(num-test (tan -6.28353057416258753420e+00+1.19209289550781250e-07i) -3.4526699672073027579e-4+1.1920930376163652988e-7i) +(num-test (tan -6.28353057416258753420e+00-1.19209289550781250e-07i) -3.4526699672073027579e-4-1.1920930376163652988e-7i) +(num-test (tan 6.28353057416258753420e+00+5.0e-01i) 2.7153443992641126612e-4+4.6211720058436229974e-1i) +(num-test (tan 6.28353057416258753420e+00-5.0e-01i) 2.7153443992641126612e-4-4.6211720058436229974e-1i) +(num-test (tan -6.28353057416258753420e+00+5.0e-01i) -2.7153443992641126612e-4+4.6211720058436229974e-1i) +(num-test (tan -6.28353057416258753420e+00-5.0e-01i) -2.7153443992641126612e-4-4.6211720058436229974e-1i) +(num-test (tan 6.28353057416258753420e+00+1.0e+00i) 1.4500326960267121913e-4+7.6159419408485704832e-1i) +(num-test (tan 6.28353057416258753420e+00-1.0e+00i) 1.4500326960267121913e-4-7.6159419408485704832e-1i) +(num-test (tan -6.28353057416258753420e+00+1.0e+00i) -1.4500326960267121913e-4+7.6159419408485704832e-1i) +(num-test (tan -6.28353057416258753420e+00-1.0e+00i) -1.4500326960267121913e-4-7.6159419408485704832e-1i) +(num-test (tan 6.28353057416258753420e+00+2.0e+00i) 2.4393395410422119654e-5+9.6402758819508310555e-1i) +(num-test (tan 6.28353057416258753420e+00-2.0e+00i) 2.4393395410422119654e-5-9.6402758819508310555e-1i) +(num-test (tan -6.28353057416258753420e+00+2.0e+00i) -2.4393395410422119654e-5+9.6402758819508310555e-1i) +(num-test (tan -6.28353057416258753420e+00-2.0e+00i) -2.4393395410422119654e-5-9.6402758819508310555e-1i) +(num-test (tan 9.42443269378637893396e+00+0.0e+00i) -3.4526699672045932728e-4+0.0i) +(num-test (tan -9.42443269378637893396e+00+0.0e+00i) 3.4526699672045932728e-4+0.0i) +(num-test (tan 9.42443269378637893396e+00+1.19209289550781250e-07i) -3.4526699672045442074e-4+1.1920930376163652985e-7i) +(num-test (tan 9.42443269378637893396e+00-1.19209289550781250e-07i) -3.4526699672045442074e-4-1.1920930376163652985e-7i) +(num-test (tan -9.42443269378637893396e+00+1.19209289550781250e-07i) 3.4526699672045442074e-4+1.1920930376163652985e-7i) +(num-test (tan -9.42443269378637893396e+00-1.19209289550781250e-07i) 3.4526699672045442074e-4-1.1920930376163652985e-7i) +(num-test (tan 9.42443269378637893396e+00+5.0e-01i) -2.7153443992619432056e-4+4.6211720058436229968e-1i) +(num-test (tan 9.42443269378637893396e+00-5.0e-01i) -2.7153443992619432056e-4-4.6211720058436229968e-1i) +(num-test (tan -9.42443269378637893396e+00+5.0e-01i) 2.7153443992619432056e-4+4.6211720058436229968e-1i) +(num-test (tan -9.42443269378637893396e+00-5.0e-01i) 2.7153443992619432056e-4-4.6211720058436229968e-1i) +(num-test (tan 9.42443269378637893396e+00+1.0e+00i) -1.4500326960255536711e-4+7.6159419408485704826e-1i) +(num-test (tan 9.42443269378637893396e+00-1.0e+00i) -1.4500326960255536711e-4-7.6159419408485704826e-1i) +(num-test (tan -9.42443269378637893396e+00+1.0e+00i) 1.4500326960255536711e-4+7.6159419408485704826e-1i) +(num-test (tan -9.42443269378637893396e+00-1.0e+00i) 1.4500326960255536711e-4-7.6159419408485704826e-1i) +(num-test (tan 9.42443269378637893396e+00+2.0e+00i) -2.4393395410402630273e-5+9.6402758819508310554e-1i) +(num-test (tan 9.42443269378637893396e+00-2.0e+00i) -2.4393395410402630273e-5-9.6402758819508310554e-1i) +(num-test (tan -9.42443269378637893396e+00+2.0e+00i) 2.4393395410402630273e-5+9.6402758819508310554e-1i) +(num-test (tan -9.42443269378637893396e+00-2.0e+00i) 2.4393395410402630273e-5-9.6402758819508310554e-1i) +(num-test (tan 9.42512322775237976202e+00+0.0e+00i) 3.4526699671972453911e-4+0.0i) +(num-test (tan -9.42512322775237976202e+00+0.0e+00i) -3.4526699671972453911e-4+0.0i) +(num-test (tan 9.42512322775237976202e+00+1.19209289550781250e-07i) 3.4526699671971963257e-4+1.1920930376163652979e-7i) +(num-test (tan 9.42512322775237976202e+00-1.19209289550781250e-07i) 3.4526699671971963257e-4-1.1920930376163652979e-7i) +(num-test (tan -9.42512322775237976202e+00+1.19209289550781250e-07i) -3.4526699671971963257e-4+1.1920930376163652979e-7i) +(num-test (tan -9.42512322775237976202e+00-1.19209289550781250e-07i) -3.4526699671971963257e-4-1.1920930376163652979e-7i) +(num-test (tan 9.42512322775237976202e+00+5.0e-01i) 2.7153443992561644811e-4+4.6211720058436229949e-1i) +(num-test (tan 9.42512322775237976202e+00-5.0e-01i) 2.7153443992561644811e-4-4.6211720058436229949e-1i) +(num-test (tan -9.42512322775237976202e+00+5.0e-01i) -2.7153443992561644811e-4+4.6211720058436229949e-1i) +(num-test (tan -9.42512322775237976202e+00-5.0e-01i) -2.7153443992561644811e-4-4.6211720058436229949e-1i) +(num-test (tan 9.42512322775237976202e+00+1.0e+00i) 1.450032696022467750e-4+7.6159419408485704810e-1i) +(num-test (tan 9.42512322775237976202e+00-1.0e+00i) 1.450032696022467750e-4-7.6159419408485704810e-1i) +(num-test (tan -9.42512322775237976202e+00+1.0e+00i) -1.450032696022467750e-4+7.6159419408485704810e-1i) +(num-test (tan -9.42512322775237976202e+00-1.0e+00i) -1.450032696022467750e-4-7.6159419408485704810e-1i) +(num-test (tan 9.42512322775237976202e+00+2.0e+00i) 2.439339541035071690e-5+9.6402758819508310550e-1i) +(num-test (tan 9.42512322775237976202e+00-2.0e+00i) 2.439339541035071690e-5-9.6402758819508310550e-1i) +(num-test (tan -9.42512322775237976202e+00+2.0e+00i) -2.439339541035071690e-5+9.6402758819508310550e-1i) +(num-test (tan -9.42512322775237976202e+00-2.0e+00i) -2.439339541035071690e-5-9.6402758819508310550e-1i) + + +;; -------- asin +(num-test (asin 0) 0.0) +(num-test (asin 1) 1.57079632679490) +(num-test (asin -1) -1.57079632679490) +(num-test (asin 2) 1.57079632679490+1.31695789692482i) +(num-test (asin -2) -1.57079632679490+1.31695789692482i) +(num-test (asin 3) 1.57079632679490+1.76274717403909i) +(num-test (asin -3) -1.57079632679490+1.76274717403909i) +(num-test (asin 10) 1.57079632679490+2.99322284612638i) +(num-test (asin -10) -1.57079632679490+2.99322284612638i) +(num-test (asin 1234) 1.57079632679490+7.81116322068415i) +(num-test (asin -1234) -1.57079632679490+7.81116322068415i) +(num-test (asin 0/1) 0.0) +(num-test (asin 0/2) 0.0) +(num-test (asin 0/3) 0.0) +(num-test (asin 0/10) 0.0) +(num-test (asin 0/1234) 0.0) +(num-test (asin 0/1234000000) 0.0) +(num-test (asin 0/500029) 0.0) +(num-test (asin 0/362880) 0.0) +(num-test (asin 1/1) 1.57079632679490) +(num-test (asin -1/1) -1.57079632679490) +(num-test (asin 1/2) 0.52359877559830) +(num-test (asin -1/2) -0.52359877559830) +(num-test (asin 1/3) 0.33983690945412) +(num-test (asin -1/3) -0.33983690945412) +(num-test (asin 1/10) 0.10016742116156) +(num-test (asin -1/10) -0.10016742116156) +(num-test (asin 1/1234) 0.00081037286017) +(num-test (asin -1/1234) -0.00081037286017) +(num-test (asin 1/1234000000) 0.00000000081037) +(num-test (asin -1/1234000000) -0.00000000081037) +(num-test (asin 1/500029) 0.00000199988401) +(num-test (asin -1/500029) -0.00000199988401) +(num-test (asin 1/362880) 0.00000275573192) +(num-test (asin -1/362880) -0.00000275573192) +(num-test (asin 2/1) 1.57079632679490+1.31695789692482i) +(num-test (asin -2/1) -1.57079632679490+1.31695789692482i) +(num-test (asin 2/2) 1.57079632679490) +(num-test (asin -2/2) -1.57079632679490) +(num-test (asin 2/3) 0.72972765622697) +(num-test (asin -2/3) -0.72972765622697) +(num-test (asin 2/10) 0.20135792079033) +(num-test (asin -2/10) -0.20135792079033) +(num-test (asin 2/1234) 0.00162074625252) +(num-test (asin -2/1234) -0.00162074625252) +(num-test (asin 2/1234000000) 0.00000000162075) +(num-test (asin -2/1234000000) -0.00000000162075) +(num-test (asin 2/500029) 0.00000399976801) +(num-test (asin -2/500029) -0.00000399976801) +(num-test (asin 2/362880) 0.00000551146384) +(num-test (asin -2/362880) -0.00000551146384) +(num-test (asin 3/1) 1.57079632679490+1.76274717403909i) +(num-test (asin -3/1) -1.57079632679490+1.76274717403909i) +(num-test (asin 3/2) 1.57079632679490+0.96242365011921i) +(num-test (asin -3/2) -1.57079632679490+0.96242365011921i) +(num-test (asin 3/3) 1.57079632679490) +(num-test (asin -3/3) -1.57079632679490) +(num-test (asin 3/10) 0.30469265401540) +(num-test (asin -3/10) -0.30469265401540) +(num-test (asin 3/1234) 0.00243112070922) +(num-test (asin -3/1234) -0.00243112070922) +(num-test (asin 3/1234000000) 0.00000000243112) +(num-test (asin -3/1234000000) -0.00000000243112) +(num-test (asin 3/500029) 0.00000599965202) +(num-test (asin -3/500029) -0.00000599965202) +(num-test (asin 3/362880) 0.00000826719577+0.0i) +(num-test (asin -3/362880) -0.00000826719577+0.0i) +(num-test (asin 10/1) 1.57079632679490+2.99322284612638i) +(num-test (asin -10/1) -1.57079632679490+2.99322284612638i) +(num-test (asin 10/2) 1.57079632679490+2.29243166956117i) +(num-test (asin -10/2) -1.57079632679490+2.29243166956117i) +(num-test (asin 10/3) 1.57079632679490+1.87382024252741i) +(num-test (asin -10/3) -1.57079632679490+1.87382024252741i) +(num-test (asin 10/10) 1.57079632679490) +(num-test (asin -10/10) -1.57079632679490) +(num-test (asin 10/1234) 0.00810381641321) +(num-test (asin -10/1234) -0.00810381641321) +(num-test (asin 10/1234000000) 0.00000000810373) +(num-test (asin -10/1234000000) -0.00000000810373) +(num-test (asin 10/500029) 0.00001999884007) +(num-test (asin -10/500029) -0.00001999884007) +(num-test (asin 10/362880) 0.00002755731923) +(num-test (asin -10/362880) -0.00002755731923) +(num-test (asin 1234/1) 1.57079632679490+7.81116322068415i) +(num-test (asin -1234/1) -1.57079632679490+7.81116322068415i) +(num-test (asin 1234/2) 1.57079632679490+7.11801554770806i) +(num-test (asin -1234/2) -1.57079632679490+7.11801554770806i) +(num-test (asin 1234/3) 1.57079632679490+6.71254961876657i) +(num-test (asin -1234/3) -1.57079632679490+6.71254961876657i) +(num-test (asin 1234/10) 1.57079632679490+5.50856187402751i) +(num-test (asin -1234/10) -1.57079632679490+5.50856187402751i) +(num-test (asin 1234/1234) 1.57079632679490) +(num-test (asin -1234/1234) -1.57079632679490) +(num-test (asin 1234/1234000000) 0.00000100000000) +(num-test (asin -1234/1234000000) -0.00000100000000) +(num-test (asin 1234/500029) 0.00246785936931) +(num-test (asin -1234/500029) -0.00246785936931) +(num-test (asin 1234/362880) 0.00340057974625) +(num-test (asin -1234/362880) -0.00340057974625) +(num-test (asin 1234000000/1234000000) 1.57079632679490) +(num-test (asin -1234000000/1234000000) -1.57079632679490) +(num-test (asin 1234000000/500029) 1.57079632679490+8.50425252675189i) +(num-test (asin -1234000000/500029) -1.57079632679490+8.50425252675189i) +(num-test (asin 1234000000/362880) 1.57079632679490+8.82484644053502i) +(num-test (asin -1234000000/362880) -1.57079632679490+8.82484644053502i) +(num-test (asin 500029/3) 1.570796326794897-12.71695626760523i) +(num-test (asin -500029/3) -1.570796326794897+12.71695626760523i) +(num-test (asin 500029/10) 1.570796326794897-1.151298346318831e1i) +(num-test (asin -500029/10) -1.57079632679490+1.151298346318831e1i) +(num-test (asin 500029/1234) 1.57079632679490+6.69755082925184i) +(num-test (asin -500029/1234) -1.57079632679490+6.69755082925184i) +(num-test (asin 500029/1234000000) 0.00040520989764) +(num-test (asin -500029/1234000000) -0.00040520989764) +(num-test (asin 500029/500029) 1.57079632679490) +(num-test (asin -500029/500029) -1.57079632679490) +(num-test (asin 500029/362880) 1.57079632679490+0.84413377868249i) +(num-test (asin -500029/362880) -1.57079632679490+0.84413377868249i) +(num-test (asin 362880/2) 1.570796326794896619231321691639751442098E0-1.280182748007387555277950474671339683536E1i) +(num-test (asin -362880/2) -1.570796326794897+12.80182748007388i) +(num-test (asin 362880/3) 1.570796326794896619231321691639751442098E0-1.239636237195621859776598192721440899765E1i) +(num-test (asin -362880/3) -1.570796326794897+12.39636237195622i) +(num-test (asin 362880/10) 1.570796326794897-1.119238956745752e1i) +(num-test (asin -362880/10) -1.57079632679490+1.119238956745752e1i) +(num-test (asin 362880/1234) 1.57079632679490+6.37695556516894i) +(num-test (asin -362880/1234) -1.57079632679490+6.37695556516894i) +(num-test (asin 362880/1234000000) 0.00029406807555) +(num-test (asin -362880/1234000000) -0.00029406807555) +(num-test (asin 362880/500029) 0.81207730383580) +(num-test (asin -362880/500029) -0.81207730383580) +(num-test (asin 362880/362880) 1.57079632679490) +(num-test (asin -362880/362880) -1.57079632679490) +(num-test (asin 0.0) 0.0) +(num-test (asin 0.00000001) 0.00000001) +(num-test (asin -0.00000001) -0.00000001) +(num-test (asin 1.0) 1.57079632679490) +(num-test (asin -1.0) -1.57079632679490) +(num-test (asin our-pi) 1.57079632679490+1.81152627246085i) +(num-test (asin -3.14159265358979) -1.57079632679490+1.81152627246085i) +(num-test (asin 2.71828182845905) 1.57079632679490+1.65745445415308i) +(num-test (asin -2.71828182845905) -1.57079632679490+1.65745445415308i) +(num-test (asin 1234.0) 1.57079632679490+7.81116322068415i) +(num-test (asin -1234.0) -1.57079632679490+7.81116322068415i) +(num-test (asin 0.0+0.0i) 0.0) +(num-test (asin -0.0+0.0i) 0.0) +(num-test (asin 0.0-0.0i) 0.0) +(num-test (asin -0.0-0.0i) -0.0) +(num-test (asin 0.0+0.00000001i) 0.0+0.00000001i) +(num-test (asin -0.0+0.00000001i) 0.0+0.00000001i) +(num-test (asin 0.0-0.00000001i) 0.0-0.00000001i) +(num-test (asin -0.0-0.00000001i) -0.0-0.00000001i) +(num-test (asin 0.0+1.0i) 0.0+0.88137358701954i) +(num-test (asin -0.0+1.0i) 0.0+0.88137358701954i) +(num-test (asin 0.0-1.0i) 0.0-0.88137358701954i) +(num-test (asin -0.0-1.0i) -0.0-0.88137358701954i) +(num-test (asin 0.0+3.14159265358979i) 0.0+1.86229574331085i) +(num-test (asin -0.0+3.14159265358979i) 0.0+1.86229574331085i) +(num-test (asin 0.0-3.14159265358979i) 0.0-1.86229574331085i) +(num-test (asin -0.0-3.14159265358979i) -0.0-1.86229574331085i) +(num-test (asin 0.0+2.71828182845905i) 0.0+1.72538255885232i) +(num-test (asin -0.0+2.71828182845905i) 0.0+1.72538255885232i) +(num-test (asin 0.0-2.71828182845905i) 0.0-1.72538255885231i) +(num-test (asin -0.0-2.71828182845905i) -0.0-1.72538255885231i) +(num-test (asin 0.0+1234.0i) 0.0+7.81116354896171i) +(num-test (asin -0.0+1234.0i) 0.0+7.81116354896171i) +(num-test (asin 0.0-1234.0i) 0.0-7.81116354920125i) +(num-test (asin -0.0-1234.0i) -0.0-7.81116354920125i) +(num-test (asin 0.0-1234000000.0i) 0.0-21.62667394298955i) +(num-test (asin -0.0-1234000000.0i) -0.0-21.62667394298955i) +(num-test (asin 0.00000001+0.0i) 0.00000001) +(num-test (asin -0.00000001+0.0i) -0.00000001) +(num-test (asin 0.00000001-0.0i) 0.00000001) +(num-test (asin -0.00000001-0.0i) -0.00000001) +(num-test (asin 0.00000001+0.00000001i) 0.00000001+0.00000001i) +(num-test (asin -0.00000001+0.00000001i) -0.00000001+0.00000001i) +(num-test (asin 0.00000001-0.00000001i) 0.00000001-0.00000001i) +(num-test (asin -0.00000001-0.00000001i) -0.00000001-0.00000001i) +(num-test (asin 0.00000001+1.0i) 0.00000000707107+0.88137358701954i) +(num-test (asin -0.00000001+1.0i) -0.00000000707107+0.88137358701954i) +(num-test (asin 0.00000001-1.0i) 0.00000000707107-0.88137358701954i) +(num-test (asin -0.00000001-1.0i) -0.00000000707107-0.88137358701954i) +(num-test (asin 0.00000001+3.14159265358979i) 0.00000000303314+1.86229574331085i) +(num-test (asin -0.00000001+3.14159265358979i) -0.00000000303314+1.86229574331085i) +(num-test (asin 0.00000001-3.14159265358979i) 0.00000000303314-1.86229574331085i) +(num-test (asin -0.00000001-3.14159265358979i) -0.00000000303314-1.86229574331085i) +(num-test (asin 0.00000001+2.71828182845905i) 0.00000000345258+1.72538255885232i) +(num-test (asin -0.00000001+2.71828182845905i) -0.00000000345258+1.72538255885232i) +(num-test (asin 0.00000001-2.71828182845905i) 0.00000000345258-1.72538255885231i) +(num-test (asin -0.00000001-2.71828182845905i) -0.00000000345258-1.72538255885231i) +(num-test (asin 0.00000001+1234.0i) 0.00000000000810+7.81116354896171i) +(num-test (asin -0.00000001+1234.0i) -0.00000000000810+7.81116354896171i) +(num-test (asin 0.00000001-1234.0i) 0.00000000000810-7.81116354920125i) +(num-test (asin -0.00000001-1234.0i) -0.00000000000810-7.81116354920125i) +(num-test (asin 0.00000001-1234000000.0i) 0.0-21.62667394298955i) +(num-test (asin -0.00000001-1234000000.0i) -0.0-21.62667394298955i) +(num-test (asin 1.0+0.0i) 1.57079632679490) +(num-test (asin -1.0+0.0i) -1.57079632679490) +(num-test (asin 1.0-0.0i) 1.57079632679490) +(num-test (asin -1.0-0.0i) -1.57079632679490) +(num-test (asin 1.0+0.00000001i) 1.57069632679498+0.00010000000008i) +(num-test (asin -1.0+0.00000001i) -1.57069632679498+0.00010000000008i) +(num-test (asin 1.0-0.00000001i) 1.57069632679498-0.00010000000008i) +(num-test (asin -1.0-0.00000001i) -1.57069632679498-0.00010000000008i) +(num-test (asin 1.0+1.0i) 0.66623943249252+1.06127506190504i) +(num-test (asin -1.0+1.0i) -0.66623943249252+1.06127506190504i) +(num-test (asin 1.0-1.0i) 0.66623943249252-1.06127506190504i) +(num-test (asin -1.0-1.0i) -0.66623943249252-1.06127506190504i) +(num-test (asin 1.0+3.14159265358979i) 0.29558503421163+1.90462768697066i) +(num-test (asin -1.0+3.14159265358979i) -0.29558503421163+1.90462768697066i) +(num-test (asin 1.0-3.14159265358979i) 0.29558503421163-1.90462768697066i) +(num-test (asin -1.0-3.14159265358979i) -0.29558503421163-1.90462768697066i) +(num-test (asin 1.0+2.71828182845905i) 0.33444277187637+1.77905438385935i) +(num-test (asin -1.0+2.71828182845905i) -0.33444277187637+1.77905438385935i) +(num-test (asin 1.0-2.71828182845905i) 0.33444277187637-1.77905438385935i) +(num-test (asin -1.0-2.71828182845905i) -0.33444277187637-1.77905438385935i) +(num-test (asin 1.0+1234.0i) 0.00081037232806+7.81116387772663i) +(num-test (asin -1.0+1234.0i) -0.00081037232806+7.81116387772663i) +(num-test (asin 1.0-1234.0i) 0.00081037232800-7.81116387755283i) +(num-test (asin -1.0-1234.0i) -0.00081037232800-7.81116387755283i) +(num-test (asin 1.0-1234000000.0i) 0.00000000081037-21.62667394298955i) +(num-test (asin -1.0-1234000000.0i) -0.00000000081037-21.62667394298955i) +(num-test (asin 3.14159265358979+0.0i) 1.57079632679490+1.81152627246085i) +(num-test (asin -3.14159265358979+0.0i) -1.57079632679490+1.81152627246085i) +(num-test (asin 3.14159265358979-0.0i) 1.57079632679490+1.81152627246085i) +(num-test (asin -3.14159265358979-0.0i) -1.57079632679490+1.81152627246085i) +(num-test (asin 3.14159265358979+0.00000001i) 1.57079632343715+1.81152627246085i) +(num-test (asin -3.14159265358979+0.00000001i) -1.57079632343715+1.81152627246085i) +(num-test (asin 3.14159265358979-0.00000001i) 1.57079632343715-1.81152627246085i) +(num-test (asin -3.14159265358979-0.00000001i) -1.57079632343715-1.81152627246085i) +(num-test (asin 3.14159265358979+1.0i) 1.24854303281344+1.86711439316026i) +(num-test (asin -3.14159265358979+1.0i) -1.24854303281344+1.86711439316026i) +(num-test (asin 3.14159265358979-1.0i) 1.24854303281344-1.86711439316026i) +(num-test (asin -3.14159265358979-1.0i) -1.24854303281344-1.86711439316026i) +(num-test (asin 3.14159265358979+3.14159265358979i) 0.77273977912748+2.18469104082751i) +(num-test (asin -3.14159265358979+3.14159265358979i) -0.77273977912748+2.18469104082751i) +(num-test (asin 3.14159265358979-3.14159265358979i) 0.77273977912748-2.18469104082751i) +(num-test (asin -3.14159265358979-3.14159265358979i) -0.77273977912748-2.18469104082751i) +(num-test (asin 3.14159265358979+2.71828182845905i) 0.84309656416035+2.11552790803290i) +(num-test (asin -3.14159265358979+2.71828182845905i) -0.84309656416035+2.11552790803290i) +(num-test (asin 3.14159265358979-2.71828182845905i) 0.84309656416035-2.11552790803290i) +(num-test (asin -3.14159265358979-2.71828182845905i) -0.84309656416035-2.11552790803290i) +(num-test (asin 3.14159265358979+1234.0i) 0.00254585480900+7.81116678966949i) +(num-test (asin -3.14159265358979+1234.0i) -0.00254585480900+7.81116678966949i) +(num-test (asin 3.14159265358979-1234.0i) 0.00254585480937-7.81116678989204i) +(num-test (asin -3.14159265358979-1234.0i) -0.00254585480937-7.81116678989204i) +(num-test (asin 3.14159265358979-1234000000.0i) 0.00000000254586-21.62667394298955i) +(num-test (asin -3.14159265358979-1234000000.0i) -0.00000000254586-21.62667394298955i) +(num-test (asin 2.71828182845905+0.0i) 1.57079632679490+1.65745445415308i) +(num-test (asin -2.71828182845905+0.0i) -1.57079632679490+1.65745445415308i) +(num-test (asin 2.71828182845905-0.0i) 1.57079632679490+1.65745445415308i) +(num-test (asin -2.71828182845905-0.0i) -1.57079632679490+1.65745445415308i) +(num-test (asin 2.71828182845905+0.00000001i) 1.57079632283867+1.65745445415308i) +(num-test (asin -2.71828182845905+0.00000001i) -1.57079632283867+1.65745445415308i) +(num-test (asin 2.71828182845905-0.00000001i) 1.57079632283867-1.65745445415308i) +(num-test (asin -2.71828182845905-0.00000001i) -1.57079632283867-1.65745445415308i) +(num-test (asin 2.71828182845905+1.0i) 1.19757808518581+1.73375471569385i) +(num-test (asin -2.71828182845905+1.0i) -1.19757808518581+1.73375471569385i) +(num-test (asin 2.71828182845905-1.0i) 1.19757808518581-1.73375471569385i) +(num-test (asin -2.71828182845905-1.0i) -1.19757808518581-1.73375471569385i) +(num-test (asin 2.71828182845905+3.14159265358979i) 0.69904796994656+2.11968336368048i) +(num-test (asin -2.71828182845905+3.14159265358979i) -0.69904796994656+2.11968336368048i) +(num-test (asin 2.71828182845905-3.14159265358979i) 0.69904796994655-2.11968336368048i) +(num-test (asin -2.71828182845905-3.14159265358979i) -0.69904796994655-2.11968336368048i) +(num-test (asin 2.71828182845905+2.71828182845905i) 0.76849735588475+2.04014932880026i) +(num-test (asin -2.71828182845905+2.71828182845905i) -0.76849735588475+2.04014932880026i) +(num-test (asin 2.71828182845905-2.71828182845905i) 0.76849735588475-2.04014932880026i) +(num-test (asin -2.71828182845905-2.71828182845905i) -0.76849735588475-2.04014932880026i) +(num-test (asin 2.71828182845905+1234.0i) 0.00220281729236+7.81116597510553i) +(num-test (asin -2.71828182845905+1234.0i) -0.00220281729236+7.81116597510553i) +(num-test (asin 2.71828182845905-1234.0i) 0.00220281729269-7.81116597540442i) +(num-test (asin -2.71828182845905-1234.0i) -0.00220281729269-7.81116597540442i) +(num-test (asin 2.71828182845905-1234000000.0i) 0.00000000220282-21.62667394298955i) +(num-test (asin -2.71828182845905-1234000000.0i) -0.00000000220282-21.62667394298955i) +(num-test (asin 1234.0+0.0i) 1.57079632679490+7.81116322068415i) +(num-test (asin -1234.0+0.0i) -1.57079632679490+7.81116322068415i) +(num-test (asin 1234.0-0.0i) 1.57079632679490+7.81116322068415i) +(num-test (asin -1234.0-0.0i) -1.57079632679490+7.81116322068415i) +(num-test (asin 1234.0+0.00000001i) 1.57079632678679+7.81116322068415i) +(num-test (asin -1234.0+0.00000001i) -1.57079632678679+7.81116322068415i) +(num-test (asin 1234.0-0.00000001i) 1.57079632678679-7.81116322084923i) +(num-test (asin -1234.0-0.00000001i) -1.57079632678679-7.81116322084923i) +(num-test (asin 1234.0+1.0i) 1.56998595393442+7.81116354944842i) +(num-test (asin -1234.0+1.0i) -1.56998595393442+7.81116354944842i) +(num-test (asin 1234.0-1.0i) 1.56998595393473-7.81116354920146i) +(num-test (asin -1234.0-1.0i) -1.56998595393473-7.81116354920146i) +(num-test (asin 1234.0+3.14159265358979i) 1.56825047031506+7.81116646138554i) +(num-test (asin -1234.0+3.14159265358979i) -1.56825047031506+7.81116646138554i) +(num-test (asin 1234.0-3.14159265358979i) 1.56825047031367-7.81116646154641i) +(num-test (asin -1234.0-3.14159265358979i) -1.56825047031367-7.81116646154641i) +(num-test (asin 1234.0+2.71828182845905i) 1.56859350805543+7.81116564738434i) +(num-test (asin -1234.0+2.71828182845905i) -1.56859350805543+7.81116564738434i) +(num-test (asin 1234.0-2.71828182845905i) 1.56859350805562-7.81116564705719i) +(num-test (asin -1234.0-2.71828182845905i) -1.56859350805562-7.81116564705719i) +(num-test (asin 1234.0+1234.0i) 0.78539808146835+8.15773697538346i) +(num-test (asin -1234.0+1234.0i) -0.78539808146835+8.15773697538346i) +(num-test (asin 1234.0-1234.0i) 0.78539808130944-8.15773697530526i) +(num-test (asin -1234.0-1234.0i) -0.78539808130944-8.15773697530526i) +(num-test (asin 1234.0-1234000000.0i) 0.00000100000000-21.62667394299005i) +(num-test (asin -1234.0-1234000000.0i) -0.00000100000000-21.62667394299005i) +(num-test (asin 1234000000.0-0.00000001i) 1.57079632679490-21.62667394298955i) +(num-test (asin -1234000000.0-0.00000001i) -1.57079632679490-21.62667394298955i) +(num-test (asin 1234000000.0-1.0i) 1.57079632598452-21.62667394298955i) +(num-test (asin -1234000000.0-1.0i) -1.57079632598452-21.62667394298955i) +(num-test (asin 1234000000.0-3.14159265358979i) 1.57079632424904-21.62667394298955i) +(num-test (asin -1234000000.0-3.14159265358979i) -1.57079632424904-21.62667394298955i) +(num-test (asin 1234000000.0-2.71828182845905i) 1.57079632459208-21.62667394298955i) +(num-test (asin -1234000000.0-2.71828182845905i) -1.57079632459208-21.62667394298955i) +(num-test (asin 1234000000.0-1234.0i) 1.57079532679490-21.62667394299005i) +(num-test (asin -1234000000.0-1234.0i) -1.57079532679490-21.62667394299005i) +(num-test (asin 1234000000.0-1234000000.0i) 0.78539816339745-21.97324753326953i) +(num-test (asin -1234000000.0-1234000000.0i) -0.78539816339745-21.97324753326953i) +(num-test (asin 8.2729394e-17) 8.2729394e-17) +(num-test (asin 1.821832e-231) 1.821832e-231) +(num-test (asin 48983.30495194942-64983.97008730317i) 0.6459128607940432-12i) +(num-test (asin 1234000000/3) 1.570796326794897-20.52806165432143i) +(num-test (asin 500029/2) 1.570796326794897-13.12242137571839i) +(num-test (asin 0.00000001+1234000000.0i) +8.103725052149596E-18+21.62667380877375i) +(num-test (asin 3.14159265358979+1234000000.0i) +2.545860611523387E-9+21.62667380877375i) +(num-test (asin 2.71828182845905+1234000000.0i) +2.2028207814967068E-9+21.62667380877375i) +(num-test (asin 1234000000.0+0.00000001i) +1.570796327200083+21.62667394298955i) +(num-test (asin 1234000000.0+3.14159265358979i) +1.570796327200083+21.62667394298955i) +(num-test (asin 0.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (asin 0.0e+00+1.19209289550781250e-07i) 0+1.1920928955078096766e-7i) +(num-test (asin 0.0e+00-1.19209289550781250e-07i) 0-1.1920928955078096766e-7i) +(num-test (asin 0.0e+00+5.0e-01i) 0+4.8121182505960344750e-1i) +(num-test (asin 0.0e+00-5.0e-01i) 0-4.8121182505960344750e-1i) +(num-test (asin 0.0e+00+1.0e+00i) 0+8.8137358701954302523e-1i) +(num-test (asin 0.0e+00-1.0e+00i) 0-8.8137358701954302523e-1i) +(num-test (asin 0.0e+00+2.0e+00i) 0+1.4436354751788103425e0i) +(num-test (asin 0.0e+00-2.0e+00i) 0-1.4436354751788103425e0i) +(num-test (asin 0.0e+00+8.3886080e+06i) 0+1.6635532333438690979e1i) +(num-test (asin 0.0e+00-8.3886080e+06i) 0-1.6635532333438690979e1i) +(num-test (asin 1.19209289550781250e-07+0.0e+00i) 1.1920928955078153234e-7+0.0i) +(num-test (asin -1.19209289550781250e-07+0.0e+00i) -1.1920928955078153234e-7+0.0i) +(num-test (asin 1.19209289550781250e-07+1.19209289550781250e-07i) 1.1920928955078068531e-7+1.1920928955078181469e-7i) +(num-test (asin 1.19209289550781250e-07-1.19209289550781250e-07i) 1.1920928955078068531e-7-1.1920928955078181469e-7i) +(num-test (asin -1.19209289550781250e-07+1.19209289550781250e-07i) -1.1920928955078068531e-7+1.1920928955078181469e-7i) +(num-test (asin -1.19209289550781250e-07-1.19209289550781250e-07i) -1.1920928955078068531e-7-1.1920928955078181469e-7i) +(num-test (asin 1.19209289550781250e-07+5.0e-01i) 1.0662402999400097805e-7+4.8121182505960598961e-1i) +(num-test (asin 1.19209289550781250e-07-5.0e-01i) 1.0662402999400097805e-7-4.8121182505960598961e-1i) +(num-test (asin -1.19209289550781250e-07+5.0e-01i) -1.0662402999400097805e-7+4.8121182505960598961e-1i) +(num-test (asin -1.19209289550781250e-07-5.0e-01i) -1.0662402999400097805e-7-4.8121182505960598961e-1i) +(num-test (asin 1.19209289550781250e-07+1.0e+00i) 8.4293697021788013662e-8+8.8137358701954553738e-1i) +(num-test (asin 1.19209289550781250e-07-1.0e+00i) 8.4293697021788013662e-8-8.8137358701954553738e-1i) +(num-test (asin -1.19209289550781250e-07+1.0e+00i) -8.4293697021788013662e-8+8.8137358701954553738e-1i) +(num-test (asin -1.19209289550781250e-07-1.0e+00i) -8.4293697021788013662e-8-8.8137358701954553738e-1i) +(num-test (asin 1.19209289550781250e-07+2.0e+00i) 5.3312014997000413263e-8+1.4436354751788116136e0i) +(num-test (asin 1.19209289550781250e-07-2.0e+00i) 5.3312014997000413263e-8-1.4436354751788116136e0i) +(num-test (asin -1.19209289550781250e-07+2.0e+00i) -5.3312014997000413263e-8+1.4436354751788116136e0i) +(num-test (asin -1.19209289550781250e-07-2.0e+00i) -5.3312014997000413263e-8-1.4436354751788116136e0i) +(num-test (asin 1.19209289550781250e-07+8.3886080e+06i) 1.4210854715201902743e-14+1.6635532333438690979e1i) +(num-test (asin 1.19209289550781250e-07-8.3886080e+06i) 1.4210854715201902743e-14-1.6635532333438690979e1i) +(num-test (asin -1.19209289550781250e-07+8.3886080e+06i) -1.4210854715201902743e-14+1.6635532333438690979e1i) +(num-test (asin -1.19209289550781250e-07-8.3886080e+06i) -1.4210854715201902743e-14-1.6635532333438690979e1i) +(num-test (asin 5.0e-01+0.0e+00i) 5.2359877559829887308e-1+0.0i) +(num-test (asin -5.0e-01+0.0e+00i) -5.2359877559829887308e-1+0.0i) +(num-test (asin 5.0e-01+1.19209289550781250e-07i) 5.2359877559829340332e-1+1.3765103082409432364e-7i) +(num-test (asin 5.0e-01-1.19209289550781250e-07i) 5.2359877559829340332e-1-1.3765103082409432364e-7i) +(num-test (asin -5.0e-01+1.19209289550781250e-07i) -5.2359877559829340332e-1+1.3765103082409432364e-7i) +(num-test (asin -5.0e-01-1.19209289550781250e-07i) -5.2359877559829340332e-1-1.3765103082409432364e-7i) +(num-test (asin 5.0e-01+5.0e-01i) 4.5227844715119068206e-1+5.3063753095251782602e-1i) +(num-test (asin 5.0e-01-5.0e-01i) 4.5227844715119068206e-1-5.3063753095251782602e-1i) +(num-test (asin -5.0e-01+5.0e-01i) -4.5227844715119068206e-1+5.3063753095251782602e-1i) +(num-test (asin -5.0e-01-5.0e-01i) -4.5227844715119068206e-1-5.3063753095251782602e-1i) +(num-test (asin 5.0e-01+1.0e+00i) 3.4943906285721329363e-1+9.2613303135018242455e-1i) +(num-test (asin 5.0e-01-1.0e+00i) 3.4943906285721329363e-1-9.2613303135018242455e-1i) +(num-test (asin -5.0e-01+1.0e+00i) -3.4943906285721329363e-1+9.2613303135018242455e-1i) +(num-test (asin -5.0e-01-1.0e+00i) -3.4943906285721329363e-1-9.2613303135018242455e-1i) +(num-test (asin 5.0e-01+2.0e+00i) 2.2101863562288385890e-1+1.4657153519472905218e0i) +(num-test (asin 5.0e-01-2.0e+00i) 2.2101863562288385890e-1-1.4657153519472905218e0i) +(num-test (asin -5.0e-01+2.0e+00i) -2.2101863562288385890e-1+1.4657153519472905218e0i) +(num-test (asin -5.0e-01-2.0e+00i) -2.2101863562288385890e-1-1.4657153519472905218e0i) +(num-test (asin 5.0e-01+8.3886080e+06i) 5.9604644775390130897e-8+1.6635532333438692755e1i) +(num-test (asin 5.0e-01-8.3886080e+06i) 5.9604644775390130897e-8-1.6635532333438692755e1i) +(num-test (asin -5.0e-01+8.3886080e+06i) -5.9604644775390130897e-8+1.6635532333438692755e1i) +(num-test (asin -5.0e-01-8.3886080e+06i) -5.9604644775390130897e-8-1.6635532333438692755e1i) +(num-test (asin 1.0e+00+0.0e+00i) 1.5707963267948966192e0+0.0i) +(num-test (asin -1.0e+00+0.0e+00i) -1.5707963267948966192e0+0.0i) +(num-test (asin 1.0e+00+1.19209289550781250e-07i) 1.5704510598153252947e0+3.4526698643116312881e-4i) +(num-test (asin 1.0e+00-1.19209289550781250e-07i) 1.5704510598153252947e0-3.4526698643116312881e-4i) +(num-test (asin -1.0e+00+1.19209289550781250e-07i) -1.5704510598153252947e0+3.4526698643116312881e-4i) +(num-test (asin -1.0e+00-1.19209289550781250e-07i) -1.5704510598153252947e0-3.4526698643116312881e-4i) +(num-test (asin 1.0e+00+5.0e-01i) 8.9590748120889023907e-1+7.3285767597364526089e-1i) +(num-test (asin 1.0e+00-5.0e-01i) 8.9590748120889023907e-1-7.3285767597364526089e-1i) +(num-test (asin -1.0e+00+5.0e-01i) -8.9590748120889023907e-1+7.3285767597364526089e-1i) +(num-test (asin -1.0e+00-5.0e-01i) -8.9590748120889023907e-1-7.3285767597364526089e-1i) +(num-test (asin 1.0e+00+1.0e+00i) 6.6623943249251525510e-1+1.0612750619050356520e0i) +(num-test (asin 1.0e+00-1.0e+00i) 6.6623943249251525510e-1-1.0612750619050356520e0i) +(num-test (asin -1.0e+00+1.0e+00i) -6.6623943249251525510e-1+1.0612750619050356520e0i) +(num-test (asin -1.0e+00-1.0e+00i) -6.6623943249251525510e-1-1.0612750619050356520e0i) +(num-test (asin 1.0e+00+2.0e+00i) 4.2707858639247612548e-1+1.5285709194809981613e0i) +(num-test (asin 1.0e+00-2.0e+00i) 4.2707858639247612548e-1-1.5285709194809981613e0i) +(num-test (asin -1.0e+00+2.0e+00i) -4.2707858639247612548e-1+1.5285709194809981613e0i) +(num-test (asin -1.0e+00-2.0e+00i) -4.2707858639247612548e-1-1.5285709194809981613e0i) +(num-test (asin 1.0e+00+8.3886080e+06i) 1.1920928955077983828e-7+1.6635532333438698084e1i) +(num-test (asin 1.0e+00-8.3886080e+06i) 1.1920928955077983828e-7-1.6635532333438698084e1i) +(num-test (asin -1.0e+00+8.3886080e+06i) -1.1920928955077983828e-7+1.6635532333438698084e1i) +(num-test (asin -1.0e+00-8.3886080e+06i) -1.1920928955077983828e-7-1.6635532333438698084e1i) +(num-test (asin 2.0e+00+0.0e+00i) 1.5707963267948966192e0-1.3169578969248167086e0i) +(num-test (asin -2.0e+00+0.0e+00i) -1.5707963267948966192e0+1.3169578969248167086e0i) +(num-test (asin 2.0e+00+1.19209289550781250e-07i) 1.5707962579693812072e0+1.3169578969248194435e0i) +(num-test (asin 2.0e+00-1.19209289550781250e-07i) 1.5707962579693812072e0-1.3169578969248194435e0i) +(num-test (asin -2.0e+00+1.19209289550781250e-07i) -1.5707962579693812072e0+1.3169578969248194435e0i) +(num-test (asin -2.0e+00-1.19209289550781250e-07i) -1.5707962579693812072e0-1.3169578969248194435e0i) +(num-test (asin 2.0e+00+5.0e-01i) 1.2930420702371826591e0+1.3618009008578457882e0i) +(num-test (asin 2.0e+00-5.0e-01i) 1.2930420702371826591e0-1.3618009008578457882e0i) +(num-test (asin -2.0e+00+5.0e-01i) -1.2930420702371826591e0+1.3618009008578457882e0i) +(num-test (asin -2.0e+00-5.0e-01i) -1.2930420702371826591e0-1.3618009008578457882e0i) +(num-test (asin 2.0e+00+1.0e+00i) 1.0634400235777520562e0+1.4693517443681852733e0i) +(num-test (asin 2.0e+00-1.0e+00i) 1.0634400235777520562e0-1.4693517443681852733e0i) +(num-test (asin -2.0e+00+1.0e+00i) -1.0634400235777520562e0+1.4693517443681852733e0i) +(num-test (asin -2.0e+00-1.0e+00i) -1.0634400235777520562e0-1.4693517443681852733e0i) +(num-test (asin 2.0e+00+2.0e+00i) 7.5424914469804604071e-1+1.7343245214879664480e0i) +(num-test (asin 2.0e+00-2.0e+00i) 7.5424914469804604071e-1-1.7343245214879664480e0i) +(num-test (asin -2.0e+00+2.0e+00i) -7.5424914469804604071e-1+1.7343245214879664480e0i) +(num-test (asin -2.0e+00-2.0e+00i) -7.5424914469804604071e-1-1.7343245214879664480e0i) +(num-test (asin 2.0e+00+8.3886080e+06i) 2.3841857910155628843e-7+1.663553233343871940e1i) +(num-test (asin 2.0e+00-8.3886080e+06i) 2.3841857910155628843e-7-1.663553233343871940e1i) +(num-test (asin -2.0e+00+8.3886080e+06i) -2.3841857910155628843e-7+1.663553233343871940e1i) +(num-test (asin -2.0e+00-8.3886080e+06i) -2.3841857910155628843e-7-1.663553233343871940e1i) +(num-test (asin 8.3886080e+06+0.0e+00i) 1.5707963267948966192e0-1.6635532333438683873e1i) +(num-test (asin -8.3886080e+06+0.0e+00i) -1.5707963267948966192e0+1.6635532333438683873e1i) +(num-test (asin 8.3886080e+06+1.19209289550781250e-07i) 1.5707963267948824084e0+1.6635532333438683873e1i) +(num-test (asin 8.3886080e+06-1.19209289550781250e-07i) 1.5707963267948824084e0-1.6635532333438683873e1i) +(num-test (asin -8.3886080e+06+1.19209289550781250e-07i) -1.5707963267948824084e0+1.6635532333438683873e1i) +(num-test (asin -8.3886080e+06-1.19209289550781250e-07i) -1.5707963267948824084e0-1.6635532333438683873e1i) +(num-test (asin 8.3886080e+06+5.0e-01i) 1.5707962671902518438e0+1.6635532333438685650e1i) +(num-test (asin 8.3886080e+06-5.0e-01i) 1.5707962671902518438e0-1.6635532333438685650e1i) +(num-test (asin -8.3886080e+06+5.0e-01i) -1.5707962671902518438e0+1.6635532333438685650e1i) +(num-test (asin -8.3886080e+06-5.0e-01i) -1.5707962671902518438e0-1.6635532333438685650e1i) +(num-test (asin 8.3886080e+06+1.0e+00i) 1.5707962075856070684e0+1.6635532333438690979e1i) +(num-test (asin 8.3886080e+06-1.0e+00i) 1.5707962075856070684e0-1.6635532333438690979e1i) +(num-test (asin -8.3886080e+06+1.0e+00i) -1.5707962075856070684e0+1.6635532333438690979e1i) +(num-test (asin -8.3886080e+06-1.0e+00i) -1.5707962075856070684e0-1.6635532333438690979e1i) +(num-test (asin 8.3886080e+06+2.0e+00i) 1.5707960883763175177e0+1.6635532333438712295e1i) +(num-test (asin 8.3886080e+06-2.0e+00i) 1.5707960883763175177e0-1.6635532333438712295e1i) +(num-test (asin -8.3886080e+06+2.0e+00i) -1.5707960883763175177e0+1.6635532333438712295e1i) +(num-test (asin -8.3886080e+06-2.0e+00i) -1.5707960883763175177e0-1.6635532333438712295e1i) +(num-test (asin 8.3886080e+06+8.3886080e+06i) 7.8539816339744653326e-1+1.6982105923718660081e1i) +(num-test (asin 8.3886080e+06-8.3886080e+06i) 7.8539816339744653326e-1-1.6982105923718660081e1i) +(num-test (asin -8.3886080e+06+8.3886080e+06i) -7.8539816339744653326e-1+1.6982105923718660081e1i) +(num-test (asin -8.3886080e+06-8.3886080e+06i) -7.8539816339744653326e-1-1.6982105923718660081e1i) +(num-test (asin -1.0e+01) -1.5707963267948966192e0+2.9932228461263808979e0i) +(num-test (asin -2.0e+00) -1.5707963267948966192e0+1.3169578969248167086e0i) +(num-test (asin -1.0e+00) -1.5707963267948966192e0+0.0i) +(num-test (asin -7.50e-01) -8.4806207898148100805e-1+0.0i) +(num-test (asin -5.0e-01) -5.2359877559829887308e-1+0.0i) +(num-test (asin -1.250e-01) -1.2532783116806539687e-1+0.0i) +(num-test (asin -3.45266983001243932001e-04) -3.4526698986108292481e-4+0.0i) +(num-test (asin -1.19209289550781250e-07) -1.1920928955078153234e-7+0.0i) +(num-test (asin 0.0e+00) 0e0+0.0i) +(num-test (asin 1.19209289550781250e-07) 1.1920928955078153234e-7+0.0i) +(num-test (asin 3.45266983001243932001e-04) 3.4526698986108292481e-4+0.0i) +(num-test (asin 1.250e-01) 1.2532783116806539687e-1+0.0i) +(num-test (asin 5.0e-01) 5.2359877559829887308e-1+0.0i) +(num-test (asin 7.50e-01) 8.4806207898148100805e-1+0.0i) +(num-test (asin 1.0e+00) 1.5707963267948966192e0+0.0i) +(num-test (asin 2.0e+00) 1.5707963267948966192e0-1.3169578969248167086e0i) +(num-test (asin 1.0e+01) 1.5707963267948966192e0-2.9932228461263808979e0i) +(num-test (asin 0) 0.0) +(num-test (asin 2) 1.570796326794897-1.316957896924817i) +(num-test (asin 3.0+70000000i) 4.2857142400327436E-8+18.7571529895002i) +(num-test (asin 70000000+3i) 1.570796279536826+18.75715298057358i) +(num-test (asin 3.0-70000000i) 4.2857142400327436E-8-18.7571529895002i) +(num-test (asin -70000000+3i) -1.570796279536826+18.75715298057358i) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x -10.0 (+ x .1))) + ((= i 200)) + (let ((y (magnitude (- x (sin (asin x)))))) + (if (> y err) (set! err y)))) + (if (> err 1e-12) + (begin (display "(sin (asin ...)) error: ") (display err) (newline)))) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x 1.0-i (+ x -.1+i))) + ((= i 100)) + (let ((y (magnitude (- x (sin (asin x)))))) + (if (> y err) (set! err y)))) + (if (> err 1e-9) + (begin (display "(sin (asin [complex] ...)) error: ") (display err) (newline)))) + + + +;; -------- acos +(num-test (acos 0) 1.57079632679490) +(num-test (acos 1) 0.0) +(num-test (acos -1) our-pi) +(num-test (acos 2) 0.0-1.31695789692482i) +(num-test (acos -2) 3.14159265358979-1.31695789692482i) +(num-test (acos 3) 0.0-1.76274717403909i) +(num-test (acos -3) 3.14159265358979-1.76274717403909i) +(num-test (acos 10) 0.0-2.99322284612638i) +(num-test (acos -10) 3.14159265358979-2.99322284612638i) +(num-test (acos 1234) 0.0-7.81116322068415i) +(num-test (acos -1234) 3.14159265358979-7.81116322068415i) +(num-test (acos 0/1) 1.57079632679490) +(num-test (acos 0/2) 1.57079632679490) +(num-test (acos 0/3) 1.57079632679490) +(num-test (acos 0/10) 1.57079632679490) +(num-test (acos 0/1234) 1.57079632679490) +(num-test (acos 0/1234000000) 1.57079632679490) +(num-test (acos 0/500029) 1.57079632679490) +(num-test (acos 0/362880) 1.57079632679490) +(num-test (acos 1/1) 0.0) +(num-test (acos -1/1) our-pi) +(num-test (acos 1/2) 1.04719755119660) +(num-test (acos -1/2) 2.09439510239320) +(num-test (acos 1/3) 1.23095941734077) +(num-test (acos -1/3) 1.91063323624902) +(num-test (acos 1/10) 1.47062890563334) +(num-test (acos -1/10) 1.67096374795646) +(num-test (acos 1/1234) 1.56998595393473) +(num-test (acos -1/1234) 1.57160669965507) +(num-test (acos 1/1234000000) 1.57079632598452) +(num-test (acos -1/1234000000) 1.57079632760527) +(num-test (acos 1/500029) 1.57079432691089) +(num-test (acos -1/500029) 1.57079832667890) +(num-test (acos 1/362880) 1.57079357106297) +(num-test (acos -1/362880) 1.57079908252682) +(num-test (acos 2/1) 0.0-1.31695789692482i) +(num-test (acos -2/1) 3.14159265358979-1.31695789692482i) +(num-test (acos 2/2) 0.0) +(num-test (acos -2/2) our-pi) +(num-test (acos 2/3) 0.84106867056793) +(num-test (acos -2/3) 2.30052398302186) +(num-test (acos 2/10) 1.36943840600457) +(num-test (acos -2/10) 1.77215424758523) +(num-test (acos 2/1234) 1.56917558054238) +(num-test (acos -2/1234) 1.57241707304741) +(num-test (acos 2/1234000000) 1.57079632517415) +(num-test (acos -2/1234000000) 1.57079632841564) +(num-test (acos 2/500029) 1.57079232702688) +(num-test (acos -2/500029) 1.57080032656291) +(num-test (acos 2/362880) 1.57079081533105) +(num-test (acos -2/362880) 1.57080183825874) +(num-test (acos 3/1) 0.0-1.76274717403909i) +(num-test (acos -3/1) 3.14159265358979-1.76274717403909i) +(num-test (acos 3/2) 0.0-0.96242365011921i) +(num-test (acos -3/2) 3.14159265358979-0.96242365011921i) +(num-test (acos 3/3) 0.0) +(num-test (acos -3/3) our-pi) +(num-test (acos 3/10) 1.26610367277950) +(num-test (acos -3/10) 1.87548898081029) +(num-test (acos 3/1234) 1.56836520608568) +(num-test (acos -3/1234) 1.57322744750412) +(num-test (acos 3/1234000000) 1.57079632436378) +(num-test (acos -3/1234000000) 1.57079632922601) +(num-test (acos 3/500029) 1.57079032714288) +(num-test (acos -3/500029) 1.57080232644692) +(num-test (acos 3/362880) 1.57078805959913-0.0i) +(num-test (acos -3/362880) 1.57080459399066-0.0i) +(num-test (acos 10/1) 0.0-2.99322284612638i) +(num-test (acos -10/1) 3.14159265358979-2.99322284612638i) +(num-test (acos 10/2) 0.0-2.29243166956117i) +(num-test (acos -10/2) 3.14159265358979-2.29243166956117i) +(num-test (acos 10/3) 0.0-1.87382024252741i) +(num-test (acos -10/3) 3.14159265358979-1.87382024252741i) +(num-test (acos 10/10) 0.0) +(num-test (acos -10/10) our-pi) +(num-test (acos 10/1234) 1.56269251038168) +(num-test (acos -10/1234) 1.57890014320811) +(num-test (acos 10/1234000000) 1.57079631869117) +(num-test (acos -10/1234000000) 1.57079633489862) +(num-test (acos 10/500029) 1.57077632795483) +(num-test (acos -10/500029) 1.57081632563497) +(num-test (acos 10/362880) 1.57076876947567) +(num-test (acos -10/362880) 1.57082388411412) +(num-test (acos 1234/1) 0.0-7.81116322068415i) +(num-test (acos -1234/1) 3.14159265358979-7.81116322068415i) +(num-test (acos 1234/2) 0.0-7.11801554770806i) +(num-test (acos -1234/2) 3.14159265358979-7.11801554770806i) +(num-test (acos 1234/3) 0.0-6.71254961876657i) +(num-test (acos -1234/3) 3.14159265358979-6.71254961876657i) +(num-test (acos 1234/10) 0.0-5.50856187402751i) +(num-test (acos -1234/10) 3.14159265358979-5.50856187402751i) +(num-test (acos 1234/1234) 0.0) +(num-test (acos -1234/1234) our-pi) +(num-test (acos 1234/1234000000) 1.57079532679490) +(num-test (acos -1234/1234000000) 1.57079732679490) +(num-test (acos 1234/500029) 1.56832846742558) +(num-test (acos -1234/500029) 1.57326418616421) +(num-test (acos 1234/362880) 1.56739574704864) +(num-test (acos -1234/362880) 1.57419690654115) +(num-test (acos 1234000000/1234000000) 0.0) +(num-test (acos -1234000000/1234000000) our-pi) +(num-test (acos 1234000000/500029) 0.0-8.50425252675189i) +(num-test (acos -1234000000/500029) 3.14159265358979-8.50425252675189i) +(num-test (acos 1234000000/362880) 0.0-8.82484644053502i) +(num-test (acos -1234000000/362880) 3.14159265358979-8.82484644053502i) +(num-test (acos 500029/3) 0+12.7169561400958i) +(num-test (acos -500029/3) 3.14159265358979-12.7169561400958i) +(num-test (acos 500029/10) 0.0+11.51298346318831i) ; maxima +(num-test (acos -500029/10) 3.14159265358979-11.51298333576987i) +(num-test (acos 500029/1234) 0.0-6.69755082925184i) +(num-test (acos -500029/1234) 3.14159265358979-6.69755082925184i) +(num-test (acos 500029/1234000000) 1.57039111689726) +(num-test (acos -500029/1234000000) 1.57120153669253) +(num-test (acos 500029/500029) 0.0) +(num-test (acos -500029/500029) our-pi) +(num-test (acos 500029/362880) 0.0-0.84413377868249i) +(num-test (acos -500029/362880) 3.14159265358979-0.84413377868249i) +(num-test (acos 362880/2) 0.0+1.280182724631953e1i) +(num-test (acos -362880/2) 3.141592653589793-12.80182748007388i) +(num-test (acos 362880/3) 0.0+12.39636237195622i) +(num-test (acos -362880/3) 3.141592653589793-12.39636237195622i) +(num-test (acos 362880/10) 0.0-11.19238956745752i) +(num-test (acos -362880/10) 3.14159265358979-11.19238956745752i) +(num-test (acos 362880/1234) 0.0-6.37695556516894i) +(num-test (acos -362880/1234) 3.14159265358979-6.37695556516894i) +(num-test (acos 362880/1234000000) 1.57050225871935) +(num-test (acos -362880/1234000000) 1.57109039487045) +(num-test (acos 362880/500029) 0.75871902295910) +(num-test (acos -362880/500029) 2.38287363063069) +(num-test (acos 362880/362880) 0.0) +(num-test (acos -362880/362880) our-pi) +(num-test (acos 0.0) 1.57079632679490) +(num-test (acos 0.00000001) 1.57079631679490) +(num-test (acos -0.00000001) 1.57079633679490) +(num-test (acos 1.0) 0.0) +(num-test (acos -1.0) our-pi) +(num-test (acos our-pi) 0.0-1.81152627246085i) +(num-test (acos -3.14159265358979) 3.14159265358979-1.81152627246085i) +(num-test (acos 2.71828182845905) 0.0-1.65745445415308i) +(num-test (acos -2.71828182845905) 3.14159265358979-1.65745445415308i) +(num-test (acos 1234.0) 0.0-7.81116322068415i) +(num-test (acos -1234.0) 3.14159265358979-7.81116322068415i) +(num-test (acos 0.0+0.0i) 1.57079632679490) +(num-test (acos -0.0+0.0i) 1.57079632679490) +(num-test (acos 0.0-0.0i) 1.57079632679490) +(num-test (acos -0.0-0.0i) 1.57079632679490) +(num-test (acos 0.0+0.00000001i) 1.57079632679490-0.00000001i) +(num-test (acos -0.0+0.00000001i) 1.57079632679490-0.00000001i) +(num-test (acos 0.0-0.00000001i) 1.57079632679490+0.00000001i) +(num-test (acos -0.0-0.00000001i) 1.57079632679490+0.00000001i) +(num-test (acos 0.0+1.0i) 1.57079632679490-0.88137358701954i) +(num-test (acos -0.0+1.0i) 1.57079632679490-0.88137358701954i) +(num-test (acos 0.0-1.0i) 1.57079632679490+0.88137358701954i) +(num-test (acos -0.0-1.0i) 1.57079632679490+0.88137358701954i) +(num-test (acos 0.0+3.14159265358979i) 1.57079632679490-1.86229574331085i) +(num-test (acos -0.0+3.14159265358979i) 1.57079632679490-1.86229574331085i) +(num-test (acos 0.0-3.14159265358979i) 1.57079632679490+1.86229574331085i) +(num-test (acos -0.0-3.14159265358979i) 1.57079632679490+1.86229574331085i) +(num-test (acos 0.0+2.71828182845905i) 1.57079632679490-1.72538255885232i) +(num-test (acos -0.0+2.71828182845905i) 1.57079632679490-1.72538255885232i) +(num-test (acos 0.0-2.71828182845905i) 1.57079632679490+1.72538255885231i) +(num-test (acos -0.0-2.71828182845905i) 1.57079632679490+1.72538255885231i) +(num-test (acos 0.0+1234.0i) 1.57079632679490-7.81116354896171i) +(num-test (acos -0.0+1234.0i) 1.57079632679490-7.81116354896171i) +(num-test (acos 0.0-1234.0i) 1.57079632679490+7.81116354920125i) +(num-test (acos -0.0-1234.0i) 1.57079632679490+7.81116354920125i) +(num-test (acos 0.0-1234000000.0i) 1.57079632679490+21.62667394298955i) +(num-test (acos -0.0-1234000000.0i) 1.57079632679490+21.62667394298955i) +(num-test (acos 0.00000001+0.0i) 1.57079631679490) +(num-test (acos -0.00000001+0.0i) 1.57079633679490) +(num-test (acos 0.00000001-0.0i) 1.57079631679490) +(num-test (acos -0.00000001-0.0i) 1.57079633679490) +(num-test (acos 0.00000001+0.00000001i) 1.57079631679490-0.00000001i) +(num-test (acos -0.00000001+0.00000001i) 1.57079633679490-0.00000001i) +(num-test (acos 0.00000001-0.00000001i) 1.57079631679490+0.00000001i) +(num-test (acos -0.00000001-0.00000001i) 1.57079633679490+0.00000001i) +(num-test (acos 0.00000001+1.0i) 1.57079631972383-0.88137358701954i) +(num-test (acos -0.00000001+1.0i) 1.57079633386596-0.88137358701954i) +(num-test (acos 0.00000001-1.0i) 1.57079631972383+0.88137358701954i) +(num-test (acos -0.00000001-1.0i) 1.57079633386596+0.88137358701954i) +(num-test (acos 0.00000001+3.14159265358979i) 1.57079632376175-1.86229574331085i) +(num-test (acos -0.00000001+3.14159265358979i) 1.57079632982804-1.86229574331085i) +(num-test (acos 0.00000001-3.14159265358979i) 1.57079632376175+1.86229574331085i) +(num-test (acos -0.00000001-3.14159265358979i) 1.57079632982804+1.86229574331085i) +(num-test (acos 0.00000001+2.71828182845905i) 1.57079632334232-1.72538255885232i) +(num-test (acos -0.00000001+2.71828182845905i) 1.57079633024747-1.72538255885232i) +(num-test (acos 0.00000001-2.71828182845905i) 1.57079632334232+1.72538255885231i) +(num-test (acos -0.00000001-2.71828182845905i) 1.57079633024747+1.72538255885231i) +(num-test (acos 0.00000001+1234.0i) 1.57079632678679-7.81116354896171i) +(num-test (acos -0.00000001+1234.0i) 1.57079632680300-7.81116354896171i) +(num-test (acos 0.00000001-1234.0i) 1.57079632678679+7.81116354920125i) +(num-test (acos -0.00000001-1234.0i) 1.57079632680300+7.81116354920125i) +(num-test (acos 0.00000001-1234000000.0i) 1.57079632679490+21.62667394298955i) +(num-test (acos -0.00000001-1234000000.0i) 1.57079632679490+21.62667394298955i) +(num-test (acos 1.0+0.0i) 0.0) +(num-test (acos -1.0+0.0i) our-pi) +(num-test (acos 1.0-0.0i) 0.0) +(num-test (acos -1.0-0.0i) our-pi) +(num-test (acos 1.0+0.00000001i) 0.00009999999992-0.00010000000008i) +(num-test (acos -1.0+0.00000001i) 3.14149265358988-0.00010000000008i) +(num-test (acos 1.0-0.00000001i) 0.00009999999992+0.00010000000008i) +(num-test (acos -1.0-0.00000001i) 3.14149265358988+0.00010000000008i) +(num-test (acos 1.0+1.0i) 0.90455689430238-1.06127506190504i) +(num-test (acos -1.0+1.0i) 2.23703575928741-1.06127506190504i) +(num-test (acos 1.0-1.0i) 0.90455689430238+1.06127506190504i) +(num-test (acos -1.0-1.0i) 2.23703575928741+1.06127506190504i) +(num-test (acos 1.0+3.14159265358979i) 1.27521129258327-1.90462768697066i) +(num-test (acos -1.0+3.14159265358979i) 1.86638136100653-1.90462768697066i) +(num-test (acos 1.0-3.14159265358979i) 1.27521129258327+1.90462768697066i) +(num-test (acos -1.0-3.14159265358979i) 1.86638136100653+1.90462768697066i) +(num-test (acos 1.0+2.71828182845905i) 1.23635355491853-1.77905438385935i) +(num-test (acos -1.0+2.71828182845905i) 1.90523909867127-1.77905438385935i) +(num-test (acos 1.0-2.71828182845905i) 1.23635355491853+1.77905438385935i) +(num-test (acos -1.0-2.71828182845905i) 1.90523909867127+1.77905438385935i) +(num-test (acos 1.0+1234.0i) 1.56998595446684-7.81116387772663i) +(num-test (acos -1.0+1234.0i) 1.57160669912296-7.81116387772663i) +(num-test (acos 1.0-1234.0i) 1.56998595446690+7.81116387755283i) +(num-test (acos -1.0-1234.0i) 1.57160669912289+7.81116387755283i) +(num-test (acos 1.0-1234000000.0i) 1.57079632598452+21.62667394298955i) +(num-test (acos -1.0-1234000000.0i) 1.57079632760527+21.62667394298955i) +(num-test (acos 3.14159265358979+0.0i) 0.0-1.81152627246085i) +(num-test (acos -3.14159265358979+0.0i) 3.14159265358979-1.81152627246085i) +(num-test (acos 3.14159265358979-0.0i) 0.0-1.81152627246085i) +(num-test (acos -3.14159265358979-0.0i) 3.14159265358979-1.81152627246085i) +(num-test (acos 3.14159265358979+0.00000001i) 0.00000000335775-1.81152627246085i) +(num-test (acos -3.14159265358979+0.00000001i) 3.14159265023205-1.81152627246085i) +(num-test (acos 3.14159265358979-0.00000001i) 0.00000000335775+1.81152627246085i) +(num-test (acos -3.14159265358979-0.00000001i) 3.14159265023205+1.81152627246085i) +(num-test (acos 3.14159265358979+1.0i) 0.32225329398146-1.86711439316026i) +(num-test (acos -3.14159265358979+1.0i) 2.81933935960833-1.86711439316026i) +(num-test (acos 3.14159265358979-1.0i) 0.32225329398146+1.86711439316026i) +(num-test (acos -3.14159265358979-1.0i) 2.81933935960833+1.86711439316026i) +(num-test (acos 3.14159265358979+3.14159265358979i) 0.79805654766741-2.18469104082751i) +(num-test (acos -3.14159265358979+3.14159265358979i) 2.34353610592238-2.18469104082751i) +(num-test (acos 3.14159265358979-3.14159265358979i) 0.79805654766741+2.18469104082751i) +(num-test (acos -3.14159265358979-3.14159265358979i) 2.34353610592238+2.18469104082751i) +(num-test (acos 3.14159265358979+2.71828182845905i) 0.72769976263454-2.11552790803290i) +(num-test (acos -3.14159265358979+2.71828182845905i) 2.41389289095525-2.11552790803290i) +(num-test (acos 3.14159265358979-2.71828182845905i) 0.72769976263454+2.11552790803290i) +(num-test (acos -3.14159265358979-2.71828182845905i) 2.41389289095525+2.11552790803290i) +(num-test (acos 3.14159265358979+1234.0i) 1.56825047198589-7.81116678966949i) +(num-test (acos -3.14159265358979+1234.0i) 1.57334218160390-7.81116678966949i) +(num-test (acos 3.14159265358979-1234.0i) 1.56825047198552+7.81116678989204i) +(num-test (acos -3.14159265358979-1234.0i) 1.57334218160427+7.81116678989204i) +(num-test (acos 3.14159265358979-1234000000.0i) 1.57079632424904+21.62667394298955i) +(num-test (acos -3.14159265358979-1234000000.0i) 1.57079632934076+21.62667394298955i) +(num-test (acos 2.71828182845905+0.0i) 0.0-1.65745445415308i) +(num-test (acos -2.71828182845905+0.0i) 3.14159265358979-1.65745445415308i) +(num-test (acos 2.71828182845905-0.0i) 0.0-1.65745445415308i) +(num-test (acos -2.71828182845905-0.0i) 3.14159265358979-1.65745445415308i) +(num-test (acos 2.71828182845905+0.00000001i) 0.00000000395623-1.65745445415308i) +(num-test (acos -2.71828182845905+0.00000001i) 3.14159264963356-1.65745445415308i) +(num-test (acos 2.71828182845905-0.00000001i) 0.00000000395623+1.65745445415308i) +(num-test (acos -2.71828182845905-0.00000001i) 3.14159264963356+1.65745445415308i) +(num-test (acos 2.71828182845905+1.0i) 0.37321824160908-1.73375471569385i) +(num-test (acos -2.71828182845905+1.0i) 2.76837441198071-1.73375471569385i) +(num-test (acos 2.71828182845905-1.0i) 0.37321824160908+1.73375471569385i) +(num-test (acos -2.71828182845905-1.0i) 2.76837441198071+1.73375471569385i) +(num-test (acos 2.71828182835905+3.14159265358979i) 0.87174835684834-2.11968336368048i) +(num-test (acos -2.71828182845905+3.14159265358979i) 2.26984429674145-2.11968336368048i) +(num-test (acos 2.71828182845905-3.14159265358979i) 0.87174835684834+2.11968336368048i) +(num-test (acos -2.71828182845905-3.14159265358979i) 2.26984429674145+2.11968336368048i) +(num-test (acos 2.71828182845905+2.71828182845905i) 0.80229897091015-2.04014932880026i) +(num-test (acos -2.71828182845905+2.71828182845905i) 2.33929368267965-2.04014932880026i) +(num-test (acos 2.71828182845905-2.71828182845905i) 0.80229897091014+2.04014932880026i) +(num-test (acos -2.71828182845905-2.71828182845905i) 2.33929368267965+2.04014932880026i) +(num-test (acos 2.71828182845905+1234.0i) 1.56859350950254-7.81116597510553i) +(num-test (acos -2.71828182845905+1234.0i) 1.57299914408725-7.81116597510553i) +(num-test (acos 2.71828182845905-1234.0i) 1.56859350950221+7.81116597540442i) +(num-test (acos -2.71828182845905-1234.0i) 1.57299914408758+7.81116597540442i) +(num-test (acos 2.71828182845905-1234000000.0i) 1.57079632459208+21.62667394298955i) +(num-test (acos -2.71828182845905-1234000000.0i) 1.57079632899772+21.62667394298955i) +(num-test (acos 1234.0+0.0i) 0.0-7.81116322068415i) +(num-test (acos -1234.0+0.0i) 3.14159265358979-7.81116322068415i) +(num-test (acos 1234.0-0.0i) 0.0-7.81116322068415i) +(num-test (acos -1234.0-0.0i) 3.14159265358979-7.81116322068415i) +(num-test (acos 1234.0+0.00000001i) 0.00000000000810-7.81116322068415i) +(num-test (acos -1234.0+0.00000001i) 3.14159265358169-7.81116322068415i) +(num-test (acos 1234.0-0.00000001i) 0.00000000000810+7.81116322084923i) +(num-test (acos -1234.0-0.00000001i) 3.14159265358169+7.81116322084923i) +(num-test (acos 1234.0+1.0i) 0.00081037286048-7.81116354944842i) +(num-test (acos -1234.0+1.0i) 3.14078228072931-7.81116354944842i) +(num-test (acos 1234.0-1.0i) 0.00081037286017+7.81116354920146i) +(num-test (acos -1234.0-1.0i) 3.14078228072962+7.81116354920146i) +(num-test (acos 1234.0+3.14159265358979i) 0.00254585647983-7.81116646138554i) +(num-test (acos -1234.0+3.14159265358979i) 3.13904679710996-7.81116646138554i) +(num-test (acos 1234.0-3.14159265358979i) 0.00254585648123+7.81116646154641i) +(num-test (acos -1234.0-3.14159265358979i) 3.13904679710856+7.81116646154641i) +(num-test (acos 1234.0+2.71828182845905i) 0.00220281873947-7.81116564738434i) +(num-test (acos -1234.0+2.71828182845905i) 3.13938983485033-7.81116564738434i) +(num-test (acos 1234.0-2.71828182845905i) 0.00220281873928+7.81116564705719i) +(num-test (acos -1234.0-2.71828182845905i) 3.13938983485052+7.81116564705719i) +(num-test (acos 1234.0+1234.0i) 0.78539824532655-8.15773697538346i) +(num-test (acos -1234.0+1234.0i) 2.35619440826324-8.15773697538346i) +(num-test (acos 1234.0-1234.0i) 0.78539824548545+8.15773697530526i) +(num-test (acos -1234.0-1234.0i) 2.35619440810434+8.15773697530526i) +(num-test (acos 1234.0-1234000000.0i) 1.57079532679490+21.62667394299005i) +(num-test (acos -1234.0-1234000000.0i) 1.57079732679490+21.62667394299005i) +(num-test (acos 1234000000.0-0.00000001i) 0.0+21.62667394298955i) +(num-test (acos -1234000000.0-0.00000001i) 3.14159265358979+21.62667394298955i) +(num-test (acos 1234000000.0-1.0i) 0.00000000081037+21.62667394298955i) +(num-test (acos -1234000000.0-1.0i) 3.14159265277942+21.62667394298955i) +(num-test (acos 1234000000.0-3.14159265358979i) 0.00000000254586+21.62667394298955i) +(num-test (acos -1234000000.0-3.14159265358979i) 3.14159265104393+21.62667394298955i) +(num-test (acos 1234000000.0-2.71828182845905i) 0.00000000220282+21.62667394298955i) +(num-test (acos -1234000000.0-2.71828182845905i) 3.14159265138697+21.62667394298955i) +(num-test (acos 1234000000.0-1234.0i) 0.00000100000000+21.62667394299005i) +(num-test (acos -1234000000.0-1234.0i) 3.14159165358979+21.62667394299005i) +(num-test (acos 1234000000.0-1234000000.0i) 0.78539816339745+21.97324753326953i) +(num-test (acos -1234000000.0-1234000000.0i) 2.35619449019234+21.97324753326953i) +(num-test (acos -2.0) 3.141592653589793-1.316957896924817i) +(num-test (acos 3.0+70000000i) 1.570796283937754-18.7571529895002i) ; C breaks near here +(num-test (acos 70000000+3i) 4.725807101202406E-8-18.75715298057358i) +(num-test (acos 3.0-70000000i) 1.570796283937754+18.7571529895002i) +(num-test (acos -70000000+3i) 3.141592606331722-18.75715298057358i) +(num-test (acos 1.5) 0.0+0.9624236501192069i) +(num-test (acos -1.5) 3.141592653589793-0.9624236501192069i) +(num-test (acos -1.0e+01) 3.1415926535897932385e0-2.9932228461263808979e0i) +(num-test (acos -2.0e+00) 3.1415926535897932385e0-1.3169578969248167086e0i) +(num-test (acos -1.0e+00) 3.1415926535897932385e0+0.0i) +(num-test (acos -7.50e-01) 2.4188584057763776273e0+0.0i) +(num-test (acos -5.0e-01) 2.0943951023931954923e0+0.0i) +(num-test (acos -1.250e-01) 1.6961241579629620161e0+0.0i) +(num-test (acos -3.45266983001243932001e-04) 1.5711415937847577022e0+0.0i) +(num-test (acos -1.19209289550781250e-07) 1.570796446004186170e0+0.0i) +(num-test (acos 0.0e+00) 1.5707963267948966192e0+0.0i) +(num-test (acos 1.19209289550781250e-07) 1.5707962075856070684e0+0.0i) +(num-test (acos 3.45266983001243932001e-04) 1.5704510598050355363e0+0.0i) +(num-test (acos 1.250e-01) 1.4454684956268312224e0+0.0i) +(num-test (acos 5.0e-01) 1.0471975511965977462e0+0.0i) +(num-test (acos 7.50e-01) 7.2273424781341561118e-1+0.0i) +(num-test (acos 1.0e+00) 0e0+0.0i) +(num-test (acos 2.0e+00) 0+1.3169578969248167086e0i) +(num-test (acos 1.0e+01) 0+2.9932228461263808979e0i) +(num-test (acos 0.0e+00+0.0e+00i) 1.5707963267948966192e0+0.0i) +(num-test (acos 0.0e+00+1.19209289550781250e-07i) 1.5707963267948966192e0-1.1920928955078096766e-7i) +(num-test (acos 0.0e+00-1.19209289550781250e-07i) 1.5707963267948966192e0+1.1920928955078096766e-7i) +(num-test (acos 0.0e+00+5.0e-01i) 1.5707963267948966192e0-4.8121182505960344750e-1i) +(num-test (acos 0.0e+00-5.0e-01i) 1.5707963267948966192e0+4.8121182505960344750e-1i) +(num-test (acos 0.0e+00+1.0e+00i) 1.5707963267948966192e0-8.8137358701954302523e-1i) +(num-test (acos 0.0e+00-1.0e+00i) 1.5707963267948966192e0+8.8137358701954302523e-1i) +(num-test (acos 0.0e+00+2.0e+00i) 1.5707963267948966192e0-1.4436354751788103425e0i) +(num-test (acos 0.0e+00-2.0e+00i) 1.5707963267948966192e0+1.4436354751788103425e0i) +(num-test (acos 0.0e+00+8.3886080e+06i) 1.5707963267948966192e0-1.6635532333438690979e1i) +(num-test (acos 0.0e+00-8.3886080e+06i) 1.5707963267948966192e0+1.6635532333438690979e1i) +(num-test (acos 1.19209289550781250e-07+0.0e+00i) 1.5707962075856070684e0+0.0i) +(num-test (acos -1.19209289550781250e-07+0.0e+00i) 1.570796446004186170e0+0.0i) +(num-test (acos 1.19209289550781250e-07+1.19209289550781250e-07i) 1.5707962075856070685e0-1.1920928955078181469e-7i) +(num-test (acos 1.19209289550781250e-07-1.19209289550781250e-07i) 1.5707962075856070685e0+1.1920928955078181469e-7i) +(num-test (acos -1.19209289550781250e-07+1.19209289550781250e-07i) 1.570796446004186170e0-1.1920928955078181469e-7i) +(num-test (acos -1.19209289550781250e-07-1.19209289550781250e-07i) 1.570796446004186170e0+1.1920928955078181469e-7i) +(num-test (acos 1.19209289550781250e-07+5.0e-01i) 1.5707962201708666252e0-4.8121182505960598961e-1i) +(num-test (acos 1.19209289550781250e-07-5.0e-01i) 1.5707962201708666252e0+4.8121182505960598961e-1i) +(num-test (acos -1.19209289550781250e-07+5.0e-01i) 1.5707964334189266132e0-4.8121182505960598961e-1i) +(num-test (acos -1.19209289550781250e-07-5.0e-01i) 1.5707964334189266132e0+4.8121182505960598961e-1i) +(num-test (acos 1.19209289550781250e-07+1.0e+00i) 1.5707962425011995974e0-8.8137358701954553738e-1i) +(num-test (acos 1.19209289550781250e-07-1.0e+00i) 1.5707962425011995974e0+8.8137358701954553738e-1i) +(num-test (acos -1.19209289550781250e-07+1.0e+00i) 1.5707964110885936410e0-8.8137358701954553738e-1i) +(num-test (acos -1.19209289550781250e-07-1.0e+00i) 1.5707964110885936410e0+8.8137358701954553738e-1i) +(num-test (acos 1.19209289550781250e-07+2.0e+00i) 1.5707962734828816222e0-1.4436354751788116136e0i) +(num-test (acos 1.19209289550781250e-07-2.0e+00i) 1.5707962734828816222e0+1.4436354751788116136e0i) +(num-test (acos -1.19209289550781250e-07+2.0e+00i) 1.5707963801069116162e0-1.4436354751788116136e0i) +(num-test (acos -1.19209289550781250e-07-2.0e+00i) 1.5707963801069116162e0+1.4436354751788116136e0i) +(num-test (acos 1.19209289550781250e-07+8.3886080e+06i) 1.5707963267948824084e0-1.6635532333438690979e1i) +(num-test (acos 1.19209289550781250e-07-8.3886080e+06i) 1.5707963267948824084e0+1.6635532333438690979e1i) +(num-test (acos -1.19209289550781250e-07+8.3886080e+06i) 1.5707963267949108301e0-1.6635532333438690979e1i) +(num-test (acos -1.19209289550781250e-07-8.3886080e+06i) 1.5707963267949108301e0+1.6635532333438690979e1i) +(num-test (acos 5.0e-01+0.0e+00i) 1.0471975511965977462e0+0.0i) +(num-test (acos -5.0e-01+0.0e+00i) 2.0943951023931954923e0+0.0i) +(num-test (acos 5.0e-01+1.19209289550781250e-07i) 1.0471975511966032159e0-1.3765103082409432364e-7i) +(num-test (acos 5.0e-01-1.19209289550781250e-07i) 1.0471975511966032159e0+1.3765103082409432364e-7i) +(num-test (acos -5.0e-01+1.19209289550781250e-07i) 2.0943951023931900225e0-1.3765103082409432364e-7i) +(num-test (acos -5.0e-01-1.19209289550781250e-07i) 2.0943951023931900225e0+1.3765103082409432364e-7i) +(num-test (acos 5.0e-01+5.0e-01i) 1.1185178796437059372e0-5.3063753095251782602e-1i) +(num-test (acos 5.0e-01-5.0e-01i) 1.1185178796437059372e0+5.3063753095251782602e-1i) +(num-test (acos -5.0e-01+5.0e-01i) 2.0230747739460873013e0-5.3063753095251782602e-1i) +(num-test (acos -5.0e-01-5.0e-01i) 2.0230747739460873013e0+5.3063753095251782602e-1i) +(num-test (acos 5.0e-01+1.0e+00i) 1.2213572639376833256e0-9.2613303135018242455e-1i) +(num-test (acos 5.0e-01-1.0e+00i) 1.2213572639376833256e0+9.2613303135018242455e-1i) +(num-test (acos -5.0e-01+1.0e+00i) 1.9202353896521099129e0-9.2613303135018242455e-1i) +(num-test (acos -5.0e-01-1.0e+00i) 1.9202353896521099129e0+9.2613303135018242455e-1i) +(num-test (acos 5.0e-01+2.0e+00i) 1.3497776911720127603e0-1.4657153519472905218e0i) +(num-test (acos 5.0e-01-2.0e+00i) 1.3497776911720127603e0+1.4657153519472905218e0i) +(num-test (acos -5.0e-01+2.0e+00i) 1.7918149624177804781e0-1.4657153519472905218e0i) +(num-test (acos -5.0e-01-2.0e+00i) 1.7918149624177804781e0+1.4657153519472905218e0i) +(num-test (acos 5.0e-01+8.3886080e+06i) 1.5707962671902518438e0-1.6635532333438692755e1i) +(num-test (acos 5.0e-01-8.3886080e+06i) 1.5707962671902518438e0+1.6635532333438692755e1i) +(num-test (acos -5.0e-01+8.3886080e+06i) 1.5707963863995413946e0-1.6635532333438692755e1i) +(num-test (acos -5.0e-01-8.3886080e+06i) 1.5707963863995413946e0+1.6635532333438692755e1i) +(num-test (acos 1.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (acos -1.0e+00+0.0e+00i) 3.1415926535897932385e0+0.0i) +(num-test (acos 1.0e+00+1.19209289550781250e-07i) 3.4526697957132450399e-4-3.4526698643116312881e-4i) +(num-test (acos 1.0e+00-1.19209289550781250e-07i) 3.4526697957132450399e-4+3.4526698643116312881e-4i) +(num-test (acos -1.0e+00+1.19209289550781250e-07i) 3.1412473866102219140e0-3.4526698643116312881e-4i) +(num-test (acos -1.0e+00-1.19209289550781250e-07i) 3.1412473866102219140e0+3.4526698643116312881e-4i) +(num-test (acos 1.0e+00+5.0e-01i) 6.7488884558600638016e-1-7.3285767597364526089e-1i) +(num-test (acos 1.0e+00-5.0e-01i) 6.7488884558600638016e-1+7.3285767597364526089e-1i) +(num-test (acos -1.0e+00+5.0e-01i) 2.4667038080037868583e0-7.3285767597364526089e-1i) +(num-test (acos -1.0e+00-5.0e-01i) 2.4667038080037868583e0+7.3285767597364526089e-1i) +(num-test (acos 1.0e+00+1.0e+00i) 9.0455689430238136413e-1-1.0612750619050356520e0i) +(num-test (acos 1.0e+00-1.0e+00i) 9.0455689430238136413e-1+1.0612750619050356520e0i) +(num-test (acos -1.0e+00+1.0e+00i) 2.2370357592874118743e0-1.0612750619050356520e0i) +(num-test (acos -1.0e+00-1.0e+00i) 2.2370357592874118743e0+1.0612750619050356520e0i) +(num-test (acos 1.0e+00+2.0e+00i) 1.1437177404024204938e0-1.5285709194809981613e0i) +(num-test (acos 1.0e+00-2.0e+00i) 1.1437177404024204938e0+1.5285709194809981613e0i) +(num-test (acos -1.0e+00+2.0e+00i) 1.9978749131873727447e0-1.5285709194809981613e0i) +(num-test (acos -1.0e+00-2.0e+00i) 1.9978749131873727447e0+1.5285709194809981613e0i) +(num-test (acos 1.0e+00+8.3886080e+06i) 1.5707962075856070685e0-1.6635532333438698084e1i) +(num-test (acos 1.0e+00-8.3886080e+06i) 1.5707962075856070685e0+1.6635532333438698084e1i) +(num-test (acos -1.0e+00+8.3886080e+06i) 1.570796446004186170e0-1.6635532333438698084e1i) +(num-test (acos -1.0e+00-8.3886080e+06i) 1.570796446004186170e0+1.6635532333438698084e1i) +(num-test (acos 2.0e+00+0.0e+00i) 0+1.3169578969248167086e0i) +(num-test (acos -2.0e+00+0.0e+00i) 3.1415926535897932385e0-1.3169578969248167086e0i) +(num-test (acos 2.0e+00+1.19209289550781250e-07i) 6.8825515412047433504e-8-1.3169578969248194435e0i) +(num-test (acos 2.0e+00-1.19209289550781250e-07i) 6.8825515412047433504e-8+1.3169578969248194435e0i) +(num-test (acos -2.0e+00+1.19209289550781250e-07i) 3.1415925847642778264e0-1.3169578969248194435e0i) +(num-test (acos -2.0e+00-1.19209289550781250e-07i) 3.1415925847642778264e0+1.3169578969248194435e0i) +(num-test (acos 2.0e+00+5.0e-01i) 2.7775425655771396018e-1-1.3618009008578457882e0i) +(num-test (acos 2.0e+00-5.0e-01i) 2.7775425655771396018e-1+1.3618009008578457882e0i) +(num-test (acos -2.0e+00+5.0e-01i) 2.8638383970320792783e0-1.3618009008578457882e0i) +(num-test (acos -2.0e+00-5.0e-01i) 2.8638383970320792783e0+1.3618009008578457882e0i) +(num-test (acos 2.0e+00+1.0e+00i) 5.0735630321714456304e-1-1.4693517443681852733e0i) +(num-test (acos 2.0e+00-1.0e+00i) 5.0735630321714456304e-1+1.4693517443681852733e0i) +(num-test (acos -2.0e+00+1.0e+00i) 2.6342363503726486754e0-1.4693517443681852733e0i) +(num-test (acos -2.0e+00-1.0e+00i) 2.6342363503726486754e0+1.4693517443681852733e0i) +(num-test (acos 2.0e+00+2.0e+00i) 8.1654718209685057852e-1-1.7343245214879664480e0i) +(num-test (acos 2.0e+00-2.0e+00i) 8.1654718209685057852e-1+1.7343245214879664480e0i) +(num-test (acos -2.0e+00+2.0e+00i) 2.3250454714929426599e0-1.7343245214879664480e0i) +(num-test (acos -2.0e+00-2.0e+00i) 2.3250454714929426599e0+1.7343245214879664480e0i) +(num-test (acos 2.0e+00+8.3886080e+06i) 1.5707960883763175177e0-1.663553233343871940e1i) +(num-test (acos 2.0e+00-8.3886080e+06i) 1.5707960883763175177e0+1.663553233343871940e1i) +(num-test (acos -2.0e+00+8.3886080e+06i) 1.5707965652134757208e0-1.663553233343871940e1i) +(num-test (acos -2.0e+00-8.3886080e+06i) 1.5707965652134757208e0+1.663553233343871940e1i) +(num-test (acos 8.3886080e+06+0.0e+00i) 0+1.6635532333438683873e1i) +(num-test (acos -8.3886080e+06+0.0e+00i) 3.1415926535897932385e0-1.6635532333438683873e1i) +(num-test (acos 8.3886080e+06+1.19209289550781250e-07i) 1.4210854715202104692e-14-1.6635532333438683873e1i) +(num-test (acos 8.3886080e+06-1.19209289550781250e-07i) 1.4210854715202104692e-14+1.6635532333438683873e1i) +(num-test (acos -8.3886080e+06+1.19209289550781250e-07i) 3.1415926535897790276e0-1.6635532333438683873e1i) +(num-test (acos -8.3886080e+06-1.19209289550781250e-07i) 3.1415926535897790276e0+1.6635532333438683873e1i) +(num-test (acos 8.3886080e+06+5.0e-01i) 5.9604644775390977930e-8-1.6635532333438685650e1i) +(num-test (acos 8.3886080e+06-5.0e-01i) 5.9604644775390977930e-8+1.6635532333438685650e1i) +(num-test (acos -8.3886080e+06+5.0e-01i) 3.1415925939851484631e0-1.6635532333438685650e1i) +(num-test (acos -8.3886080e+06-5.0e-01i) 3.1415925939851484631e0+1.6635532333438685650e1i) +(num-test (acos 8.3886080e+06+1.0e+00i) 1.1920928955078153234e-7-1.6635532333438690979e1i) +(num-test (acos 8.3886080e+06-1.0e+00i) 1.1920928955078153234e-7+1.6635532333438690979e1i) +(num-test (acos -8.3886080e+06+1.0e+00i) 3.1415925343805036877e0-1.6635532333438690979e1i) +(num-test (acos -8.3886080e+06-1.0e+00i) 3.1415925343805036877e0+1.6635532333438690979e1i) +(num-test (acos 8.3886080e+06+2.0e+00i) 2.3841857910155967656e-7-1.6635532333438712295e1i) +(num-test (acos 8.3886080e+06-2.0e+00i) 2.3841857910155967656e-7+1.6635532333438712295e1i) +(num-test (acos -8.3886080e+06+2.0e+00i) 3.1415924151712141369e0-1.6635532333438712295e1i) +(num-test (acos -8.3886080e+06-2.0e+00i) 3.1415924151712141369e0+1.6635532333438712295e1i) +(num-test (acos 8.3886080e+06+8.3886080e+06i) 7.8539816339745008597e-1-1.6982105923718660081e1i) +(num-test (acos 8.3886080e+06-8.3886080e+06i) 7.8539816339745008597e-1+1.6982105923718660081e1i) +(num-test (acos -8.3886080e+06+8.3886080e+06i) 2.3561944901923431525e0-1.6982105923718660081e1i) +(num-test (acos -8.3886080e+06-8.3886080e+06i) 2.3561944901923431525e0+1.6982105923718660081e1i) +(num-test (acos 1234000000/3) 0+20.52806165432143i) +(num-test (acos 0.00000001+1234000000.0i) 1.570796326794897-21.62667380877375i) +(num-test (acos 3.14159265358979+1234000000.0i) 1.570796324249036-21.62667380877375i) +(num-test (acos 2.71828182845905+1234000000.0i) 1.570796324592076-21.62667380877375i) +(num-test (acos 1234000000.0+0.00000001i) -4.051865509779873E-10-21.62667394298955i) +(num-test (acos 1234000000.0+3.14159265358979i) -4.051865509779873E-10-21.62667394298955i) +(num-test (acos 1234000000.0+2.71828182845905i) -4.051865509779873E-10-21.62667394298955i) +(num-test (acos -64983.97009220963-48983.30494825104i) 2.495679792792491+12.0i) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x -10.0 (+ x .1))) + ((= i 200)) + (let ((y (magnitude (- x (cos (acos x)))))) + (if (> y err) (set! err y)))) + (if (> err 1e-12) + (begin (display "(cos (acos ...)) error: ") (display err) (newline)))) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x 1.0-i (+ x -0.1+0.1i))) + ((= i 200)) + (let ((y (magnitude (- x (cos (acos x)))))) + (if (> y err) (set! err y)))) + (if (> err 1e-10) + (begin (display "(cos (acos [complex] ...)) error: ") (display err) (newline)))) + + +;; -------- atan +(num-test (atan 0) 0.0) +(num-test (atan 1) 0.78539816339745) +(num-test (atan -1) -0.78539816339745) +(num-test (atan 2) 1.10714871779409) +(num-test (atan -2) -1.10714871779409) +(num-test (atan 3) 1.24904577239825) +(num-test (atan -3) -1.24904577239825) +(num-test (atan 10) 1.47112767430373) +(num-test (atan -10) -1.47112767430373) +(num-test (atan 1234) 1.56998595420081) +(num-test (atan -1234) -1.56998595420081) +(num-test (atan 0/1) 0.0) +(num-test (atan 0/2) 0.0) +(num-test (atan 0/3) 0.0) +(num-test (atan 0/10) 0.0) +(num-test (atan 0/1234) 0.0) +(num-test (atan 0/1234000000) 0.0) +(num-test (atan 0/500029) 0.0) +(num-test (atan 0/362880) 0.0) +(num-test (atan 1/1) 0.78539816339745) +(num-test (atan -1/1) -0.78539816339745) +(num-test (atan 1/2) 0.46364760900081) +(num-test (atan -1/2) -0.46364760900081) +(num-test (atan 1/3) 0.32175055439664) +(num-test (atan -1/3) -0.32175055439664) +(num-test (atan 1/10) 0.09966865249116) +(num-test (atan -1/10) -0.09966865249116) +(num-test (atan 1/1234) 0.00081037259408) +(num-test (atan -1/1234) -0.00081037259408) +(num-test (atan 1/1234000000) 0.00000000081037) +(num-test (atan -1/1234000000) -0.00000000081037) +(num-test (atan 1/500029) 0.00000199988401) +(num-test (atan -1/500029) -0.00000199988401) +(num-test (atan 1/362880) 0.00000275573192) +(num-test (atan -1/362880) -0.00000275573192) +(num-test (atan 2/1) 1.10714871779409) +(num-test (atan -2/1) -1.10714871779409) +(num-test (atan 2/2) 0.78539816339745) +(num-test (atan -2/2) -0.78539816339745) +(num-test (atan 2/3) 0.58800260354757) +(num-test (atan -2/3) -0.58800260354757) +(num-test (atan 2/10) 0.19739555984988) +(num-test (atan -2/10) -0.19739555984988) +(num-test (atan 2/1234) 0.00162074412382) +(num-test (atan -2/1234) -0.00162074412382) +(num-test (atan 2/1234000000) 0.00000000162075) +(num-test (atan -2/1234000000) -0.00000000162075) +(num-test (atan 2/500029) 0.00000399976801) +(num-test (atan -2/500029) -0.00000399976801) +(num-test (atan 2/362880) 0.00000551146384) +(num-test (atan -2/362880) -0.00000551146384) +(num-test (atan 3/1) 1.24904577239825) +(num-test (atan -3/1) -1.24904577239825) +(num-test (atan 3/2) 0.98279372324733) +(num-test (atan -3/2) -0.98279372324733) +(num-test (atan 3/3) 0.78539816339745) +(num-test (atan -3/3) -0.78539816339745) +(num-test (atan 3/10) 0.29145679447787) +(num-test (atan -3/10) -0.29145679447787) +(num-test (atan 3/1234) 0.00243111352487) +(num-test (atan -3/1234) -0.00243111352487) +(num-test (atan 3/1234000000) 0.00000000243112) +(num-test (atan -3/1234000000) -0.00000000243112) +(num-test (atan 3/500029) 0.00000599965202) +(num-test (atan -3/500029) -0.00000599965202) +(num-test (atan 3/362880) 0.00000826719577) +(num-test (atan -3/362880) -0.00000826719577) +(num-test (atan 10/1) 1.47112767430373) +(num-test (atan -10/1) -1.47112767430373) +(num-test (atan 10/2) 1.37340076694502) +(num-test (atan -10/2) -1.37340076694502) +(num-test (atan 10/3) 1.27933953231703) +(num-test (atan -10/3) -1.27933953231703) +(num-test (atan 10/10) 0.78539816339745) +(num-test (atan -10/10) -0.78539816339745) +(num-test (atan 10/1234) 0.00810355033005) +(num-test (atan -10/1234) -0.00810355033005) +(num-test (atan 10/1234000000) 0.00000000810373) +(num-test (atan -10/1234000000) -0.00000000810373) +(num-test (atan 10/500029) 0.00001999884006) +(num-test (atan -10/500029) -0.00001999884006) +(num-test (atan 10/362880) 0.00002755731922) +(num-test (atan -10/362880) -0.00002755731922) +(num-test (atan 1234/1) 1.56998595420081) +(num-test (atan -1234/1) -1.56998595420081) +(num-test (atan 1234/2) 1.56917558267108) +(num-test (atan -1234/2) -1.56917558267108) +(num-test (atan 1234/3) 1.56836521327003) +(num-test (atan -1234/3) -1.56836521327003) +(num-test (atan 1234/10) 1.56269277646485) +(num-test (atan -1234/10) -1.56269277646485) +(num-test (atan 1234/1234) 0.78539816339745) +(num-test (atan -1234/1234) -0.78539816339745) +(num-test (atan 1234/1234000000) 0.00000100000000) +(num-test (atan -1234/1234000000) -0.00000100000000) +(num-test (atan 1234/500029) 0.00246785185431) +(num-test (atan -1234/500029) -0.00246785185431) +(num-test (atan 1234/362880) 0.00340056008437) +(num-test (atan -1234/362880) -0.00340056008437) +(num-test (atan 1234000000/1234000000) 0.78539816339745) +(num-test (atan -1234000000/1234000000) -0.78539816339745) +(num-test (atan 1234000000/500029) 1.57039111693053) +(num-test (atan -1234000000/500029) -1.57039111693053) +(num-test (atan 1234000000/362880) 1.57050225873206) +(num-test (atan -1234000000/362880) -1.57050225873206) +(num-test (atan 500029/2) 1.57079232702688) +(num-test (atan -500029/2) -1.57079232702688) +(num-test (atan 500029/3) 1.57079032714288) +(num-test (atan -500029/3) -1.57079032714288) +(num-test (atan 500029/10) 1.57077632795483) +(num-test (atan -500029/10) -1.57077632795483) +(num-test (atan 500029/1234) 1.56832847494059) +(num-test (atan -500029/1234) -1.56832847494059) +(num-test (atan 500029/1234000000) 0.00040520986437) +(num-test (atan -500029/1234000000) -0.00040520986437) +(num-test (atan 500029/500029) 0.78539816339745) +(num-test (atan -500029/500029) -0.78539816339745) +(num-test (atan 500029/362880) 0.94301772831206) +(num-test (atan -500029/362880) -0.94301772831206) +(num-test (atan 362880/2) 1.57079081533105) +(num-test (atan -362880/2) -1.57079081533105) +(num-test (atan 362880/3) 1.57078805959913) +(num-test (atan -362880/3) -1.57078805959913) +(num-test (atan 362880/10) 1.57076876947568) +(num-test (atan -362880/10) -1.57076876947568) +(num-test (atan 362880/1234) 1.56739576671053) +(num-test (atan -362880/1234) -1.56739576671053) +(num-test (atan 362880/1234000000) 0.00029406806284) +(num-test (atan -362880/1234000000) -0.00029406806284) +(num-test (atan 362880/500029) 0.62777859848283) +(num-test (atan -362880/500029) -0.62777859848283) +(num-test (atan 362880/362880) 0.78539816339745) +(num-test (atan -362880/362880) -0.78539816339745) +(num-test (atan 0.0) 0.0) +(num-test (atan 0.00000001) 0.00000001) +(num-test (atan -0.00000001) -0.00000001) +(num-test (atan 1.0) 0.78539816339745) +(num-test (atan -1.0) -0.78539816339745) +(num-test (atan our-pi) 1.26262725567891) +(num-test (atan -3.14159265358979) -1.26262725567891) +(num-test (atan 2.71828182845905) 1.21828290501728) +(num-test (atan -2.71828182845905) -1.21828290501728) +(num-test (atan 1234.0) 1.56998595420081) +(num-test (atan -1234.0) -1.56998595420081) +(num-test (atan 0.0+0.0i) 0.0) +(num-test (atan -0.0+0.0i) 0.0) +(num-test (atan 0.0-0.0i) 0.0) +(num-test (atan -0.0-0.0i) -0.0) +(num-test (atan 0.0+0.00000001i) 0.0+0.00000001i) +(num-test (atan -0.0+0.00000001i) 0.0+0.00000001i) +(num-test (atan 0.0-0.00000001i) 0.0-0.00000001i) +(num-test (atan -0.0-0.00000001i) -0.0-0.00000001i) +(num-test (atan 0.0+3.14159265358979i) 1.57079632679490+0.32976531495670i) +(num-test (atan -0.0+3.14159265358979i) 1.57079632679490+0.32976531495670i) +(num-test (atan 0.0-3.14159265358979i) 1.57079632679490-0.32976531495670i) +(num-test (atan -0.0-3.14159265358979i) -1.57079632679490-0.32976531495670i) +(num-test (atan 0.0+2.71828182845905i) 1.57079632679490+0.38596841645265i) +(num-test (atan -0.0+2.71828182845905i) 1.57079632679490+0.38596841645265i) +(num-test (atan 0.0-2.71828182845905i) 1.57079632679490-0.38596841645265i) +(num-test (atan -0.0-2.71828182845905i) -1.57079632679490-0.38596841645265i) +(num-test (atan 0.0+1234.0i) 1.57079632679490+0.00081037294887i) +(num-test (atan -0.0+1234.0i) 1.57079632679490+0.00081037294887i) +(num-test (atan 0.0-1234.0i) 1.57079632679490-0.00081037294887i) +(num-test (atan -0.0-1234.0i) -1.57079632679490-0.00081037294887i) +(num-test (atan 0.00000001+0.0i) 0.00000001) +(num-test (atan -0.00000001+0.0i) -0.00000001) +(num-test (atan 0.00000001-0.0i) 0.00000001) +(num-test (atan -0.00000001-0.0i) -0.00000001) +(num-test (atan 0.00000001+0.00000001i) 0.00000001+0.00000001i) +(num-test (atan -0.00000001+0.00000001i) -0.00000001+0.00000001i) +(num-test (atan 0.00000001-0.00000001i) 0.00000001-0.00000001i) +(num-test (atan -0.00000001-0.00000001i) -0.00000001-0.00000001i) +(num-test (atan 0.00000001+1.0i) 0.78539816589789+9.55691396225616i) +(num-test (atan -0.00000001+1.0i) -0.78539816589789+9.55691396225616i) +(num-test (atan 0.00000001-1.0i) 0.78539816589789-9.55691396225616i) +(num-test (atan -0.00000001-1.0i) -0.78539816589789-9.55691396225616i) +(num-test (atan 0.00000001+3.14159265358979i) 1.57079632566745+0.32976531495670i) +(num-test (atan -0.00000001+3.14159265358979i) -1.57079632566745+0.32976531495670i) +(num-test (atan 0.00000001-3.14159265358979i) 1.57079632566745-0.32976531495670i) +(num-test (atan -0.00000001-3.14159265358979i) -1.57079632566745-0.32976531495670i) +(num-test (atan 0.00000001+2.71828182845905i) 1.57079632522972+0.38596841645265i) +(num-test (atan -0.00000001+2.71828182845905i) -1.57079632522972+0.38596841645265i) +(num-test (atan 0.00000001-2.71828182845905i) 1.57079632522972-0.38596841645265i) +(num-test (atan -0.00000001-2.71828182845905i) -1.57079632522972-0.38596841645265i) +(num-test (atan 0.00000001+1234.0i) 1.57079632679489+0.00081037294887i) +(num-test (atan -0.00000001+1234.0i) -1.57079632679489+0.00081037294887i) +(num-test (atan 0.00000001-1234.0i) 1.57079632679489-0.00081037294887i) +(num-test (atan -0.00000001-1234.0i) -1.57079632679489-0.00081037294887i) +(num-test (atan 1.0+0.0i) 0.78539816339745) +(num-test (atan -1.0+0.0i) -0.78539816339745) +(num-test (atan 1.0-0.0i) 0.78539816339745) +(num-test (atan -1.0-0.0i) -0.78539816339745) +(num-test (atan 1.0+0.00000001i) 0.78539816339745+0.00000000500000i) +(num-test (atan -1.0+0.00000001i) -0.78539816339745+0.00000000500000i) +(num-test (atan 1.0-0.00000001i) 0.78539816339745-0.00000000500000i) +(num-test (atan -1.0-0.00000001i) -0.78539816339745-0.00000000500000i) +(num-test (atan 1.0+1.0i) 1.01722196789785+0.40235947810853i) +(num-test (atan -1.0+1.0i) -1.01722196789785+0.40235947810853i) +(num-test (atan 1.0-1.0i) 1.01722196789785-0.40235947810853i) +(num-test (atan -1.0-1.0i) -1.01722196789785-0.40235947810853i) +(num-test (atan 1.0+3.14159265358979i) 1.47082882591946+0.29462144034086i) +(num-test (atan -1.0+3.14159265358979i) -1.47082882591946+0.29462144034086i) +(num-test (atan 1.0-3.14159265358979i) 1.47082882591946-0.29462144034086i) +(num-test (atan -1.0-3.14159265358979i) -1.47082882591946-0.29462144034086i) +(num-test (atan 1.0+2.71828182845905i) 1.43862796047891+0.33050259272341i) +(num-test (atan -1.0+2.71828182845905i) -1.43862796047891+0.33050259272341i) +(num-test (atan 1.0-2.71828182845905i) 1.43862796047891-0.33050259272341i) +(num-test (atan -1.0-2.71828182845905i) -1.43862796047891-0.33050259272341i) +(num-test (atan 1.0+1234.0i) 1.57079567009087+0.00081037241669i) +(num-test (atan -1.0+1234.0i) -1.57079567009087+0.00081037241669i) +(num-test (atan 1.0-1234.0i) 1.57079567009087-0.00081037241669i) +(num-test (atan -1.0-1234.0i) -1.57079567009087-0.00081037241669i) +(num-test (atan 3.14159265358979+0.0i) 1.26262725567891) +(num-test (atan -3.14159265358979+0.0i) -1.26262725567891) +(num-test (atan 3.14159265358979-0.0i) 1.26262725567891) +(num-test (atan -3.14159265358979-0.0i) -1.26262725567891) +(num-test (atan 3.14159265358979+0.00000001i) 1.26262725567891+0.00000000092000i) +(num-test (atan -3.14159265358979+0.00000001i) -1.26262725567891+0.00000000092000i) +(num-test (atan 3.14159265358979-0.00000001i) 1.26262725567891-0.00000000092000i) +(num-test (atan -3.14159265358979-0.00000001i) -1.26262725567891-0.00000000092000i) +(num-test (atan 3.14159265358979+1.0i) 1.28734057432439+0.08505998507745i) +(num-test (atan -3.14159265358979+1.0i) -1.28734057432439+0.08505998507745i) +(num-test (atan 3.14159265358979-1.0i) 1.28734057432439-0.08505998507745i) +(num-test (atan -3.14159265358979-1.0i) -1.28734057432439-0.08505998507745i) +(num-test (atan 3.14159265358979+3.14159265358979i) 1.40903828502376+0.15638868878130i) +(num-test (atan -3.14159265358979+3.14159265358979i) -1.40903828502376+0.15638868878130i) +(num-test (atan 3.14159265358979-3.14159265358979i) 1.40903828502376-0.15638868878130i) +(num-test (atan -3.14159265358979-3.14159265358979i) -1.40903828502376-0.15638868878130i) +(num-test (atan 3.14159265358979+2.71828182845905i) 1.38641010899673+0.15352587926173i) +(num-test (atan -3.14159265358979+2.71828182845905i) -1.38641010899673+0.15352587926173i) +(num-test (atan 3.14159265358979-2.71828182845905i) 1.38641010899673-0.15352587926173i) +(num-test (atan -3.14159265358979-2.71828182845905i) -1.38641010899673-0.15352587926173i) +(num-test (atan 3.14159265358979+1234.0i) 1.57079426371036+0.00081036769654i) +(num-test (atan -3.14159265358979+1234.0i) -1.57079426371036+0.00081036769654i) +(num-test (atan 3.14159265358979-1234.0i) 1.57079426371036-0.00081036769654i) +(num-test (atan -3.14159265358979-1234.0i) -1.57079426371036-0.00081036769654i) +(num-test (atan 2.71828182845905+0.0i) 1.21828290501728) +(num-test (atan -2.71828182845905+0.0i) -1.21828290501728) +(num-test (atan 2.71828182845905-0.0i) 1.21828290501728) +(num-test (atan -2.71828182845905-0.0i) -1.21828290501728) +(num-test (atan 2.71828182845905+0.00000001i) 1.21828290501728+0.00000000119203i) +(num-test (atan -2.71828182845905+0.00000001i) -1.21828290501728+0.00000000119203i) +(num-test (atan 2.71828182845905-0.00000001i) 1.21828290501728-0.00000000119203i) +(num-test (atan -2.71828182845905-0.00000001i) -1.21828290501728-0.00000000119203i) +(num-test (atan 2.71828182845905+1.0i) 1.25363416718071+0.10816322574795i) +(num-test (atan -2.71828182845905+1.0i) -1.25363416718071+0.10816322574795i) +(num-test (atan 2.71828182845905-1.0i) 1.25363416718071-0.10816322574795i) +(num-test (atan -2.71828182845905-1.0i) -1.25363416718071-0.10816322574795i) +(num-test (atan 2.71828182845905+3.14159265358979i) 1.40945039787275+0.17937970703436i) +(num-test (atan -2.71828182845905+3.14159265358979i) -1.40945039787275+0.17937970703436i) +(num-test (atan 2.71828182845905-3.14159265358979i) 1.40945039787275-0.17937970703436i) +(num-test (atan -2.71828182845905-3.14159265358979i) -1.40945039787275-0.17937970703436i) +(num-test (atan 2.71828182845905+2.71828182845905i) 1.38288382352616+0.17963089485802i) +(num-test (atan -2.71828182845905+2.71828182845905i) -1.38288382352616+0.17963089485802i) +(num-test (atan 2.71828182845905-2.71828182845905i) 1.38288382352616-0.17963089485802i) +(num-test (atan -2.71828182845905-2.71828182845905i) -1.38288382352616-0.17963089485802i) +(num-test (atan 2.71828182845905+1234.0i) 1.57079454169576+0.00081036901661i) +(num-test (atan -2.71828182845905+1234.0i) -1.57079454169576+0.00081036901661i) +(num-test (atan 2.71828182845905-1234.0i) 1.57079454169576-0.00081036901661i) +(num-test (atan -2.71828182845905-1234.0i) -1.57079454169576-0.00081036901661i) +(num-test (atan 1234.0+0.0i) 1.56998595420081) +(num-test (atan -1234.0+0.0i) -1.56998595420081) +(num-test (atan 1234.0-0.0i) 1.56998595420081) +(num-test (atan -1234.0-0.0i) -1.56998595420081) +(num-test (atan 1234.0+0.00000001i) 1.56998595420081+0.00000000000001i) +(num-test (atan -1234.0+0.00000001i) -1.56998595420081+0.00000000000001i) +(num-test (atan 1234.0-0.00000001i) 1.56998595420081-0.00000000000001i) +(num-test (atan -1234.0-0.00000001i) -1.56998595420081-0.00000000000001i) +(num-test (atan 1234.0+1.0i) 1.56998595473299+0.00000065670317i) +(num-test (atan -1234.0+1.0i) -1.56998595473299+0.00000065670317i) +(num-test (atan 1234.0-1.0i) 1.56998595473299-0.00000065670317i) +(num-test (atan -1234.0-1.0i) -1.56998595473299-0.00000065670317i) +(num-test (atan 1234.0+3.14159265358979i) 1.56998595945313+0.00000206308183i) +(num-test (atan -1234.0+3.14159265358979i) -1.56998595945313+0.00000206308183i) +(num-test (atan 1234.0-3.14159265358979i) 1.56998595945313-0.00000206308183i) +(num-test (atan -1234.0-3.14159265358979i) -1.56998595945313-0.00000206308183i) +(num-test (atan 1234.0+2.71828182845905i) 1.56998595813306+0.00000178509679i) +(num-test (atan -1234.0+2.71828182845905i) -1.56998595813306+0.00000178509679i) +(num-test (atan 1234.0-2.71828182845905i) 1.56998595813306-0.00000178509679i) +(num-test (atan -1234.0-2.71828182845905i) -1.56998595813306-0.00000178509679i) +(num-test (atan 1234.0+1234.0i) 1.57039114036481+0.00040518634139i) +(num-test (atan -1234.0+1234.0i) -1.57039114036481+0.00040518634139i) +(num-test (atan 1234.0-1234.0i) 1.57039114036481-0.00040518634139i) +(num-test (atan -1234.0-1234.0i) -1.57039114036481-0.00040518634139i) +(num-test (atan 6.9279836e-17) 6.9279836e-17) +(num-test (atan 1.7976931e+308) 1.5707963267949) +(num-test (atan 0 0) 0.0) +(num-test (atan 0 1.0) 0.0) +(num-test (atan 0 -1.0) our-pi) +(num-test (atan 1.0 0) (/ our-pi 2)) +(num-test (atan -1.0 0) (/ our-pi -2)) +(num-test (atan 0.0 0.0) 0.0) +(num-test (atan 0.0 0.00000001) 0.0) +(num-test (atan 0.0 1.0) 0.0) +(num-test (atan 0.0 our-pi) 0.0) +(num-test (atan 0.0 2.71828182845905) 0.0) +(num-test (atan 0.0 1234.0) 0.0) +(num-test (atan 0.0 1234000000.0) 0.0) +(num-test (atan 0.00000001 0.0) 1.57079632679490) +(num-test (atan 0.00000001 0.00000001) 0.78539816339745) +(num-test (atan 0.00000001 1.0) 0.00000001) +(num-test (atan 0.00000001 our-pi) 0.00000000318310) +(num-test (atan 0.00000001 2.71828182845905) 0.00000000367879) +(num-test (atan 0.00000001 1234.0) 0.00000000000810) +(num-test (atan 0.00000001 1234000000.0) 0.0) +(num-test (atan 1.0 0.0) 1.57079632679490) +(num-test (atan 1.0 0.00000001) 1.57079631679490) +(num-test (atan 1.0 1.0) 0.78539816339745) +(num-test (atan 1.0 our-pi) 0.30816907111598) +(num-test (atan 1.0 2.71828182845905) 0.35251342177762) +(num-test (atan 1.0 1234.0) 0.00081037259408) +(num-test (atan 1.0 1234000000.0) 0.00000000081037) +(num-test (atan 3.14159265358979 0.0) 1.57079632679490) +(num-test (atan 3.14159265358979 0.00000001) 1.57079632361180) +(num-test (atan 3.14159265358979 1.0) 1.26262725567891) +(num-test (atan 3.14159265358979 our-pi) 0.78539816339745) +(num-test (atan 3.14159265358979 2.71828182845905) 0.85751178635585) +(num-test (atan 3.14159265358979 1234.0) 0.00254585564530) +(num-test (atan 3.14159265358979 1234000000.0) 0.00000000254586) +(num-test (atan 2.71828182845905 0.0) 1.57079632679490) +(num-test (atan 2.71828182845905 0.00000001) 1.57079632311610) +(num-test (atan 2.71828182845905 1.0) 1.21828290501728) +(num-test (atan 2.71828182845905 our-pi) 0.71328454043905) +(num-test (atan 2.71828182845905 2.71828182845905) 0.78539816339745) +(num-test (atan 2.71828182845905 1234.0) 0.00220281801598) +(num-test (atan 2.71828182845905 1234000000.0) 0.00000000220282) +(num-test (atan 1234.0 0.0) 1.57079632679490) +(num-test (atan 1234.0 0.00000001) 1.57079632678679) +(num-test (atan 1234.0 1.0) 1.56998595420081) +(num-test (atan 1234.0 our-pi) 1.56825047114960) +(num-test (atan 1234.0 2.71828182845905) 1.56859350877892) +(num-test (atan 1234.0 1234.0) 0.78539816339745) +(num-test (atan 1234.0 1234000000.0) 0.00000100000000) +(num-test (atan 1234000000.0 0.0) 1.57079632679490) +(num-test (atan 1234000000.0 0.00000001) 1.57079632679490) +(num-test (atan 1234000000.0 1.0) 1.57079632598452) +(num-test (atan 1234000000.0 our-pi) 1.57079632424904) +(num-test (atan 1234000000.0 2.71828182845905) 1.57079632459208) +(num-test (atan 1234000000.0 1234.0) 1.57079532679490) +(num-test (atan 1234000000.0 1234000000.0) 0.78539816339745) +(num-test (atan 1234000000/3) 1.570796324363778) +(num-test (atan 0.00000001+1234000000.0i) +1.570796326794897+8.103727714748784E-10i) +(num-test (atan 3.14159265358979+1234000000.0i) +1.570796326794897+8.103727714748784E-10i) +(num-test (atan 2.71828182845905+1234000000.0i) +1.570796326794897+8.103727714748784E-10i) +(num-test (atan 1234000000.0+0.00000001i) +1.570796325984524+6.567040287478756E-27i) +(num-test (atan 1234000000.0+3.14159265358979i) +1.570796325984524+2.063096552297151E-18i) +(num-test (atan 1234000000.0+2.71828182845905i) +1.570796325984524+1.785106628021167E-18i) +(num-test (atan 1) 0.7853981633974483) +(num-test (atan 0.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (atan 0.0e+00+1.19209289550781250e-07i) 0+1.1920928955078181469e-7i) +(num-test (atan 0.0e+00-1.19209289550781250e-07i) 0-1.1920928955078181469e-7i) +(num-test (atan 0.0e+00+5.0e-01i) 0+5.4930614433405484570e-1i) +(num-test (atan 0.0e+00-5.0e-01i) 0-5.4930614433405484570e-1i) +(num-test (atan 0.0e+00+2.0e+00i) 1.5707963267948966192e0+5.4930614433405484570e-1i) +(num-test (atan 0.0e+00-2.0e+00i) -1.5707963267948966192e0-5.4930614433405484570e-1i) +(num-test (atan 0.0e+00+8.3886080e+06i) 1.5707963267948966192e0+1.1920928955078181469e-7i) +(num-test (atan 0.0e+00-8.3886080e+06i) -1.5707963267948966192e0-1.1920928955078181469e-7i) +(num-test (atan 1.19209289550781250e-07+0.0e+00i) 1.1920928955078068531e-7+0.0i) +(num-test (atan -1.19209289550781250e-07+0.0e+00i) -1.1920928955078068531e-7+0.0i) +(num-test (atan 1.19209289550781250e-07+1.19209289550781250e-07i) 1.1920928955078237938e-7+1.1920928955078012062e-7i) +(num-test (atan 1.19209289550781250e-07-1.19209289550781250e-07i) 1.1920928955078237938e-7-1.1920928955078012062e-7i) +(num-test (atan -1.19209289550781250e-07+1.19209289550781250e-07i) -1.1920928955078237938e-7+1.1920928955078012062e-7i) +(num-test (atan -1.19209289550781250e-07-1.19209289550781250e-07i) -1.1920928955078237938e-7-1.1920928955078012062e-7i) +(num-test (atan 1.19209289550781250e-07+5.0e-01i) 1.5894571940103932425e-7+5.4930614433404221383e-1i) +(num-test (atan 1.19209289550781250e-07-5.0e-01i) 1.5894571940103932425e-7-5.4930614433404221383e-1i) +(num-test (atan -1.19209289550781250e-07+5.0e-01i) -1.5894571940103932425e-7+5.4930614433404221383e-1i) +(num-test (atan -1.19209289550781250e-07-5.0e-01i) -1.5894571940103932425e-7-5.4930614433404221383e-1i) +(num-test (atan 1.19209289550781250e-07+1.0e+00i) 7.8539819319977069731e-1+8.3177661667193446012e0i) +(num-test (atan 1.19209289550781250e-07-1.0e+00i) 7.8539819319977069731e-1-8.3177661667193446012e0i) +(num-test (atan -1.19209289550781250e-07+1.0e+00i) -7.8539819319977069731e-1+8.3177661667193446012e0i) +(num-test (atan -1.19209289550781250e-07-1.0e+00i) -7.8539819319977069731e-1-8.3177661667193446012e0i) +(num-test (atan 1.19209289550781250e-07+2.0e+00i) 1.5707962870584667690e0+5.4930614433405168773e-1i) +(num-test (atan 1.19209289550781250e-07-2.0e+00i) 1.5707962870584667690e0-5.4930614433405168773e-1i) +(num-test (atan -1.19209289550781250e-07+2.0e+00i) -1.5707962870584667690e0+5.4930614433405168773e-1i) +(num-test (atan -1.19209289550781250e-07-2.0e+00i) -1.5707962870584667690e0-5.4930614433405168773e-1i) +(num-test (atan 1.19209289550781250e-07+8.3886080e+06i) 1.5707963267948966192e0+1.1920928955078181469e-7i) +(num-test (atan 1.19209289550781250e-07-8.3886080e+06i) 1.5707963267948966192e0-1.1920928955078181469e-7i) +(num-test (atan -1.19209289550781250e-07+8.3886080e+06i) -1.5707963267948966192e0+1.1920928955078181469e-7i) +(num-test (atan -1.19209289550781250e-07-8.3886080e+06i) -1.5707963267948966192e0-1.1920928955078181469e-7i) +(num-test (atan 5.0e-01+0.0e+00i) 4.6364760900080611621e-1+0.0i) +(num-test (atan -5.0e-01+0.0e+00i) -4.6364760900080611621e-1+0.0i) +(num-test (atan 5.0e-01+1.19209289550781250e-07i) 4.6364760900081066369e-1+9.5367431640625072280e-8i) +(num-test (atan 5.0e-01-1.19209289550781250e-07i) 4.6364760900081066369e-1-9.5367431640625072280e-8i) +(num-test (atan -5.0e-01+1.19209289550781250e-07i) -4.6364760900081066369e-1+9.5367431640625072280e-8i) +(num-test (atan -5.0e-01-1.19209289550781250e-07i) -4.6364760900081066369e-1-9.5367431640625072280e-8i) +(num-test (atan 5.0e-01+5.0e-01i) 5.5357435889704525151e-1+4.0235947810852509365e-1i) +(num-test (atan 5.0e-01-5.0e-01i) 5.5357435889704525151e-1-4.0235947810852509365e-1i) +(num-test (atan -5.0e-01+5.0e-01i) -5.5357435889704525151e-1+4.0235947810852509365e-1i) +(num-test (atan -5.0e-01-5.0e-01i) -5.5357435889704525151e-1-4.0235947810852509365e-1i) +(num-test (atan 5.0e-01+1.0e+00i) 9.0788749496088038670e-1+7.0830333601405402006e-1i) +(num-test (atan 5.0e-01-1.0e+00i) 9.0788749496088038670e-1-7.0830333601405402006e-1i) +(num-test (atan -5.0e-01+1.0e+00i) -9.0788749496088038670e-1+7.0830333601405402006e-1i) +(num-test (atan -5.0e-01-1.0e+00i) -9.0788749496088038670e-1-7.0830333601405402006e-1i) +(num-test (atan 5.0e-01+2.0e+00i) 1.4215468610018069803e0+5.0037000005253101744e-1i) +(num-test (atan 5.0e-01-2.0e+00i) 1.4215468610018069803e0-5.0037000005253101744e-1i) +(num-test (atan -5.0e-01+2.0e+00i) -1.4215468610018069803e0+5.0037000005253101744e-1i) +(num-test (atan -5.0e-01-2.0e+00i) -1.4215468610018069803e0-5.0037000005253101744e-1i) +(num-test (atan 5.0e-01+8.3886080e+06i) 1.5707963267948895138e0+1.1920928955078139117e-7i) +(num-test (atan 5.0e-01-8.3886080e+06i) 1.5707963267948895138e0-1.1920928955078139117e-7i) +(num-test (atan -5.0e-01+8.3886080e+06i) -1.5707963267948895138e0+1.1920928955078139117e-7i) +(num-test (atan -5.0e-01-8.3886080e+06i) -1.5707963267948895138e0-1.1920928955078139117e-7i) +(num-test (atan 1.0e+00+0.0e+00i) 7.8539816339744830962e-1+0.0i) +(num-test (atan -1.0e+00+0.0e+00i) -7.8539816339744830962e-1+0.0i) +(num-test (atan 1.0e+00+1.19209289550781250e-07i) 7.8539816339745186233e-1+5.9604644775390483828e-8i) +(num-test (atan 1.0e+00-1.19209289550781250e-07i) 7.8539816339745186233e-1-5.9604644775390483828e-8i) +(num-test (atan -1.0e+00+1.19209289550781250e-07i) -7.8539816339745186233e-1+5.9604644775390483828e-8i) +(num-test (atan -1.0e+00-1.19209289550781250e-07i) -7.8539816339745186233e-1-5.9604644775390483828e-8i) +(num-test (atan 1.0e+00+5.0e-01i) 8.4757566067082902713e-1+2.3887786125685909036e-1i) +(num-test (atan 1.0e+00-5.0e-01i) 8.4757566067082902713e-1-2.3887786125685909036e-1i) +(num-test (atan -1.0e+00+5.0e-01i) -8.4757566067082902713e-1+2.3887786125685909036e-1i) +(num-test (atan -1.0e+00-5.0e-01i) -8.4757566067082902713e-1-2.3887786125685909036e-1i) +(num-test (atan 1.0e+00+1.0e+00i) 1.0172219678978513677e0+4.0235947810852509365e-1i) +(num-test (atan 1.0e+00-1.0e+00i) 1.0172219678978513677e0-4.0235947810852509365e-1i) +(num-test (atan -1.0e+00+1.0e+00i) -1.0172219678978513677e0+4.0235947810852509365e-1i) +(num-test (atan -1.0e+00-1.0e+00i) -1.0172219678978513677e0-4.0235947810852509365e-1i) +(num-test (atan 1.0e+00+2.0e+00i) 1.3389725222944935611e0+4.0235947810852509365e-1i) +(num-test (atan 1.0e+00-2.0e+00i) 1.3389725222944935611e0-4.0235947810852509365e-1i) +(num-test (atan -1.0e+00+2.0e+00i) -1.3389725222944935611e0+4.0235947810852509365e-1i) +(num-test (atan -1.0e+00-2.0e+00i) -1.3389725222944935611e0-4.0235947810852509365e-1i) +(num-test (atan 1.0e+00+8.3886080e+06i) 1.5707963267948824084e0+1.1920928955078012062e-7i) +(num-test (atan 1.0e+00-8.3886080e+06i) 1.5707963267948824084e0-1.1920928955078012062e-7i) +(num-test (atan -1.0e+00+8.3886080e+06i) -1.5707963267948824084e0+1.1920928955078012062e-7i) +(num-test (atan -1.0e+00-8.3886080e+06i) -1.5707963267948824084e0-1.1920928955078012062e-7i) +(num-test (atan 2.0e+00+0.0e+00i) 1.1071487177940905030e0+0.0i) +(num-test (atan -2.0e+00+0.0e+00i) -1.1071487177940905030e0+0.0i) +(num-test (atan 2.0e+00+1.19209289550781250e-07i) 1.1071487177940916399e0+2.3841857910156200307e-8i) +(num-test (atan 2.0e+00-1.19209289550781250e-07i) 1.1071487177940916399e0-2.3841857910156200307e-8i) +(num-test (atan -2.0e+00+1.19209289550781250e-07i) -1.1071487177940916399e0+2.3841857910156200307e-8i) +(num-test (atan -2.0e+00-1.19209289550781250e-07i) -1.1071487177940916399e0-2.3841857910156200307e-8i) +(num-test (atan 2.0e+00+5.0e-01i) 1.1265564408348223487e0+9.6415620202996167238e-2i) +(num-test (atan 2.0e+00-5.0e-01i) 1.1265564408348223487e0-9.6415620202996167238e-2i) +(num-test (atan -2.0e+00+5.0e-01i) -1.1265564408348223487e0+9.6415620202996167238e-2i) +(num-test (atan -2.0e+00-5.0e-01i) -1.1265564408348223487e0-9.6415620202996167238e-2i) +(num-test (atan 2.0e+00+1.0e+00i) 1.1780972450961724644e0+1.7328679513998632735e-1i) +(num-test (atan 2.0e+00-1.0e+00i) 1.1780972450961724644e0-1.7328679513998632735e-1i) +(num-test (atan -2.0e+00+1.0e+00i) -1.1780972450961724644e0+1.7328679513998632735e-1i) +(num-test (atan -2.0e+00-1.0e+00i) -1.1780972450961724644e0-1.7328679513998632735e-1i) +(num-test (atan 2.0e+00+2.0e+00i) 1.3112232696716351433e0+2.3887786125685909036e-1i) +(num-test (atan 2.0e+00-2.0e+00i) 1.3112232696716351433e0-2.3887786125685909036e-1i) +(num-test (atan -2.0e+00+2.0e+00i) -1.3112232696716351433e0+2.3887786125685909036e-1i) +(num-test (atan -2.0e+00-2.0e+00i) -1.3112232696716351433e0-2.3887786125685909036e-1i) +(num-test (atan 2.0e+00+8.3886080e+06i) 1.5707963267948681975e0+1.1920928955077503843e-7i) +(num-test (atan 2.0e+00-8.3886080e+06i) 1.5707963267948681975e0-1.1920928955077503843e-7i) +(num-test (atan -2.0e+00+8.3886080e+06i) -1.5707963267948681975e0+1.1920928955077503843e-7i) +(num-test (atan -2.0e+00-8.3886080e+06i) -1.5707963267948681975e0-1.1920928955077503843e-7i) +(num-test (atan 8.3886080e+06+0.0e+00i) 1.5707962075856070685e0+0.0i) +(num-test (atan -8.3886080e+06+0.0e+00i) -1.5707962075856070685e0+0.0i) +(num-test (atan 8.3886080e+06+1.19209289550781250e-07i) 1.5707962075856070685e0+1.6940658945085766040e-21i) +(num-test (atan 8.3886080e+06-1.19209289550781250e-07i) 1.5707962075856070685e0-1.6940658945085766040e-21i) +(num-test (atan -8.3886080e+06+1.19209289550781250e-07i) -1.5707962075856070685e0+1.6940658945085766040e-21i) +(num-test (atan -8.3886080e+06-1.19209289550781250e-07i) -1.5707962075856070685e0-1.6940658945085766040e-21i) +(num-test (atan 8.3886080e+06+5.0e-01i) 1.5707962075856070685e0+7.1054273576008756410e-15i) +(num-test (atan 8.3886080e+06-5.0e-01i) 1.5707962075856070685e0-7.1054273576008756410e-15i) +(num-test (atan -8.3886080e+06+5.0e-01i) -1.5707962075856070685e0+7.1054273576008756410e-15i) +(num-test (atan -8.3886080e+06-5.0e-01i) -1.5707962075856070685e0-7.1054273576008756410e-15i) +(num-test (atan 8.3886080e+06+1.0e+00i) 1.5707962075856070685e0+1.4210854715201599821e-14i) +(num-test (atan 8.3886080e+06-1.0e+00i) 1.5707962075856070685e0-1.4210854715201599821e-14i) +(num-test (atan -8.3886080e+06+1.0e+00i) -1.5707962075856070685e0+1.4210854715201599821e-14i) +(num-test (atan -8.3886080e+06-1.0e+00i) -1.5707962075856070685e0-1.4210854715201599821e-14i) +(num-test (atan 8.3886080e+06+2.0e+00i) 1.5707962075856070685e0+2.8421709430401987951e-14i) +(num-test (atan 8.3886080e+06-2.0e+00i) 1.5707962075856070685e0-2.8421709430401987951e-14i) +(num-test (atan -8.3886080e+06+2.0e+00i) -1.5707962075856070685e0+2.8421709430401987951e-14i) +(num-test (atan -8.3886080e+06-2.0e+00i) -1.5707962075856070685e0-2.8421709430401987951e-14i) +(num-test (atan 8.3886080e+06+8.3886080e+06i) 1.5707962671902518438e0+5.9604644775390483828e-8i) +(num-test (atan 8.3886080e+06-8.3886080e+06i) 1.5707962671902518438e0-5.9604644775390483828e-8i) +(num-test (atan -8.3886080e+06+8.3886080e+06i) -1.5707962671902518438e0+5.9604644775390483828e-8i) +(num-test (atan -8.3886080e+06-8.3886080e+06i) -1.5707962671902518438e0-5.9604644775390483828e-8i) + + +;; -------- sqrt +(num-test (sqrt 0) 0) +(num-test (sqrt 1) 1) +(num-test (sqrt -1) 0.0+1.0i) +(num-test (sqrt 2) 1.41421356237310) +(num-test (sqrt -2) 0.0+1.41421356237310i) +(num-test (sqrt 3) 1.73205080756888) +(num-test (sqrt -3) 0.0+1.73205080756888i) +(num-test (sqrt 10) 3.16227766016838) +(num-test (sqrt -10) 0.0+3.16227766016838i) +(num-test (sqrt 1234) 35.12833614050059) +(num-test (sqrt -1234) 0.0+35.12833614050059i) +(num-test (sqrt 1234000000) 35128.33614050059259) +(num-test (sqrt -1234000000) 0.0+35128.33614050059259i) +(num-test (sqrt 500029) 707.12728698587216) +(num-test (sqrt -500029) 0.0+707.12728698587216i) +(num-test (sqrt 362880) 602.39521910453436) +(num-test (sqrt -362880) 0.0+602.39521910453436i) +(num-test (sqrt 0/1) 0) +(num-test (sqrt 0/2) 0) +(num-test (sqrt 0/3) 0) +(num-test (sqrt 0/10) 0) +(num-test (sqrt 0/1234) 0) +(num-test (sqrt 0/1234000000) 0) +(num-test (sqrt 0/500029) 0) +(num-test (sqrt 0/362880) 0) +(num-test (sqrt 1/1) 1) +(num-test (sqrt -1/1) 0.0+1.0i) +(num-test (sqrt 1/2) 0.70710678118655) +(num-test (sqrt -1/2) 0.0+0.70710678118655i) +(num-test (sqrt 1/3) 0.57735026918963) +(num-test (sqrt -1/3) 0.0+0.57735026918963i) +(num-test (sqrt 1/10) 0.31622776601684) +(num-test (sqrt -1/10) 0.0+0.31622776601684i) +(num-test (sqrt 1/1234) 0.02846704711548) +(num-test (sqrt -1/1234) 0.0+0.02846704711548i) +(num-test (sqrt 1/1234000000) 0.00002846704712) +(num-test (sqrt -1/1234000000) 0.0+0.00002846704712i) +(num-test (sqrt 1/500029) 0.00141417255196) +(num-test (sqrt -1/500029) 0.0+0.00141417255196i) +(num-test (sqrt 1/362880) 0.00166003973519) +(num-test (sqrt -1/362880) 0.0+0.00166003973519i) +(num-test (sqrt 2/1) 1.41421356237310) +(num-test (sqrt -2/1) 0.0+1.41421356237310i) +(num-test (sqrt 2/2) 1) +(num-test (sqrt -2/2) 0.0+1.0i) +(num-test (sqrt 2/3) 0.81649658092773) +(num-test (sqrt -2/3) 0.0+0.81649658092773i) +(num-test (sqrt 2/10) 0.44721359549996) +(num-test (sqrt -2/10) 0.0+0.44721359549996i) +(num-test (sqrt 2/1234) 0.04025848411142) +(num-test (sqrt -2/1234) 0.0+0.04025848411142i) +(num-test (sqrt 2/1234000000) 0.00004025848411) +(num-test (sqrt -2/1234000000) 0.0+0.00004025848411i) +(num-test (sqrt 2/500029) 0.00199994200252) +(num-test (sqrt -2/500029) 0.0+0.00199994200252i) +(num-test (sqrt 2/362880) 0.00234765070758) +(num-test (sqrt -2/362880) 0.0+0.00234765070758i) +(num-test (sqrt 3/1) 1.73205080756888) +(num-test (sqrt -3/1) 0.0+1.73205080756888i) +(num-test (sqrt 3/2) 1.22474487139159) +(num-test (sqrt -3/2) 0.0+1.22474487139159i) +(num-test (sqrt 3/3) 1) +(num-test (sqrt -3/3) 0.0+1.0i) +(num-test (sqrt 3/10) 0.54772255750517) +(num-test (sqrt -3/10) 0.0+0.54772255750517i) +(num-test (sqrt 3/1234) 0.04930637194547) +(num-test (sqrt -3/1234) 0.0+0.04930637194547i) +(num-test (sqrt 3/1234000000) 0.00004930637195) +(num-test (sqrt -3/1234000000) 0.0+0.00004930637195i) +(num-test (sqrt 3/500029) 0.00244941871067) +(num-test (sqrt -3/500029) 0.0+0.00244941871067i) +(num-test (sqrt 3/362880) 0.00287527316393) +(num-test (sqrt -3/362880) 0.0+0.00287527316393i) +(num-test (sqrt 10/1) 3.16227766016838) +(num-test (sqrt -10/1) 0.0+3.16227766016838i) +(num-test (sqrt 10/2) 2.23606797749979) +(num-test (sqrt -10/2) 0.0+2.23606797749979i) +(num-test (sqrt 10/3) 1.82574185835055) +(num-test (sqrt -10/3) 0.0+1.82574185835055i) +(num-test (sqrt 10/10) 1) +(num-test (sqrt -10/10) 0.0+1.0i) +(num-test (sqrt 10/1234) 0.09002070714424) +(num-test (sqrt -10/1234) 0.0+0.09002070714424i) +(num-test (sqrt 10/1234000000) 0.00009002070714) +(num-test (sqrt -10/1234000000) 0.0+0.00009002070714i) +(num-test (sqrt 10/500029) 0.00447200626870) +(num-test (sqrt -10/500029) 0.0+0.00447200626870i) +(num-test (sqrt 10/362880) 0.00524950656957) +(num-test (sqrt -10/362880) 0.0+0.00524950656957i) +(num-test (sqrt 1234/1) 35.12833614050059) +(num-test (sqrt -1234/1) 0.0+35.12833614050059i) +(num-test (sqrt 1234/2) 24.83948469674844) +(num-test (sqrt -1234/2) 0.0+24.83948469674844i) +(num-test (sqrt 1234/3) 20.28135432690167) +(num-test (sqrt -1234/3) 0.0+20.28135432690167i) +(num-test (sqrt 1234/10) 11.10855526159905) +(num-test (sqrt -1234/10) 0.0+11.10855526159905i) +(num-test (sqrt 1234/1234) 1) +(num-test (sqrt -1234/1234) 0.0+1.0i) +(num-test (sqrt 1234/1234000000) 0.001) +(num-test (sqrt -1234/1234000000) 0.0+0.001i) +(num-test (sqrt 1234/500029) 0.04967752876605) +(num-test (sqrt -1234/500029) 0.0+0.04967752876605i) +(num-test (sqrt 1234/362880) 0.05831443382422) +(num-test (sqrt -1234/362880) 0.0+0.05831443382422i) +(num-test (sqrt 1234000000/1) 35128.33614050059259) +(num-test (sqrt -1234000000/1) 0.0+35128.33614050059259i) +(num-test (sqrt 1234000000/2) 24839.48469674844091) +(num-test (sqrt -1234000000/2) 0.0+24839.48469674844091i) +(num-test (sqrt 1234000000/3) 20281.35432690167727) +(num-test (sqrt -1234000000/3) 0.0+20281.35432690167727i) +(num-test (sqrt 1234000000/10) 11108.55526159905276) +(num-test (sqrt -1234000000/10) 0.0+11108.55526159905276i) +(num-test (sqrt 1234000000/1234) 1000) +(num-test (sqrt -1234000000/1234) 0.0+1000.0i) +(num-test (sqrt 1234000000/1234000000) 1) +(num-test (sqrt -1234000000/1234000000) 0.0+1.0i) +(num-test (sqrt 1234000000/500029) 49.67752876605147) +(num-test (sqrt -1234000000/500029) 0.0+49.67752876605147i) +(num-test (sqrt 1234000000/362880) 58.31443382422451) +(num-test (sqrt -1234000000/362880) 0.0+58.31443382422451i) +(num-test (sqrt 500029/1) 707.12728698587216) +(num-test (sqrt -500029/1) 0.0+707.12728698587216i) +(num-test (sqrt 500029/2) 500.01449978975609) +(num-test (sqrt -500029/2) 0.0+500.01449978975609i) +(num-test (sqrt 500029/3) 408.26012949262304) +(num-test (sqrt -500029/3) 0.0+408.26012949262304i) +(num-test (sqrt 500029/10) 223.61328225308978) +(num-test (sqrt -500029/10) 0.0+223.61328225308978i) +(num-test (sqrt 500029/1234) 20.12982579526738) +(num-test (sqrt -500029/1234) 0.0+20.12982579526738i) +(num-test (sqrt 500029/1234000000) 0.02012982579527) +(num-test (sqrt -500029/1234000000) 0.0+0.02012982579527i) +(num-test (sqrt 500029/500029) 1) +(num-test (sqrt -500029/500029) 0.0+1.0i) +(num-test (sqrt 500029/362880) 1.17385939423129) +(num-test (sqrt -500029/362880) 0.0+1.17385939423129i) +(num-test (sqrt 362880/1) 602.39521910453436) +(num-test (sqrt -362880/1) 0.0+602.39521910453436i) +(num-test (sqrt 362880/2) 425.95774438317238) +(num-test (sqrt -362880/2) 0.0+425.95774438317238i) +(num-test (sqrt 362880/3) 347.79304190854651) +(num-test (sqrt -362880/3) 0.0+347.79304190854651i) +(num-test (sqrt 362880/10) 190.49409439665052) +(num-test (sqrt -362880/10) 0.0+190.49409439665052i) +(num-test (sqrt 362880/1234) 17.14841308438784) +(num-test (sqrt -362880/1234) 0.0+17.14841308438784i) +(num-test (sqrt 362880/1234000000) 0.01714841308439) +(num-test (sqrt -362880/1234000000) 0.0+0.01714841308439i) +(num-test (sqrt 362880/500029) 0.85189078429181) +(num-test (sqrt -362880/500029) 0.0+0.85189078429181i) +(num-test (sqrt 362880/362880) 1) +(num-test (sqrt -362880/362880) 0.0+1.0i) +(num-test (sqrt 0.0) 0.0) +(num-test (sqrt 0.00000001) 0.00010000000000) +(num-test (sqrt -0.00000001) 0.0+0.00010000000000i) +(num-test (sqrt 1.0) 1.0) +(num-test (sqrt -1.0) 0.0+1.0i) +(num-test (sqrt our-pi) 1.77245385090552) +(num-test (sqrt -3.14159265358979) 0.0+1.77245385090552i) +(num-test (sqrt 2.71828182845905) 1.64872127070013) +(num-test (sqrt -2.71828182845905) 0.0+1.64872127070013i) +(num-test (sqrt 1234.0) 35.12833614050059) +(num-test (sqrt -1234.0) 0.0+35.12833614050059i) +(num-test (sqrt 1234000000.0) 35128.33614050059259) +(num-test (sqrt -1234000000.0) 0.0+35128.33614050059259i) +(num-test (sqrt 0.0+0.0i) 0.0) +(num-test (sqrt -0.0+0.0i) 0.0) +(num-test (sqrt 0.0-0.0i) 0.0) +(num-test (sqrt -0.0-0.0i) 0.0) +(num-test (sqrt 0.0+0.00000001i) 0.00007071067812+0.00007071067812i) +(num-test (sqrt -0.0+0.00000001i) 0.00007071067812+0.00007071067812i) +(num-test (sqrt 0.0-0.00000001i) 0.00007071067812-0.00007071067812i) +(num-test (sqrt -0.0-0.00000001i) 0.00007071067812-0.00007071067812i) +(num-test (sqrt 0.0+1.0i) 0.70710678118655+0.70710678118655i) +(num-test (sqrt -0.0+1.0i) 0.70710678118655+0.70710678118655i) +(num-test (sqrt 0.0-1.0i) 0.70710678118655-0.70710678118655i) +(num-test (sqrt -0.0-1.0i) 0.70710678118655-0.70710678118655i) +(num-test (sqrt 0.0+3.14159265358979i) 1.25331413731550+1.25331413731550i) +(num-test (sqrt -0.0+3.14159265358979i) 1.25331413731550+1.25331413731550i) +(num-test (sqrt 0.0-3.14159265358979i) 1.25331413731550-1.25331413731550i) +(num-test (sqrt -0.0-3.14159265358979i) 1.25331413731550-1.25331413731550i) +(num-test (sqrt 0.0+2.71828182845905i) 1.16582199079856+1.16582199079856i) +(num-test (sqrt -0.0+2.71828182845905i) 1.16582199079856+1.16582199079856i) +(num-test (sqrt 0.0-2.71828182845905i) 1.16582199079856-1.16582199079856i) +(num-test (sqrt -0.0-2.71828182845905i) 1.16582199079856-1.16582199079856i) +(num-test (sqrt 0.0+1234.0i) 24.83948469674844+24.83948469674844i) +(num-test (sqrt -0.0+1234.0i) 24.83948469674844+24.83948469674844i) +(num-test (sqrt 0.0-1234.0i) 24.83948469674844-24.83948469674844i) +(num-test (sqrt -0.0-1234.0i) 24.83948469674844-24.83948469674844i) +(num-test (sqrt 0.0+1234000000.0i) 24839.48469674844091+24839.48469674844091i) +(num-test (sqrt -0.0+1234000000.0i) 24839.48469674844091+24839.48469674844091i) +(num-test (sqrt 0.0-1234000000.0i) 24839.48469674844091-24839.48469674844091i) +(num-test (sqrt -0.0-1234000000.0i) 24839.48469674844091-24839.48469674844091i) +(num-test (sqrt 0.00000001+0.0i) 0.00010000000000) +(num-test (sqrt -0.00000001+0.0i) 0.0+0.00010000000000i) +(num-test (sqrt 0.00000001-0.0i) 0.00010000000000) +(num-test (sqrt -0.00000001-0.0i) 0.0+0.00010000000000i) +(num-test (sqrt 0.00000001+0.00000001i) 0.00010986841135+0.00004550898606i) +(num-test (sqrt -0.00000001+0.00000001i) 0.00004550898606+0.00010986841135i) +(num-test (sqrt 0.00000001-0.00000001i) 0.00010986841135-0.00004550898606i) +(num-test (sqrt -0.00000001-0.00000001i) 0.00004550898606-0.00010986841135i) +(num-test (sqrt 0.00000001+1.0i) 0.70710678472208+0.70710677765101i) +(num-test (sqrt -0.00000001+1.0i) 0.70710677765101+0.70710678472208i) +(num-test (sqrt 0.00000001-1.0i) 0.70710678472208-0.70710677765101i) +(num-test (sqrt -0.00000001-1.0i) 0.70710677765101-0.70710678472208i) +(num-test (sqrt 0.00000001+3.14159265358979i) 1.25331413931021+1.25331413532079i) +(num-test (sqrt -0.00000001+3.14159265358979i) 1.25331413532079+1.25331413931021i) +(num-test (sqrt 0.00000001-3.14159265358979i) 1.25331413931021-1.25331413532079i) +(num-test (sqrt -0.00000001-3.14159265358979i) 1.25331413532079-1.25331413931021i) +(num-test (sqrt 0.00000001+2.71828182845905i) 1.16582199294297+1.16582198865415i) +(num-test (sqrt -0.00000001+2.71828182845905i) 1.16582198865415+1.16582199294297i) +(num-test (sqrt 0.00000001-2.71828182845905i) 1.16582199294297-1.16582198865415i) +(num-test (sqrt -0.00000001-2.71828182845905i) 1.16582198865415-1.16582199294297i) +(num-test (sqrt 0.00000001+1234.0i) 24.83948469684909+24.83948469664779i) +(num-test (sqrt -0.00000001+1234.0i) 24.83948469664779+24.83948469684909i) +(num-test (sqrt 0.00000001-1234.0i) 24.83948469684909-24.83948469664779i) +(num-test (sqrt -0.00000001-1234.0i) 24.83948469664779-24.83948469684909i) +(num-test (sqrt 0.00000001+1234000000.0i) 24839.48469674844091+24839.48469674844091i) +(num-test (sqrt -0.00000001+1234000000.0i) 24839.48469674844091+24839.48469674844091i) +(num-test (sqrt 0.00000001-1234000000.0i) 24839.48469674844091-24839.48469674844091i) +(num-test (sqrt -0.00000001-1234000000.0i) 24839.48469674844091-24839.48469674844091i) +(num-test (sqrt 1.0+0.0i) 1.0) +(num-test (sqrt -1.0+0.0i) 0.0+1.0i) +(num-test (sqrt 1.0-0.0i) 1.0) +(num-test (sqrt -1.0-0.0i) 0.0+1.0i) +(num-test (sqrt 1.0+0.00000001i) 1.0+0.00000000500000i) +(num-test (sqrt -1.0+0.00000001i) 0.00000000500000+1.0i) +(num-test (sqrt 1.0-0.00000001i) 1.0-0.00000000500000i) +(num-test (sqrt -1.0-0.00000001i) 0.00000000500000-1.0i) +(num-test (sqrt 1.0+1.0i) 1.09868411346781+0.45508986056223i) +(num-test (sqrt -1.0+1.0i) 0.45508986056223+1.09868411346781i) +(num-test (sqrt 1.0-1.0i) 1.09868411346781-0.45508986056223i) +(num-test (sqrt -1.0-1.0i) 0.45508986056223-1.09868411346781i) +(num-test (sqrt 1.0+3.14159265358979i) 1.46576060621706+1.07165953303174i) +(num-test (sqrt -1.0+3.14159265358979i) 1.07165953303174+1.46576060621706i) +(num-test (sqrt 1.0-3.14159265358979i) 1.46576060621706-1.07165953303174i) +(num-test (sqrt -1.0-3.14159265358979i) 1.07165953303174-1.46576060621706i) +(num-test (sqrt 1.0+2.71828182845905i) 1.39577697566445+0.97375220964833i) +(num-test (sqrt -1.0+2.71828182845905i) 0.97375220964833+1.39577697566445i) +(num-test (sqrt 1.0-2.71828182845905i) 1.39577697566445-0.97375220964833i) +(num-test (sqrt -1.0-2.71828182845905i) 0.97375220964833-1.39577697566445i) +(num-test (sqrt 1.0+1234.0i) 24.84955135597340+24.82942211557006i) +(num-test (sqrt -1.0+1234.0i) 24.82942211557006+24.84955135597340i) +(num-test (sqrt 1.0-1234.0i) 24.84955135597340-24.82942211557006i) +(num-test (sqrt -1.0-1234.0i) 24.82942211557006-24.84955135597340i) +(num-test (sqrt 1.0+1234000000.0i) 24839.48470681306208+24839.48468668381975i) +(num-test (sqrt -1.0+1234000000.0i) 24839.48468668381975+24839.48470681306208i) +(num-test (sqrt 1.0-1234000000.0i) 24839.48470681306208-24839.48468668381975i) +(num-test (sqrt -1.0-1234000000.0i) 24839.48468668381975-24839.48470681306208i) +(num-test (sqrt 3.14159265358979+0.0i) 1.77245385090552) +(num-test (sqrt -3.14159265358979+0.0i) 0.0+1.77245385090552i) +(num-test (sqrt 3.14159265358979-0.0i) 1.77245385090552) +(num-test (sqrt -3.14159265358979-0.0i) 0.0+1.77245385090552i) +(num-test (sqrt 3.14159265358979+0.00000001i) 1.77245385090552+0.00000000282095i) +(num-test (sqrt -3.14159265358979+0.00000001i) 0.00000000282095+1.77245385090552i) +(num-test (sqrt 3.14159265358979-0.00000001i) 1.77245385090552-0.00000000282095i) +(num-test (sqrt -3.14159265358979-0.00000001i) 0.00000000282095-1.77245385090552i) +(num-test (sqrt 3.14159265358979+1.0i) 1.79422698718214+0.27867154132224i) +(num-test (sqrt -3.14159265358979+1.0i) 0.27867154132224+1.79422698718214i) +(num-test (sqrt 3.14159265358979-1.0i) 1.79422698718214-0.27867154132224i) +(num-test (sqrt -3.14159265358979-1.0i) 0.27867154132224-1.79422698718214i) +(num-test (sqrt 3.14159265358979+3.14159265358979i) 1.94736688784473+0.80662577586157i) +(num-test (sqrt -3.14159265358979+3.14159265358979i) 0.80662577586157+1.94736688784473i) +(num-test (sqrt 3.14159265358979-3.14159265358979i) 1.94736688784473-0.80662577586157i) +(num-test (sqrt -3.14159265358979-3.14159265358979i) 0.80662577586157-1.94736688784473i) +(num-test (sqrt 3.14159265358979+2.71828182845905i) 1.90996689184696+0.71160443672153i) +(num-test (sqrt -3.14159265358979+2.71828182845905i) 0.71160443672153+1.90996689184696i) +(num-test (sqrt 3.14159265358979-2.71828182845905i) 1.90996689184696-0.71160443672153i) +(num-test (sqrt -3.14159265358979-2.71828182845905i) 0.71160443672153-1.90996689184696i) +(num-test (sqrt 3.14159265358979+1234.0i) 24.87112373493049+24.80788590719961i) +(num-test (sqrt -3.14159265358979+1234.0i) 24.80788590719961+24.87112373493049i) +(num-test (sqrt 3.14159265358979-1234.0i) 24.87112373493049-24.80788590719961i) +(num-test (sqrt -3.14159265358979-1234.0i) 24.80788590719961-24.87112373493049i) +(num-test (sqrt 3.14159265358979+1234000000.0i) 24839.48472836738074+24839.48466512950108i) +(num-test (sqrt -3.14159265358979+1234000000.0i) 24839.48466512950108+24839.48472836738074i) +(num-test (sqrt 3.14159265358979-1234000000.0i) 24839.48472836738074-24839.48466512950108i) +(num-test (sqrt -3.14159265358979-1234000000.0i) 24839.48466512950108-24839.48472836738074i) +(num-test (sqrt 2.71828182845905+0.0i) 1.64872127070013) +(num-test (sqrt -2.71828182845905+0.0i) 0.0+1.64872127070013i) +(num-test (sqrt 2.71828182845905-0.0i) 1.64872127070013) +(num-test (sqrt -2.71828182845905-0.0i) 0.0+1.64872127070013i) +(num-test (sqrt 2.71828182845905+0.00000001i) 1.64872127070013+0.00000000303265i) +(num-test (sqrt -2.71828182845905+0.00000001i) 0.00000000303265+1.64872127070013i) +(num-test (sqrt 2.71828182845905-0.00000001i) 1.64872127070013-0.00000000303265i) +(num-test (sqrt -2.71828182845905-0.00000001i) 0.00000000303265-1.64872127070013i) +(num-test (sqrt 2.71828182845905+1.0i) 1.67551015515410+0.29841657387867i) +(num-test (sqrt -2.71828182845905+1.0i) 0.29841657387867+1.67551015515410i) +(num-test (sqrt 2.71828182845905-1.0i) 1.67551015515410-0.29841657387867i) +(num-test (sqrt -2.71828182845905-1.0i) 0.29841657387867-1.67551015515410i) +(num-test (sqrt 2.71828182845905+3.14159265358979i) 1.85373086379501+0.84737021833856i) +(num-test (sqrt -2.71828182845905+3.14159265358979i) 0.84737021833856+1.85373086379501i) +(num-test (sqrt 2.71828182845905-3.14159265358979i) 1.85373086379501-0.84737021833856i) +(num-test (sqrt -2.71828182845905-3.14159265358979i) 0.84737021833856-1.85373086379501i) +(num-test (sqrt 2.71828182845905+2.71828182845905i) 1.81142386765469+0.75031633318890i) +(num-test (sqrt -2.71828182845905+2.71828182845905i) 0.75031633318890+1.81142386765469i) +(num-test (sqrt 2.71828182845905-2.71828182845905i) 1.81142386765469-0.75031633318890i) +(num-test (sqrt -2.71828182845905-2.71828182845905i) 0.75031633318890-1.81142386765469i) +(num-test (sqrt 2.71828182845905+1234.0i) 24.86685822304219+24.81214130333015i) +(num-test (sqrt -2.71828182845905+1234.0i) 24.81214130333015+24.86685822304219i) +(num-test (sqrt 2.71828182845905-1234.0i) 24.86685822304219-24.81214130333015i) +(num-test (sqrt -2.71828182845905-1234.0i) 24.81214130333015-24.86685822304219i) +(num-test (sqrt 2.71828182845905+1234000000.0i) 24839.48472410691829+24839.48466938996353i) +(num-test (sqrt -2.71828182845905+1234000000.0i) 24839.48466938996353+24839.48472410691829i) +(num-test (sqrt 2.71828182845905-1234000000.0i) 24839.48472410691829-24839.48466938996353i) +(num-test (sqrt -2.71828182845905-1234000000.0i) 24839.48466938996353-24839.48472410691829i) +(num-test (sqrt 1234.0+0.0i) 35.12833614050059) +(num-test (sqrt -1234.0+0.0i) 0.0+35.12833614050059i) +(num-test (sqrt 1234.0-0.0i) 35.12833614050059) +(num-test (sqrt -1234.0-0.0i) 0.0+35.12833614050059i) +(num-test (sqrt 1234.0+0.00000001i) 35.12833614050059+0.00000000014234i) +(num-test (sqrt -1234.0+0.00000001i) 0.00000000014234+35.12833614050059i) +(num-test (sqrt 1234.0-0.00000001i) 35.12833614050059-0.00000000014234i) +(num-test (sqrt -1234.0-0.00000001i) 0.00000000014234-35.12833614050059i) +(num-test (sqrt 1234.0+1.0i) 35.12833902411499+0.01423352238934i) +(num-test (sqrt -1234.0+1.0i) 0.01423352238934+35.12833902411499i) +(num-test (sqrt 1234.0-1.0i) 35.12833902411499-0.01423352238934i) +(num-test (sqrt -1234.0-1.0i) 0.01423352238934-35.12833902411499i) +(num-test (sqrt 1234.0+3.14159265358979i) 35.12836460058208+0.04471589681601i) +(num-test (sqrt -1234.0+3.14159265358979i) 0.04471589681601+35.12836460058208i) +(num-test (sqrt 1234.0-3.14159265358979i) 35.12836460058208-0.04471589681601i) +(num-test (sqrt -1234.0-3.14159265358979i) 0.04471589681601-35.12836460058208i) +(num-test (sqrt 1234.0+2.71828182845905i) 35.12835744766116+0.03869070497402i) +(num-test (sqrt -1234.0+2.71828182845905i) 0.03869070497402+35.12835744766116i) +(num-test (sqrt 1234.0-2.71828182845905i) 35.12835744766116-0.03869070497402i) +(num-test (sqrt -1234.0-2.71828182845905i) 0.03869070497402-35.12835744766116i) +(num-test (sqrt 1234.0+1234.0i) 38.59494485012512+15.98654959596347i) +(num-test (sqrt -1234.0+1234.0i) 15.98654959596347+38.59494485012512i) +(num-test (sqrt 1234.0-1234.0i) 38.59494485012512-15.98654959596347i) +(num-test (sqrt -1234.0-1234.0i) 15.98654959596347-38.59494485012512i) +(num-test (sqrt 1234.0+1234000000.0i) 24839.49711649389428+24839.47227700919757i) +(num-test (sqrt -1234.0+1234000000.0i) 24839.47227700919757+24839.49711649389428i) +(num-test (sqrt 1234.0-1234000000.0i) 24839.49711649389428-24839.47227700919757i) +(num-test (sqrt -1234.0-1234000000.0i) 24839.47227700919757-24839.49711649389428i) +(num-test (sqrt 1234000000.0+0.0i) 35128.33614050059259) +(num-test (sqrt -1234000000.0+0.0i) 0.0+35128.33614050059259i) +(num-test (sqrt 1234000000.0-0.0i) 35128.33614050059259) +(num-test (sqrt -1234000000.0-0.0i) 0.0+35128.33614050059259i) +(num-test (sqrt 1234000000.0+0.00000001i) 35128.33614050059259+0.00000000000014i) +(num-test (sqrt -1234000000.0+0.00000001i) 0.00000000000014+35128.33614050059259i) +(num-test (sqrt 1234000000.0-0.00000001i) 35128.33614050059259-0.00000000000014i) +(num-test (sqrt -1234000000.0-0.00000001i) 0.00000000000014-35128.33614050059259i) +(num-test (sqrt 1234000000.0+1.0i) 35128.33614050059259+0.00001423352356i) +(num-test (sqrt -1234000000.0+1.0i) 0.00001423352356+35128.33614050059259i) +(num-test (sqrt 1234000000.0-1.0i) 35128.33614050059259-0.00001423352356i) +(num-test (sqrt -1234000000.0-1.0i) 0.00001423352356-35128.33614050059259i) +(num-test (sqrt 1234000000.0+3.14159265358979i) 35128.33614050059259+0.00004471593304i) +(num-test (sqrt -1234000000.0+3.14159265358979i) 0.00004471593304+35128.33614050059259i) +(num-test (sqrt 1234000000.0-3.14159265358979i) 35128.33614050059259-0.00004471593304i) +(num-test (sqrt -1234000000.0-3.14159265358979i) 0.00004471593304-35128.33614050059259i) +(num-test (sqrt 1234000000.0+2.71828182845905i) 35128.33614050059259+0.00003869072844i) +(num-test (sqrt -1234000000.0+2.71828182845905i) 0.00003869072844+35128.33614050059259i) +(num-test (sqrt 1234000000.0-2.71828182845905i) 35128.33614050059259-0.00003869072844i) +(num-test (sqrt -1234000000.0-2.71828182845905i) 0.00003869072844-35128.33614050059259i) +(num-test (sqrt 1234000000.0+1234.0i) 35128.33614050497999+0.01756416807025i) +(num-test (sqrt -1234000000.0+1234.0i) 0.01756416807025+35128.33614050497999i) +(num-test (sqrt 1234000000.0-1234.0i) 35128.33614050497999-0.01756416807025i) +(num-test (sqrt -1234000000.0-1234.0i) 0.01756416807025-35128.33614050497999i) +(num-test (sqrt 1234000000.0+1234000000.0i) 38594.94485012512450+15986.54959596346634i) +(num-test (sqrt -1234000000.0+1234000000.0i) 15986.54959596346634+38594.94485012512450i) +(num-test (sqrt 1234000000.0-1234000000.0i) 38594.94485012512450-15986.54959596346634i) +(num-test (sqrt -1234000000.0-1234000000.0i) 15986.54959596346634-38594.94485012512450i) +(num-test (sqrt 2.2250739e-308) 1.4916681e-154) +(num-test (sqrt 1.7976931e+308) 1.3407808e+154) +(num-test (sqrt 0.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (sqrt 0.0e+00+1.19209289550781250e-07i) 2.44140625e-4+2.44140625e-4i) +(num-test (sqrt 0.0e+00-1.19209289550781250e-07i) 2.44140625e-4-2.44140625e-4i) +(num-test (sqrt 0.0e+00+5.0e-01i) 5e-1+5e-1i) +(num-test (sqrt 0.0e+00-5.0e-01i) 5e-1-5e-1i) +(num-test (sqrt 0.0e+00+1.0e+00i) 7.0710678118654752440e-1+7.0710678118654752440e-1i) +(num-test (sqrt 0.0e+00-1.0e+00i) 7.0710678118654752440e-1-7.0710678118654752440e-1i) +(num-test (sqrt 0.0e+00+2.0e+00i) 1+1i) +(num-test (sqrt 0.0e+00-2.0e+00i) 1-1i) +(num-test (sqrt 0.0e+00+8.3886080e+06i) 2048+2048i) +(num-test (sqrt 0.0e+00-8.3886080e+06i) 2048-2048i) +(num-test (sqrt 1.19209289550781250e-07+0.0e+00i) 3.4526698300124390840e-4+0.0i) +(num-test (sqrt -1.19209289550781250e-07+0.0e+00i) 0+3.4526698300124390840e-4i) +(num-test (sqrt 1.19209289550781250e-07+1.19209289550781250e-07i) 3.7933934912842707699e-4+1.5712750315077700799e-4i) +(num-test (sqrt 1.19209289550781250e-07-1.19209289550781250e-07i) 3.7933934912842707699e-4-1.5712750315077700799e-4i) +(num-test (sqrt -1.19209289550781250e-07+1.19209289550781250e-07i) 1.5712750315077700799e-4+3.7933934912842707699e-4i) +(num-test (sqrt -1.19209289550781250e-07-1.19209289550781250e-07i) 1.5712750315077700799e-4-3.7933934912842707699e-4i) +(num-test (sqrt 1.19209289550781250e-07+5.0e-01i) 5.0000005960464832810e-1+4.9999994039535877732e-1i) +(num-test (sqrt 1.19209289550781250e-07-5.0e-01i) 5.0000005960464832810e-1-4.9999994039535877732e-1i) +(num-test (sqrt -1.19209289550781250e-07+5.0e-01i) 4.9999994039535877732e-1+5.0000005960464832810e-1i) +(num-test (sqrt -1.19209289550781250e-07-5.0e-01i) 4.9999994039535877732e-1-5.0000005960464832810e-1i) +(num-test (sqrt 1.19209289550781250e-07+1.0e+00i) 7.0710682333339729137e-1+7.0710673903970026958e-1i) +(num-test (sqrt 1.19209289550781250e-07-1.0e+00i) 7.0710682333339729137e-1-7.0710673903970026958e-1i) +(num-test (sqrt -1.19209289550781250e-07+1.0e+00i) 7.0710673903970026958e-1+7.0710682333339729137e-1i) +(num-test (sqrt -1.19209289550781250e-07-1.0e+00i) 7.0710673903970026958e-1-7.0710682333339729137e-1i) +(num-test (sqrt 1.19209289550781250e-07+2.0e+00i) 1.0000000298023228318e0+9.9999997019767805639e-1i) +(num-test (sqrt 1.19209289550781250e-07-2.0e+00i) 1.0000000298023228318e0-9.9999997019767805639e-1i) +(num-test (sqrt -1.19209289550781250e-07+2.0e+00i) 9.9999997019767805639e-1+1.0000000298023228318e0i) +(num-test (sqrt -1.19209289550781250e-07-2.0e+00i) 9.9999997019767805639e-1-1.0000000298023228318e0i) +(num-test (sqrt 1.19209289550781250e-07+8.3886080e+06i) 2.0480000000000145519e3+2.0479999999999854481e3i) +(num-test (sqrt 1.19209289550781250e-07-8.3886080e+06i) 2.0480000000000145519e3-2.0479999999999854481e3i) +(num-test (sqrt -1.19209289550781250e-07+8.3886080e+06i) 2.0479999999999854481e3+2.0480000000000145519e3i) +(num-test (sqrt -1.19209289550781250e-07-8.3886080e+06i) 2.0479999999999854481e3-2.0480000000000145519e3i) +(num-test (sqrt 5.0e-01+0.0e+00i) 7.0710678118654752440e-1+0.0i) +(num-test (sqrt -5.0e-01+0.0e+00i) 0+7.0710678118654752440e-1i) +(num-test (sqrt 5.0e-01+1.19209289550781250e-07i) 7.0710678118655254870e-1+8.4293697021787464631e-8i) +(num-test (sqrt 5.0e-01-1.19209289550781250e-07i) 7.0710678118655254870e-1-8.4293697021787464631e-8i) +(num-test (sqrt -5.0e-01+1.19209289550781250e-07i) 8.4293697021787464631e-8+7.0710678118655254870e-1i) +(num-test (sqrt -5.0e-01-1.19209289550781250e-07i) 8.4293697021787464631e-8-7.0710678118655254870e-1i) +(num-test (sqrt 5.0e-01+5.0e-01i) 7.7688698701501865367e-1+3.2179712645279131237e-1i) +(num-test (sqrt 5.0e-01-5.0e-01i) 7.7688698701501865367e-1-3.2179712645279131237e-1i) +(num-test (sqrt -5.0e-01+5.0e-01i) 3.2179712645279131237e-1+7.7688698701501865367e-1i) +(num-test (sqrt -5.0e-01-5.0e-01i) 3.2179712645279131237e-1-7.7688698701501865367e-1i) +(num-test (sqrt 5.0e-01+1.0e+00i) 8.9945371997393363613e-1+5.5589297025142117199e-1i) +(num-test (sqrt 5.0e-01-1.0e+00i) 8.9945371997393363613e-1-5.5589297025142117199e-1i) +(num-test (sqrt -5.0e-01+1.0e+00i) 5.5589297025142117199e-1+8.9945371997393363613e-1i) +(num-test (sqrt -5.0e-01-1.0e+00i) 5.5589297025142117199e-1-8.9945371997393363613e-1i) +(num-test (sqrt 5.0e-01+2.0e+00i) 1.1317139242778694103e0+8.8361553087551326576e-1i) +(num-test (sqrt 5.0e-01-2.0e+00i) 1.1317139242778694103e0-8.8361553087551326576e-1i) +(num-test (sqrt -5.0e-01+2.0e+00i) 8.8361553087551326576e-1+1.1317139242778694103e0i) +(num-test (sqrt -5.0e-01-2.0e+00i) 8.8361553087551326576e-1-1.1317139242778694103e0i) +(num-test (sqrt 5.0e-01+8.3886080e+06i) 2.0480000610351571595e3+2.0479999389648446595e3i) +(num-test (sqrt 5.0e-01-8.3886080e+06i) 2.0480000610351571595e3-2.0479999389648446595e3i) +(num-test (sqrt -5.0e-01+8.3886080e+06i) 2.0479999389648446595e3+2.0480000610351571595e3i) +(num-test (sqrt -5.0e-01-8.3886080e+06i) 2.0479999389648446595e3-2.0480000610351571595e3i) +(num-test (sqrt 1.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (sqrt -1.0e+00+0.0e+00i) 0+1i) +(num-test (sqrt 1.0e+00+1.19209289550781250e-07i) 1.0000000000000017764e0+5.9604644775390519121e-8i) +(num-test (sqrt 1.0e+00-1.19209289550781250e-07i) 1.0000000000000017764e0-5.9604644775390519121e-8i) +(num-test (sqrt -1.0e+00+1.19209289550781250e-07i) 5.9604644775390519121e-8+1.0000000000000017764e0i) +(num-test (sqrt -1.0e+00-1.19209289550781250e-07i) 5.9604644775390519121e-8-1.0000000000000017764e0i) +(num-test (sqrt 1.0e+00+5.0e-01i) 1.0290855136357461252e0+2.4293413587832283909e-1i) +(num-test (sqrt 1.0e+00-5.0e-01i) 1.0290855136357461252e0-2.4293413587832283909e-1i) +(num-test (sqrt -1.0e+00+5.0e-01i) 2.4293413587832283909e-1+1.0290855136357461252e0i) +(num-test (sqrt -1.0e+00-5.0e-01i) 2.4293413587832283909e-1-1.0290855136357461252e0i) +(num-test (sqrt 1.0e+00+1.0e+00i) 1.0986841134678099660e0+4.5508986056222734130e-1i) +(num-test (sqrt 1.0e+00-1.0e+00i) 1.0986841134678099660e0-4.5508986056222734130e-1i) +(num-test (sqrt -1.0e+00+1.0e+00i) 4.5508986056222734130e-1+1.0986841134678099660e0i) +(num-test (sqrt -1.0e+00-1.0e+00i) 4.5508986056222734130e-1-1.0986841134678099660e0i) +(num-test (sqrt 1.0e+00+2.0e+00i) 1.2720196495140689643e0+7.8615137775742328607e-1i) +(num-test (sqrt 1.0e+00-2.0e+00i) 1.2720196495140689643e0-7.8615137775742328607e-1i) +(num-test (sqrt -1.0e+00+2.0e+00i) 7.8615137775742328607e-1+1.2720196495140689643e0i) +(num-test (sqrt -1.0e+00-2.0e+00i) 7.8615137775742328607e-1-1.2720196495140689643e0i) +(num-test (sqrt 1.0e+00+8.3886080e+06i) 2.0480001220703161380e3+2.0479998779296911380e3i) +(num-test (sqrt 1.0e+00-8.3886080e+06i) 2.0480001220703161380e3-2.0479998779296911380e3i) +(num-test (sqrt -1.0e+00+8.3886080e+06i) 2.0479998779296911380e3+2.0480001220703161380e3i) +(num-test (sqrt -1.0e+00-8.3886080e+06i) 2.0479998779296911380e3-2.0480001220703161380e3i) +(num-test (sqrt 2.0e+00+0.0e+00i) 1.4142135623730950488e0+0.0i) +(num-test (sqrt -2.0e+00+0.0e+00i) 0+1.4142135623730950488e0i) +(num-test (sqrt 2.0e+00+1.19209289550781250e-07i) 1.4142135623730956768e0+4.2146848510894013070e-8i) +(num-test (sqrt 2.0e+00-1.19209289550781250e-07i) 1.4142135623730956768e0-4.2146848510894013070e-8i) +(num-test (sqrt -2.0e+00+1.19209289550781250e-07i) 4.2146848510894013070e-8+1.4142135623730956768e0i) +(num-test (sqrt -2.0e+00-1.19209289550781250e-07i) 4.2146848510894013070e-8-1.4142135623730956768e0i) +(num-test (sqrt 2.0e+00+5.0e-01i) 1.4250531240639470060e0+1.7543205637629383228e-1i) +(num-test (sqrt 2.0e+00-5.0e-01i) 1.4250531240639470060e0-1.7543205637629383228e-1i) +(num-test (sqrt -2.0e+00+5.0e-01i) 1.7543205637629383228e-1+1.4250531240639470060e0i) +(num-test (sqrt -2.0e+00-5.0e-01i) 1.7543205637629383228e-1-1.4250531240639470060e0i) +(num-test (sqrt 2.0e+00+1.0e+00i) 1.4553466902253548081e0+3.4356074972251246414e-1i) +(num-test (sqrt 2.0e+00-1.0e+00i) 1.4553466902253548081e0-3.4356074972251246414e-1i) +(num-test (sqrt -2.0e+00+1.0e+00i) 3.4356074972251246414e-1+1.4553466902253548081e0i) +(num-test (sqrt -2.0e+00-1.0e+00i) 3.4356074972251246414e-1-1.4553466902253548081e0i) +(num-test (sqrt 2.0e+00+2.0e+00i) 1.5537739740300373073e0+6.4359425290558262474e-1i) +(num-test (sqrt 2.0e+00-2.0e+00i) 1.5537739740300373073e0-6.4359425290558262474e-1i) +(num-test (sqrt -2.0e+00+2.0e+00i) 6.4359425290558262474e-1+1.5537739740300373073e0i) +(num-test (sqrt -2.0e+00-2.0e+00i) 6.4359425290558262474e-1-1.5537739740300373073e0i) +(num-test (sqrt 2.0e+00+8.3886080e+06i) 2.0480002441406395519e3+2.0479997558593895519e3i) +(num-test (sqrt 2.0e+00-8.3886080e+06i) 2.0480002441406395519e3-2.0479997558593895519e3i) +(num-test (sqrt -2.0e+00+8.3886080e+06i) 2.0479997558593895519e3+2.0480002441406395519e3i) +(num-test (sqrt -2.0e+00-8.3886080e+06i) 2.0479997558593895519e3-2.0480002441406395519e3i) +(num-test (sqrt 8.3886080e+06+0.0e+00i) 2.8963093757400986599e3+0.0i) +(num-test (sqrt -8.3886080e+06+0.0e+00i) 0+2.8963093757400986599e3i) +(num-test (sqrt 8.3886080e+06+1.19209289550781250e-07i) 2.8963093757400986599e3+2.0579515874459976458e-11i) +(num-test (sqrt 8.3886080e+06-1.19209289550781250e-07i) 2.8963093757400986599e3-2.0579515874459976458e-11i) +(num-test (sqrt -8.3886080e+06+1.19209289550781250e-07i) 2.0579515874459976458e-11+2.8963093757400986599e3i) +(num-test (sqrt -8.3886080e+06-1.19209289550781250e-07i) 2.0579515874459976458e-11-2.8963093757400986599e3i) +(num-test (sqrt 8.3886080e+06+5.0e-01i) 2.8963093757400999462e3+8.6316745750310938767e-5i) +(num-test (sqrt 8.3886080e+06-5.0e-01i) 2.8963093757400999462e3-8.6316745750310938767e-5i) +(num-test (sqrt -8.3886080e+06+5.0e-01i) 8.6316745750310938767e-5+2.8963093757400999462e3i) +(num-test (sqrt -8.3886080e+06-5.0e-01i) 8.6316745750310938767e-5-2.8963093757400999462e3i) +(num-test (sqrt 8.3886080e+06+1.0e+00i) 2.8963093757401038048e3+1.7263349150062164754e-4i) +(num-test (sqrt 8.3886080e+06-1.0e+00i) 2.8963093757401038048e3-1.7263349150062164754e-4i) +(num-test (sqrt -8.3886080e+06+1.0e+00i) 1.7263349150062164754e-4+2.8963093757401038048e3i) +(num-test (sqrt -8.3886080e+06-1.0e+00i) 1.7263349150062164754e-4-2.8963093757401038048e3i) +(num-test (sqrt 8.3886080e+06+2.0e+00i) 2.8963093757401192395e3+3.4526698300124145513e-4i) +(num-test (sqrt 8.3886080e+06-2.0e+00i) 2.8963093757401192395e3-3.4526698300124145513e-4i) +(num-test (sqrt -8.3886080e+06+2.0e+00i) 3.4526698300124145513e-4+2.8963093757401192395e3i) +(num-test (sqrt -8.3886080e+06-2.0e+00i) 3.4526698300124145513e-4-2.8963093757401192395e3i) +(num-test (sqrt 8.3886080e+06+8.3886080e+06i) 3.1821290988135164054e3+1.3180810299506332155e3i) +(num-test (sqrt 8.3886080e+06-8.3886080e+06i) 3.1821290988135164054e3-1.3180810299506332155e3i) +(num-test (sqrt -8.3886080e+06+8.3886080e+06i) 1.3180810299506332155e3+3.1821290988135164054e3i) +(num-test (sqrt -8.3886080e+06-8.3886080e+06i) 1.3180810299506332155e3-3.1821290988135164054e3i) +(num-test (sqrt -1.0e+01) 0+3.1622776601683793320e0i) +(num-test (sqrt -2.0e+00) 0+1.4142135623730950488e0i) +(num-test (sqrt -1.0e+00) 0+1i) +(num-test (sqrt -7.50e-01) 0+8.6602540378443864676e-1i) +(num-test (sqrt -5.0e-01) 0+7.0710678118654752440e-1i) +(num-test (sqrt -1.250e-01) 0+3.5355339059327376220e-1i) +(num-test (sqrt -3.45266983001243932001e-04) 0+1.8581361171917517303e-2i) +(num-test (sqrt -1.19209289550781250e-07) 0+3.4526698300124390840e-4i) +(num-test (sqrt 0.0e+00) 0e0+0.0i) +(num-test (sqrt 1.19209289550781250e-07) 3.4526698300124390840e-4+0.0i) +(num-test (sqrt 3.45266983001243932001e-04) 1.8581361171917517303e-2+0.0i) +(num-test (sqrt 1.250e-01) 3.5355339059327376220e-1+0.0i) +(num-test (sqrt 5.0e-01) 7.0710678118654752440e-1+0.0i) +(num-test (sqrt 7.50e-01) 8.6602540378443864676e-1+0.0i) +(num-test (sqrt 1.0e+00) 1e0+0.0i) +(num-test (sqrt 2.0e+00) 1.4142135623730950488e0+0.0i) +(num-test (sqrt 1.0e+01) 3.1622776601683793320e0+0.0i) +(num-test (sqrt 9) 3) +(num-test (sqrt -9.0) 0.0+3.0i) +(num-test (sqrt (sqrt (sqrt 256))) 2) +(num-test (sqrt (sqrt (sqrt 1/256))) 1/2) + +(if (and (integer? (sqrt 4)) + (exact? (sqrt 4))) + (begin + (for-each + (lambda (n sqn) + (if (positive? n) ; in case 32 bit int + (let ((val (sqrt n))) + (if (or (not (integer? val)) + (not (eqv? sqn val))) + (begin + (display "(sqrt ") (display n) (display ") expected ") + (display sqn) (display " but got ") (display val) (newline)))))) + (list 9 491401 19439281 1248844921 235565593201) + (list 3 701 4409 35339 485351)) + + (for-each + (lambda (n) + (if (positive? n) + (let ((val (sqrt n))) + (if (or (integer? val) + (> (abs (- (* val val) n)) .001)) + (begin + (display "(sqrt ") (display n) (display ") expected ") + (display (sqrt (exact->inexact n))) (display " but got ") (display val) (newline)))))) + (list 10 491400 19439282 1248844920 235565593200)) + + (test (eqv? (expt 2 3) 8) #t) + ;(test (eqv? (log 8 2) 3) #t) ; optimization in C (-O2) changes this + (num-test (log 8 2) 3) + (num-test (log 1/8 2) -3) + (test (eqv? (expt 701 2) 491401) #t) + (test (eqv? (log 491401 701) 2) #t) + )) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x -10.0 (+ x .1))) + ((= i 200)) + (let ((y (magnitude (- x (* (sqrt x) (sqrt x)))))) + (if (> y err) (set! err y)))) + (if (> err 1e-14) + (begin (display "(sqr (sqrt ...)) error: ") (display err) (newline)))) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x -10.0+i (+ x .1+i))) + ((= i 200)) + (let ((y (magnitude (- x (* (sqrt x) (sqrt x)))))) + (if (> y err) (set! err y)))) + (if (> err 1e-12) + (begin (display "(sqr (sqrt [complex] ...)) error: ") (display err) (newline)))) + + + +;; -------- exp +(num-test (exp 0) 1.0) +(num-test (exp 1) 2.71828182845905) +(num-test (exp -1) 0.36787944117144) +(num-test (exp 2) 7.38905609893065) +(num-test (exp -2) 0.13533528323661) +(num-test (exp 3) 20.08553692318767) +(num-test (exp -3) 0.04978706836786) +(num-test (exp 10) 22026.46579480671789) +(num-test (exp -10) 0.00004539992976) +(num-test (exp 0/1) 1.0) +(num-test (exp 0/2) 1.0) +(num-test (exp 0/3) 1.0) +(num-test (exp 0/10) 1.0) +(num-test (exp 0/1234) 1.0) +(num-test (exp 0/1234000000) 1.0) +(num-test (exp 0/500029) 1.0) +(num-test (exp 0/362880) 1.0) +(num-test (exp 1/1) 2.71828182845905) +(num-test (exp -1/1) 0.36787944117144) +(num-test (exp 1/2) 1.64872127070013) +(num-test (exp -1/2) 0.60653065971263) +(num-test (exp 1/3) 1.39561242508609) +(num-test (exp -1/3) 0.71653131057379) +(num-test (exp 1/10) 1.10517091807565) +(num-test (exp -1/10) 0.90483741803596) +(num-test (exp 1/1234) 1.00081070121220) +(num-test (exp -1/1234) 0.99918995549186) +(num-test (exp 1/1234000000) 1.00000000081037) +(num-test (exp -1/1234000000) 0.99999999918963) +(num-test (exp 1/500029) 1.00000199988601) +(num-test (exp -1/500029) 0.99999800011799) +(num-test (exp 1/362880) 1.00000275573572) +(num-test (exp -1/362880) 0.99999724427187) +(num-test (exp 2/1) 7.38905609893065) +(num-test (exp -2/1) 0.13533528323661) +(num-test (exp 2/2) 2.71828182845905) +(num-test (exp -2/2) 0.36787944117144) +(num-test (exp 2/3) 1.94773404105468) +(num-test (exp -2/3) 0.51341711903259) +(num-test (exp 2/10) 1.22140275816017) +(num-test (exp -2/10) 0.81873075307798) +(num-test (exp 2/1234) 1.00162205966086) +(num-test (exp -2/1234) 0.99838056715583) +(num-test (exp 2/1234000000) 1.00000000162075) +(num-test (exp -2/1234000000) 0.99999999837925) +(num-test (exp 2/500029) 1.00000399977601) +(num-test (exp -2/500029) 0.99999600023999) +(num-test (exp 2/362880) 1.00000551147903) +(num-test (exp -2/362880) 0.99999448855134) +(num-test (exp 3/1) 20.08553692318767) +(num-test (exp -3/1) 0.04978706836786) +(num-test (exp 3/2) 4.48168907033806) +(num-test (exp -3/2) 0.22313016014843) +(num-test (exp 3/3) 2.71828182845905) +(num-test (exp -3/3) 0.36787944117144) +(num-test (exp 3/10) 1.34985880757600) +(num-test (exp -3/10) 0.74081822068172) +(num-test (exp 3/1234) 1.00243407587880) +(num-test (exp -3/1234) 0.99757183446037) +(num-test (exp 3/1234000000) 1.00000000243112) +(num-test (exp -3/1234000000) 0.99999999756888) +(num-test (exp 3/500029) 1.00000599967002) +(num-test (exp -3/500029) 0.99999400036598) +(num-test (exp 3/362880) 1.00000826722994) +(num-test (exp -3/362880) 0.99999173283841) +(num-test (exp 10/1) 22026.46579480671789) +(num-test (exp -10/1) 0.00004539992976) +(num-test (exp 10/2) 148.41315910257660) +(num-test (exp -10/2) 0.00673794699909) +(num-test (exp 10/3) 28.03162489452614) +(num-test (exp -10/3) 0.03567399334725) +(num-test (exp 10/10) 2.71828182845905) +(num-test (exp -10/10) 0.36787944117144) +(num-test (exp 10/1234) 1.00813665179201) +(num-test (exp -10/1234) 0.99192901897025) +(num-test (exp 10/1234000000) 1.00000000810373) +(num-test (exp -10/1234000000) 0.99999999189627) +(num-test (exp 10/500029) 1.00001999904005) +(num-test (exp -10/500029) 0.99998000135991) +(num-test (exp 10/362880) 1.00002755769893) +(num-test (exp -10/362880) 0.99997244306048) +(num-test (exp 1234/1234) 2.71828182845905) +(num-test (exp -1234/1234) 0.36787944117144) +(num-test (exp 1234/1234000000) 1.00000100000050) +(num-test (exp -1234/1234000000) 0.99999900000050) +(num-test (exp 1234/500029) 1.00247090452960) +(num-test (exp -1234/500029) 0.99753518579099) +(num-test (exp 1234/362880) 1.00340636170081) +(num-test (exp -1234/362880) 0.99660520220837) +(num-test (exp 1234000000/1234000000) 2.71828182845905) +(num-test (exp -1234000000/1234000000) 0.36787944117144) +(num-test (exp 500029/1234000000) 1.00040529199516) +(num-test (exp -500029/1234000000) 0.99959487219989) +(num-test (exp 500029/500029) 2.71828182845905) +(num-test (exp -500029/500029) 0.36787944117144) +(num-test (exp 500029/362880) 3.96674507247837) +(num-test (exp -500029/362880) 0.25209585736630) +(num-test (exp 362880/1234000000) 1.00029411131357) +(num-test (exp -362880/1234000000) 0.99970597516246) +(num-test (exp 362880/500029) 2.06621391988774) +(num-test (exp -362880/500029) 0.48397699307646) +(num-test (exp 362880/362880) 2.71828182845905) +(num-test (exp -362880/362880) 0.36787944117144) +(num-test (exp 0.0) 1.0) +(num-test (exp 0.00000001) 1.00000001) +(num-test (exp -0.00000001) 0.99999999000000) +(num-test (exp 1.0) 2.71828182845905) +(num-test (exp -1.0) 0.36787944117144) +(num-test (exp our-pi) 23.14069263277927) +(num-test (exp -3.14159265358979) 0.04321391826377) +(num-test (exp 2.71828182845905) 15.15426224147926) +(num-test (exp -2.71828182845905) 0.06598803584531) +(num-test (exp 0.0+0.0i) 1.0) +(num-test (exp -0.0+0.0i) 1.0) +(num-test (exp 0.0-0.0i) 1.0) +(num-test (exp -0.0-0.0i) 1.0) +(num-test (exp 0.0+0.00000001i) 1.0+0.00000001i) +(num-test (exp -0.0+0.00000001i) 1.0+0.00000001i) +(num-test (exp 0.0-0.00000001i) 1.0-0.00000001i) +(num-test (exp -0.0-0.00000001i) 1.0-0.00000001i) +(num-test (exp 0.0+1.0i) 0.54030230586814+0.84147098480790i) +(num-test (exp -0.0+1.0i) 0.54030230586814+0.84147098480790i) +(num-test (exp 0.0-1.0i) 0.54030230586814-0.84147098480790i) +(num-test (exp -0.0-1.0i) 0.54030230586814-0.84147098480790i) +(num-test (exp 0.0+3.14159265358979i) -1.0+0.0i) +(num-test (exp -0.0+3.14159265358979i) -1.0+0.0i) +(num-test (exp 0.0-3.14159265358979i) -1.0-0.0i) +(num-test (exp -0.0-3.14159265358979i) -1.0-0.0i) +(num-test (exp 0.0+2.71828182845905i) -0.91173391478697+0.41078129050291i) +(num-test (exp -0.0+2.71828182845905i) -0.91173391478697+0.41078129050291i) +(num-test (exp 0.0-2.71828182845905i) -0.91173391478697-0.41078129050291i) +(num-test (exp -0.0-2.71828182845905i) -0.91173391478697-0.41078129050291i) +(num-test (exp 0.00000001+0.0i) 1.00000001) +(num-test (exp -0.00000001+0.0i) 0.99999999000000) +(num-test (exp 0.00000001-0.0i) 1.00000001) +(num-test (exp -0.00000001-0.0i) 0.99999999000000) +(num-test (exp 0.00000001+0.00000001i) 1.00000001+0.00000001i) +(num-test (exp -0.00000001+0.00000001i) 0.99999999000000+0.00000001i) +(num-test (exp 0.00000001-0.00000001i) 1.00000001-0.00000001i) +(num-test (exp -0.00000001-0.00000001i) 0.99999999000000-0.00000001i) +(num-test (exp 0.00000001+1.0i) 0.54030231127116+0.84147099322261i) +(num-test (exp -0.00000001+1.0i) 0.54030230046512+0.84147097639319i) +(num-test (exp 0.00000001-1.0i) 0.54030231127116-0.84147099322261i) +(num-test (exp -0.00000001-1.0i) 0.54030230046512-0.84147097639319i) +(num-test (exp 0.00000001+3.14159265358979i) -1.00000001+0.0i) +(num-test (exp -0.00000001+3.14159265358979i) -0.99999999000000+0.0i) +(num-test (exp 0.00000001-3.14159265358979i) -1.00000001-0.0i) +(num-test (exp -0.00000001-3.14159265358979i) -0.99999999000000-0.0i) +(num-test (exp 0.00000001+2.71828182845905i) -0.91173392390430+0.41078129461072i) +(num-test (exp -0.00000001+2.71828182845905i) -0.91173390566963+0.41078128639510i) +(num-test (exp 0.00000001-2.71828182845905i) -0.91173392390430-0.41078129461072i) +(num-test (exp -0.00000001-2.71828182845905i) -0.91173390566963-0.41078128639510i) +(num-test (exp 1.0+0.0i) 2.71828182845905) +(num-test (exp -1.0+0.0i) 0.36787944117144) +(num-test (exp 1.0-0.0i) 2.71828182845905) +(num-test (exp -1.0-0.0i) 0.36787944117144) +(num-test (exp 1.0+0.00000001i) 2.71828182845905+0.00000002718282i) +(num-test (exp -1.0+0.00000001i) 0.36787944117144+0.00000000367879i) +(num-test (exp 1.0-0.00000001i) 2.71828182845905-0.00000002718282i) +(num-test (exp -1.0-0.00000001i) 0.36787944117144-0.00000000367879i) +(num-test (exp 1.0+1.0i) 1.46869393991589+2.28735528717884i) +(num-test (exp -1.0+1.0i) 0.19876611034641+0.30955987565311i) +(num-test (exp 1.0-1.0i) 1.46869393991589-2.28735528717884i) +(num-test (exp -1.0-1.0i) 0.19876611034641-0.30955987565311i) +(num-test (exp 1.0+3.14159265358979i) -2.71828182845905+0.0i) +(num-test (exp -1.0+3.14159265358979i) -0.36787944117144+0.0i) +(num-test (exp 1.0-3.14159265358979i) -2.71828182845905-0.0i) +(num-test (exp -1.0-3.14159265358979i) -0.36787944117144-0.0i) +(num-test (exp 1.0+2.71828182845905i) -2.47834973295523+1.11661931744501i) +(num-test (exp -1.0+2.71828182845905i) -0.33540816306888+0.15111799159389i) +(num-test (exp 1.0-2.71828182845905i) -2.47834973295523-1.11661931744501i) +(num-test (exp -1.0-2.71828182845905i) -0.33540816306888-0.15111799159389i) +(num-test (exp 3.14159265358979+0.0i) 23.14069263277927) +(num-test (exp -3.14159265358979+0.0i) 0.04321391826377) +(num-test (exp 3.14159265358979-0.0i) 23.14069263277927) +(num-test (exp -3.14159265358979-0.0i) 0.04321391826377) +(num-test (exp 3.14159265358979+0.00000001i) 23.14069263277926+0.00000023140693i) +(num-test (exp -3.14159265358979+0.00000001i) 0.04321391826377+0.00000000043214i) +(num-test (exp 3.14159265358979-0.00000001i) 23.14069263277926-0.00000023140693i) +(num-test (exp -3.14159265358979-0.00000001i) 0.04321391826377-0.00000000043214i) +(num-test (exp 3.14159265358979+1.0i) 12.50296958887651+19.47222141884161i) +(num-test (exp -3.14159265358979+1.0i) 0.02334857968351+0.03636325835882i) +(num-test (exp 3.14159265358979-1.0i) 12.50296958887651-19.47222141884161i) +(num-test (exp -3.14159265358979-1.0i) 0.02334857968351-0.03636325835882i) +(num-test (exp 3.14159265358979+3.14159265358979i) -23.14069263277927+0.0i) +(num-test (exp -3.14159265358979+3.14159265358979i) -0.04321391826377+0.0i) +(num-test (exp 3.14159265358979-3.14159265358979i) -23.14069263277927-0.0i) +(num-test (exp -3.14159265358979-3.14159265358979i) -0.04321391826377-0.0i) +(num-test (exp 3.14159265358979+2.71828182845905i) -21.09815428496572+9.50576358282422i) +(num-test (exp -3.14159265358979+2.71828182845905i) -0.03939959487191+0.01775146911208i) +(num-test (exp 3.14159265358979-2.71828182845905i) -21.09815428496572-9.50576358282422i) +(num-test (exp -3.14159265358979-2.71828182845905i) -0.03939959487191-0.01775146911208i) +(num-test (exp 2.71828182845905+0.0i) 15.15426224147926) +(num-test (exp -2.71828182845905+0.0i) 0.06598803584531) +(num-test (exp 2.71828182845905-0.0i) 15.15426224147926) +(num-test (exp -2.71828182845905-0.0i) 0.06598803584531) +(num-test (exp 2.71828182845905+0.00000001i) 15.15426224147926+0.00000015154262i) +(num-test (exp -2.71828182845905+0.00000001i) 0.06598803584531+0.00000000065988i) +(num-test (exp 2.71828182845905-0.00000001i) 15.15426224147926-0.00000015154262i) +(num-test (exp -2.71828182845905-0.00000001i) 0.06598803584531-0.00000000065988i) +(num-test (exp 2.71828182845905+1.0i) 8.18788283280173+12.75187197237468i) +(num-test (exp -2.71828182845905+1.0i) 0.03565348792693+0.05552701750829i) +(num-test (exp 2.71828182845905-1.0i) 8.18788283280173-12.75187197237468i) +(num-test (exp -2.71828182845905-1.0i) 0.03565348792693-0.05552701750829i) +(num-test (exp 2.71828182845905+3.14159265358979i) -15.15426224147926+0.0i) +(num-test (exp -2.71828182845905+3.14159265358979i) -0.06598803584531+0.0i) +(num-test (exp 2.71828182845905-3.14159265358979i) -15.15426224147926-0.0i) +(num-test (exp -2.71828182845905-3.14159265358979i) -0.06598803584531-0.0i) +(num-test (exp 2.71828182845905+2.71828182845905i) -13.81665483913218+6.22508740017436i) +(num-test (exp -2.71828182845905+2.71828182845905i) -0.06016353025035+0.02710665052229i) +(num-test (exp 2.71828182845905-2.71828182845905i) -13.81665483913218-6.22508740017436i) +(num-test (exp -2.71828182845905-2.71828182845905i) -0.06016353025035-0.02710665052229i) +(num-test (exp -1234.0+0.0i) 0.0) +(num-test (exp -1234.0-0.0i) 0.0) +(num-test (exp -1234.0+0.00000001i) 0.0) +(num-test (exp -1234.0-0.00000001i) 0.0) +(num-test (exp -1234.0+3.14159265358979i) -0.0) +(num-test (exp -1234.0-3.14159265358979i) -0.0) +(num-test (exp -1234.0+2.71828182845905i) -0.0) +(num-test (exp -1234.0-2.71828182845905i) -0.0) +(num-test (exp -1234000000.0+0.0i) 0.0) +(num-test (exp -1234000000.0-0.0i) 0.0) +(num-test (exp -1234000000.0+0.00000001i) 0.0) +(num-test (exp -1234000000.0-0.00000001i) 0.0) +(num-test (exp -1234000000.0+3.14159265358979i) -0.0) +(num-test (exp -1234000000.0-3.14159265358979i) -0.0) +(num-test (exp -1234000000.0+2.71828182845905i) -0.0) +(num-test (exp -1234000000.0-2.71828182845905i) -0.0) +(num-test (exp 10.0) 22026.46579480672) +(num-test (exp 100.0) 2.688117141816135E+43) +(num-test (exp -10.0) 4.5399929762484853E-5) +(num-test (exp -100.0) 3.720075976020836E-44) +(num-test (exp -7.080000e+02) 3.307553e-308) +(num-test (exp 7.090000e+02) 8.218407461554972189241372386597816393254E307) +(num-test (exp 0.00000001+1234.0i) -0.7985506315730906+0.601927660781774i) +(num-test (exp 0.00000001+1234000000.0i) .1589091324793142-0.987293222712823i) +(num-test (exp 3.14159265358979+1234.0i) -18.47901453215463+13.92902284602872i) +(num-test (exp 3.14159265358979+1234000000.0i) 3.677267354472762-22.8466487767572i) +(num-test (exp 2.71828182845905+1234.0i) -12.1014455629425+9.121769530669065i) +(num-test (exp 2.71828182845905+1234000000.0i) 2.408150642075881-14.96170025660763i) +(num-test (exp 0.0e+00-3.45266983001243932001e-04i) 9.9999994039535581673e-1-3.4526697614140534807e-4i) +(num-test (exp 0.0e+00+3.45266983001243932001e-04i) 9.9999994039535581673e-1+3.4526697614140534807e-4i) +(num-test (exp 0.0e+00+1.57045105981189525579e+00i) 3.4526697614152485627e-4+9.9999994039535581669e-1i) +(num-test (exp 0.0e+00-1.57045105981189525579e+00i) 3.4526697614152485627e-4-9.9999994039535581669e-1i) +(num-test (exp 0.0e+00+1.57114159377789786021e+00i) -3.4526697614140239160e-4+9.9999994039535581673e-1i) +(num-test (exp 0.0e+00-1.57114159377789786021e+00i) -3.4526697614140239160e-4-9.9999994039535581673e-1i) +(num-test (exp 0.0e+00+3.14124738660679181379e+00i) -9.9999994039535581667e-1+3.4526697614158608860e-4i) +(num-test (exp 0.0e+00-3.14124738660679181379e+00i) -9.9999994039535581667e-1-3.4526697614158608860e-4i) +(num-test (exp 0.0e+00+3.14193792057279441821e+00i) -9.9999994039535581675e-1-3.4526697614134115926e-4i) +(num-test (exp 0.0e+00-3.14193792057279441821e+00i) -9.9999994039535581675e-1+3.4526697614134115926e-4i) +(num-test (exp 0.0e+00+4.71204371340168837179e+00i) -3.4526697614164732094e-4-9.9999994039535581664e-1i) +(num-test (exp 0.0e+00-4.71204371340168837179e+00i) -3.4526697614164732094e-4+9.9999994039535581664e-1i) +(num-test (exp 0.0e+00+4.71273424736769097620e+00i) 3.4526697614127992692e-4-9.9999994039535581677e-1i) +(num-test (exp 0.0e+00-4.71273424736769097620e+00i) 3.4526697614127992692e-4+9.9999994039535581677e-1i) +(num-test (exp 0.0e+00+6.28284004019658492979e+00i) 9.9999994039535581662e-1-3.4526697614170855328e-4i) +(num-test (exp 0.0e+00-6.28284004019658492979e+00i) 9.9999994039535581662e-1+3.4526697614170855328e-4i) +(num-test (exp 0.0e+00+6.28353057416258753420e+00i) 9.9999994039535581679e-1+3.4526697614121869459e-4i) +(num-test (exp 0.0e+00-6.28353057416258753420e+00i) 9.9999994039535581679e-1-3.4526697614121869459e-4i) +(num-test (exp 0.0e+00+9.42443269378637893396e+00i) -9.9999994039535581689e-1+3.4526697614094283958e-4i) +(num-test (exp 0.0e+00-9.42443269378637893396e+00i) -9.9999994039535581689e-1-3.4526697614094283958e-4i) +(num-test (exp 0.0e+00+9.42512322775237976202e+00i) -9.9999994039535581714e-1-3.4526697614020805155e-4i) +(num-test (exp 0.0e+00-9.42512322775237976202e+00i) -9.9999994039535581714e-1+3.4526697614020805155e-4i) +(num-test (exp 1.19209289550781250e-07-3.45266983001243932001e-04i) 1.0000000596046453675e0-3.4526701730043873250e-4i) +(num-test (exp 1.19209289550781250e-07+3.45266983001243932001e-04i) 1.0000000596046453675e0+3.4526701730043873250e-4i) +(num-test (exp -1.19209289550781250e-07-3.45266983001243932001e-04i) 9.9999982118608047680e-1-3.4526693498237687017e-4i) +(num-test (exp -1.19209289550781250e-07+3.45266983001243932001e-04i) 9.9999982118608047680e-1+3.4526693498237687017e-4i) +(num-test (exp 1.19209289550781250e-07+1.57045105981189525579e+00i) 3.4526701730055824072e-4+1.0000000596046453675e0i) +(num-test (exp 1.19209289550781250e-07-1.57045105981189525579e+00i) 3.4526701730055824072e-4-1.0000000596046453675e0i) +(num-test (exp -1.19209289550781250e-07+1.57045105981189525579e+00i) 3.4526693498249637836e-4+9.9999982118608047676e-1i) +(num-test (exp -1.19209289550781250e-07-1.57045105981189525579e+00i) 3.4526693498249637836e-4-9.9999982118608047676e-1i) +(num-test (exp 1.19209289550781250e-07+1.57114159377789786021e+00i) -3.4526701730043577603e-4+1.0000000596046453675e0i) +(num-test (exp 1.19209289550781250e-07-1.57114159377789786021e+00i) -3.4526701730043577603e-4-1.0000000596046453675e0i) +(num-test (exp -1.19209289550781250e-07+1.57114159377789786021e+00i) -3.4526693498237391370e-4+9.9999982118608047680e-1i) +(num-test (exp -1.19209289550781250e-07-1.57114159377789786021e+00i) -3.4526693498237391370e-4-9.9999982118608047680e-1i) +(num-test (exp 1.19209289550781250e-07+3.14124738660679181379e+00i) -1.0000000596046453674e0+3.4526701730061947306e-4i) +(num-test (exp 1.19209289550781250e-07-3.14124738660679181379e+00i) -1.0000000596046453674e0-3.4526701730061947306e-4i) +(num-test (exp -1.19209289550781250e-07+3.14124738660679181379e+00i) -9.9999982118608047674e-1+3.4526693498255761069e-4i) +(num-test (exp -1.19209289550781250e-07-3.14124738660679181379e+00i) -9.9999982118608047674e-1-3.4526693498255761069e-4i) +(num-test (exp 1.19209289550781250e-07+3.14193792057279441821e+00i) -1.0000000596046453675e0-3.4526701730037454368e-4i) +(num-test (exp 1.19209289550781250e-07-3.14193792057279441821e+00i) -1.0000000596046453675e0+3.4526701730037454368e-4i) +(num-test (exp -1.19209289550781250e-07+3.14193792057279441821e+00i) -9.9999982118608047682e-1-3.4526693498231268137e-4i) +(num-test (exp -1.19209289550781250e-07-3.14193792057279441821e+00i) -9.9999982118608047682e-1+3.4526693498231268137e-4i) +(num-test (exp 1.19209289550781250e-07+4.71204371340168837179e+00i) -3.4526701730068070540e-4-1.0000000596046453674e0i) +(num-test (exp 1.19209289550781250e-07-4.71204371340168837179e+00i) -3.4526701730068070540e-4+1.0000000596046453674e0i) +(num-test (exp -1.19209289550781250e-07+4.71204371340168837179e+00i) -3.4526693498261884302e-4-9.9999982118608047672e-1i) +(num-test (exp -1.19209289550781250e-07-4.71204371340168837179e+00i) -3.4526693498261884302e-4+9.9999982118608047672e-1i) +(num-test (exp 1.19209289550781250e-07+4.71273424736769097620e+00i) 3.4526701730031331134e-4-1.0000000596046453676e0i) +(num-test (exp 1.19209289550781250e-07-4.71273424736769097620e+00i) 3.4526701730031331134e-4+1.0000000596046453676e0i) +(num-test (exp -1.19209289550781250e-07+4.71273424736769097620e+00i) 3.4526693498225144904e-4-9.9999982118608047684e-1i) +(num-test (exp -1.19209289550781250e-07-4.71273424736769097620e+00i) 3.4526693498225144904e-4+9.9999982118608047684e-1i) +(num-test (exp 1.19209289550781250e-07+6.28284004019658492979e+00i) 1.0000000596046453674e0-3.4526701730074193775e-4i) +(num-test (exp 1.19209289550781250e-07-6.28284004019658492979e+00i) 1.0000000596046453674e0+3.4526701730074193775e-4i) +(num-test (exp -1.19209289550781250e-07+6.28284004019658492979e+00i) 9.9999982118608047670e-1-3.4526693498268007535e-4i) +(num-test (exp -1.19209289550781250e-07-6.28284004019658492979e+00i) 9.9999982118608047670e-1+3.4526693498268007535e-4i) +(num-test (exp 1.19209289550781250e-07+6.28353057416258753420e+00i) 1.0000000596046453676e0+3.452670173002520790e-4i) +(num-test (exp 1.19209289550781250e-07-6.28353057416258753420e+00i) 1.0000000596046453676e0-3.452670173002520790e-4i) +(num-test (exp -1.19209289550781250e-07+6.28353057416258753420e+00i) 9.9999982118608047687e-1+3.4526693498219021671e-4i) +(num-test (exp -1.19209289550781250e-07-6.28353057416258753420e+00i) 9.9999982118608047687e-1-3.4526693498219021671e-4i) +(num-test (exp 1.19209289550781250e-07+9.42443269378637893396e+00i) -1.0000000596046453677e0+3.4526701729997622396e-4i) +(num-test (exp 1.19209289550781250e-07-9.42443269378637893396e+00i) -1.0000000596046453677e0-3.4526701729997622396e-4i) +(num-test (exp -1.19209289550781250e-07+9.42443269378637893396e+00i) -9.9999982118608047696e-1+3.4526693498191436174e-4i) +(num-test (exp -1.19209289550781250e-07-9.42443269378637893396e+00i) -9.9999982118608047696e-1-3.4526693498191436174e-4i) +(num-test (exp 1.19209289550781250e-07+9.42512322775237976202e+00i) -1.0000000596046453679e0-3.4526701729924143584e-4i) +(num-test (exp 1.19209289550781250e-07-9.42512322775237976202e+00i) -1.0000000596046453679e0+3.4526701729924143584e-4i) +(num-test (exp -1.19209289550781250e-07+9.42512322775237976202e+00i) -9.9999982118608047721e-1-3.4526693498117957380e-4i) +(num-test (exp -1.19209289550781250e-07-9.42512322775237976202e+00i) -9.9999982118608047721e-1+3.4526693498117957380e-4i) +(num-test (exp 5.0e-01-3.45266983001243932001e-04i) 1.6487211724286834494e0-5.6924900763464865323e-4i) +(num-test (exp 5.0e-01+3.45266983001243932001e-04i) 1.6487211724286834494e0+5.6924900763464865323e-4i) +(num-test (exp -5.0e-01-3.45266983001243932001e-04i) 6.0653062356058926519e-1-2.0941500681603265022e-4i) +(num-test (exp -5.0e-01+3.45266983001243932001e-04i) 6.0653062356058926519e-1+2.0941500681603265022e-4i) +(num-test (exp 5.0e-01+1.57045105981189525579e+00i) 5.6924900763484568894e-4+1.6487211724286834493e0i) +(num-test (exp 5.0e-01-1.57045105981189525579e+00i) 5.6924900763484568894e-4-1.6487211724286834493e0i) +(num-test (exp -5.0e-01+1.57045105981189525579e+00i) 2.0941500681610513560e-4+6.0653062356058926516e-1i) +(num-test (exp -5.0e-01-1.57045105981189525579e+00i) 2.0941500681610513560e-4-6.0653062356058926516e-1i) +(num-test (exp 5.0e-01+1.57114159377789786021e+00i) -5.6924900763464377883e-4+1.6487211724286834494e0i) +(num-test (exp 5.0e-01-1.57114159377789786021e+00i) -5.6924900763464377883e-4-1.6487211724286834494e0i) +(num-test (exp -5.0e-01+1.57114159377789786021e+00i) -2.0941500681603085702e-4+6.0653062356058926519e-1i) +(num-test (exp -5.0e-01-1.57114159377789786021e+00i) -2.0941500681603085702e-4-6.0653062356058926519e-1i) +(num-test (exp 5.0e-01+3.14124738660679181379e+00i) -1.6487211724286834493e0+5.6924900763494664399e-4i) +(num-test (exp 5.0e-01-3.14124738660679181379e+00i) -1.6487211724286834493e0-5.6924900763494664399e-4i) +(num-test (exp -5.0e-01+3.14124738660679181379e+00i) -6.0653062356058926515e-1+2.0941500681614227489e-4i) +(num-test (exp -5.0e-01-3.14124738660679181379e+00i) -6.0653062356058926515e-1-2.0941500681614227489e-4i) +(num-test (exp 5.0e-01+3.14193792057279441821e+00i) -1.6487211724286834494e0-5.6924900763454282377e-4i) +(num-test (exp 5.0e-01-3.14193792057279441821e+00i) -1.6487211724286834494e0+5.6924900763454282377e-4i) +(num-test (exp -5.0e-01+3.14193792057279441821e+00i) -6.0653062356058926520e-1-2.0941500681599371773e-4i) +(num-test (exp -5.0e-01-3.14193792057279441821e+00i) -6.0653062356058926520e-1+2.0941500681599371773e-4i) +(num-test (exp 5.0e-01+4.71204371340168837179e+00i) -5.6924900763504759905e-4-1.6487211724286834492e0i) +(num-test (exp 5.0e-01-4.71204371340168837179e+00i) -5.6924900763504759905e-4+1.6487211724286834492e0i) +(num-test (exp -5.0e-01+4.71204371340168837179e+00i) -2.0941500681617941418e-4-6.0653062356058926514e-1i) +(num-test (exp -5.0e-01-4.71204371340168837179e+00i) -2.0941500681617941418e-4+6.0653062356058926514e-1i) +(num-test (exp 5.0e-01+4.71273424736769097620e+00i) 5.6924900763444186872e-4-1.6487211724286834494e0i) +(num-test (exp 5.0e-01-4.71273424736769097620e+00i) 5.6924900763444186872e-4+1.6487211724286834494e0i) +(num-test (exp -5.0e-01+4.71273424736769097620e+00i) 2.0941500681595657844e-4-6.0653062356058926521e-1i) +(num-test (exp -5.0e-01-4.71273424736769097620e+00i) 2.0941500681595657844e-4+6.0653062356058926521e-1i) +(num-test (exp 5.0e-01+6.28284004019658492979e+00i) 1.6487211724286834492e0-5.6924900763514855410e-4i) +(num-test (exp 5.0e-01-6.28284004019658492979e+00i) 1.6487211724286834492e0+5.6924900763514855410e-4i) +(num-test (exp -5.0e-01+6.28284004019658492979e+00i) 6.0653062356058926512e-1-2.0941500681621655347e-4i) +(num-test (exp -5.0e-01-6.28284004019658492979e+00i) 6.0653062356058926512e-1+2.0941500681621655347e-4i) +(num-test (exp 5.0e-01+6.28353057416258753420e+00i) 1.6487211724286834495e0+5.6924900763434091366e-4i) +(num-test (exp 5.0e-01-6.28353057416258753420e+00i) 1.6487211724286834495e0-5.6924900763434091366e-4i) +(num-test (exp -5.0e-01+6.28353057416258753420e+00i) 6.0653062356058926523e-1+2.0941500681591943916e-4i) +(num-test (exp -5.0e-01-6.28353057416258753420e+00i) 6.0653062356058926523e-1-2.0941500681591943916e-4i) +(num-test (exp 5.0e-01+9.42443269378637893396e+00i) -1.6487211724286834496e0+5.6924900763388610565e-4i) +(num-test (exp 5.0e-01-9.42443269378637893396e+00i) -1.6487211724286834496e0-5.6924900763388610565e-4i) +(num-test (exp -5.0e-01+9.42443269378637893396e+00i) -6.0653062356058926528e-1+2.0941500681575212464e-4i) +(num-test (exp -5.0e-01-9.42443269378637893396e+00i) -6.0653062356058926528e-1-2.0941500681575212464e-4i) +(num-test (exp 5.0e-01+9.42512322775237976202e+00i) -1.6487211724286834501e0-5.6924900763267464498e-4i) +(num-test (exp 5.0e-01-9.42512322775237976202e+00i) -1.6487211724286834501e0+5.6924900763267464498e-4i) +(num-test (exp -5.0e-01+9.42512322775237976202e+00i) -6.0653062356058926544e-1-2.0941500681530645317e-4i) +(num-test (exp -5.0e-01-9.42512322775237976202e+00i) -6.0653062356058926544e-1+2.0941500681530645317e-4i) +(num-test (exp 1.0e+00-3.45266983001243932001e-04i) 2.7182816664368240602e0-9.3853294721218487636e-4i) +(num-test (exp 1.0e+00+3.45266983001243932001e-04i) 2.7182816664368240602e0+9.3853294721218487636e-4i) +(num-test (exp -1.0e+00-3.45266983001243932001e-04i) 3.6787941924411912823e-1-1.2701662223785390836e-4i) +(num-test (exp -1.0e+00+3.45266983001243932001e-04i) 3.6787941924411912823e-1+1.2701662223785390836e-4i) +(num-test (exp 1.0e+00+1.57045105981189525579e+00i) 9.3853294721250973333e-4+2.7182816664368240601e0i) +(num-test (exp 1.0e+00-1.57045105981189525579e+00i) 9.3853294721250973333e-4-2.7182816664368240601e0i) +(num-test (exp -1.0e+00+1.57045105981189525579e+00i) 1.2701662223789787297e-4+3.6787941924411912822e-1i) +(num-test (exp -1.0e+00-1.57045105981189525579e+00i) 1.2701662223789787297e-4-3.6787941924411912822e-1i) +(num-test (exp 1.0e+00+1.57114159377789786021e+00i) -9.3853294721217683983e-4+2.7182816664368240602e0i) +(num-test (exp 1.0e+00-1.57114159377789786021e+00i) -9.3853294721217683983e-4-2.7182816664368240602e0i) +(num-test (exp -1.0e+00+1.57114159377789786021e+00i) -1.2701662223785282074e-4+3.6787941924411912823e-1i) +(num-test (exp -1.0e+00-1.57114159377789786021e+00i) -1.2701662223785282074e-4-3.6787941924411912823e-1i) +(num-test (exp 1.0e+00+3.14124738660679181379e+00i) -2.718281666436824060e0+9.3853294721267618008e-4i) +(num-test (exp 1.0e+00-3.14124738660679181379e+00i) -2.718281666436824060e0-9.3853294721267618008e-4i) +(num-test (exp -1.0e+00+3.14124738660679181379e+00i) -3.6787941924411912821e-1+1.2701662223792039909e-4i) +(num-test (exp -1.0e+00-3.14124738660679181379e+00i) -3.6787941924411912821e-1-1.2701662223792039909e-4i) +(num-test (exp 1.0e+00+3.14193792057279441821e+00i) -2.7182816664368240603e0-9.3853294721201039309e-4i) +(num-test (exp 1.0e+00-3.14193792057279441821e+00i) -2.7182816664368240603e0+9.3853294721201039309e-4i) +(num-test (exp -1.0e+00+3.14193792057279441821e+00i) -3.6787941924411912824e-1-1.2701662223783029462e-4i) +(num-test (exp -1.0e+00-3.14193792057279441821e+00i) -3.6787941924411912824e-1+1.2701662223783029462e-4i) +(num-test (exp 1.0e+00+4.71204371340168837179e+00i) -9.3853294721284262682e-4-2.718281666436824060e0i) +(num-test (exp 1.0e+00-4.71204371340168837179e+00i) -9.3853294721284262682e-4+2.718281666436824060e0i) +(num-test (exp -1.0e+00+4.71204371340168837179e+00i) -1.2701662223794292521e-4-3.6787941924411912820e-1i) +(num-test (exp -1.0e+00-4.71204371340168837179e+00i) -1.2701662223794292521e-4+3.6787941924411912820e-1i) +(num-test (exp 1.0e+00+4.71273424736769097620e+00i) 9.3853294721184394634e-4-2.7182816664368240603e0i) +(num-test (exp 1.0e+00-4.71273424736769097620e+00i) 9.3853294721184394634e-4+2.7182816664368240603e0i) +(num-test (exp -1.0e+00+4.71273424736769097620e+00i) 1.2701662223780776850e-4-3.6787941924411912825e-1i) +(num-test (exp -1.0e+00-4.71273424736769097620e+00i) 1.2701662223780776850e-4+3.6787941924411912825e-1i) +(num-test (exp 1.0e+00+6.28284004019658492979e+00i) 2.7182816664368240599e0-9.3853294721300907357e-4i) +(num-test (exp 1.0e+00-6.28284004019658492979e+00i) 2.7182816664368240599e0+9.3853294721300907357e-4i) +(num-test (exp -1.0e+00+6.28284004019658492979e+00i) 3.6787941924411912819e-1-1.2701662223796545132e-4i) +(num-test (exp -1.0e+00-6.28284004019658492979e+00i) 3.6787941924411912819e-1+1.2701662223796545132e-4i) +(num-test (exp 1.0e+00+6.28353057416258753420e+00i) 2.7182816664368240604e0+9.3853294721167749959e-4i) +(num-test (exp 1.0e+00-6.28353057416258753420e+00i) 2.7182816664368240604e0-9.3853294721167749959e-4i) +(num-test (exp -1.0e+00+6.28353057416258753420e+00i) 3.6787941924411912825e-1+1.2701662223778524238e-4i) +(num-test (exp -1.0e+00-6.28353057416258753420e+00i) 3.6787941924411912825e-1-1.2701662223778524238e-4i) +(num-test (exp 1.0e+00+9.42443269378637893396e+00i) -2.7182816664368240606e0+9.3853294721092764795e-4i) +(num-test (exp 1.0e+00-9.42443269378637893396e+00i) -2.7182816664368240606e0-9.3853294721092764795e-4i) +(num-test (exp -1.0e+00+9.42443269378637893396e+00i) -3.6787941924411912829e-1+1.270166222376837610e-4i) +(num-test (exp -1.0e+00-9.42443269378637893396e+00i) -3.6787941924411912829e-1-1.270166222376837610e-4i) +(num-test (exp 1.0e+00+9.42512322775237976202e+00i) -2.7182816664368240613e0-9.3853294720893028698e-4i) +(num-test (exp 1.0e+00-9.42512322775237976202e+00i) -2.7182816664368240613e0+9.3853294720893028698e-4i) +(num-test (exp -1.0e+00+9.42512322775237976202e+00i) -3.6787941924411912838e-1-1.2701662223741344759e-4i) +(num-test (exp -1.0e+00-9.42512322775237976202e+00i) -3.6787941924411912838e-1+1.2701662223741344759e-4i) +(num-test (exp 2.0e+00-3.45266983001243932001e-04i) 7.3890556585085906002e0-2.5511970558169944872e-3i) +(num-test (exp 2.0e+00+3.45266983001243932001e-04i) 7.3890556585085906002e0+2.5511970558169944872e-3i) +(num-test (exp -2.0e+00-3.45266983001243932001e-04i) 1.3533527517000128913e-1-4.6726804008345889445e-5i) +(num-test (exp -2.0e+00+3.45266983001243932001e-04i) 1.3533527517000128913e-1+4.6726804008345889445e-5i) +(num-test (exp 2.0e+00+1.57045105981189525579e+00i) 2.551197055817877540e-3+7.3890556585085905999e0i) +(num-test (exp 2.0e+00-1.57045105981189525579e+00i) 2.551197055817877540e-3-7.3890556585085905999e0i) +(num-test (exp -2.0e+00+1.57045105981189525579e+00i) 4.6726804008362063122e-5+1.3533527517000128913e-1i) +(num-test (exp -2.0e+00-1.57045105981189525579e+00i) 4.6726804008362063122e-5-1.3533527517000128913e-1i) +(num-test (exp 2.0e+00+1.57114159377789786021e+00i) -2.5511970558169726417e-3+7.3890556585085906002e0i) +(num-test (exp 2.0e+00-1.57114159377789786021e+00i) -2.5511970558169726417e-3-7.3890556585085906002e0i) +(num-test (exp -2.0e+00+1.57114159377789786021e+00i) -4.6726804008345489330e-5+1.3533527517000128913e-1i) +(num-test (exp -2.0e+00-1.57114159377789786021e+00i) -4.6726804008345489330e-5-1.3533527517000128913e-1i) +(num-test (exp 2.0e+00+3.14124738660679181379e+00i) -7.3890556585085905998e0+2.5511970558183299892e-3i) +(num-test (exp 2.0e+00-3.14124738660679181379e+00i) -7.3890556585085905998e0-2.5511970558183299892e-3i) +(num-test (exp -2.0e+00+3.14124738660679181379e+00i) -1.3533527517000128912e-1+4.6726804008370350017e-5i) +(num-test (exp -2.0e+00-3.14124738660679181379e+00i) -1.3533527517000128912e-1-4.6726804008370350017e-5i) +(num-test (exp 2.0e+00+3.14193792057279441821e+00i) -7.3890556585085906004e0-2.5511970558165201925e-3i) +(num-test (exp 2.0e+00-3.14193792057279441821e+00i) -7.3890556585085906004e0+2.5511970558165201925e-3i) +(num-test (exp -2.0e+00+3.14193792057279441821e+00i) -1.3533527517000128914e-1-4.6726804008337202435e-5i) +(num-test (exp -2.0e+00-3.14193792057279441821e+00i) -1.3533527517000128914e-1+4.6726804008337202435e-5i) +(num-test (exp 2.0e+00+4.71204371340168837179e+00i) -2.5511970558187824384e-3-7.3890556585085905996e0i) +(num-test (exp 2.0e+00-4.71204371340168837179e+00i) -2.5511970558187824384e-3+7.3890556585085905996e0i) +(num-test (exp -2.0e+00+4.71204371340168837179e+00i) -4.6726804008378636913e-5-1.3533527517000128912e-1i) +(num-test (exp -2.0e+00-4.71204371340168837179e+00i) -4.6726804008378636913e-5+1.3533527517000128912e-1i) +(num-test (exp 2.0e+00+4.71273424736769097620e+00i) 2.5511970558160677434e-3-7.3890556585085906006e0i) +(num-test (exp 2.0e+00-4.71273424736769097620e+00i) 2.5511970558160677434e-3+7.3890556585085906006e0i) +(num-test (exp -2.0e+00+4.71273424736769097620e+00i) 4.6726804008328915539e-5-1.3533527517000128914e-1i) +(num-test (exp -2.0e+00-4.71273424736769097620e+00i) 4.6726804008328915539e-5+1.3533527517000128914e-1i) +(num-test (exp 2.0e+00+6.28284004019658492979e+00i) 7.3890556585085905995e0-2.5511970558192348875e-3i) +(num-test (exp 2.0e+00-6.28284004019658492979e+00i) 7.3890556585085905995e0+2.5511970558192348875e-3i) +(num-test (exp -2.0e+00+6.28284004019658492979e+00i) 1.3533527517000128912e-1-4.6726804008386923808e-5i) +(num-test (exp -2.0e+00-6.28284004019658492979e+00i) 1.3533527517000128912e-1+4.6726804008386923808e-5i) +(num-test (exp 2.0e+00+6.28353057416258753420e+00i) 7.3890556585085906007e0+2.5511970558156152942e-3i) +(num-test (exp 2.0e+00-6.28353057416258753420e+00i) 7.3890556585085906007e0-2.5511970558156152942e-3i) +(num-test (exp -2.0e+00+6.28353057416258753420e+00i) 1.3533527517000128914e-1+4.6726804008320628644e-5i) +(num-test (exp -2.0e+00-6.28353057416258753420e+00i) 1.3533527517000128914e-1-4.6726804008320628644e-5i) +(num-test (exp 2.0e+00+9.42443269378637893396e+00i) -7.3890556585085906014e0+2.5511970558135769861e-3i) +(num-test (exp 2.0e+00-9.42443269378637893396e+00i) -7.3890556585085906014e0-2.5511970558135769861e-3i) +(num-test (exp -2.0e+00+9.42443269378637893396e+00i) -1.3533527517000128916e-1+4.6726804008283295729e-5i) +(num-test (exp -2.0e+00-9.42443269378637893396e+00i) -1.3533527517000128916e-1-4.6726804008283295729e-5i) +(num-test (exp 2.0e+00+9.42512322775237976202e+00i) -7.3890556585085906033e0-2.5511970558081475961e-3i) +(num-test (exp 2.0e+00-9.42512322775237976202e+00i) -7.3890556585085906033e0+2.5511970558081475961e-3i) +(num-test (exp -2.0e+00+9.42512322775237976202e+00i) -1.3533527517000128919e-1-4.6726804008183852982e-5i) +(num-test (exp -2.0e+00-9.42512322775237976202e+00i) -1.3533527517000128919e-1+4.6726804008183852982e-5i) +(num-test (exp -1000) 0.0) +(num-test (exp -1000000) 0.0) +(num-test (exp (make-rectangular 0.0 (* 0.5 our-pi))) 0+i) +(num-test (exp (make-rectangular 0.0 our-pi)) -1) +(num-test (exp 100.0) 2.688117141816135e43) +(num-test (exp 500.0) 1.40359221785284E+217) +(num-test (exp -100.0) 3.720075976020836E-44) +(num-test (exp -500.0) 7.12457640674129E-218) + + +;; -------- log +;(num-test (log (/ (+ 1 (sqrt 5)) 2)) (acosh (/ (sqrt 5) 2))) +(num-test (log 1) 0.0) +(num-test (log -1) 0.0+3.14159265358979i) +(num-test (log 2) 0.69314718055995) +(num-test (log -2) 0.69314718055995+3.14159265358979i) +(num-test (log 3) 1.09861228866811) +(num-test (log -3) 1.09861228866811+3.14159265358979i) +(num-test (log 10) 2.30258509299405) +(num-test (log -10) 2.30258509299405+3.14159265358979i) +(num-test (log 1234) 7.11801620446533) +(num-test (log -1234) 7.11801620446533+3.14159265358979i) +(num-test (log 1234000000) 20.93352676242961) +(num-test (log -1234000000) 20.93352676242961+3.14159265358979i) +(num-test (log 500029) 13.12242137572239) +(num-test (log -500029) 13.12242137572239+3.14159265358979i) +(num-test (log 362880) 12.80182748008147) +(num-test (log -362880) 12.80182748008147+3.14159265358979i) +(num-test (log 1/1) 0.0) +(num-test (log -1/1) 0.0+3.14159265358979i) +(num-test (log 1/2) -0.69314718055995) +(num-test (log -1/2) -0.69314718055995+3.14159265358979i) +(num-test (log 1/3) -1.09861228866811) +(num-test (log -1/3) -1.09861228866811+3.14159265358979i) +(num-test (log 1/10) -2.30258509299405) +(num-test (log -1/10) -2.30258509299405+3.14159265358979i) +(num-test (log 1/1234) -7.11801620446533) +(num-test (log -1/1234) -7.11801620446533+3.14159265358979i) +(num-test (log 1/1234000000) -20.93352676242961) +(num-test (log -1/1234000000) -20.93352676242961+3.14159265358979i) +(num-test (log 1/500029) -13.12242137572239) +(num-test (log -1/500029) -13.12242137572239+3.14159265358979i) +(num-test (log 1/362880) -12.80182748008147) +(num-test (log -1/362880) -12.80182748008147+3.14159265358979i) +(num-test (log 2/1) 0.69314718055995) +(num-test (log -2/1) 0.69314718055995+3.14159265358979i) +(num-test (log 2/2) 0.0) +(num-test (log -2/2) 0.0+3.14159265358979i) +(num-test (log 2/3) -0.40546510810816) +(num-test (log -2/3) -0.40546510810816+3.14159265358979i) +(num-test (log 2/10) -1.60943791243410) +(num-test (log -2/10) -1.60943791243410+3.14159265358979i) +(num-test (log 2/1234) -6.42486902390539) +(num-test (log -2/1234) -6.42486902390539+3.14159265358979i) +(num-test (log 2/1234000000) -20.24037958186966) +(num-test (log -2/1234000000) -20.24037958186966+3.14159265358979i) +(num-test (log 2/500029) -12.42927419516245) +(num-test (log -2/500029) -12.42927419516245+3.14159265358979i) +(num-test (log 2/362880) -12.10868029952152) +(num-test (log -2/362880) -12.10868029952152+3.14159265358979i) +(num-test (log 3/1) 1.09861228866811) +(num-test (log -3/1) 1.09861228866811+3.14159265358979i) +(num-test (log 3/2) 0.40546510810816) +(num-test (log -3/2) 0.40546510810816+3.14159265358979i) +(num-test (log 3/3) 0.0) +(num-test (log -3/3) 0.0+3.14159265358979i) +(num-test (log 3/10) -1.20397280432594) +(num-test (log -3/10) -1.20397280432594+3.14159265358979i) +(num-test (log 3/1234) -6.01940391579722) +(num-test (log -3/1234) -6.01940391579722+3.14159265358979i) +(num-test (log 3/1234000000) -19.83491447376150) +(num-test (log -3/1234000000) -19.83491447376150+3.14159265358979i) +(num-test (log 3/500029) -12.02380908705428) +(num-test (log -3/500029) -12.02380908705428+3.14159265358979i) +(num-test (log 3/362880) -11.70321519141336) +(num-test (log -3/362880) -11.70321519141336+3.14159265358979i) +(num-test (log 10/1) 2.30258509299405) +(num-test (log -10/1) 2.30258509299405+3.14159265358979i) +(num-test (log 10/2) 1.60943791243410) +(num-test (log -10/2) 1.60943791243410+3.14159265358979i) +(num-test (log 10/3) 1.20397280432594) +(num-test (log -10/3) 1.20397280432594+3.14159265358979i) +(num-test (log 10/10) 0.0) +(num-test (log -10/10) 0.0+3.14159265358979i) +(num-test (log 10/1234) -4.81543111147129) +(num-test (log -10/1234) -4.81543111147129+3.14159265358979i) +(num-test (log 10/1234000000) -18.63094166943556) +(num-test (log -10/1234000000) -18.63094166943556+3.14159265358979i) +(num-test (log 10/500029) -10.81983628272835) +(num-test (log -10/500029) -10.81983628272835+3.14159265358979i) +(num-test (log 10/362880) -10.49924238708742) +(num-test (log -10/362880) -10.49924238708742+3.14159265358979i) +(num-test (log 1234/1) 7.11801620446533) +(num-test (log -1234/1) 7.11801620446533+3.14159265358979i) +(num-test (log 1234/2) 6.42486902390539) +(num-test (log -1234/2) 6.42486902390539+3.14159265358979i) +(num-test (log 1234/3) 6.01940391579722) +(num-test (log -1234/3) 6.01940391579722+3.14159265358979i) +(num-test (log 1234/10) 4.81543111147129) +(num-test (log -1234/10) 4.81543111147129+3.14159265358979i) +(num-test (log 1234/1234) 0.0) +(num-test (log -1234/1234) 0.0+3.14159265358979i) +(num-test (log 1234/1234000000) -13.81551055796427) +(num-test (log -1234/1234000000) -13.81551055796427+3.14159265358979i) +(num-test (log 1234/500029) -6.00440517125706) +(num-test (log -1234/500029) -6.00440517125706+3.14159265358979i) +(num-test (log 1234/362880) -5.68381127561614) +(num-test (log -1234/362880) -5.68381127561614+3.14159265358979i) +(num-test (log 1234000000/1) 20.93352676242961) +(num-test (log -1234000000/1) 20.93352676242961+3.14159265358979i) +(num-test (log 1234000000/2) 20.24037958186966) +(num-test (log -1234000000/2) 20.24037958186966+3.14159265358979i) +(num-test (log 1234000000/3) 19.83491447376150) +(num-test (log -1234000000/3) 19.83491447376150+3.14159265358979i) +(num-test (log 1234000000/10) 18.63094166943556) +(num-test (log -1234000000/10) 18.63094166943556+3.14159265358979i) +(num-test (log 1234000000/1234) 13.81551055796427) +(num-test (log -1234000000/1234) 13.81551055796427+3.14159265358979i) +(num-test (log 1234000000/1234000000) 0.0) +(num-test (log -1234000000/1234000000) 0.0+3.14159265358979i) +(num-test (log 1234000000/500029) 7.81110538670721) +(num-test (log -1234000000/500029) 7.81110538670721+3.14159265358979i) +(num-test (log 1234000000/362880) 8.13169928234814) +(num-test (log -1234000000/362880) 8.13169928234814+3.14159265358979i) +(num-test (log 500029/1) 13.12242137572239) +(num-test (log -500029/1) 13.12242137572239+3.14159265358979i) +(num-test (log 500029/2) 12.42927419516245) +(num-test (log -500029/2) 12.42927419516245+3.14159265358979i) +(num-test (log 500029/3) 12.02380908705428) +(num-test (log -500029/3) 12.02380908705428+3.14159265358979i) +(num-test (log 500029/10) 10.81983628272835) +(num-test (log -500029/10) 10.81983628272835+3.14159265358979i) +(num-test (log 500029/1234) 6.00440517125706) +(num-test (log -500029/1234) 6.00440517125706+3.14159265358979i) +(num-test (log 500029/1234000000) -7.81110538670721) +(num-test (log -500029/1234000000) -7.81110538670721+3.14159265358979i) +(num-test (log 500029/500029) 0.0) +(num-test (log -500029/500029) 0.0+3.14159265358979i) +(num-test (log 500029/362880) 0.32059389564092) +(num-test (log -500029/362880) 0.32059389564092+3.14159265358979i) +(num-test (log 362880/1) 12.80182748008147) +(num-test (log -362880/1) 12.80182748008147+3.14159265358979i) +(num-test (log 362880/2) 12.10868029952152) +(num-test (log -362880/2) 12.10868029952152+3.14159265358979i) +(num-test (log 362880/3) 11.70321519141336) +(num-test (log -362880/3) 11.70321519141336+3.14159265358979i) +(num-test (log 362880/10) 10.49924238708742) +(num-test (log -362880/10) 10.49924238708742+3.14159265358979i) +(num-test (log 362880/1234) 5.68381127561614) +(num-test (log -362880/1234) 5.68381127561614+3.14159265358979i) +(num-test (log 362880/1234000000) -8.13169928234814) +(num-test (log -362880/1234000000) -8.13169928234814+3.14159265358979i) +(num-test (log 362880/500029) -0.32059389564092) +(num-test (log -362880/500029) -0.32059389564092+3.14159265358979i) +(num-test (log 362880/362880) 0.0) +(num-test (log -362880/362880) 0.0+3.14159265358979i) +(num-test (log 0.00000001) -18.42068074395237) +(num-test (log -0.00000001) -18.42068074395237+3.14159265358979i) +(num-test (log 1.0) 0.0) +(num-test (log -1.0) 0.0+3.14159265358979i) +(num-test (log our-pi) 1.14472988584940) +(num-test (log -3.14159265358979) 1.14472988584940+3.14159265358979i) +(num-test (log 2.71828182845905) 1.0) +(num-test (log -2.71828182845905) 1.0+3.14159265358979i) +(num-test (log 1234.0) 7.11801620446533) +(num-test (log -1234.0) 7.11801620446533+3.14159265358979i) +(num-test (log 1234000000.0) 20.93352676242961) +(num-test (log -1234000000.0) 20.93352676242961+3.14159265358979i) +(num-test (log 0.0+0.00000001i) -18.42068074395237+1.57079632679490i) +(num-test (log -0.0+0.00000001i) -18.42068074395237+1.57079632679490i) +(num-test (log 0.0-0.00000001i) -18.42068074395237-1.57079632679490i) +(num-test (log -0.0-0.00000001i) -18.42068074395237-1.57079632679490i) +(num-test (log 0.0+1.0i) 0.0+1.57079632679490i) +(num-test (log -0.0+1.0i) 0.0+1.57079632679490i) +(num-test (log 0.0-1.0i) 0.0-1.57079632679490i) +(num-test (log -0.0-1.0i) 0.0-1.57079632679490i) +(num-test (log 0.0+3.14159265358979i) 1.14472988584940+1.57079632679490i) +(num-test (log -0.0+3.14159265358979i) 1.14472988584940+1.57079632679490i) +(num-test (log 0.0-3.14159265358979i) 1.14472988584940-1.57079632679490i) +(num-test (log -0.0-3.14159265358979i) 1.14472988584940-1.57079632679490i) +(num-test (log 0.0+2.71828182845905i) 1.0+1.57079632679490i) +(num-test (log -0.0+2.71828182845905i) 1.0+1.57079632679490i) +(num-test (log 0.0-2.71828182845905i) 1.0-1.57079632679490i) +(num-test (log -0.0-2.71828182845905i) 1.0-1.57079632679490i) +(num-test (log 0.0+1234.0i) 7.11801620446533+1.57079632679490i) +(num-test (log -0.0+1234.0i) 7.11801620446533+1.57079632679490i) +(num-test (log 0.0-1234.0i) 7.11801620446533-1.57079632679490i) +(num-test (log -0.0-1234.0i) 7.11801620446533-1.57079632679490i) +(num-test (log 0.0+1234000000.0i) 20.93352676242961+1.57079632679490i) +(num-test (log -0.0+1234000000.0i) 20.93352676242961+1.57079632679490i) +(num-test (log 0.0-1234000000.0i) 20.93352676242961-1.57079632679490i) +(num-test (log -0.0-1234000000.0i) 20.93352676242961-1.57079632679490i) +(num-test (log 0.00000001+0.0i) -18.42068074395237) +(num-test (log -0.00000001+0.0i) -18.42068074395237+3.14159265358979i) +(num-test (log 0.00000001-0.0i) -18.42068074395237) +(num-test (log -0.00000001-0.0i) -18.42068074395237+3.14159265358979i) +(num-test (log 0.00000001+0.00000001i) -18.07410715367239+0.78539816339745i) +(num-test (log -0.00000001+0.00000001i) -18.07410715367239+2.35619449019234i) +(num-test (log 0.00000001-0.00000001i) -18.07410715367239-0.78539816339745i) +(num-test (log -0.00000001-0.00000001i) -18.07410715367239-2.35619449019234i) +(num-test (log 0.00000001+1.0i) 0.0+1.57079631679490i) +(num-test (log -0.00000001+1.0i) 0.0+1.57079633679490i) +(num-test (log 0.00000001-1.0i) 0.0-1.57079631679490i) +(num-test (log -0.00000001-1.0i) 0.0-1.57079633679490i) +(num-test (log 0.00000001+3.14159265358979i) 1.14472988584940+1.57079632361180i) +(num-test (log -0.00000001+3.14159265358979i) 1.14472988584940+1.57079632997800i) +(num-test (log 0.00000001-3.14159265358979i) 1.14472988584940-1.57079632361180i) +(num-test (log -0.00000001-3.14159265358979i) 1.14472988584940-1.57079632997800i) +(num-test (log 0.00000001+2.71828182845905i) 1.0+1.57079632311610i) +(num-test (log -0.00000001+2.71828182845905i) 1.0+1.57079633047369i) +(num-test (log 0.00000001-2.71828182845905i) 1.0-1.57079632311610i) +(num-test (log -0.00000001-2.71828182845905i) 1.0-1.57079633047369i) +(num-test (log 0.00000001+1234.0i) 7.11801620446533+1.57079632678679i) +(num-test (log -0.00000001+1234.0i) 7.11801620446533+1.57079632680300i) +(num-test (log 0.00000001-1234.0i) 7.11801620446533-1.57079632678679i) +(num-test (log -0.00000001-1234.0i) 7.11801620446533-1.57079632680300i) +(num-test (log 0.00000001+1234000000.0i) 20.93352676242961+1.57079632679490i) +(num-test (log -0.00000001+1234000000.0i) 20.93352676242961+1.57079632679490i) +(num-test (log 0.00000001-1234000000.0i) 20.93352676242961-1.57079632679490i) +(num-test (log -0.00000001-1234000000.0i) 20.93352676242961-1.57079632679490i) +(num-test (log 1.0+0.0i) 0.0) +(num-test (log -1.0+0.0i) 0.0+3.14159265358979i) +(num-test (log 1.0-0.0i) 0.0) +(num-test (log -1.0-0.0i) 0.0+3.14159265358979i) +(num-test (log 1.0+0.00000001i) 0.0+0.00000001i) +(num-test (log -1.0+0.00000001i) 0.0+3.14159264358979i) +(num-test (log 1.0-0.00000001i) 0.0-0.00000001i) +(num-test (log -1.0-0.00000001i) 0.0-3.14159264358979i) +(num-test (log 1.0+1.0i) 0.34657359027997+0.78539816339745i) +(num-test (log -1.0+1.0i) 0.34657359027997+2.35619449019234i) +(num-test (log 1.0-1.0i) 0.34657359027997-0.78539816339745i) +(num-test (log -1.0-1.0i) 0.34657359027997-2.35619449019234i) +(num-test (log 1.0+3.14159265358979i) 1.19298515341341+1.26262725567891i) +(num-test (log -1.0+3.14159265358979i) 1.19298515341341+1.87896539791088i) +(num-test (log 1.0-3.14159265358979i) 1.19298515341341-1.26262725567891i) +(num-test (log -1.0-3.14159265358979i) 1.19298515341341-1.87896539791088i) +(num-test (log 1.0+2.71828182845905i) 1.06346400552149+1.21828290501728i) +(num-test (log -1.0+2.71828182845905i) 1.06346400552149+1.92330974857252i) +(num-test (log 1.0-2.71828182845905i) 1.06346400552149-1.21828290501728i) +(num-test (log -1.0-2.71828182845905i) 1.06346400552149-1.92330974857252i) +(num-test (log 1.0+1234.0i) 7.11801653281724+1.56998595420081i) +(num-test (log -1.0+1234.0i) 7.11801653281724+1.57160669938898i) +(num-test (log 1.0-1234.0i) 7.11801653281724-1.56998595420081i) +(num-test (log -1.0-1234.0i) 7.11801653281724-1.57160669938898i) +(num-test (log 1.0+1234000000.0i) 20.93352676242961+1.57079632598452i) +(num-test (log -1.0+1234000000.0i) 20.93352676242961+1.57079632760527i) +(num-test (log 1.0-1234000000.0i) 20.93352676242961-1.57079632598452i) +(num-test (log -1.0-1234000000.0i) 20.93352676242961-1.57079632760527i) +(num-test (log 3.14159265358979+0.0i) 1.14472988584940) +(num-test (log -3.14159265358979+0.0i) 1.14472988584940+3.14159265358979i) +(num-test (log 3.14159265358979-0.0i) 1.14472988584940) +(num-test (log -3.14159265358979-0.0i) 1.14472988584940+3.14159265358979i) +(num-test (log 3.14159265358979+0.00000001i) 1.14472988584940+0.00000000318310i) +(num-test (log -3.14159265358979+0.00000001i) 1.14472988584940+3.14159265040669i) +(num-test (log 3.14159265358979-0.00000001i) 1.14472988584940-0.00000000318310i) +(num-test (log -3.14159265358979-0.00000001i) 1.14472988584940-3.14159265040669i) +(num-test (log 3.14159265358979+1.0i) 1.19298515341341+0.30816907111598i) +(num-test (log -3.14159265358979+1.0i) 1.19298515341341+2.83342358247381i) +(num-test (log 3.14159265358979-1.0i) 1.19298515341341-0.30816907111598i) +(num-test (log -3.14159265358979-1.0i) 1.19298515341341-2.83342358247381i) +(num-test (log 3.14159265358979+3.14159265358979i) 1.49130347612937+0.78539816339745i) +(num-test (log -3.14159265358979+3.14159265358979i) 1.49130347612937+2.35619449019234i) +(num-test (log 3.14159265358979-3.14159265358979i) 1.49130347612937-0.78539816339745i) +(num-test (log -3.14159265358979-3.14159265358979i) 1.49130347612937-2.35619449019234i) +(num-test (log 3.14159265358979+2.71828182845905i) 1.42415703773030+0.71328454043905i) +(num-test (log -3.14159265358979+2.71828182845905i) 1.42415703773030+2.42830811315074i) +(num-test (log 3.14159265358979-2.71828182845905i) 1.42415703773030-0.71328454043905i) +(num-test (log -3.14159265358979-2.71828182845905i) 1.42415703773030-2.42830811315074i) +(num-test (log 3.14159265358979+1234.0i) 7.11801944515932+1.56825047114960i) +(num-test (log -3.14159265358979+1234.0i) 7.11801944515932+1.57334218244020i) +(num-test (log 3.14159265358979-1234.0i) 7.11801944515932-1.56825047114960i) +(num-test (log -3.14159265358979-1234.0i) 7.11801944515932-1.57334218244020i) +(num-test (log 3.14159265358979+1234000000.0i) 20.93352676242961+1.57079632424904i) +(num-test (log -3.14159265358979+1234000000.0i) 20.93352676242961+1.57079632934076i) +(num-test (log 3.14159265358979-1234000000.0i) 20.93352676242961-1.57079632424904i) +(num-test (log -3.14159265358979-1234000000.0i) 20.93352676242961-1.57079632934076i) +(num-test (log 2.71828182845905+0.0i) 1.0) +(num-test (log -2.71828182845905+0.0i) 1.0+3.14159265358979i) +(num-test (log 2.71828182845905-0.0i) 1.0) +(num-test (log -2.71828182845905-0.0i) 1.0+3.14159265358979i) +(num-test (log 2.71828182845905+0.00000001i) 1.0+0.00000000367879i) +(num-test (log -2.71828182845905+0.00000001i) 1.0+3.14159264991100i) +(num-test (log 2.71828182845905-0.00000001i) 1.0-0.00000000367879i) +(num-test (log -2.71828182845905-0.00000001i) 1.0-3.14159264991100i) +(num-test (log 2.71828182845905+1.0i) 1.06346400552149+0.35251342177762i) +(num-test (log -2.71828182845905+1.0i) 1.06346400552149+2.78907923181217i) +(num-test (log 2.71828182845905-1.0i) 1.06346400552149-0.35251342177762i) +(num-test (log -2.71828182845905-1.0i) 1.06346400552149-2.78907923181217i) +(num-test (log 2.71828182845905+3.14159265358979i) 1.42415703773030+0.85751178635585i) +(num-test (log -2.71828182845905+3.14159265358979i) 1.42415703773030+2.28408086723395i) +(num-test (log 2.71828182845905-3.14159265358979i) 1.42415703773030-0.85751178635585i) +(num-test (log -2.71828182845905-3.14159265358979i) 1.42415703773030-2.28408086723395i) +(num-test (log 2.71828182845905+2.71828182845905i) 1.34657359027997+0.78539816339745i) +(num-test (log -2.71828182845905+2.71828182845905i) 1.34657359027997+2.35619449019234i) +(num-test (log 2.71828182845905-2.71828182845905i) 1.34657359027997-0.78539816339745i) +(num-test (log -2.71828182845905-2.71828182845905i) 1.34657359027997-2.35619449019234i) +(num-test (log 2.71828182845905+1234.0i) 7.11801863067090+1.56859350877892i) +(num-test (log -2.71828182845905+1234.0i) 7.11801863067090+1.57299914481088i) +(num-test (log 2.71828182845905-1234.0i) 7.11801863067090-1.56859350877892i) +(num-test (log -2.71828182845905-1234.0i) 7.11801863067090-1.57299914481088i) +(num-test (log 2.71828182845905+1234000000.0i) 20.93352676242961+1.57079632459208i) +(num-test (log -2.71828182845905+1234000000.0i) 20.93352676242961+1.57079632899772i) +(num-test (log 2.71828182845905-1234000000.0i) 20.93352676242961-1.57079632459208i) +(num-test (log -2.71828182845905-1234000000.0i) 20.93352676242961-1.57079632899772i) +(num-test (log 1234.0+0.0i) 7.11801620446533) +(num-test (log -1234.0+0.0i) 7.11801620446533+3.14159265358979i) +(num-test (log 1234.0-0.0i) 7.11801620446533) +(num-test (log -1234.0-0.0i) 7.11801620446533+3.14159265358979i) +(num-test (log 1234.0+0.00000001i) 7.11801620446533+0.00000000000810i) +(num-test (log -1234.0+0.00000001i) 7.11801620446533+3.14159265358169i) +(num-test (log 1234.0-0.00000001i) 7.11801620446533-0.00000000000810i) +(num-test (log -1234.0-0.00000001i) 7.11801620446533-3.14159265358169i) +(num-test (log 1234.0+1.0i) 7.11801653281724+0.00081037259408i) +(num-test (log -1234.0+1.0i) 7.11801653281724+3.14078228099571i) +(num-test (log 1234.0-1.0i) 7.11801653281724-0.00081037259408i) +(num-test (log -1234.0-1.0i) 7.11801653281724-3.14078228099571i) +(num-test (log 1234.0+3.14159265358979i) 7.11801944515932+0.00254585564530i) +(num-test (log -1234.0+3.14159265358979i) 7.11801944515932+3.13904679794449i) +(num-test (log 1234.0-3.14159265358979i) 7.11801944515932-0.00254585564530i) +(num-test (log -1234.0-3.14159265358979i) 7.11801944515932-3.13904679794449i) +(num-test (log 1234.0+2.71828182845905i) 7.11801863067090+0.00220281801598i) +(num-test (log -1234.0+2.71828182845905i) 7.11801863067090+3.13938983557381i) +(num-test (log 1234.0-2.71828182845905i) 7.11801863067090-0.00220281801598i) +(num-test (log -1234.0-2.71828182845905i) 7.11801863067090-3.13938983557381i) +(num-test (log 1234.0+1234.0i) 7.46458979474531+0.78539816339745i) +(num-test (log -1234.0+1234.0i) 7.46458979474531+2.35619449019234i) +(num-test (log 1234.0-1234.0i) 7.46458979474531-0.78539816339745i) +(num-test (log -1234.0-1234.0i) 7.46458979474531-2.35619449019234i) +(num-test (log 1234.0+1234000000.0i) 20.93352676243011+1.57079532679490i) +(num-test (log -1234.0+1234000000.0i) 20.93352676243011+1.57079732679490i) +(num-test (log 1234.0-1234000000.0i) 20.93352676243011-1.57079532679490i) +(num-test (log -1234.0-1234000000.0i) 20.93352676243011-1.57079732679490i) +(num-test (log 1234000000.0+0.0i) 20.93352676242961) +(num-test (log -1234000000.0+0.0i) 20.93352676242961+3.14159265358979i) +(num-test (log 1234000000.0-0.0i) 20.93352676242961) +(num-test (log -1234000000.0-0.0i) 20.93352676242961+3.14159265358979i) +(num-test (log 1234000000.0+0.00000001i) 20.93352676242961+0.0i) +(num-test (log -1234000000.0+0.00000001i) 20.93352676242961+3.14159265358979i) +(num-test (log 1234000000.0-0.00000001i) 20.93352676242961-0.0i) +(num-test (log -1234000000.0-0.00000001i) 20.93352676242961-3.14159265358979i) +(num-test (log 1234000000.0+1.0i) 20.93352676242961+0.00000000081037i) +(num-test (log -1234000000.0+1.0i) 20.93352676242961+3.14159265277942i) +(num-test (log 1234000000.0-1.0i) 20.93352676242961-0.00000000081037i) +(num-test (log -1234000000.0-1.0i) 20.93352676242961-3.14159265277942i) +(num-test (log 1234000000.0+3.14159265358979i) 20.93352676242961+0.00000000254586i) +(num-test (log -1234000000.0+3.14159265358979i) 20.93352676242961+3.14159265104393i) +(num-test (log 1234000000.0-3.14159265358979i) 20.93352676242961-0.00000000254586i) +(num-test (log -1234000000.0-3.14159265358979i) 20.93352676242961-3.14159265104393i) +(num-test (log 1234000000.0+2.71828182845905i) 20.93352676242961+0.00000000220282i) +(num-test (log -1234000000.0+2.71828182845905i) 20.93352676242961+3.14159265138697i) +(num-test (log 1234000000.0-2.71828182845905i) 20.93352676242961-0.00000000220282i) +(num-test (log -1234000000.0-2.71828182845905i) 20.93352676242961-3.14159265138697i) +(num-test (log 1234000000.0+1234.0i) 20.93352676243011+0.00000100000000i) +(num-test (log -1234000000.0+1234.0i) 20.93352676243011+3.14159165358979i) +(num-test (log 1234000000.0-1234.0i) 20.93352676243011-0.00000100000000i) +(num-test (log -1234000000.0-1234.0i) 20.93352676243011-3.14159165358979i) +(num-test (log 1234000000.0+1234000000.0i) 21.28010035270958+0.78539816339745i) +(num-test (log -1234000000.0+1234000000.0i) 21.28010035270958+2.35619449019234i) +(num-test (log 1234000000.0-1234000000.0i) 21.28010035270958-0.78539816339745i) +(num-test (log -1234000000.0-1234000000.0i) 21.28010035270958-2.35619449019234i) +(num-test (log .3678794411714423) -1.0) +(num-test (log 22026.46579480672) 10.0) +(num-test (log 2.688117141816135E+43) 100.0) +(num-test (log 4.5399929762484853E-5) -10.0) +(num-test (log 3.720075976020836E-44) -100.0) +(num-test (log 2.2250739e-308) -708.39641851362) +(num-test (log 1.7976931e+308) 709.78271287399) +(num-test (log 1.19209289550781250e-07+0.0e+00i) -1.5942385152878742117e1+0.0i) +(num-test (log -1.19209289550781250e-07+0.0e+00i) -1.5942385152878742117e1+3.1415926535897932385e0i) +(num-test (log 1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+7.8539816339744830962e-1i) +(num-test (log 1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-7.8539816339744830962e-1i) +(num-test (log -1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+2.3561944901923449288e0i) +(num-test (log -1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-2.3561944901923449288e0i) +(num-test (log 1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707960883763175177e0i) +(num-test (log 1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707960883763175177e0i) +(num-test (log -1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707965652134757208e0i) +(num-test (log -1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707965652134757208e0i) +(num-test (log 1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.5707962075856070685e0i) +(num-test (log 1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.5707962075856070685e0i) +(num-test (log -1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.570796446004186170e0i) +(num-test (log -1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.570796446004186170e0i) +(num-test (log 1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707962671902518438e0i) +(num-test (log 1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707962671902518438e0i) +(num-test (log -1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707963863995413946e0i) +(num-test (log -1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707963863995413946e0i) +(num-test (log 1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267948824084e0i) +(num-test (log 1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267948824084e0i) +(num-test (log -1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267949108301e0i) +(num-test (log -1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267949108301e0i) +(num-test (log 5.0e-01+0.0e+00i) -6.9314718055994530942e-1+0.0i) +(num-test (log -5.0e-01+0.0e+00i) -6.9314718055994530942e-1+3.1415926535897932385e0i) +(num-test (log 5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+2.3841857910155798249e-7i) +(num-test (log 5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-2.3841857910155798249e-7i) +(num-test (log -5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+3.1415924151712141369e0i) +(num-test (log -5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-3.1415924151712141369e0i) +(num-test (log 5.0e-01+5.0e-01i) -3.4657359027997265471e-1+7.8539816339744830962e-1i) +(num-test (log 5.0e-01-5.0e-01i) -3.4657359027997265471e-1-7.8539816339744830962e-1i) +(num-test (log -5.0e-01+5.0e-01i) -3.4657359027997265471e-1+2.3561944901923449288e0i) +(num-test (log -5.0e-01-5.0e-01i) -3.4657359027997265471e-1-2.3561944901923449288e0i) +(num-test (log 5.0e-01+1.0e+00i) 1.1157177565710487788e-1+1.1071487177940905030e0i) +(num-test (log 5.0e-01-1.0e+00i) 1.1157177565710487788e-1-1.1071487177940905030e0i) +(num-test (log -5.0e-01+1.0e+00i) 1.1157177565710487788e-1+2.0344439357957027354e0i) +(num-test (log -5.0e-01-1.0e+00i) 1.1157177565710487788e-1-2.0344439357957027354e0i) +(num-test (log 5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.3258176636680324651e0i) +(num-test (log 5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.3258176636680324651e0i) +(num-test (log -5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.8157749899217607734e0i) +(num-test (log -5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.8157749899217607734e0i) +(num-test (log 5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707962671902518438e0i) +(num-test (log 5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707962671902518438e0i) +(num-test (log -5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707963863995413946e0i) +(num-test (log -5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707963863995413946e0i) +(num-test (log 1.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (log -1.0e+00+0.0e+00i) 0+3.1415926535897932385e0i) +(num-test (log 1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+1.1920928955078068531e-7i) +(num-test (log 1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-1.1920928955078068531e-7i) +(num-test (log -1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+3.1415925343805036877e0i) +(num-test (log -1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-3.1415925343805036877e0i) +(num-test (log 1.0e+00+5.0e-01i) 1.1157177565710487788e-1+4.6364760900080611621e-1i) +(num-test (log 1.0e+00-5.0e-01i) 1.1157177565710487788e-1-4.6364760900080611621e-1i) +(num-test (log -1.0e+00+5.0e-01i) 1.1157177565710487788e-1+2.6779450445889871222e0i) +(num-test (log -1.0e+00-5.0e-01i) 1.1157177565710487788e-1-2.6779450445889871222e0i) +(num-test (log 1.0e+00+1.0e+00i) 3.4657359027997265471e-1+7.8539816339744830962e-1i) +(num-test (log 1.0e+00-1.0e+00i) 3.4657359027997265471e-1-7.8539816339744830962e-1i) +(num-test (log -1.0e+00+1.0e+00i) 3.4657359027997265471e-1+2.3561944901923449288e0i) +(num-test (log -1.0e+00-1.0e+00i) 3.4657359027997265471e-1-2.3561944901923449288e0i) +(num-test (log 1.0e+00+2.0e+00i) 8.0471895621705018730e-1+1.1071487177940905030e0i) +(num-test (log 1.0e+00-2.0e+00i) 8.0471895621705018730e-1-1.1071487177940905030e0i) +(num-test (log -1.0e+00+2.0e+00i) 8.0471895621705018730e-1+2.0344439357957027354e0i) +(num-test (log -1.0e+00-2.0e+00i) 8.0471895621705018730e-1-2.0344439357957027354e0i) +(num-test (log 1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.5707962075856070685e0i) +(num-test (log 1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.5707962075856070685e0i) +(num-test (log -1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.570796446004186170e0i) +(num-test (log -1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.570796446004186170e0i) +(num-test (log 2.0e+00+0.0e+00i) 6.9314718055994530942e-1+0.0i) +(num-test (log -2.0e+00+0.0e+00i) 6.9314718055994530942e-1+3.1415926535897932385e0i) +(num-test (log 2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+5.9604644775390554414e-8i) +(num-test (log 2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-5.9604644775390554414e-8i) +(num-test (log -2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+3.1415925939851484631e0i) +(num-test (log -2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-3.1415925939851484631e0i) +(num-test (log 2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.4497866312686415417e-1i) +(num-test (log 2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.4497866312686415417e-1i) +(num-test (log -2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.8966139904629290843e0i) +(num-test (log -2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.8966139904629290843e0i) +(num-test (log 2.0e+00+1.0e+00i) 8.0471895621705018730e-1+4.6364760900080611621e-1i) +(num-test (log 2.0e+00-1.0e+00i) 8.0471895621705018730e-1-4.6364760900080611621e-1i) +(num-test (log -2.0e+00+1.0e+00i) 8.0471895621705018730e-1+2.6779450445889871222e0i) +(num-test (log -2.0e+00-1.0e+00i) 8.0471895621705018730e-1-2.6779450445889871222e0i) +(num-test (log 2.0e+00+2.0e+00i) 1.0397207708399179641e0+7.8539816339744830962e-1i) +(num-test (log 2.0e+00-2.0e+00i) 1.0397207708399179641e0-7.8539816339744830962e-1i) +(num-test (log -2.0e+00+2.0e+00i) 1.0397207708399179641e0+2.3561944901923449288e0i) +(num-test (log -2.0e+00-2.0e+00i) 1.0397207708399179641e0-2.3561944901923449288e0i) +(num-test (log 2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707960883763175177e0i) +(num-test (log 2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707960883763175177e0i) +(num-test (log -2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707965652134757208e0i) +(num-test (log -2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707965652134757208e0i) +(num-test (log 8.3886080e+06+0.0e+00i) 1.5942385152878742117e1+0.0i) +(num-test (log -8.3886080e+06+0.0e+00i) 1.5942385152878742117e1+3.1415926535897932385e0i) +(num-test (log 8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+1.4210854715202003717e-14i) +(num-test (log 8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-1.4210854715202003717e-14i) +(num-test (log -8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+3.1415926535897790276e0i) +(num-test (log -8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-3.1415926535897790276e0i) +(num-test (log 8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+5.9604644775390554414e-8i) +(num-test (log 8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-5.9604644775390554414e-8i) +(num-test (log -8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+3.1415925939851484631e0i) +(num-test (log -8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-3.1415925939851484631e0i) +(num-test (log 8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+1.1920928955078068531e-7i) +(num-test (log 8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-1.1920928955078068531e-7i) +(num-test (log -8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+3.1415925343805036877e0i) +(num-test (log -8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-3.1415925343805036877e0i) +(num-test (log 8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+2.3841857910155798249e-7i) +(num-test (log 8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-2.3841857910155798249e-7i) +(num-test (log -8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+3.1415924151712141369e0i) +(num-test (log -8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-3.1415924151712141369e0i) +(num-test (log 8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+7.8539816339744830962e-1i) +(num-test (log 8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-7.8539816339744830962e-1i) +(num-test (log -8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+2.3561944901923449288e0i) +(num-test (log -8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-2.3561944901923449288e0i) +(num-test (log 0.0e+00+1.19209289550781250e-07i) -1.5942385152878742117e1+1.5707963267948966192e0i) +(num-test (log 0.0e+00-1.19209289550781250e-07i) -1.5942385152878742117e1-1.5707963267948966192e0i) +(num-test (log 0.0e+00+5.0e-01i) -6.9314718055994530942e-1+1.5707963267948966192e0i) +(num-test (log 0.0e+00-5.0e-01i) -6.9314718055994530942e-1-1.5707963267948966192e0i) +(num-test (log 0.0e+00+1.0e+00i) 0+1.5707963267948966192e0i) +(num-test (log 0.0e+00-1.0e+00i) 0-1.5707963267948966192e0i) +(num-test (log 0.0e+00+2.0e+00i) 6.9314718055994530942e-1+1.5707963267948966192e0i) +(num-test (log 0.0e+00-2.0e+00i) 6.9314718055994530942e-1-1.5707963267948966192e0i) +(num-test (log 0.0e+00+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267948966192e0i) +(num-test (log 0.0e+00-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267948966192e0i) +(num-test (log 1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+7.8539816339744830962e-1i) +(num-test (log 1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-7.8539816339744830962e-1i) +(num-test (log -1.19209289550781250e-07+1.19209289550781250e-07i) -1.5595811562598769462e1+2.3561944901923449288e0i) +(num-test (log -1.19209289550781250e-07-1.19209289550781250e-07i) -1.5595811562598769462e1-2.3561944901923449288e0i) +(num-test (log 1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707960883763175177e0i) +(num-test (log 1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707960883763175177e0i) +(num-test (log -1.19209289550781250e-07+5.0e-01i) -6.9314718055991688771e-1+1.5707965652134757208e0i) +(num-test (log -1.19209289550781250e-07-5.0e-01i) -6.9314718055991688771e-1-1.5707965652134757208e0i) +(num-test (log 1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.5707962075856070685e0i) +(num-test (log 1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.5707962075856070685e0i) +(num-test (log -1.19209289550781250e-07+1.0e+00i) 7.1054273576009513716e-15+1.570796446004186170e0i) +(num-test (log -1.19209289550781250e-07-1.0e+00i) 7.1054273576009513716e-15-1.570796446004186170e0i) +(num-test (log 1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707962671902518438e0i) +(num-test (log 1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707962671902518438e0i) +(num-test (log -1.19209289550781250e-07+2.0e+00i) 6.9314718055994708577e-1+1.5707963863995413946e0i) +(num-test (log -1.19209289550781250e-07-2.0e+00i) 6.9314718055994708577e-1-1.5707963863995413946e0i) +(num-test (log 1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267948824084e0i) +(num-test (log 1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267948824084e0i) +(num-test (log -1.19209289550781250e-07+8.3886080e+06i) 1.5942385152878742117e1+1.5707963267949108301e0i) +(num-test (log -1.19209289550781250e-07-8.3886080e+06i) 1.5942385152878742117e1-1.5707963267949108301e0i) +(num-test (log 5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+2.3841857910155798249e-7i) +(num-test (log 5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-2.3841857910155798249e-7i) +(num-test (log -5.0e-01+1.19209289550781250e-07i) -6.9314718055991688771e-1+3.1415924151712141369e0i) +(num-test (log -5.0e-01-1.19209289550781250e-07i) -6.9314718055991688771e-1-3.1415924151712141369e0i) +(num-test (log 5.0e-01+5.0e-01i) -3.4657359027997265471e-1+7.8539816339744830962e-1i) +(num-test (log 5.0e-01-5.0e-01i) -3.4657359027997265471e-1-7.8539816339744830962e-1i) +(num-test (log -5.0e-01+5.0e-01i) -3.4657359027997265471e-1+2.3561944901923449288e0i) +(num-test (log -5.0e-01-5.0e-01i) -3.4657359027997265471e-1-2.3561944901923449288e0i) +(num-test (log 5.0e-01+1.0e+00i) 1.1157177565710487788e-1+1.1071487177940905030e0i) +(num-test (log 5.0e-01-1.0e+00i) 1.1157177565710487788e-1-1.1071487177940905030e0i) +(num-test (log -5.0e-01+1.0e+00i) 1.1157177565710487788e-1+2.0344439357957027354e0i) +(num-test (log -5.0e-01-1.0e+00i) 1.1157177565710487788e-1-2.0344439357957027354e0i) +(num-test (log 5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.3258176636680324651e0i) +(num-test (log 5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.3258176636680324651e0i) +(num-test (log -5.0e-01+2.0e+00i) 7.2345949146816273071e-1+1.8157749899217607734e0i) +(num-test (log -5.0e-01-2.0e+00i) 7.2345949146816273071e-1-1.8157749899217607734e0i) +(num-test (log 5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707962671902518438e0i) +(num-test (log 5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707962671902518438e0i) +(num-test (log -5.0e-01+8.3886080e+06i) 1.5942385152878743893e1+1.5707963863995413946e0i) +(num-test (log -5.0e-01-8.3886080e+06i) 1.5942385152878743893e1-1.5707963863995413946e0i) +(num-test (log 1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+1.1920928955078068531e-7i) +(num-test (log 1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-1.1920928955078068531e-7i) +(num-test (log -1.0e+00+1.19209289550781250e-07i) 7.1054273576009513716e-15+3.1415925343805036877e0i) +(num-test (log -1.0e+00-1.19209289550781250e-07i) 7.1054273576009513716e-15-3.1415925343805036877e0i) +(num-test (log 1.0e+00+5.0e-01i) 1.1157177565710487788e-1+4.6364760900080611621e-1i) +(num-test (log 1.0e+00-5.0e-01i) 1.1157177565710487788e-1-4.6364760900080611621e-1i) +(num-test (log -1.0e+00+5.0e-01i) 1.1157177565710487788e-1+2.6779450445889871222e0i) +(num-test (log -1.0e+00-5.0e-01i) 1.1157177565710487788e-1-2.6779450445889871222e0i) +(num-test (log 1.0e+00+1.0e+00i) 3.4657359027997265471e-1+7.8539816339744830962e-1i) +(num-test (log 1.0e+00-1.0e+00i) 3.4657359027997265471e-1-7.8539816339744830962e-1i) +(num-test (log -1.0e+00+1.0e+00i) 3.4657359027997265471e-1+2.3561944901923449288e0i) +(num-test (log -1.0e+00-1.0e+00i) 3.4657359027997265471e-1-2.3561944901923449288e0i) +(num-test (log 1.0e+00+2.0e+00i) 8.0471895621705018730e-1+1.1071487177940905030e0i) +(num-test (log 1.0e+00-2.0e+00i) 8.0471895621705018730e-1-1.1071487177940905030e0i) +(num-test (log -1.0e+00+2.0e+00i) 8.0471895621705018730e-1+2.0344439357957027354e0i) +(num-test (log -1.0e+00-2.0e+00i) 8.0471895621705018730e-1-2.0344439357957027354e0i) +(num-test (log 1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.5707962075856070685e0i) +(num-test (log 1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.5707962075856070685e0i) +(num-test (log -1.0e+00+8.3886080e+06i) 1.5942385152878749222e1+1.570796446004186170e0i) +(num-test (log -1.0e+00-8.3886080e+06i) 1.5942385152878749222e1-1.570796446004186170e0i) +(num-test (log 2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+5.9604644775390554414e-8i) +(num-test (log 2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-5.9604644775390554414e-8i) +(num-test (log -2.0e+00+1.19209289550781250e-07i) 6.9314718055994708577e-1+3.1415925939851484631e0i) +(num-test (log -2.0e+00-1.19209289550781250e-07i) 6.9314718055994708577e-1-3.1415925939851484631e0i) +(num-test (log 2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.4497866312686415417e-1i) +(num-test (log 2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.4497866312686415417e-1i) +(num-test (log -2.0e+00+5.0e-01i) 7.2345949146816273071e-1+2.8966139904629290843e0i) +(num-test (log -2.0e+00-5.0e-01i) 7.2345949146816273071e-1-2.8966139904629290843e0i) +(num-test (log 2.0e+00+1.0e+00i) 8.0471895621705018730e-1+4.6364760900080611621e-1i) +(num-test (log 2.0e+00-1.0e+00i) 8.0471895621705018730e-1-4.6364760900080611621e-1i) +(num-test (log -2.0e+00+1.0e+00i) 8.0471895621705018730e-1+2.6779450445889871222e0i) +(num-test (log -2.0e+00-1.0e+00i) 8.0471895621705018730e-1-2.6779450445889871222e0i) +(num-test (log 2.0e+00+2.0e+00i) 1.0397207708399179641e0+7.8539816339744830962e-1i) +(num-test (log 2.0e+00-2.0e+00i) 1.0397207708399179641e0-7.8539816339744830962e-1i) +(num-test (log -2.0e+00+2.0e+00i) 1.0397207708399179641e0+2.3561944901923449288e0i) +(num-test (log -2.0e+00-2.0e+00i) 1.0397207708399179641e0-2.3561944901923449288e0i) +(num-test (log 2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707960883763175177e0i) +(num-test (log 2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707960883763175177e0i) +(num-test (log -2.0e+00+8.3886080e+06i) 1.5942385152878770538e1+1.5707965652134757208e0i) +(num-test (log -2.0e+00-8.3886080e+06i) 1.5942385152878770538e1-1.5707965652134757208e0i) +(num-test (log 8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+1.4210854715202003717e-14i) +(num-test (log 8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-1.4210854715202003717e-14i) +(num-test (log -8.3886080e+06+1.19209289550781250e-07i) 1.5942385152878742117e1+3.1415926535897790276e0i) +(num-test (log -8.3886080e+06-1.19209289550781250e-07i) 1.5942385152878742117e1-3.1415926535897790276e0i) +(num-test (log 8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+5.9604644775390554414e-8i) +(num-test (log 8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-5.9604644775390554414e-8i) +(num-test (log -8.3886080e+06+5.0e-01i) 1.5942385152878743893e1+3.1415925939851484631e0i) +(num-test (log -8.3886080e+06-5.0e-01i) 1.5942385152878743893e1-3.1415925939851484631e0i) +(num-test (log 8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+1.1920928955078068531e-7i) +(num-test (log 8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-1.1920928955078068531e-7i) +(num-test (log -8.3886080e+06+1.0e+00i) 1.5942385152878749222e1+3.1415925343805036877e0i) +(num-test (log -8.3886080e+06-1.0e+00i) 1.5942385152878749222e1-3.1415925343805036877e0i) +(num-test (log 8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+2.3841857910155798249e-7i) +(num-test (log 8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-2.3841857910155798249e-7i) +(num-test (log -8.3886080e+06+2.0e+00i) 1.5942385152878770538e1+3.1415924151712141369e0i) +(num-test (log -8.3886080e+06-2.0e+00i) 1.5942385152878770538e1-3.1415924151712141369e0i) +(num-test (log 8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+7.8539816339744830962e-1i) +(num-test (log 8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-7.8539816339744830962e-1i) +(num-test (log -8.3886080e+06+8.3886080e+06i) 1.6288958743158714771e1+2.3561944901923449288e0i) +(num-test (log -8.3886080e+06-8.3886080e+06i) 1.6288958743158714771e1-2.3561944901923449288e0i) +(num-test (exp (log 8)) 8.0) +(num-test (exp (log 1000)) 1000.0) +(num-test (exp (log 1000000)) 1000000.0) +(num-test (exp (log 1000000000)) 1000000000.0) +(num-test (log (exp 0.1)) 0.1) +(num-test (log (exp 0.0001)) 0.0001) +(num-test (log (exp 0.0000001)) 0.0000001) +(num-test (log (exp 8)) 8.0) +(num-test (log 0+i) (make-rectangular 0.0 (* 0.5 our-pi))) +(num-test (log 0-i) (make-rectangular 0.0 (* -0.5 our-pi))) +(num-test (log 1.0e-8) -18.42068074395237) +(num-test (log 1.0e-12) -27.63102111592855) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x -10.0 (+ x .1))) + ((= i 200)) + (if (not (zero? x)) + (let ((y (magnitude (- x (exp (log x)))))) + (if (> y err) (set! err y))))) + (if (> err 1e-14) + (begin (display "(exp (log ...)) error: ") (display err) (newline)))) + +(let ((err 0.0)) + (do ((i 0 (+ i 1)) + (x -10.0+i (+ x 0.1-0.1i))) + ((= i 200)) + (if (not (zero? x)) + (let ((y (magnitude (- x (exp (log x)))))) + (if (> y err) (set! err y))))) + (if (> err 1e-14) + (begin (display "(exp (log [complex] ...)) error: ") (display err) (newline)))) + +;; -------- expt +(num-test (expt 0 0) 1) +(num-test (expt 0 1) 0) +(num-test (expt 0 2) 0) +(num-test (expt 0 3) 0) +(num-test (expt 0 10) 0) +(num-test (expt 0 1234) 0) +(num-test (expt 1 0) 1) +(num-test (expt -1 0) 1) +(num-test (expt 1 0) 1) +(num-test (expt 1 1) 1) +(num-test (expt -1 1) -1) +(num-test (expt 1 -1) 1) +(num-test (expt 1 2) 1) +(num-test (expt -1 2) 1) +(num-test (expt 1 -2) 1) +(num-test (expt 1 3) 1) +(num-test (expt -1 3) -1) +(num-test (expt 1 -3) 1) +(num-test (expt 1 10) 1) +(num-test (expt -1 10) 1) +(num-test (expt 1 -10) 1) +(num-test (expt 1 1234) 1) +(num-test (expt -1 1234) 1) +(num-test (expt 1 -1234) 1) + +(if with-large-powers + (begin + (num-test (expt 0 1234000000) 0) + (num-test (expt 0 500029) 0) + (num-test (expt 0 362880) 0) + (num-test (expt 1 1234000000) 1) + (num-test (expt -1 1234000000) 1) + (num-test (expt 1 -1234000000) 1) + (num-test (expt 1 500029) 1) + (num-test (expt -1 500029) -1) + (num-test (expt 1 -500029) 1) + (num-test (expt 1 362880) 1) + (num-test (expt -1 362880) 1) + (num-test (expt 1 -362880) 1) + (num-test (expt 3 10) 59049) + (num-test (expt -3 10) 59049) + (num-test (expt 3 -10) 1/59049) + (num-test (expt 1234 2) 1522756) + (num-test (expt -1234 2) 1522756) + (num-test (expt 1234 -2) 1/1522756) + (num-test (expt 1234 -3) 1/1879080904) + (num-test (expt 1234000000 -1) 1/1234000000) + (num-test (expt 500029 0) 1) + (num-test (expt -500029 0) 1) + (num-test (expt 500029 0) 1) + (num-test (expt 500029 1) 500029) + (num-test (expt -500029 1) -500029) + (num-test (expt 500029 -1) 1/500029) + (if (or with-bignums with-64-bit-ints) (num-test (expt 500029 -2) 1/250029000841)) + (num-test (expt 362880 1) 362880) + (num-test (expt -362880 1) -362880) + (num-test (expt 362880 -1) 1/362880) + (if (or with-bignums with-64-bit-ints) (num-test (expt 362880 -2) 1/131681894400)) + (num-test (expt 2/3 1234/362880) 0.99862213634996) + (num-test (expt -2/3 1234/362880) 0.99856514997103+0.01066829281071i) + (num-test (expt 2/10 1234000000/500029) 0.0) + (num-test (expt -2/10 1234000000/500029) 0.0) + (num-test (expt 2/1234 500029/1234000000) 0.99739996551176) + (num-test (expt -2/1234 500029/1234000000) 0.99739915734849+0.00126969420446i) + (num-test (expt 2/1234000000 362880/1234) 0.0) (num-test (expt -2/1234000000 362880/1234) 0.0) + (num-test (expt 2/500029 0/10) 1) + (num-test (expt -2/500029 0/10) 1) + (num-test (expt 2/362880 1/3) 0.01766399721581) + (test (or (< (magnitude (- (expt -2/362880 1/3) 0.00883199860790+0.01529747032127i)) 1e-6) + (< (magnitude (- (expt -2/362880 1/3) 0.00883199860790-0.01529747032127i)) 1e-6) + (< (magnitude (- (expt -2/362880 1/3) -0.017663997215805)) 1e-6)) #t) + (num-test (expt 3/1 10/2) 243) + (num-test (expt -3/1 10/2) -243) + (num-test (expt 3/10 500029/362880) 0.19032743228093) + (num-test (expt -3/10 500029/362880) -0.07120470796705-0.17650615015342i) + (num-test (expt 3/1234 362880/500029) 0.01267163536282) + (num-test (expt -3/1234 362880/500029) -0.00825127977478+0.00961700186370i) + (num-test (expt 3/1234000000 0/1234000000) 1) + (num-test (expt -3/1234000000 0/1234000000) 1) + (num-test (expt 3/500029 1/1234) 0.99030354920325) + (num-test (expt -3/500029 1/1234) 0.99030033992383+0.00252117260474i) + (num-test (expt 3/362880 2/10) 0.09626571578282) + (num-test (expt -3/362880 2/10) 0.07788060004397+0.05658356803852i) + (num-test (expt 10/1234 0/362880) 1) + (num-test (expt -10/1234 0/362880) 1) + (num-test (expt 10/1234000000 1/500029) 0.99996274097186) + (num-test (expt -10/1234000000 1/500029) 0.99996274095212+0.00000628258681i) + (num-test (expt 10/500029 2/1234000000) 0.99999998246380) + (num-test (expt -10/500029 2/1234000000) 0.99999998246380+0.00000000509172i) + (num-test (expt 10/362880 3/1234) 0.97479810574733) + (num-test (expt -10/362880 3/1234) 0.97476967459219+0.00744502948457i) + (num-test (expt 1234/10 0/1) 1) + (num-test (expt -1234/10 0/1) 1) + (num-test (expt 1234/1234000000 2/362880) 0.99992385921192) + (num-test (expt -1234/1234000000 2/362880) 0.99992385906203+0.00001731345596i) + (num-test (expt 1234/500029 3/500029) 0.99996397630725) + (num-test (expt -1234/500029 3/500029) 0.99996397612963+0.00001884778372i) + (num-test (expt 1234/362880 10/1234000000) 0.99999995393994) + (num-test (expt -1234/362880 10/1234000000) 0.99999995393994+0.00000002545861i) + (num-test (expt 1234000000/3 0/3) 1) + (num-test (expt -1234000000/3 0/3) 1) + (num-test (expt 1234000000/10 1/2) 11108.55526159905094) + (num-test (expt -1234000000/10 1/2) 0.00000000000068+11108.55526159905094i) + (num-test (expt 1234000000/500029 10/362880) 1.00021527629325) + (num-test (expt -1234000000/500029 10/362880) 1.00021527254493+0.00008659250882i) + (num-test (expt 1234000000/362880 1234/500029) 1.02027058333165) + (num-test (expt -1234000000/362880 1234/500029) 1.02023991975054+0.00791007960266i) + (num-test (expt 500029/1 362880/1234000000) 1.00386634022855) + (num-test (expt -500029/1 362880/1234000000) 1.00386591183654+0.00092741384842i) + (num-test (expt 500029/2 0/1234) 1) + (num-test (expt -500029/2 0/1234) 1) + (num-test (expt 500029/3 1/10) 3.32803123591083) + (num-test (expt -500029/3 1/10) 3.16514579334680+1.02841820970710i) + (num-test (expt 500029/10 2/3) 1357.26128653075921) + (num-test (expt -500029/10 2/3) -678.63064326537926+1175.42275370878747i) + (num-test (expt 500029/1234 3/2) 8156.80442672750178) + (num-test (expt -500029/1234 3/2) -0.00000000000150-8156.80442672750178i) + (num-test (expt 500029/1234000000 10/1) 0.0) + (num-test (expt -500029/1234000000 10/1) 0.0-0.0i) + (num-test (expt 362880/1 0/500029) 1) + (num-test (expt -362880/1 0/500029) 1) + (num-test (expt 362880/2 1/1234000000) 1.00000000981254) + (num-test (expt -362880/2 1/1234000000) 1.00000000981254+0.00000000254586i) + (num-test (expt 362880/3 2/1234) 1.01914896791961) + (num-test (expt -362880/3 2/1234) 1.01913575690562+0.00518920109559i) + (num-test (expt 362880/10 3/10) 23.33076127248722) + (num-test (expt -362880/10 3/10) 13.71347740072436+18.87498236114703i) + (num-test (expt 362880/1234 10/3) 169106218.17807236313820) + (num-test (expt -362880/1234 10/3) -84553109.08903615176678-146450280.88012450933456i) + (num-test (expt 362880/1234000000 1234/2) 0.0) + (num-test (expt -362880/1234000000 1234/2) -0.0))) + +(num-test (expt 2 0) 1) +(num-test (expt -2 0) 1) +(num-test (expt 2 0) 1) +(num-test (expt 2 1) 2) +(num-test (expt -2 1) -2) +(num-test (expt 2 -1) 1/2) +(num-test (expt 2 2) 4) +(num-test (expt -2 2) 4) +(num-test (expt 2 -2) 1/4) +(num-test (expt 2 3) 8) +(num-test (expt -2 3) -8) +(num-test (expt 2 -3) 1/8) +(num-test (expt 2 10) 1024) +(num-test (expt -2 10) 1024) +(num-test (expt 2 -10) 1/1024) +(num-test (expt 3 0) 1) +(num-test (expt -3 0) 1) +(num-test (expt 3 0) 1) +(num-test (expt 3 1) 3) +(num-test (expt -3 1) -3) +(num-test (expt 3 -1) 1/3) +(num-test (expt 3 2) 9) +(num-test (expt -3 2) 9) +(num-test (expt 3 -2) 1/9) +(num-test (expt 3 3) 27) +(num-test (expt -3 3) -27) +(num-test (expt 3 -3) 1/27) +(num-test (expt 2.0 -1.0220000e+03) 2.225073858507201383090232717332404063624E-308) +(num-test (expt 2.0 1.0230000e+03) 8.98846567431157953864652595394512365232E307) +(num-test (expt 0+i 1/2) (make-rectangular (/ (sqrt 2)) (/ (sqrt 2)))) +(num-test (expt (expt 0+i 1/3) 3) 0+i) +(num-test (expt (expt 0+i 1/4) 4) 0+i) +(num-test (expt (expt 1+i 1/2) 2) 1+i) +(num-test (expt (expt 1+i 1/3) 3) 1+i) +(num-test (expt (expt 1+i 1/4) 4) 1+i) +(num-test (expt (expt 1-i 1/2) 2) 1-i) +(num-test (expt (expt 1-i 1/3) 3) 1-i) +(num-test (expt (expt 1-i 1/4) 4) 1-i) +(num-test (expt (expt 0+i 1/10) 10) 0+i) +(num-test (expt (expt 0+i -1/2) -2) 0+i) +(num-test (expt (expt 0+i -1/3) -3) 0+i) +(num-test (expt (expt 0+i -1/4) -4) 0+i) +(num-test (expt 0+i 2) -1) +(num-test (expt 0-i 2) -1) +(num-test (expt (expt 2 0+i) (/ 0+i)) 2) +(num-test (expt -1 1/2) 0+i) +(num-test (expt -1.0 1/2) 0+i) +(num-test (expt (expt -1/2 1/2) 2) -1/2) +(num-test (expt (expt -1/2 -1/2) -2) -1/2) +(num-test (expt (expt 1/2 -1/2) -2) 1/2) +(num-test (expt (expt -1/3 1/3) 3) -1/3) +(num-test (expt (expt -1/3 1/2) 2) -1/3) +(num-test (expt (expt -1/3 -1/2) -2) -1/3) +(num-test (expt (expt -2 1/2) 2) -2) +(num-test (expt (expt -2 -1/2) -2) -2) +(num-test (expt (expt -1 -1/2) -2) -1) +(num-test (expt (expt 1 -1/2) -2) 1) +(num-test (expt (expt 1 1/123) 123) 1) +(num-test (expt (expt -1 1/123) 123) -1) +(num-test (expt -1/8 -3) -512) + +(let ((xs (list 2 3 4 1/2 1/3 1/4 2.5 1+i 2.5+1.5i 2.5-.5i)) + (ys (list 2 3 4 -2 -3 -4 1/2 1/3 1/4 -1/2 -1/3 -1/4 2.5 -3.5 1+i -1+2i 2.5+1.5i 2.5-.5i))) + (for-each + (lambda (x) + (for-each + (lambda (y) + (num-test (expt (expt x y) (/ y)) x) + ;; (if (> (magnitude (- (expt (expt x y) (/ y)) x)) 1e-6) + ;; (format #t "(expt (expt ~A ~A) (/ ~A)) -> ~A (~A)~%" x y y (expt (expt x y) (/ y)) (magnitude (- (expt (expt x y) (/ y)) x)))) + ) + ys)) + xs)) + +(if with-bignums + (begin + (num-test (expt 4722366482869645213696 1/2) 68719476736) + (num-test (expt 324518553658426726783156020576256 1/3) 68719476736) + (num-test (expt 4722366482869645213696/6561 1/2) 68719476736/81) + (num-test (expt 324518553658426726783156020576256/19683 1/3) 68719476736/27) + + (num-test (expt 4722366482869645213696/6561 -1/2) (/ 68719476736/81)) + (num-test (expt (expt -4722366482869645213696/6561 1/2) 2) -4722366482869645213696/6561) + + (num-test (numerator 1195068768795265792518361315725116351898245581/48889032896862784894921) 24444516448431392447461) + (num-test (denominator 1195068768795265792518361315725116351898245581/48889032896862784894921) 1) + (num-test (numerator 24444516448431392447461/1195068768795265792518361315725116351898245581) 1) + (num-test (denominator 24444516448431392447461/1195068768795265792518361315725116351898245581) 48889032896862784894921) + + (if with-bigfloats + (begin + (num-test (expt 4722366482869645213696.0 1/2) 68719476736.0) + (num-test (expt 324518553658426726783156020576256.0 1/3) 68719476736.0) + (num-test (+ 12345678901234567890+12345678901234567890i 12345678901234567890-12345678901234567890i) 2.469135780246913578E19) + (num-test (* 2 12345678901234567890+12345678901234567890i) 2.469135780246913578E19+2.469135780246913578E19i) + (num-test (- 2 12345678901234567890+12345678901234567890i) -12345678901234567890-12345678901234567890i) + )) + )) + +(num-test (expt 10 0) 1) +(num-test (expt -10 0) 1) +(num-test (expt 10 0) 1) +(num-test (expt 10 1) 10) +(num-test (expt -10 1) -10) +(num-test (expt 10 -1) 1/10) +(num-test (expt 10 2) 100) +(num-test (expt -10 2) 100) +(num-test (expt 10 -2) 1/100) +(num-test (expt 10 3) 1000) +(num-test (expt -10 3) -1000) +(num-test (expt 10 -3) 1/1000) +(if (or with-bignums with-64-bit-ints) (num-test (expt 10 -10) 1/10000000000)) +(num-test (expt 1234 0) 1) +(num-test (expt -1234 0) 1) +(num-test (expt 1234 0) 1) +(num-test (expt 1234 1) 1234) +(num-test (expt -1234 1) -1234) +(num-test (expt 1234 -1) 1/1234) +(num-test (expt 1234000000 0) 1) +(num-test (expt -1234000000 0) 1) +(num-test (expt 1234000000 0) 1) +(num-test (expt 0/500029 500029/2) 0.0) +(num-test (expt 0/362880 362880/1) 0) +(num-test (expt 1/2 3/362880) 0.99999426963298) +(num-test (expt -1/2 3/362880) 0.99999426929571+0.00002597201266i) +(num-test (expt 1/3 10/500029) 0.99997802926990) +(num-test (expt -1/3 10/500029) 0.99997802729625+0.00006282682861i) +(num-test (expt 1/10 1234/1234000000) 0.99999769741756) +(num-test (expt -1/10 1234/1234000000) 0.99999769741262+0.00000314158542i) +(num-test (expt 1/1234000000 500029/10) 0.0) +(num-test (expt -1/1234000000 500029/10) -0.0) +(num-test (expt 1/500029 362880/3) 0.0) +(num-test (expt -1/500029 362880/3) 0.0) +(num-test (expt 362880 0) 1) +(num-test (expt -362880 0) 1) +(num-test (expt 362880 0) 1) +(num-test (expt 0/1 1/362880) 0.0) +(num-test (expt 0/2 2/500029) 0.0) +(num-test (expt 0/3 3/1234000000) 0.0) +(num-test (expt 0/10 10/1234) 0.0) +(num-test (expt 0/1234 1234/10) 0.0) +(num-test (expt 1/362880 0/2) 1) +(num-test (expt -1/362880 0/2) 1) +(num-test (expt 2/1 3/1) 8) +(num-test (expt 1/4 -2) 16) +(num-test (expt 16 1/4) 2) +(num-test (expt -2/1 3/1) -8) +(num-test (expt 0 0.00000001) 0.0) +(num-test (expt 0 1.0) 0.0) +(num-test (expt 0 our-pi) 0.0) +(num-test (expt 0 2.71828182845905) 0.0) +(num-test (expt 0 1234.0) 0.0) +(num-test (expt 0 1234000000.0) 0.0) +(num-test (expt 1 0.0) 1.0) +(num-test (expt -1 0.0) 1.0) +(num-test (expt 1 -0.0) 1.0) +(num-test (expt 1 0.00000001) 1.0) +(num-test (expt -1 0.00000001) 1.0+0.00000003141593i) +(num-test (expt 1 -0.00000001) 1.0) +(num-test (expt 1 1.0) 1.0) +(num-test (expt -1 1.0) -1.0+0.0i) +(num-test (expt 1 -1.0) 1.0) +(num-test (expt 1 our-pi) 1.0) +(num-test (expt -1 our-pi) -0.90268536193307-0.43030121700009i) +(num-test (expt 1 -3.14159265358979) 1.0) +(num-test (expt 1 2.71828182845905) 1.0) +(num-test (expt -1 2.71828182845905) -0.63325565131482+0.77394268526671i) +(num-test (expt 1 -2.71828182845905) 1.0) +(num-test (expt 1 1234.0) 1.0) +(num-test (expt -1 1234.0) 1.0) +(num-test (expt 1 -1234.0) 1.0) +(num-test (expt 1 1234000000.0) 1.0) +(num-test (expt -1 1234000000.0) 1.0) +(num-test (expt 1 -1234000000.0) 1.0) +(num-test (expt 2 0.0) 1.0) +(num-test (expt -2 0.0) 1.0) +(num-test (expt 2 -0.0) 1.0) +(num-test (expt 2 0.00000001) 1.00000000693147) +(num-test (expt -2 0.00000001) 1.00000000693147+0.00000003141593i) +(num-test (expt 2 -0.00000001) 0.99999999306853) +(num-test (expt 2 1.0) 2.0) +(num-test (expt -2 1.0) -2.0+0.0i) +(num-test (expt 2 -1.0) 0.50000000000000) +(num-test (expt 2 our-pi) 8.82497782707629) +(num-test (expt -2 our-pi) -7.96617830388569-3.79739869898975i) +(num-test (expt 2 -3.14159265358979) 0.11331473229676) +(num-test (expt 2 2.71828182845905) 6.58088599101792) +(num-test (expt -2 2.71828182845905) -4.16738324447062+5.09322857532248i) +(num-test (expt 2 -2.71828182845905) 0.15195522325791) +(num-test (expt 3 0.0) 1.0) +(num-test (expt -3 0.0) 1.0) +(num-test (expt 3 -0.0) 1.0) +(num-test (expt 3 0.00000001) 1.00000001098612) +(num-test (expt -3 0.00000001) 1.00000001098612+0.00000003141593i) +(num-test (expt 3 -0.00000001) 0.99999998901388) +(num-test (expt 3 1.0) 3.0) +(num-test (expt -3 1.0) -3.0+0.0i) +(num-test (expt 3 -1.0) 0.33333333333333) +(num-test (expt 3 our-pi) 31.54428070019755) +(num-test (expt -3 our-pi) -28.47456044077623-13.57354237468751i) +(num-test (expt 3 -3.14159265358979) 0.03170146783514) +(num-test (expt 3 2.71828182845905) 19.81299074527465) +(num-test (expt -3 2.71828182845905) -12.54668835889338+15.33411926056231i) +(num-test (expt 3 -2.71828182845905) 0.05047193595639) +(num-test (expt 10 0.0) 1.0) +(num-test (expt -10 0.0) 1.0) +(num-test (expt 10 -0.0) 1.0) +(num-test (expt 10 0.00000001) 1.00000002302585) +(num-test (expt -10 0.00000001) 1.00000002302585+0.00000003141593i) +(num-test (expt 10 -0.00000001) 0.99999997697415) +(num-test (expt 10 1.0) 10.0) +(num-test (expt -10 1.0) -10.0+0.0i) +(num-test (expt 10 -1.0) 0.1) +(num-test (expt 10 our-pi) 1385.45573136701182) +(num-test (expt -10 our-pi) -1250.63060831127905-596.16328730697728i) +(num-test (expt 10 -3.14159265358979) 0.00072178415907) +(num-test (expt 10 2.71828182845905) 522.73529967043669) +(num-test (expt -10 2.71828182845905) -331.02508265804954+404.56716151063557i) +(num-test (expt 10 -2.71828182845905) 0.00191301410222) +(num-test (expt 1234 0.0) 1.0) +(num-test (expt -1234 0.0) 1.0) +(num-test (expt 1234 -0.0) 1.0) +(num-test (expt 1234 0.00000001) 1.00000007118016) +(num-test (expt -1234 0.00000001) 1.00000007118016+0.00000003141593i) +(num-test (expt 1234 -0.00000001) 0.99999992881984) +(num-test (expt 1234 1.0) 1234.00000000000045) +(num-test (expt -1234 1.0) -1234.00000000000045+0.00000000000015i) +(num-test (expt 1234 -1.0) 0.00081037277147) +(num-test (expt 1234 -3.14159265358979) 0.00000000019424) +(num-test (expt 1234 2.71828182845905) 252968138.32201290130615) +(num-test (expt -1234 2.71828182845905) -160193503.19500353932381+195782840.25985893607140i) +(num-test (expt 1234 -2.71828182845905) 0.00000000395307) +(num-test (expt 1234000000 0.0) 1.0) +(num-test (expt -1234000000 0.0) 1.0) +(num-test (expt 1234000000 -0.0) 1.0) +(num-test (expt 1234000000 0.00000001) 1.00000020933529) +(num-test (expt -1234000000 0.00000001) 1.00000020933529+0.00000003141593i) +(num-test (expt 1234000000 -0.00000001) 0.99999979066475) +(num-test (expt 1234000000 -1.0) 0.00000000081037) +(num-test (expt 500029 0.0) 1.0) +(num-test (expt -500029 0.0) 1.0) +(num-test (expt 500029 -0.0) 1.0) +(num-test (expt 500029 0.00000001) 1.00000013122422) +(num-test (expt -500029 0.00000001) 1.00000013122422+0.00000003141593i) +(num-test (expt 500029 -0.00000001) 0.99999986877579) +(num-test (expt 500029 1.0) 500029.00000000040745) +(num-test (expt -500029 1.0) -500029.00000000040745+0.00000000006123i) +(num-test (expt 500029 -1.0) 0.00000199988401) +(num-test (expt 362880 0.0) 1.0) +(num-test (expt -362880 0.0) 1.0) +(num-test (expt 362880 -0.0) 1.0) +(num-test (expt 362880 0.00000001) 1.00000012801828) +(num-test (expt -362880 0.00000001) 1.00000012801828+0.00000003141593i) +(num-test (expt 362880 -0.00000001) 0.99999987198173) +(num-test (expt 362880 1.0) 362879.99999999982538) +(num-test (expt -362880 1.0) -362879.99999999982538+0.00000000004444i) +(num-test (expt 362880 -1.0) 0.00000275573192) +(num-test (expt 0.0 0.00000001) 0.0) +(num-test (expt -0.0 0.00000001) 0.0) +(num-test (expt 0.0 1.0) 0.0) +(num-test (expt -0.0 1.0) 0.0) +(num-test (expt 0.0 our-pi) 0.0) +(num-test (expt -0.0 our-pi) 0.0) +(num-test (expt 0.0 2.71828182845905) 0.0) +(num-test (expt -0.0 2.71828182845905) 0.0) +(num-test (expt 0.0 1234.0) 0.0) +(num-test (expt -0.0 1234.0) 0.0) +(num-test (expt 0.0 1234000000.0) 0.0) +(num-test (expt -0.0 1234000000.0) 0.0) +(num-test (expt 0.00000001 0.0) 1.0) +(num-test (expt -0.00000001 0.0) 1.0) +(num-test (expt 0.00000001 -0.0) 1.0) +(num-test (expt -0.00000001 -0.0) 1.0) +(num-test (expt 0.00000001 0.00000001) 0.99999981579321) +(num-test (expt -0.00000001 0.00000001) 0.99999981579321+0.00000003141592i) +(num-test (expt 0.00000001 -0.00000001) 1.00000018420682) +(num-test (expt -0.00000001 -0.00000001) 1.00000018420682-0.00000003141593i) +(num-test (expt 0.00000001 1.0) 0.00000001) +(num-test (expt -0.00000001 1.0) -0.00000001+0.0i) +(num-test (expt 0.00000001 -1.0) 100000000.00000017881393) +(num-test (expt -0.00000001 -1.0) -100000000.00000017881393-0.00000001224606i) +(num-test (expt 0.00000001 our-pi) 0.0) +(num-test (expt -0.00000001 our-pi) -0.0-0.0i) +(num-test (expt 0.00000001 2.71828182845905) 0.0) +(num-test (expt -0.00000001 2.71828182845905) -0.0+0.0i) +(num-test (expt 0.00000001 1234.0) 0.0) +(num-test (expt -0.00000001 1234.0) 0.0) +(num-test (expt 0.00000001 1234000000.0) 0.0) +(num-test (expt -0.00000001 1234000000.0) 0.0) +(num-test (expt 1.0 0.0) 1.0) +(num-test (expt -1.0 0.0) 1.0) +(num-test (expt 1.0 -0.0) 1.0) +(num-test (expt -1.0 -0.0) 1.0) +(num-test (expt 1.0 0.00000001) 1.0) +(num-test (expt -1.0 0.00000001) 1.0+0.00000003141593i) +(num-test (expt 1.0 -0.00000001) 1.0) +(num-test (expt -1.0 -0.00000001) 1.0-0.00000003141593i) +(num-test (expt 1.0 1.0) 1.0) +(num-test (expt -1.0 1.0) -1.0+0.0i) +(num-test (expt 1.0 -1.0) 1.0) +(num-test (expt -1.0 -1.0) -1.0-0.0i) +(num-test (expt 1.0 our-pi) 1.0) +(num-test (expt -1.0 our-pi) -0.90268536193307-0.43030121700009i) +(num-test (expt 1.0 -3.14159265358979) 1.0) +(num-test (expt -1.0 -3.14159265358979) -0.90268536193307+0.43030121700009i) +(num-test (expt 1.0 2.71828182845905) 1.0) +(num-test (expt -1.0 2.71828182845905) -0.63325565131482+0.77394268526671i) +(num-test (expt 1.0 -2.71828182845905) 1.0) +(num-test (expt -1.0 -2.71828182845905) -0.63325565131482-0.77394268526671i) +(num-test (expt 1.0 1234.0) 1.0) +(num-test (expt -1.0 1234.0) 1.0) +(num-test (expt 1.0 -1234.0) 1.0) +(num-test (expt -1.0 -1234.0) 1.0) +(num-test (expt 1.0 1234000000.0) 1.0) +(num-test (expt -1.0 1234000000.0) 1.0) +(num-test (expt 1.0 -1234000000.0) 1.0) +(num-test (expt -1.0 -1234000000.0) 1.0) +(num-test (expt 3.14159265358979 0.0) 1.0) +(num-test (expt -3.14159265358979 0.0) 1.0) +(num-test (expt 3.14159265358979 -0.0) 1.0) +(num-test (expt -3.14159265358979 -0.0) 1.0) +(num-test (expt 3.14159265358979 0.00000001) 1.00000001144730) +(num-test (expt -3.14159265358979 0.00000001) 1.00000001144730+0.00000003141593i) +(num-test (expt 3.14159265358979 -0.00000001) 0.99999998855270) +(num-test (expt -3.14159265358979 -0.00000001) 0.99999998855270-0.00000003141593i) +(num-test (expt 3.14159265358979 1.0) our-pi) +(num-test (expt -3.14159265358979 1.0) -3.14159265358979+0.0i) +(num-test (expt 3.14159265358979 -1.0) 0.31830988618379) +(num-test (expt -3.14159265358979 -1.0) -0.31830988618379-0.0i) +(num-test (expt 3.14159265358979 our-pi) 36.46215960720790) +(num-test (expt -3.14159265358979 our-pi) -32.91385774189388-15.68971165343314i) +(num-test (expt 3.14159265358979 -3.14159265358979) 0.02742569312330) +(num-test (expt -3.14159265358979 -3.14159265358979) -0.02475677172327+0.01180130912803i) +(num-test (expt 3.14159265358979 2.71828182845905) 22.45915771836104) +(num-test (expt -3.14159265358979 2.71828182845905) -14.22238854892297+17.38210083337688i) +(num-test (expt 3.14159265358979 -2.71828182845905) 0.04452526726692) +(num-test (expt -3.14159265358979 -2.71828182845905) -0.02819587712308-0.03446000491078i) +(num-test (expt 2.71828182845905 0.0) 1.0) +(num-test (expt -2.71828182845905 0.0) 1.0) +(num-test (expt 2.71828182845905 -0.0) 1.0) +(num-test (expt -2.71828182845905 -0.0) 1.0) +(num-test (expt 2.71828182845905 0.00000001) 1.00000001) +(num-test (expt -2.71828182845905 0.00000001) 1.00000001+0.00000003141593i) +(num-test (expt 2.71828182845905 -0.00000001) 0.99999999000000) +(num-test (expt -2.71828182845905 -0.00000001) 0.99999999000000-0.00000003141593i) +(num-test (expt 2.71828182845905 1.0) 2.71828182845905) +(num-test (expt -2.71828182845905 1.0) -2.71828182845905+0.0i) +(num-test (expt 2.71828182845905 -1.0) 0.36787944117144) +(num-test (expt -2.71828182845905 -1.0) -0.36787944117144-0.0i) +(num-test (expt 2.71828182845905 our-pi) 23.14069263277927) +(num-test (expt -2.71828182845905 our-pi) -20.88876450460231-9.95746820210997i) +(num-test (expt 2.71828182845905 -3.14159265358979) 0.04321391826377) +(num-test (expt -2.71828182845905 -3.14159265358979) -0.03900857144848+0.01859500162024i) +(num-test (expt 2.71828182845905 2.71828182845905) 15.15426224147926) +(num-test (expt -2.71828182845905 2.71828182845905) -9.59652220592352+11.72853041240636i) +(num-test (expt 2.71828182845905 -2.71828182845905) 0.06598803584531) +(num-test (expt -2.71828182845905 -2.71828182845905) -0.04178729661821-0.05107095765760i) +(num-test (expt 1234.0 0.0) 1.0) +(num-test (expt -1234.0 0.0) 1.0) +(num-test (expt 1234.0 -0.0) 1.0) +(num-test (expt -1234.0 -0.0) 1.0) +(num-test (expt 1234.0 0.00000001) 1.00000007118016) +(num-test (expt -1234.0 0.00000001) 1.00000007118016+0.00000003141593i) +(num-test (expt 1234.0 -0.00000001) 0.99999992881984) +(num-test (expt -1234.0 -0.00000001) 0.99999992881984-0.00000003141592i) +(num-test (expt 1234.0 1.0) 1234.00000000000045) +(num-test (expt -1234.0 1.0) -1234.00000000000045+0.00000000000015i) +(num-test (expt 1234.0 -1.0) 0.00081037277147) +(num-test (expt -1234.0 -1.0) -0.00081037277147-0.0i) +(num-test (expt 1234.0 -3.14159265358979) 0.00000000019424) +(num-test (expt -1234.0 -3.14159265358979) -0.00000000017534+0.00000000008358i) +(num-test (expt 1234.0 2.71828182845905) 252968138.32201290130615) +(num-test (expt -1234.0 2.71828182845905) -160193503.19500353932381+195782840.25985893607140i) +(num-test (expt 1234.0 -2.71828182845905) 0.00000000395307) +(num-test (expt -1234.0 -2.71828182845905) -0.00000000250330-0.00000000305945i) +(num-test (expt 1234000000.0 0.0) 1.0) +(num-test (expt -1234000000.0 0.0) 1.0) +(num-test (expt 1234000000.0 -0.0) 1.0) +(num-test (expt -1234000000.0 -0.0) 1.0) +(num-test (expt 1234000000.0 0.00000001) 1.00000020933529) +(num-test (expt -1234000000.0 0.00000001) 1.00000020933529+0.00000003141593i) +(num-test (expt 1234000000.0 -0.00000001) 0.99999979066475) +(num-test (expt -1234000000.0 -0.00000001) 0.99999979066475-0.00000003141592i) +(num-test (expt 1234000000.0 -1.0) 0.00000000081037) +(num-test (expt -1234000000.0 -1.0) -0.00000000081037-0.0i) +(num-test (expt 0.00000001 0) 1.0) +(num-test (expt -0.00000001 0) 1.0) +(num-test (expt 0.00000001 0) 1.0) +(num-test (expt -0.00000001 0) 1.0) +(num-test (expt 0.00000001 1) 0.00000001) +(num-test (expt -0.00000001 1) -0.00000001+0.0i) +(num-test (expt 0.00000001 -1) 100000000.00000017881393) +(num-test (expt -0.00000001 -1) -100000000.00000017881393-0.00000001224606i) +(num-test (expt 0.00000001 2) 0.0) +(num-test (expt -0.00000001 2) 0.0-0.0i) +(num-test (expt 0.00000001 3) 0.0) +(num-test (expt -0.00000001 3) -0.0+0.0i) +(num-test (expt 0.00000001 10) 0.0) +(num-test (expt -0.00000001 10) 0.0-0.0i) +(num-test (expt 0.00000001 1234) 0.0) +(num-test (expt -0.00000001 1234) 0.0) +(num-test (expt 0.00000001 1234000000) 0.0) +(num-test (expt -0.00000001 1234000000) 0.0) +(num-test (expt 0.00000001 500029) 0.0) +(num-test (expt -0.00000001 500029) -0.0) +(num-test (expt 0.00000001 362880) 0.0) +(num-test (expt -0.00000001 362880) 0.0) +(num-test (expt 1.0 0) 1.0) +(num-test (expt -1.0 0) 1.0) +(num-test (expt 1.0 0) 1.0) +(num-test (expt -1.0 0) 1.0) +(num-test (expt 1.0 1) 1.0) +(num-test (expt -1.0 1) -1.0+0.0i) +(num-test (expt 1.0 -1) 1.0) +(num-test (expt -1.0 -1) -1.0-0.0i) +(num-test (expt 1.0 2) 1.0) +(num-test (expt -1.0 2) 1.0-0.0i) +(num-test (expt 1.0 -2) 1.0) +(num-test (expt -1.0 -2) 1.0+0.0i) +(num-test (expt 1.0 3) 1.0) +(num-test (expt -1.0 3) -1.0+0.0i) +(num-test (expt 1.0 -3) 1.0) +(num-test (expt -1.0 -3) -1.0-0.0i) +(num-test (expt 1.0 10) 1.0) +(num-test (expt -1.0 10) 1.0-0.0i) +(num-test (expt 1.0 -10) 1.0) +(num-test (expt -1.0 -10) 1.0+0.0i) +(num-test (expt 1.0 1234) 1.0) +(num-test (expt -1.0 1234) 1.0) +(num-test (expt 1.0 -1234) 1.0) +(num-test (expt -1.0 -1234) 1.0) +(num-test (expt 1.0 1234000000) 1.0) +(num-test (expt -1.0 1234000000) 1.0) +(num-test (expt 1.0 -1234000000) 1.0) +(num-test (expt -1.0 -1234000000) 1.0) +(num-test (expt 1.0 500029) 1.0) +(num-test (expt -1.0 500029) -1.0) +(num-test (expt 1.0 -500029) 1.0) +(num-test (expt -1.0 -500029) -1.0) +(num-test (expt 1.0 362880) 1.0) +(num-test (expt -1.0 362880) 1.0) +(num-test (expt 1.0 -362880) 1.0) +(num-test (expt -1.0 -362880) 1.0) +(num-test (expt 3.14159265358979 0) 1.0) +(num-test (expt -3.14159265358979 0) 1.0) +(num-test (expt 3.14159265358979 0) 1.0) +(num-test (expt -3.14159265358979 0) 1.0) +(num-test (expt 3.14159265358979 1) our-pi) +(num-test (expt -3.14159265358979 1) -3.14159265358979+0.0i) +(num-test (expt 3.14159265358979 -1) 0.31830988618379) +(num-test (expt -3.14159265358979 -1) -0.31830988618379-0.0i) +(num-test (expt 3.14159265358979 2) 9.86960440108936) +(num-test (expt -3.14159265358979 2) 9.86960440108936-0.0i) +(num-test (expt 3.14159265358979 -2) 0.10132118364234) +(num-test (expt -3.14159265358979 -2) 0.10132118364234+0.0i) +(num-test (expt 3.14159265358979 3) 31.00627668029983) +(num-test (expt -3.14159265358979 3) -31.00627668029983) +(num-test (expt 3.14159265358979 -3) 0.03225153443320) +(num-test (expt -3.14159265358979 -3) -0.03225153443320-0.0i) +(num-test (expt 3.14159265358979 10) 93648.04747608296748) +(num-test (expt -3.14159265358979 10) 93648.04747608296748) +(num-test (expt 3.14159265358979 -10) 0.00001067827923) +(num-test (expt -3.14159265358979 -10) 0.00001067827923+0.0i) +(num-test (expt 2.71828182845905 0) 1.0) +(num-test (expt -2.71828182845905 0) 1.0) +(num-test (expt 2.71828182845905 0) 1.0) +(num-test (expt -2.71828182845905 0) 1.0) +(num-test (expt 2.71828182845905 1) 2.71828182845905) +(num-test (expt -2.71828182845905 1) -2.71828182845905+0.0i) +(num-test (expt 2.71828182845905 -1) 0.36787944117144) +(num-test (expt -2.71828182845905 -1) -0.36787944117144-0.0i) +(num-test (expt 2.71828182845905 2) 7.38905609893065) +(num-test (expt -2.71828182845905 2) 7.38905609893065-0.0i) +(num-test (expt 2.71828182845905 -2) 0.13533528323661) +(num-test (expt -2.71828182845905 -2) 0.13533528323661+0.0i) +(num-test (expt 2.71828182845905 3) 20.08553692318767) +(num-test (expt -2.71828182845905 3) -20.08553692318767+0.00000000000001i) +(num-test (expt 2.71828182845905 -3) 0.04978706836786) +(num-test (expt -2.71828182845905 -3) -0.04978706836786-0.0i) +(num-test (expt 2.71828182845905 10) 22026.46579480671789) +(num-test (expt -2.71828182845905 10) 22026.46579480671789-0.00000000002697i) +(num-test (expt 2.71828182845905 -10) 0.00004539992976) +(num-test (expt -2.71828182845905 -10) 0.00004539992976+0.0i) +(num-test (expt 1234.0 0) 1.0) +(num-test (expt -1234.0 0) 1.0) +(num-test (expt 1234.0 0) 1.0) +(num-test (expt -1234.0 0) 1.0) +(num-test (expt 1234.0 1) 1234.00000000000045) +(num-test (expt -1234.0 1) -1234.00000000000045+0.00000000000015i) +(num-test (expt 1234.0 -1) 0.00081037277147) +(num-test (expt -1234.0 -1) -0.00081037277147-0.0i) +(num-test (expt 1234.0 2) 1522756.00000000093132) +(num-test (expt -1234.0 2) 1522756.00000000093132-0.00000000037296i) +(num-test (expt 1234.0 -2) 0.00000065670403) +(num-test (expt -1234.0 -2) 0.00000065670403+0.0i) +(num-test (expt 1234.0 -3) 0.00000000053218) +(num-test (expt -1234.0 -3) -0.00000000053218-0.0i) +(num-test (expt 1234000000.0 0) 1.0) +(num-test (expt -1234000000.0 0) 1.0) +(num-test (expt 1234000000.0 0) 1.0) +(num-test (expt -1234000000.0 0) 1.0) +(num-test (expt 1234000000.0 -1) 0.00000000081037) +(num-test (expt -1234000000.0 -1) -0.00000000081037-0.0i) +(num-test (expt 0.0-1234000000.0i -1234000000.0+0.00000001i) 0.0) +(num-test (expt -0.0-1234000000.0i -1234000000.0-0.00000001i) 0.0) +(num-test (expt 0.00000001+0.0i 0.00000001+0.00000001i) 0.99999981579319-0.00000018420677i) +(num-test (expt -0.00000001+0.0i 0.00000001-0.00000001i) 0.99999984720911+0.00000021562270i) +(num-test (expt 0.00000001-0.0i -0.00000001+0.00000001i) 1.00000018420681-0.00000018420684i) +(num-test (expt -0.00000001-0.0i -0.00000001-0.00000001i) 1.00000021562275+0.00000015279091i) +(num-test (expt 0.00000001+0.00000001i 1.0+0.0i) 0.00000001+0.00000001i) +(num-test (expt -0.00000001+0.00000001i 1.0-0.0i) -0.00000001+0.00000001i) +(num-test (expt 0.00000001-0.00000001i -1.0+0.0i) 50000000.00000004470348+50000000.00000003725290i) +(num-test (expt -0.00000001-0.00000001i -1.0-0.0i) -50000000.00000003725290+50000000.00000004470348i) +(num-test (expt 1.0+0.00000001i 3.14159265358979+0.00000001i) 1.0+0.00000003141593i) +(num-test (expt -1.0+0.00000001i 3.14159265358979-0.00000001i) -0.90268540381008-0.43030120215971i) +(num-test (expt 1.0-0.00000001i -3.14159265358979+0.00000001i) 1.0+0.00000003141593i) +(num-test (expt -1.0-0.00000001i -3.14159265358979-0.00000001i) -0.90268534709269-0.43030117512308i) +(num-test (expt 1.0+1.0i 2.71828182845905+0.0i) -1.37164508585166+2.16782742612896i) +(num-test (expt -1.0+1.0i 2.71828182845905-0.0i) 2.54637618158683+0.31121428769451i) +(num-test (expt 1.0-1.0i -2.71828182845905+0.0i) -0.20842863525121+0.32941270052205i) +(num-test (expt -1.0-1.0i -2.71828182845905-0.0i) 0.38693516117166+0.04729063656767i) +(num-test (expt 3.14159265358979-1.0i -1234.0+0.00000001i) -0.0) +(num-test (expt -3.14159265358979-1.0i -1234.0-0.00000001i) -0.0) +(num-test (expt 3.14159265358979-3.14159265358979i -1234000000.0+0.0i) 0.0) +(num-test (expt -3.14159265358979-3.14159265358979i -1234000000.0-0.0i) 0.0) +(num-test (expt 2.71828182845905+3.14159265358979i 0.0+0.00000001i) 0.99999999142488+0.00000001424157i) +(num-test (expt -2.71828182845905+3.14159265358979i 0.0-0.00000001i) 1.00000002284081-0.00000001424157i) +(num-test (expt 2.71828182845905-3.14159265358979i -0.0+0.00000001i) 1.00000000857512+0.00000001424157i) +(num-test (expt -2.71828182845905-3.14159265358979i -0.0-0.00000001i) 0.99999997715919-0.00000001424157i) +(num-test (expt 2.71828182845905+2.71828182845905i 0.00000001+0.0i) 1.00000001346574+0.00000000785398i) +(num-test (expt -2.71828182845905+2.71828182845905i 0.00000001-0.0i) 1.00000001346574+0.00000002356195i) +(num-test (expt 2.71828182845905-2.71828182845905i -0.00000001+0.0i) 0.99999998653426+0.00000000785398i) +(num-test (expt -2.71828182845905-2.71828182845905i -0.00000001-0.0i) 0.99999998653426+0.00000002356194i) +(num-test (expt 1234.0+2.71828182845905i 1.0+0.00000001i) 1233.99999977932634+2.71836966474906i) +(num-test (expt -1234.0+2.71828182845905i 1.0-0.00000001i) -1234.00003854658053+2.71836975014915i) +(num-test (expt 1234.0-2.71828182845905i -1.0+0.00000001i) 0.00081036883911+0.00000178515565i) +(num-test (expt -1234.0-2.71828182845905i -1.0-0.00000001i) -0.00081036881365+0.00000178515559i) +(num-test (expt 1234.0+1234.0i 3.14159265358979+0.0i) -11947544392.17545890808105+9547275530.50568199157715i) +(num-test (expt -1234.0+1234.0i 3.14159265358979-0.0i) 6676669154.05054950714111+13759228759.84499740600586i) +(num-test (expt 1234.0-1234.0i -3.14159265358979+0.0i) -5.108095859217296E-11+4.081876325659167E-11i) +(num-test (expt -1234.0-1234.0i -3.14159265358979-0.0i) 2.854567008891443E-11+5.882669873167984E-11i) +(num-test (expt 1234000000.0-1234.0i -2.71828182845905+0.00000001i) 0.0+0.0i) +(num-test (expt -1234000000.0-1234.0i -2.71828182845905-0.00000001i) -0.0+0.0i) +(num-test (expt 1234000000.0-1234000000.0i -1234.0+0.0i) 0.0) +(num-test (expt -1234000000.0-1234000000.0i -1234.0-0.0i) 0.0) +(num-test (expt 1.0e+00+0.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 1.0e+00+0.0e+00i 1.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 1.0e+00+0.0e+00i 0.0e+00+1.0e+00i) 1e0+0.0i) +(num-test (expt 1.0e+00+0.0e+00i -1.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 1.0e+00+0.0e+00i 0.0e+00-1.0e+00i) 1e0+0.0i) +(num-test (expt 1.0e+00+0.0e+00i 5.0e-01+1.00000000000000005551e-01i) 1e0+0.0i) +(num-test (expt 1.0e+00+0.0e+00i 5.0e-01-1.00000000000000005551e-01i) 1e0+0.0i) +(num-test (expt 0.0e+00+1.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 0.0e+00+1.0e+00i 1.0e+00+0.0e+00i) 0+1i) +(num-test (expt 0.0e+00+1.0e+00i 0.0e+00+1.0e+00i) 2.0787957635076190855e-1+0.0i) +(num-test (expt 0.0e+00+1.0e+00i -1.0e+00+0.0e+00i) 0-1i) +(num-test (expt 0.0e+00+1.0e+00i 0.0e+00-1.0e+00i) 4.8104773809653516555e0+0.0i) +(num-test (expt 0.0e+00+1.0e+00i 5.0e-01+1.00000000000000005551e-01i) 6.0431891044739184057e-1+6.0431891044739184057e-1i) +(num-test (expt 0.0e+00+1.0e+00i 5.0e-01-1.00000000000000005551e-01i) 8.2737771622906514822e-1+8.2737771622906514822e-1i) +(num-test (expt -1.0e+00+0.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt -1.0e+00+0.0e+00i 1.0e+00+0.0e+00i) -1e0+0.0i) +(num-test (expt -1.0e+00+0.0e+00i 0.0e+00+1.0e+00i) 4.3213918263772249774e-2+0.0i) +(num-test (expt -1.0e+00+0.0e+00i -1.0e+00+0.0e+00i) -1e0+0.0i) +(num-test (expt -1.0e+00+0.0e+00i 0.0e+00-1.0e+00i) 2.3140692632779269006e1+0.0i) +(num-test (expt -1.0e+00+0.0e+00i 5.0e-01+1.00000000000000005551e-01i) 0+7.3040269104864559813e-1i) +(num-test (expt -1.0e+00+0.0e+00i 5.0e-01-1.00000000000000005551e-01i) 0+1.3691077706248469087e0i) +(num-test (expt 0.0e+00-1.0e+00i 0.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 0.0e+00-1.0e+00i 1.0e+00+0.0e+00i) 0-1i) +(num-test (expt 0.0e+00-1.0e+00i 0.0e+00+1.0e+00i) 4.8104773809653516555e0+0.0i) +(num-test (expt 0.0e+00-1.0e+00i -1.0e+00+0.0e+00i) 0+1i) +(num-test (expt 0.0e+00-1.0e+00i 0.0e+00-1.0e+00i) 2.0787957635076190855e-1+0.0i) +(num-test (expt 0.0e+00-1.0e+00i 5.0e-01+1.00000000000000005551e-01i) 8.2737771622906514822e-1-8.2737771622906514822e-1i) +(num-test (expt 0.0e+00-1.0e+00i 5.0e-01-1.00000000000000005551e-01i) 6.0431891044739184057e-1-6.0431891044739184057e-1i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i 0.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i 1.0e+00+0.0e+00i) 5e-1+1.0000000000000000555e-1i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i 0.0e+00+1.0e+00i) 6.4160554864378080418e-1-5.1201864456768275590e-1i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i -1.0e+00+0.0e+00i) 1.9230769230769230687e0-3.8461538461538463509e-1i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i 0.0e+00-1.0e+00i) 9.5219021866126714108e-1+7.5987364224031834571e-1i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i 5.0e-01+1.00000000000000005551e-01i) 6.9977300530987816719e-1+2.1940939105372143160e-2i) +(num-test (expt 5.0e-01+1.00000000000000005551e-01i 5.0e-01-1.00000000000000005551e-01i) 7.1829191470060938876e-1+1.2038189555821612762e-1i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i 0.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i 1.0e+00+0.0e+00i) 5e-1-1.0000000000000000555e-1i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i 0.0e+00+1.0e+00i) 9.5219021866126714108e-1-7.5987364224031834571e-1i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i -1.0e+00+0.0e+00i) 1.9230769230769230687e0+3.8461538461538463509e-1i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i 0.0e+00-1.0e+00i) 6.4160554864378080418e-1+5.1201864456768275590e-1i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i 5.0e-01+1.00000000000000005551e-01i) 7.1829191470060938876e-1-1.2038189555821612762e-1i) +(num-test (expt 5.0e-01-1.00000000000000005551e-01i 5.0e-01-1.00000000000000005551e-01i) 6.9977300530987816719e-1-2.1940939105372143160e-2i) + +(num-test (expt 0 10) 0) +(num-test (expt 1 10) 1) +(num-test (expt 2 10) 1024) +(num-test (expt 3 10) 59049) +(num-test (expt 4 10) 1048576) +(num-test (expt 5 10) 9765625) +(num-test (expt 6 10) 60466176) +(num-test (expt 7 10) 282475249) +(num-test (expt 8 10) 1073741824) +(if (or with-bignums with-64-bit-ints) (num-test (expt 9 10) 3486784401)) +(if (or with-bignums with-64-bit-ints) (num-test (expt 10 10) 10000000000)) +(if (or with-bignums with-64-bit-ints) (num-test (expt 11 10) 25937424601)) +(num-test (expt 0 1/10) 0) +(num-test (expt 1 1/10) 1) +(num-test (expt 1024 1/10) 2) +(num-test (expt 59049 1/10) 3) +(num-test (expt 1048576 1/10) 4) +(num-test (expt 9765625 1/10) 5) +(num-test (expt 60466176 1/10) 6) +(num-test (expt 282475249 1/10) 7) +(num-test (expt 1073741824 1/10) 8) +(if (or with-bignums with-64-bit-ints) (num-test (expt 3486784401 1/10) 9)) +(if (or with-bignums with-64-bit-ints) (num-test (expt 10000000000 1/10) 10)) +(if (or with-bignums with-64-bit-ints) (num-test (expt 25937424601 1/10) 11)) +(num-test (expt 2 9) 512) +(num-test (expt 8 1/3) 2) +(num-test (expt 1024 1/10) 2) +(num-test (expt 512 1/9) 2) +(num-test (expt (expt 20 10) 1/10) 20) +(num-test (expt (expt 40 10) 1/10) 40) +(num-test (expt (expt 2 30) 1/30) 2) +(num-test (expt (expt 2 50) 1/50) 2) +(num-test (expt (expt 2 1/10) 10) 2) +(num-test (expt (expt 2 1/30) 30) 2) +(num-test (expt 64 1/6) 2) +(num-test (expt 64 1/3) 4) +(num-test (expt 64 2/3) 16) +(num-test (expt 64 1/2) 8) +(num-test (expt 64 3/2) 512) +(num-test (expt 1/2 3) 1/8) +(num-test (expt 1/64 1/2) 1/8) +(num-test (expt 1/64 1/3) 1/4) +(num-test (expt 1/64 3/2) 1/512) +(num-test (expt 1/64 2/3) 1/16) +(num-test (expt 1/2 10) 1/1024) +(num-test (expt 2/3 5) (* 2/3 2/3 2/3 2/3 2/3)) +(num-test (expt 2 -10) 1/1024) +(num-test (expt 2 -9) 1/512) +(num-test (expt 64 -1/6) 1/2) +(num-test (expt 64 -1/3) 1/4) +(num-test (expt 64 -2/3) 1/16) +(num-test (expt 64 -1/2) 1/8) +(num-test (expt 64 -3/2) 1/512) +(num-test (expt 1/2 -3) 8) +(num-test (expt 1/64 -1/2) 8) +(num-test (expt 1/64 -1/3) 4) +(num-test (expt 1/64 -3/2) 512) +(num-test (expt 1/64 -2/3) 16) +(num-test (expt 1/2 -10) 1024) +(num-test (expt 2718/1000 617/5) 3.858179469787681136058424024656091858698003418770850904916305853631035158956514884526199288e53) ; not an int! +(num-test (expt 2/3 -5) (/ 1 (* 2/3 2/3 2/3 2/3 2/3))) +;(num-test (expt 0 0.0) 0.0) ; ?? -- guile returns 1.0 +(num-test (expt 0 1.0+i) 0.0) ; ?? +;(num-test (expt 0 -1.0+i) 0.0) ; ?? guile says +inf.0+nan.0i +(num-test (expt 0 1.0) 0.0) +;(num-test (expt 0 -1.0) 0.0) ; ?? guile says inf +(test (expt 0 0) 1 ) +(test (expt 0 1) 0 ) +(test (expt 0 256) 0 ) +;(test (expt 0 -255) 0 ) +(test (expt -1 256) 1 ) +(test (expt -1 255) -1 ) +(test (expt -1 -256) 1 ) +(test (expt -1 -255) -1 ) +(test (expt 256 0) 1 ) +(test (expt -256 0) 1 ) +(test (expt 256 1) 256 ) +(test (expt -256 1) -256 ) +(test (expt 2 3) 8 ) +(test (expt -2 3) -8 ) +(test (expt 3 2) 9 ) +(test (expt -3 2) 9 ) + +(let ((x-10 (lambda (n) (- (expt n 10) (* n n n n n n n n n n))))) + (let ((happy #t) + (lim (if with-bignums 100 + (if with-64-bit-ints 74 + 8)))) + (do ((i 1 (+ i 2))) + ((or (not happy) (> i lim))) ; stop around 63 bits + (let ((val (x-10 (/ i 2)))) + (if (not (= val 0)) + (begin + (set! happy #f) + (display "(expt ") (display i) (display "/2 10) = ") (display (expt (/ i 2) 10)) + (display " but (* ") (display i) (display "/2 ... 10x) = ") + (display (/ (* i i i i i i i i i i) 1024)) (newline))))))) + +(let ((x-10 (lambda (n) (- (expt n -10) (/ 1 (* n n n n n n n n n n)))))) + (let ((happy #t) + (lim (if with-bignums 100 + (if with-64-bit-ints 74 + 8)))) + (do ((i 1 (+ i 2))) + ((or (not happy) (> i lim))) ; stop around 63 bits + (let ((val (x-10 (/ i 2)))) + (if (not (= val 0)) + (begin + (set! happy #f) + (display "(expt ") (display i) (display "/2 -10) = ") (display (expt (/ i 2) -10)) + (display " but (* 1/(") (display i) (display "/2) ... 10x) = ") + (display (/ 1024 (* i i i i i i i i i i))) + (display " [diff=") (display val) (display "]") + (newline))))))) + +(let ((happy #t) + (lim (if with-bignums 50 + (if with-64-bit-ints 19 + 4)))) + (do ((i 1 (+ i 1))) + ((or (not happy) (> i lim))) + (let* ((val1 (expt 3 i)) + (val2 (sqrt (* val1 val1)))) + (if (not (= val1 val2)) + (begin + (set! happy #f) + (display "[3^i] (sqrt ") (display (* val1 val1)) (display " = ") (display val2) + (display " but should be ") (display val1) (newline)))))) + + + +;;; -------- rationalize (both versions) + +(if with-rationalize + (begin + (num-test (rationalize 0.0 1.0001) 0) + (num-test (rationalize -0.0 1.0001) 0) + (num-test (rationalize 0.0 0.50000000000000) 0) + (num-test (rationalize -0.0 0.50000000000000) 0) + (num-test (rationalize 0.0 0.1) 0) + (num-test (rationalize -0.0 0.1) 0) + (num-test (rationalize 0.0 0.001) 0) + (num-test (rationalize -0.0 0.001) 0) + (num-test (rationalize 0.0 0.00300000000000) 0) + (num-test (rationalize -0.0 0.00300000000000) 0) + (num-test (rationalize 0.0 0.00002000000000) 0) + (num-test (rationalize -0.0 0.00002000000000) 0) + (num-test (rationalize 0.0 0.00000001) 0) + (num-test (rationalize -0.0 0.00000001) 0) + (num-test (rationalize 0.00000001 1.0) 0) + (num-test (rationalize -0.00000001 1.0) 0) + (num-test (rationalize 0.00000001 0.50000000000000) 0) + (num-test (rationalize -0.00000001 0.50000000000000) 0) + (num-test (rationalize 0.00000001 0.1) 0) + (num-test (rationalize -0.00000001 0.1) 0) + (num-test (rationalize 0.00000001 0.001) 0) + (num-test (rationalize -0.00000001 0.001) 0) + (num-test (rationalize 0.00000001 0.00300000000000) 0) + (num-test (rationalize -0.00000001 0.00300000000000) 0) + (num-test (rationalize 0.00000001 0.00002000000000) 0) + (num-test (rationalize -0.00000001 0.00002000000000) 0) + (num-test (rationalize 0.00000001 0.000000011) 0) + (num-test (rationalize -0.00000001 0.000000011) 0) + (num-test (rationalize 1.0 1.0001) 0) + (num-test (rationalize -1.0 1.0001) 0) + (num-test (rationalize 1.0 0.999) 1) + (num-test (rationalize -1.0 0.999) -1) + (num-test (rationalize 1.0 0.50000000000000) 1) + (num-test (rationalize -1.0 0.50000000000000) -1) + (num-test (rationalize 1.0 0.1) 1) + (num-test (rationalize -1.0 0.1) -1) + (num-test (rationalize 1.0 0.001) 1) + (num-test (rationalize -1.0 0.001) -1) + (num-test (rationalize 1.0 0.00300000000000) 1) + (num-test (rationalize -1.0 0.00300000000000) -1) + (num-test (rationalize 1.0 0.00002000000000) 1) + (num-test (rationalize -1.0 0.00002000000000) -1) + (num-test (rationalize 1.0 0.00000001) 1) + (num-test (rationalize -1.0 0.00000001) -1) + (num-test (rationalize 3.14159265358979 1.0) 3) + (num-test (rationalize -3.14159265358979 1.0) -3) + (num-test (rationalize 3.14159265358979 0.50000000000000) 3) + (num-test (rationalize -3.14159265358979 0.50000000000000) -3) + (num-test (rationalize 3.14159265358979 0.1) 16/5) + (num-test (rationalize -3.14159265358979 0.1) -16/5) + (num-test (rationalize 3.14159265358979 0.001) 201/64) + (num-test (rationalize -3.14159265358979 0.001) -201/64) + (num-test (rationalize 3.14159265358979 0.00300000000000) 22/7) + (num-test (rationalize -3.14159265358979 0.00300000000000) -22/7) + (num-test (rationalize 3.14159265358979 0.00002000000000) 355/113) + (num-test (rationalize -3.14159265358979 0.00002000000000) -355/113) + (num-test (rationalize 3.14159265358979 0.00000001) 100798/32085) + (num-test (rationalize -3.14159265358979 0.00000001) -100798/32085) + (num-test (rationalize 2.71828182845905 1.0) 2) + (num-test (rationalize -2.71828182845905 1.0) -2) + (num-test (rationalize 2.71828182845905 0.50000000000000) 3) + (num-test (rationalize -2.71828182845905 0.50000000000000) -3) + (num-test (rationalize 2.71828182845905 0.1) 8/3) + (num-test (rationalize -2.71828182845905 0.1) -8/3) + (num-test (rationalize 2.71828182845905 0.001) 87/32) + (num-test (rationalize -2.71828182845905 0.001) -87/32) + (num-test (rationalize 2.71828182845905 0.00300000000000) 68/25) + (num-test (rationalize -2.71828182845905 0.00300000000000) -68/25) + (num-test (rationalize 2.71828182845905 0.00002000000000) 878/323) + (num-test (rationalize -2.71828182845905 0.00002000000000) -878/323) + (num-test (rationalize 2.71828182845905 0.00000001) 23225/8544) + (num-test (rationalize -2.71828182845905 0.00000001) -23225/8544) + (num-test (rationalize 1234.12339999999995 1.0) 1234) + (num-test (rationalize -1234.12339999999995 1.0) -1234) + (num-test (rationalize 1234.12339999999995 0.50000000000000) 1234) + (num-test (rationalize -1234.12339999999995 0.50000000000000) -1234) + (num-test (rationalize 1234.12339999999995 0.1) 6171/5) + (num-test (rationalize -1234.12339999999995 0.1) -6171/5) + (num-test (rationalize 1234.12339999999995 0.001) 60472/49) + (num-test (rationalize -1234.12339999999995 0.001) -60472/49) + (num-test (rationalize 1234.12339999999995 0.00300000000000) 9873/8) + (num-test (rationalize -1234.12339999999995 0.00300000000000) -9873/8) + (num-test (rationalize 1234.12339999999995 0.00002000000000) 290019/235) + (num-test (rationalize -1234.12339999999995 0.00002000000000) -290019/235) + (num-test (rationalize 1234.12339999999995 0.00000001) 6170617/5000) + (num-test (rationalize -1234.12339999999995 0.00000001) -6170617/5000) + (num-test (rationalize 1234000000.01234006881714 1.0) 1234000000/1) + (num-test (rationalize -1234000000.01234006881714 1.0) -1234000000/1) + (num-test (rationalize 1234000000.01234006881714 0.50000000000000) 1234000000/1) + (num-test (rationalize -1234000000.01234006881714 0.50000000000000) -1234000000/1) + (num-test (rationalize 1234000000.01234006881714 0.1) 1234000000/1) + (num-test (rationalize -1234000000.01234006881714 0.1) -1234000000/1) + (num-test (rationalize 1234000000.01234006881714 0.001) 92550000001/75) + (num-test (rationalize -1234000000.01234006881714 0.001) -92550000001/75) + (num-test (rationalize 1234000000.01234006881714 0.00300000000000) 81444000001/66) + (num-test (rationalize -1234000000.01234006881714 0.00300000000000) -81444000001/66) + (num-test (rationalize 1234000000.01234006881714 0.00002000000000) 99954000001/81) + (num-test (rationalize -1234000000.01234006881714 0.00002000000000) -99954000001/81) + (num-test (rationalize 1234000000.01234006881714 0.000001) 2400130000024/1945) + (num-test (rationalize -1234000000.01234006881714 0.000001) -2400130000024/1945) + (num-test (rationalize 0.33 1.0) 0) + (num-test (rationalize -0.33 1.0) 0) + (num-test (rationalize 0.33 0.50000000000000) 0) + (num-test (rationalize -0.33 0.50000000000000) 0) + (num-test (rationalize 0.33 0.1) 1/3) + (num-test (rationalize -0.33 0.1) -1/3) + (num-test (rationalize 0.33 0.001) 26/79) + (num-test (rationalize -0.33 0.001) -26/79) + (num-test (rationalize 0.33 0.00300000000000) 18/55) + (num-test (rationalize -0.33 0.00300000000000) -18/55) + (num-test (rationalize 0.33 0.00002000000000) 33/100) + (num-test (rationalize -0.33 0.00002000000000) -33/100) + (num-test (rationalize 0.33 0.00000001) 33/100) + (num-test (rationalize -0.33 0.00000001) -33/100) + (num-test (rationalize 0.99990 1.0) 0) + (num-test (rationalize -0.99990 1.0) 0) + (num-test (rationalize 0.99990 0.50000000000000) 1) + (num-test (rationalize -0.99990 0.50000000000000) -1) + (num-test (rationalize 0.99990 0.1) 1) + (num-test (rationalize -0.99990 0.1) -1) + (num-test (rationalize 0.99990 0.001) 1) + (num-test (rationalize -0.99990 0.001) -1) + (num-test (rationalize 0.99990 0.00300000000000) 1) + (num-test (rationalize -0.99990 0.00300000000000) -1) + (num-test (rationalize 0.99990 0.00002000000000) 8333/8334) + (num-test (rationalize -0.99990 0.00002000000000) -8333/8334) + (num-test (rationalize 0.99990 0.00000001) 9999/10000) + (num-test (rationalize -0.99990 0.00000001) -9999/10000) + (num-test (rationalize 0.5010 1.0) 0) + (num-test (rationalize -0.5010 1.0) 0) + (num-test (rationalize 0.5010 0.50000000000000) 1) + (num-test (rationalize -0.5010 0.50000000000000) -1) + (num-test (rationalize 0.5010 0.1) 1/2) + (num-test (rationalize -0.5010 0.1) -1/2) + (num-test (rationalize 0.5010 0.00099) 127/253) + (num-test (rationalize -0.5010 0.00099) -127/253) + (num-test (rationalize 0.5010 0.00300000000000) 1/2) + (num-test (rationalize -0.5010 0.00300000000000) -1/2) + (num-test (rationalize 0.5010 0.00002000000000) 246/491) + (num-test (rationalize -0.5010 0.00002000000000) -246/491) + (num-test (rationalize 0.5010 0.00000001) 501/1000) + (num-test (rationalize -0.5010 0.00000001) -501/1000) + (num-test (rationalize 0.499 1.0) 0) + (num-test (rationalize -0.499 1.0) 0) + (num-test (rationalize 0.499 0.50000000000000) 0) + (num-test (rationalize -0.499 0.50000000000000) 0) + (num-test (rationalize 0.499 0.1) 1/2) + (num-test (rationalize -0.499 0.1) -1/2) + (num-test (rationalize 0.499 0.00099) 126/253) + (num-test (rationalize -0.499 0.00099) -126/253) + (num-test (rationalize 0.499 0.00300000000000) 1/2) + (num-test (rationalize -0.499 0.00300000000000) -1/2) + (num-test (rationalize 0.499 0.00002000000000) 245/491) + (num-test (rationalize -0.499 0.00002000000000) -245/491) + (num-test (rationalize 0.499 0.00000001) 499/1000) + (num-test (rationalize -0.499 0.00000001) -499/1000) + (num-test (rationalize 1.501 1.0) 1) + (num-test (rationalize -1.501 1.0) -1) + (num-test (rationalize 1.501 0.50000000000000) 2) + (num-test (rationalize -1.501 0.50000000000000) -2) + (num-test (rationalize 1.501 0.1) 3/2) + (num-test (rationalize -1.501 0.1) -3/2) + (num-test (rationalize 1.501 0.001) 3/2) + (num-test (rationalize -1.501 0.001) -3/2) + (num-test (rationalize 1.501 0.00300000000000) 3/2) + (num-test (rationalize -1.501 0.00300000000000) -3/2) + (num-test (rationalize 1.501 0.00002000000000) 737/491) + (num-test (rationalize -1.501 0.00002000000000) -737/491) + (num-test (rationalize 1.501 0.00000001) 1501/1000) + (num-test (rationalize -1.501 0.00000001) -1501/1000) + (num-test (rationalize 1.499 1.0) 1) + (num-test (rationalize -1.499 1.0) -1) + (num-test (rationalize 1.499 0.50000000000000) 1) + (num-test (rationalize -1.499 0.50000000000000) -1) + (num-test (rationalize 1.499 0.1) 3/2) + (num-test (rationalize -1.499 0.1) -3/2) + (num-test (rationalize 1.499 0.001) 3/2) + (num-test (rationalize -1.499 0.001) -3/2) + (num-test (rationalize 1.499 0.00300000000000) 3/2) + (num-test (rationalize -1.499 0.00300000000000) -3/2) + (num-test (rationalize 1.499 0.00002000000000) 736/491) + (num-test (rationalize -1.499 0.00002000000000) -736/491) + (num-test (rationalize 1.499 0.00000001) 1499/1000) + (num-test (rationalize -1.499 0.00000001) -1499/1000) + + (num-test (rationalize 1.16 .2) 1) + (num-test (rationalize 1.16 .1) 5/4) + (num-test (rationalize 1.16 .041) 6/5) + (num-test (rationalize 1.16 .039) 7/6) + (num-test (rationalize 1.16 .007) 7/6) + (num-test (rationalize 1.16 .006) 22/19) + (num-test (rationalize 1.16 .0022) 22/19) + (num-test (rationalize 1.16 .002) 29/25) + (num-test (rationalize 1.16 .0000001) 29/25) + + (num-test (rationalize 23.1 22.0) 2) + (num-test (rationalize 23.1 22) 2) + (num-test (rationalize 23.1 .5) 23) + (num-test (rationalize 23.1 1/2) 23) + + (num-test (rationalize 1/2 3/4) 0) + (num-test (rationalize 1/2 1/4) 1/2) + (num-test (rationalize 1 3) 0) + (num-test (rationalize 11/10 1/5) 1) + (num-test (rationalize 3/4 1/2) 1) + (num-test (rationalize 1/4 1/3) 0) + (num-test (rationalize 1/4 1/6) 1/3) + (num-test (rationalize 2/3 1/4) 1/2) + (num-test (rationalize 1/3 1/3) 0) + (num-test (rationalize 1/3 1/4) 1/2) + (num-test (rationalize 3/10 1/10) 1/3) + + (num-test (rationalize (exact->inexact 1/2) 3/4) 0) + (num-test (rationalize (exact->inexact 1/2) 1/4) 1/2) + (num-test (rationalize (exact->inexact 1) 3) 0) + (num-test (rationalize (exact->inexact 11/10) 1/5) 1) + (num-test (rationalize (exact->inexact 3/4) 1/2) 1) + (num-test (rationalize (exact->inexact 1/4) 1/3) 0) + (num-test (rationalize (exact->inexact 1/4) 1/6) 1/3) + (num-test (rationalize (exact->inexact 2/3) 1/4) 1/2) + (num-test (rationalize (exact->inexact 1/3) 1/4) 1/2) + (num-test (rationalize (exact->inexact 3/10) 1/10) 1/3) + + (num-test (rationalize 1/2 (exact->inexact 3/4)) 0) + (num-test (rationalize 1/2 (exact->inexact 1/4)) 1/2) + (num-test (rationalize 1 (exact->inexact 3)) 0) + (num-test (rationalize 11/10 (exact->inexact 1/5)) 1) + (num-test (rationalize 3/4 (exact->inexact 1/2)) 1) + (num-test (rationalize 1/4 (exact->inexact 1/3)) 0) + (num-test (rationalize 1/4 (exact->inexact 1/6)) 1/3) + (num-test (rationalize 2/3 (exact->inexact 1/4)) 1/2) + (num-test (rationalize 1/3 (exact->inexact 1/4)) 1/2) + (num-test (rationalize 3/10 (exact->inexact 1/10)) 1/3) + + (num-test (rationalize (exact->inexact 1/2) (exact->inexact 3/4)) 0) + (num-test (rationalize (exact->inexact 1/2) (exact->inexact 1/4)) 1/2) + (num-test (rationalize (exact->inexact 1) (exact->inexact 3)) 0) + (num-test (rationalize (exact->inexact 11/10) (exact->inexact 1/5)) 1) + (num-test (rationalize (exact->inexact 3/4) (exact->inexact 1/2)) 1) + (num-test (rationalize (exact->inexact 1/4) (exact->inexact 1/3)) 0) + (num-test (rationalize (exact->inexact 1/4) (exact->inexact 1/6)) 1/3) + (num-test (rationalize (exact->inexact 2/3) (exact->inexact 1/4)) 1/2) + (num-test (rationalize (exact->inexact 1/3) (exact->inexact 1/4)) 1/2) + (num-test (rationalize (exact->inexact 3/10) (exact->inexact 1/10)) 1/3) + + (num-test (rationalize -1/2 3/4) 0) + (num-test (rationalize -1/2 1/4) -1/2) + (num-test (rationalize -1 3) 0) + (num-test (rationalize -11/10 1/5) -1) + (num-test (rationalize -3/4 1/2) -1) + (num-test (rationalize -1/4 1/3) 0) + (num-test (rationalize -1/4 1/6) -1/3) + (num-test (rationalize -2/3 1/4) -1/2) + (num-test (rationalize -1/3 1/4) -1/2) + (num-test (rationalize -1/3 1/3) 0) + (num-test (rationalize -3/10 1/10) -1/3) + + (num-test (rationalize .239 .0005) 11/46) ;baseball of course... the average .001 is the hardest to get: 1/667 + (num-test (rationalize .001 .0005) 1/667) + (num-test (rationalize .334 .0005) 96/287) + + (num-test (rationalize 1.0000001 0.00000001) 9090911/9090910) + (num-test (rationalize 0.000000015 0.000000001) 1/62500001) + + (num-test (rationalize -1 -1) 0) ;; spec says "differs by no more than", but that seems to imply a comparison + ;; on either side, so a negative error doesn't change the result?? + (num-test (rationalize 1/4 -1/6) 1/3) + (num-test (rationalize -3/10 -1/10) -1/3) + (num-test (rationalize (exact->inexact 1/3) (exact->inexact -1/4)) 1/2) + + (if with-bigfloats + (begin + ;; can this sort of thing be handled with locally set precisions? + (num-test (rationalize 385817946978768113605842402465609185854927496022065152.5) 771635893957536227211684804931218371709854992044130305/2) + )) + + (num-test (rationalize 0.5 0.02) 1/2) + )) + + +;; -------- gcd and lcm + +(num-test (gcd) 0) +(num-test (lcm) 1) +(num-test (gcd 1 0) 1) +(num-test (lcm 1 0) 0) +(num-test (gcd 0) 0) +(num-test (lcm 0) 0) +(num-test (gcd 0) 0) +(num-test (lcm 0) 0) +(num-test (gcd 1) 1) +(num-test (lcm 1) 1) +(num-test (gcd -1) 1) +(num-test (lcm -1) 1) +(num-test (gcd 2) 2) +(num-test (lcm 2) 2) +(num-test (gcd -2) 2) +(num-test (lcm -2) 2) +(num-test (gcd 3) 3) +(num-test (lcm 3) 3) +(num-test (gcd -3) 3) +(num-test (lcm -3) 3) +(num-test (gcd 10) 10) +(num-test (lcm 10) 10) +(num-test (gcd -10) 10) +(num-test (lcm -10) 10) +(num-test (gcd 1234) 1234) +(num-test (lcm 1234) 1234) +(num-test (gcd -1234) 1234) +(num-test (lcm -1234) 1234) +(num-test (gcd 1234000000) 1234000000) +(num-test (lcm 1234000000) 1234000000) +(num-test (gcd -1234000000) 1234000000) +(num-test (lcm -1234000000) 1234000000) +(num-test (gcd 500029) 500029) +(num-test (lcm 500029) 500029) +(num-test (gcd -500029) 500029) +(num-test (lcm -500029) 500029) +(num-test (gcd 362880) 362880) +(num-test (lcm 362880) 362880) +(num-test (gcd -362880) 362880) +(num-test (lcm -362880) 362880) +(num-test (gcd 0 0) 0) +(num-test (lcm 0 0) 0) +(num-test (gcd 0 0) 0) +(num-test (lcm 0 0) 0) +(num-test (gcd 0 0) 0) +(num-test (lcm 0 0) 0) +(num-test (gcd 0 0) 0) +(num-test (lcm 0 0) 0) +(num-test (gcd 0 1) 1) +(num-test (lcm 0 1) 0) +(num-test (gcd 0 1) 1) +(num-test (lcm 0 1) 0) +(num-test (gcd 0 -1) 1) +(num-test (lcm 0 -1) 0) +(num-test (gcd 0 -1) 1) +(num-test (lcm 0 -1) 0) +(num-test (gcd 0 2) 2) +(num-test (lcm 0 2) 0) +(num-test (gcd 0 2) 2) +(num-test (lcm 0 2) 0) +(num-test (gcd 0 -2) 2) +(num-test (lcm 0 -2) 0) +(num-test (gcd 0 -2) 2) +(num-test (lcm 0 -2) 0) +(num-test (gcd 0 3) 3) +(num-test (lcm 0 3) 0) +(num-test (gcd 0 3) 3) +(num-test (lcm 0 3) 0) +(num-test (gcd 0 -3) 3) +(num-test (lcm 0 -3) 0) +(num-test (gcd 0 -3) 3) +(num-test (lcm 0 -3) 0) +(num-test (gcd 0 10) 10) +(num-test (lcm 0 10) 0) +(num-test (gcd 0 10) 10) +(num-test (lcm 0 10) 0) +(num-test (gcd 0 -10) 10) +(num-test (lcm 0 -10) 0) +(num-test (gcd 0 -10) 10) +(num-test (lcm 0 -10) 0) +(num-test (gcd 0 1234) 1234) +(num-test (lcm 0 1234) 0) +(num-test (gcd 0 1234) 1234) +(num-test (lcm 0 1234) 0) +(num-test (gcd 0 -1234) 1234) +(num-test (lcm 0 -1234) 0) +(num-test (gcd 0 -1234) 1234) +(num-test (lcm 0 -1234) 0) +(num-test (gcd 0 1234000000) 1234000000) +(num-test (lcm 0 1234000000) 0) +(num-test (gcd 0 1234000000) 1234000000) +(num-test (lcm 0 1234000000) 0) +(num-test (gcd 0 -1234000000) 1234000000) +(num-test (lcm 0 -1234000000) 0) +(num-test (gcd 0 -1234000000) 1234000000) +(num-test (lcm 0 -1234000000) 0) +(num-test (gcd 0 500029) 500029) +(num-test (lcm 0 500029) 0) +(num-test (gcd 0 500029) 500029) +(num-test (lcm 0 500029) 0) +(num-test (gcd 0 -500029) 500029) +(num-test (lcm 0 -500029) 0) +(num-test (gcd 0 -500029) 500029) +(num-test (lcm 0 -500029) 0) +(num-test (gcd 0 362880) 362880) +(num-test (lcm 0 362880) 0) +(num-test (gcd 0 362880) 362880) +(num-test (lcm 0 362880) 0) +(num-test (gcd 0 -362880) 362880) +(num-test (lcm 0 -362880) 0) +(num-test (gcd 0 -362880) 362880) +(num-test (lcm 0 -362880) 0) +(num-test (gcd 1 0) 1) +(num-test (lcm 1 0) 0) +(num-test (gcd -1 0) 1) +(num-test (lcm -1 0) 0) +(num-test (gcd 1 0) 1) +(num-test (lcm 1 0) 0) +(num-test (gcd -1 0) 1) +(num-test (lcm -1 0) 0) +(num-test (gcd 1 1) 1) +(num-test (lcm 1 1) 1) +(num-test (gcd -1 1) 1) +(num-test (lcm -1 1) 1) +(num-test (gcd 1 -1) 1) +(num-test (lcm 1 -1) 1) +(num-test (gcd -1 -1) 1) +(num-test (lcm -1 -1) 1) +(num-test (gcd 1 2) 1) +(num-test (lcm 1 2) 2) +(num-test (gcd -1 2) 1) +(num-test (lcm -1 2) 2) +(num-test (gcd 1 -2) 1) +(num-test (lcm 1 -2) 2) +(num-test (gcd -1 -2) 1) +(num-test (lcm -1 -2) 2) +(num-test (gcd 1 3) 1) +(num-test (lcm 1 3) 3) +(num-test (gcd -1 3) 1) +(num-test (lcm -1 3) 3) +(num-test (gcd 1 -3) 1) +(num-test (lcm 1 -3) 3) +(num-test (gcd -1 -3) 1) +(num-test (lcm -1 -3) 3) +(num-test (gcd 1 10) 1) +(num-test (lcm 1 10) 10) +(num-test (gcd -1 10) 1) +(num-test (lcm -1 10) 10) +(num-test (gcd 1 -10) 1) +(num-test (lcm 1 -10) 10) +(num-test (gcd -1 -10) 1) +(num-test (lcm -1 -10) 10) +(num-test (gcd 1 1234) 1) +(num-test (lcm 1 1234) 1234) +(num-test (gcd -1 1234) 1) +(num-test (lcm -1 1234) 1234) +(num-test (gcd 1 -1234) 1) +(num-test (lcm 1 -1234) 1234) +(num-test (gcd -1 -1234) 1) +(num-test (lcm -1 -1234) 1234) +(num-test (gcd 1 1234000000) 1) +(num-test (lcm 1 1234000000) 1234000000) +(num-test (gcd -1 1234000000) 1) +(num-test (lcm -1 1234000000) 1234000000) +(num-test (gcd 1 -1234000000) 1) +(num-test (lcm 1 -1234000000) 1234000000) +(num-test (gcd -1 -1234000000) 1) +(num-test (lcm -1 -1234000000) 1234000000) +(num-test (gcd 1 500029) 1) +(num-test (lcm 1 500029) 500029) +(num-test (gcd -1 500029) 1) +(num-test (lcm -1 500029) 500029) +(num-test (gcd 1 -500029) 1) +(num-test (lcm 1 -500029) 500029) +(num-test (gcd -1 -500029) 1) +(num-test (lcm -1 -500029) 500029) +(num-test (gcd 1 362880) 1) +(num-test (lcm 1 362880) 362880) +(num-test (gcd -1 362880) 1) +(num-test (lcm -1 362880) 362880) +(num-test (gcd 1 -362880) 1) +(num-test (lcm 1 -362880) 362880) +(num-test (gcd -1 -362880) 1) +(num-test (lcm -1 -362880) 362880) +(num-test (gcd 2 0) 2) +(num-test (lcm 2 0) 0) +(num-test (gcd -2 0) 2) +(num-test (lcm -2 0) 0) +(num-test (gcd 2 0) 2) +(num-test (lcm 2 0) 0) +(num-test (gcd -2 0) 2) +(num-test (lcm -2 0) 0) +(num-test (gcd 2 1) 1) +(num-test (lcm 2 1) 2) +(num-test (gcd -2 1) 1) +(num-test (lcm -2 1) 2) +(num-test (gcd 2 -1) 1) +(num-test (lcm 2 -1) 2) +(num-test (gcd -2 -1) 1) +(num-test (lcm -2 -1) 2) +(num-test (gcd 2 2) 2) +(num-test (lcm 2 2) 2) +(num-test (gcd -2 2) 2) +(num-test (lcm -2 2) 2) +(num-test (gcd 2 -2) 2) +(num-test (lcm 2 -2) 2) +(num-test (gcd -2 -2) 2) +(num-test (lcm -2 -2) 2) +(num-test (gcd 2 3) 1) +(num-test (lcm 2 3) 6) +(num-test (gcd -2 3) 1) +(num-test (lcm -2 3) 6) +(num-test (gcd 2 -3) 1) +(num-test (lcm 2 -3) 6) +(num-test (gcd -2 -3) 1) +(num-test (lcm -2 -3) 6) +(num-test (gcd 2 10) 2) +(num-test (lcm 2 10) 10) +(num-test (gcd -2 10) 2) +(num-test (lcm -2 10) 10) +(num-test (gcd 2 -10) 2) +(num-test (lcm 2 -10) 10) +(num-test (gcd -2 -10) 2) +(num-test (lcm -2 -10) 10) +(num-test (gcd 2 1234) 2) +(num-test (lcm 2 1234) 1234) +(num-test (gcd -2 1234) 2) +(num-test (lcm -2 1234) 1234) +(num-test (gcd 2 -1234) 2) +(num-test (lcm 2 -1234) 1234) +(num-test (gcd -2 -1234) 2) +(num-test (lcm -2 -1234) 1234) +(num-test (gcd 2 1234000000) 2) +(num-test (lcm 2 1234000000) 1234000000) +(num-test (gcd -2 1234000000) 2) +(num-test (lcm -2 1234000000) 1234000000) +(num-test (gcd 2 -1234000000) 2) +(num-test (lcm 2 -1234000000) 1234000000) +(num-test (gcd -2 -1234000000) 2) +(num-test (lcm -2 -1234000000) 1234000000) +(num-test (gcd 2 500029) 1) +(num-test (lcm 2 500029) 1000058) +(num-test (gcd -2 500029) 1) +(num-test (lcm -2 500029) 1000058) +(num-test (gcd 2 -500029) 1) +(num-test (lcm 2 -500029) 1000058) +(num-test (gcd -2 -500029) 1) +(num-test (lcm -2 -500029) 1000058) +(num-test (gcd 2 362880) 2) +(num-test (lcm 2 362880) 362880) +(num-test (gcd -2 362880) 2) +(num-test (lcm -2 362880) 362880) +(num-test (gcd 2 -362880) 2) +(num-test (lcm 2 -362880) 362880) +(num-test (gcd -2 -362880) 2) +(num-test (lcm -2 -362880) 362880) +(num-test (gcd 3 0) 3) +(num-test (lcm 3 0) 0) +(num-test (gcd -3 0) 3) +(num-test (lcm -3 0) 0) +(num-test (gcd 3 0) 3) +(num-test (lcm 3 0) 0) +(num-test (gcd -3 0) 3) +(num-test (lcm -3 0) 0) +(num-test (gcd 3 1) 1) +(num-test (lcm 3 1) 3) +(num-test (gcd -3 1) 1) +(num-test (lcm -3 1) 3) +(num-test (gcd 3 -1) 1) +(num-test (lcm 3 -1) 3) +(num-test (gcd -3 -1) 1) +(num-test (lcm -3 -1) 3) +(num-test (gcd 3 2) 1) +(num-test (lcm 3 2) 6) +(num-test (gcd -3 2) 1) +(num-test (lcm -3 2) 6) +(num-test (gcd 3 -2) 1) +(num-test (lcm 3 -2) 6) +(num-test (gcd -3 -2) 1) +(num-test (lcm -3 -2) 6) +(num-test (gcd 3 3) 3) +(num-test (lcm 3 3) 3) +(num-test (gcd -3 3) 3) +(num-test (lcm -3 3) 3) +(num-test (gcd 3 -3) 3) +(num-test (lcm 3 -3) 3) +(num-test (gcd -3 -3) 3) +(num-test (lcm -3 -3) 3) +(num-test (gcd 3 10) 1) +(num-test (lcm 3 10) 30) +(num-test (gcd -3 10) 1) +(num-test (lcm -3 10) 30) +(num-test (gcd 3 -10) 1) +(num-test (lcm 3 -10) 30) +(num-test (gcd -3 -10) 1) +(num-test (lcm -3 -10) 30) +(num-test (gcd 3 1234) 1) +(num-test (lcm 3 1234) 3702) +(num-test (gcd -3 1234) 1) +(num-test (lcm -3 1234) 3702) +(num-test (gcd 3 -1234) 1) +(num-test (lcm 3 -1234) 3702) +(num-test (gcd -3 -1234) 1) +(num-test (lcm -3 -1234) 3702) +(num-test (gcd 3 1234000000) 1) +(num-test (lcm 3 1234000000) 3702000000) +(num-test (gcd -3 1234000000) 1) +(num-test (lcm -3 1234000000) 3702000000) +(num-test (gcd 3 -1234000000) 1) +(num-test (lcm 3 -1234000000) 3702000000) +(num-test (gcd -3 -1234000000) 1) +(num-test (lcm -3 -1234000000) 3702000000) +(num-test (gcd 3 500029) 1) +(num-test (lcm 3 500029) 1500087) +(num-test (gcd -3 500029) 1) +(num-test (lcm -3 500029) 1500087) +(num-test (gcd 3 -500029) 1) +(num-test (lcm 3 -500029) 1500087) +(num-test (gcd -3 -500029) 1) +(num-test (lcm -3 -500029) 1500087) +(num-test (gcd 3 362880) 3) +(num-test (lcm 3 362880) 362880) +(num-test (gcd -3 362880) 3) +(num-test (lcm -3 362880) 362880) +(num-test (gcd 3 -362880) 3) +(num-test (lcm 3 -362880) 362880) +(num-test (gcd -3 -362880) 3) +(num-test (lcm -3 -362880) 362880) +(num-test (gcd 10 0) 10) +(num-test (lcm 10 0) 0) +(num-test (gcd -10 0) 10) +(num-test (lcm -10 0) 0) +(num-test (gcd 10 0) 10) +(num-test (lcm 10 0) 0) +(num-test (gcd -10 0) 10) +(num-test (lcm -10 0) 0) +(num-test (gcd 10 1) 1) +(num-test (lcm 10 1) 10) +(num-test (gcd -10 1) 1) +(num-test (lcm -10 1) 10) +(num-test (gcd 10 -1) 1) +(num-test (lcm 10 -1) 10) +(num-test (gcd -10 -1) 1) +(num-test (lcm -10 -1) 10) +(num-test (gcd 10 2) 2) +(num-test (lcm 10 2) 10) +(num-test (gcd -10 2) 2) +(num-test (lcm -10 2) 10) +(num-test (gcd 10 -2) 2) +(num-test (lcm 10 -2) 10) +(num-test (gcd -10 -2) 2) +(num-test (lcm -10 -2) 10) +(num-test (gcd 10 3) 1) +(num-test (lcm 10 3) 30) +(num-test (gcd -10 3) 1) +(num-test (lcm -10 3) 30) +(num-test (gcd 10 -3) 1) +(num-test (lcm 10 -3) 30) +(num-test (gcd -10 -3) 1) +(num-test (lcm -10 -3) 30) +(num-test (gcd 10 10) 10) +(num-test (lcm 10 10) 10) +(num-test (gcd -10 10) 10) +(num-test (lcm -10 10) 10) +(num-test (gcd 10 -10) 10) +(num-test (lcm 10 -10) 10) +(num-test (gcd -10 -10) 10) +(num-test (lcm -10 -10) 10) +(num-test (gcd 10 1234) 2) +(num-test (lcm 10 1234) 6170) +(num-test (gcd -10 1234) 2) +(num-test (lcm -10 1234) 6170) +(num-test (gcd 10 -1234) 2) +(num-test (lcm 10 -1234) 6170) +(num-test (gcd -10 -1234) 2) +(num-test (lcm -10 -1234) 6170) +(num-test (gcd 10 1234000000) 10) +(num-test (lcm 10 1234000000) 1234000000) +(num-test (gcd -10 1234000000) 10) +(num-test (lcm -10 1234000000) 1234000000) +(num-test (gcd 10 -1234000000) 10) +(num-test (lcm 10 -1234000000) 1234000000) +(num-test (gcd -10 -1234000000) 10) +(num-test (lcm -10 -1234000000) 1234000000) +(num-test (gcd 10 500029) 1) +(num-test (lcm 10 500029) 5000290) +(num-test (gcd -10 500029) 1) +(num-test (lcm -10 500029) 5000290) +(num-test (gcd 10 -500029) 1) +(num-test (lcm 10 -500029) 5000290) +(num-test (gcd -10 -500029) 1) +(num-test (lcm -10 -500029) 5000290) +(num-test (gcd 10 362880) 10) +(num-test (lcm 10 362880) 362880) +(num-test (gcd -10 362880) 10) +(num-test (lcm -10 362880) 362880) +(num-test (gcd 10 -362880) 10) +(num-test (lcm 10 -362880) 362880) +(num-test (gcd -10 -362880) 10) +(num-test (lcm -10 -362880) 362880) +(num-test (gcd 1234 0) 1234) +(num-test (lcm 1234 0) 0) +(num-test (gcd -1234 0) 1234) +(num-test (lcm -1234 0) 0) +(num-test (gcd 1234 0) 1234) +(num-test (lcm 1234 0) 0) +(num-test (gcd -1234 0) 1234) +(num-test (lcm -1234 0) 0) +(num-test (gcd 1234 1) 1) +(num-test (lcm 1234 1) 1234) +(num-test (gcd -1234 1) 1) +(num-test (lcm -1234 1) 1234) +(num-test (gcd 1234 -1) 1) +(num-test (lcm 1234 -1) 1234) +(num-test (gcd -1234 -1) 1) +(num-test (lcm -1234 -1) 1234) +(num-test (gcd 1234 2) 2) +(num-test (lcm 1234 2) 1234) +(num-test (gcd -1234 2) 2) +(num-test (lcm -1234 2) 1234) +(num-test (gcd 1234 -2) 2) +(num-test (lcm 1234 -2) 1234) +(num-test (gcd -1234 -2) 2) +(num-test (lcm -1234 -2) 1234) +(num-test (gcd 1234 3) 1) +(num-test (lcm 1234 3) 3702) +(num-test (gcd -1234 3) 1) +(num-test (lcm -1234 3) 3702) +(num-test (gcd 1234 -3) 1) +(num-test (lcm 1234 -3) 3702) +(num-test (gcd -1234 -3) 1) +(num-test (lcm -1234 -3) 3702) +(num-test (gcd 1234 10) 2) +(num-test (lcm 1234 10) 6170) +(num-test (gcd -1234 10) 2) +(num-test (lcm -1234 10) 6170) +(num-test (gcd 1234 -10) 2) +(num-test (lcm 1234 -10) 6170) +(num-test (gcd -1234 -10) 2) +(num-test (lcm -1234 -10) 6170) +(num-test (gcd 1234 1234) 1234) +(num-test (lcm 1234 1234) 1234) +(num-test (gcd -1234 1234) 1234) +(num-test (lcm -1234 1234) 1234) +(num-test (gcd 1234 -1234) 1234) +(num-test (lcm 1234 -1234) 1234) +(num-test (gcd -1234 -1234) 1234) +(num-test (lcm -1234 -1234) 1234) +(num-test (gcd 1234 1234000000) 1234) +(num-test (lcm 1234 1234000000) 1234000000) +(num-test (gcd -1234 1234000000) 1234) +(num-test (lcm -1234 1234000000) 1234000000) +(num-test (gcd 1234 -1234000000) 1234) +(num-test (lcm 1234 -1234000000) 1234000000) +(num-test (gcd -1234 -1234000000) 1234) +(num-test (lcm -1234 -1234000000) 1234000000) +(num-test (gcd 1234 500029) 1) +(num-test (lcm 1234 500029) 617035786) +(num-test (gcd -1234 500029) 1) +(num-test (lcm -1234 500029) 617035786) +(num-test (gcd 1234 -500029) 1) +(num-test (lcm 1234 -500029) 617035786) +(num-test (gcd -1234 -500029) 1) +(num-test (lcm -1234 -500029) 617035786) +(num-test (gcd 1234 362880) 2) +(num-test (lcm 1234 362880) 223896960) +(num-test (gcd -1234 362880) 2) +(num-test (lcm -1234 362880) 223896960) +(num-test (gcd 1234 -362880) 2) +(num-test (lcm 1234 -362880) 223896960) +(num-test (gcd -1234 -362880) 2) +(num-test (lcm -1234 -362880) 223896960) +(num-test (gcd 1234000000 0) 1234000000) +(num-test (lcm 1234000000 0) 0) +(num-test (gcd -1234000000 0) 1234000000) +(num-test (lcm -1234000000 0) 0) +(num-test (gcd 1234000000 0) 1234000000) +(num-test (lcm 1234000000 0) 0) +(num-test (gcd -1234000000 0) 1234000000) +(num-test (lcm -1234000000 0) 0) +(num-test (gcd 1234000000 1) 1) +(num-test (lcm 1234000000 1) 1234000000) +(num-test (gcd -1234000000 1) 1) +(num-test (lcm -1234000000 1) 1234000000) +(num-test (gcd 1234000000 -1) 1) +(num-test (lcm 1234000000 -1) 1234000000) +(num-test (gcd -1234000000 -1) 1) +(num-test (lcm -1234000000 -1) 1234000000) +(num-test (gcd 1234000000 2) 2) +(num-test (lcm 1234000000 2) 1234000000) +(num-test (gcd -1234000000 2) 2) +(num-test (lcm -1234000000 2) 1234000000) +(num-test (gcd 1234000000 -2) 2) +(num-test (lcm 1234000000 -2) 1234000000) +(num-test (gcd -1234000000 -2) 2) +(num-test (lcm -1234000000 -2) 1234000000) +(num-test (gcd 1234000000 3) 1) +(num-test (lcm 1234000000 3) 3702000000) +(num-test (gcd -1234000000 3) 1) +(num-test (lcm -1234000000 3) 3702000000) +(num-test (gcd 1234000000 -3) 1) +(num-test (lcm 1234000000 -3) 3702000000) +(num-test (gcd -1234000000 -3) 1) +(num-test (lcm -1234000000 -3) 3702000000) +(num-test (gcd 1234000000 10) 10) +(num-test (lcm 1234000000 10) 1234000000) +(num-test (gcd -1234000000 10) 10) +(num-test (lcm -1234000000 10) 1234000000) +(num-test (gcd 1234000000 -10) 10) +(num-test (lcm 1234000000 -10) 1234000000) +(num-test (gcd -1234000000 -10) 10) +(num-test (lcm -1234000000 -10) 1234000000) +(num-test (gcd 1234000000 1234) 1234) +(num-test (lcm 1234000000 1234) 1234000000) +(num-test (gcd -1234000000 1234) 1234) +(num-test (lcm -1234000000 1234) 1234000000) +(num-test (gcd 1234000000 -1234) 1234) +(num-test (lcm 1234000000 -1234) 1234000000) +(num-test (gcd -1234000000 -1234) 1234) +(num-test (lcm -1234000000 -1234) 1234000000) +(num-test (gcd 1234000000 1234000000) 1234000000) +(num-test (lcm 1234000000 1234000000) 1234000000) +(num-test (gcd -1234000000 1234000000) 1234000000) +(num-test (lcm -1234000000 1234000000) 1234000000) +(num-test (gcd 1234000000 -1234000000) 1234000000) +(num-test (lcm 1234000000 -1234000000) 1234000000) +(num-test (gcd -1234000000 -1234000000) 1234000000) +(num-test (lcm -1234000000 -1234000000) 1234000000) +(num-test (gcd 1234000000 500029) 1) +(num-test (lcm 1234000000 500029) 617035786000000) +(num-test (gcd -1234000000 500029) 1) +(num-test (lcm -1234000000 500029) 617035786000000) +(num-test (gcd 1234000000 -500029) 1) +(num-test (lcm 1234000000 -500029) 617035786000000) +(num-test (gcd -1234000000 -500029) 1) +(num-test (lcm -1234000000 -500029) 617035786000000) +(num-test (gcd 1234000000 362880) 640) +(num-test (lcm 1234000000 362880) 699678000000) +(num-test (gcd -1234000000 362880) 640) +(num-test (lcm -1234000000 362880) 699678000000) +(num-test (gcd 1234000000 -362880) 640) +(num-test (lcm 1234000000 -362880) 699678000000) +(num-test (gcd -1234000000 -362880) 640) +(num-test (lcm -1234000000 -362880) 699678000000) +(num-test (gcd 500029 0) 500029) +(num-test (lcm 500029 0) 0) +(num-test (gcd -500029 0) 500029) +(num-test (lcm -500029 0) 0) +(num-test (gcd 500029 0) 500029) +(num-test (lcm 500029 0) 0) +(num-test (gcd -500029 0) 500029) +(num-test (lcm -500029 0) 0) +(num-test (gcd 500029 1) 1) +(num-test (lcm 500029 1) 500029) +(num-test (gcd -500029 1) 1) +(num-test (lcm -500029 1) 500029) +(num-test (gcd 500029 -1) 1) +(num-test (lcm 500029 -1) 500029) +(num-test (gcd -500029 -1) 1) +(num-test (lcm -500029 -1) 500029) +(num-test (gcd 500029 2) 1) +(num-test (lcm 500029 2) 1000058) +(num-test (gcd -500029 2) 1) +(num-test (lcm -500029 2) 1000058) +(num-test (gcd 500029 -2) 1) +(num-test (lcm 500029 -2) 1000058) +(num-test (gcd -500029 -2) 1) +(num-test (lcm -500029 -2) 1000058) +(num-test (gcd 500029 3) 1) +(num-test (lcm 500029 3) 1500087) +(num-test (gcd -500029 3) 1) +(num-test (lcm -500029 3) 1500087) +(num-test (gcd 500029 -3) 1) +(num-test (lcm 500029 -3) 1500087) +(num-test (gcd -500029 -3) 1) +(num-test (lcm -500029 -3) 1500087) +(num-test (gcd 500029 10) 1) +(num-test (lcm 500029 10) 5000290) +(num-test (gcd -500029 10) 1) +(num-test (lcm -500029 10) 5000290) +(num-test (gcd 500029 -10) 1) +(num-test (lcm 500029 -10) 5000290) +(num-test (gcd -500029 -10) 1) +(num-test (lcm -500029 -10) 5000290) +(num-test (gcd 500029 1234) 1) +(num-test (lcm 500029 1234) 617035786) +(num-test (gcd -500029 1234) 1) +(num-test (lcm -500029 1234) 617035786) +(num-test (gcd 500029 -1234) 1) +(num-test (lcm 500029 -1234) 617035786) +(num-test (gcd -500029 -1234) 1) +(num-test (lcm -500029 -1234) 617035786) +(num-test (gcd 500029 1234000000) 1) +(num-test (lcm 500029 1234000000) 617035786000000) +(num-test (gcd -500029 1234000000) 1) +(num-test (lcm -500029 1234000000) 617035786000000) +(num-test (gcd 500029 -1234000000) 1) +(num-test (lcm 500029 -1234000000) 617035786000000) +(num-test (gcd -500029 -1234000000) 1) +(num-test (lcm -500029 -1234000000) 617035786000000) +(num-test (gcd 500029 500029) 500029) +(num-test (lcm 500029 500029) 500029) +(num-test (gcd -500029 500029) 500029) +(num-test (lcm -500029 500029) 500029) +(num-test (gcd 500029 -500029) 500029) +(num-test (lcm 500029 -500029) 500029) +(num-test (gcd -500029 -500029) 500029) +(num-test (lcm -500029 -500029) 500029) +(num-test (gcd 500029 362880) 1) +(num-test (lcm 500029 362880) 181450523520) +(num-test (gcd -500029 362880) 1) +(num-test (lcm -500029 362880) 181450523520) +(num-test (gcd 500029 -362880) 1) +(num-test (lcm 500029 -362880) 181450523520) +(num-test (gcd -500029 -362880) 1) +(num-test (lcm -500029 -362880) 181450523520) +(num-test (gcd 362880 0) 362880) +(num-test (lcm 362880 0) 0) +(num-test (gcd -362880 0) 362880) +(num-test (lcm -362880 0) 0) +(num-test (gcd 362880 0) 362880) +(num-test (lcm 362880 0) 0) +(num-test (gcd -362880 0) 362880) +(num-test (lcm -362880 0) 0) +(num-test (gcd 362880 1) 1) +(num-test (lcm 362880 1) 362880) +(num-test (gcd -362880 1) 1) +(num-test (lcm -362880 1) 362880) +(num-test (gcd 362880 -1) 1) +(num-test (lcm 362880 -1) 362880) +(num-test (gcd -362880 -1) 1) +(num-test (lcm -362880 -1) 362880) +(num-test (gcd 362880 2) 2) +(num-test (lcm 362880 2) 362880) +(num-test (gcd -362880 2) 2) +(num-test (lcm -362880 2) 362880) +(num-test (gcd 362880 -2) 2) +(num-test (lcm 362880 -2) 362880) +(num-test (gcd -362880 -2) 2) +(num-test (lcm -362880 -2) 362880) +(num-test (gcd 362880 3) 3) +(num-test (lcm 362880 3) 362880) +(num-test (gcd -362880 3) 3) +(num-test (lcm -362880 3) 362880) +(num-test (gcd 362880 -3) 3) +(num-test (lcm 362880 -3) 362880) +(num-test (gcd -362880 -3) 3) +(num-test (lcm -362880 -3) 362880) +(num-test (gcd 362880 10) 10) +(num-test (lcm 362880 10) 362880) +(num-test (gcd -362880 10) 10) +(num-test (lcm -362880 10) 362880) +(num-test (gcd 362880 -10) 10) +(num-test (lcm 362880 -10) 362880) +(num-test (gcd -362880 -10) 10) +(num-test (lcm -362880 -10) 362880) +(num-test (gcd 362880 1234) 2) +(num-test (lcm 362880 1234) 223896960) +(num-test (gcd -362880 1234) 2) +(num-test (lcm -362880 1234) 223896960) +(num-test (gcd 362880 -1234) 2) +(num-test (lcm 362880 -1234) 223896960) +(num-test (gcd -362880 -1234) 2) +(num-test (lcm -362880 -1234) 223896960) +(num-test (gcd 362880 1234000000) 640) +(num-test (lcm 362880 1234000000) 699678000000) +(num-test (gcd -362880 1234000000) 640) +(num-test (lcm -362880 1234000000) 699678000000) +(num-test (gcd 362880 -1234000000) 640) +(num-test (lcm 362880 -1234000000) 699678000000) +(num-test (gcd -362880 -1234000000) 640) +(num-test (lcm -362880 -1234000000) 699678000000) +(num-test (gcd 362880 500029) 1) +(num-test (lcm 362880 500029) 181450523520) +(num-test (gcd -362880 500029) 1) +(num-test (lcm -362880 500029) 181450523520) +(num-test (gcd 362880 -500029) 1) +(num-test (lcm 362880 -500029) 181450523520) +(num-test (gcd -362880 -500029) 1) +(num-test (lcm -362880 -500029) 181450523520) +(num-test (gcd 362880 362880) 362880) +(num-test (lcm 362880 362880) 362880) +(num-test (gcd -362880 362880) 362880) +(num-test (lcm -362880 362880) 362880) +(num-test (gcd 362880 -362880) 362880) +(num-test (lcm 362880 -362880) 362880) +(num-test (gcd -362880 -362880) 362880) +(num-test (lcm -362880 -362880) 362880) +(num-test (gcd 60 42) 6) +(num-test (gcd 3333 -33 101) 1) +(num-test (gcd 3333 -33 1002001) 11) +(num-test (gcd 91 -49) 7) +(num-test (gcd 63 -42 35) 7) +(num-test (gcd 0 0 0 10) 10) +(num-test (lcm 0 0 0 10) 0) +(num-test (gcd 0 1 -1 362880) 1) +(num-test (gcd 0 2 2 -500029) 1) +(num-test (gcd 0 3 -3 -1234000000) 1) +(num-test (gcd 0 10 10 1234) 2) +(num-test (lcm 0 10 10 1234) 0) +(num-test (gcd 0 1234 -1234 10) 2) +(num-test (lcm 0 1234 -1234 10) 0) +(num-test (gcd 0 1234000000 1234000000 -3) 1) +(num-test (gcd 0 500029 -500029 -2) 1) +(num-test (gcd 0 362880 362880 1) 1) +(num-test (gcd 1 0 -1 1) 1) +(num-test (lcm 1 0 -1 1) 0) +(num-test (gcd 1 1 2 -10) 1) +(num-test (lcm 1 1 2 -10) 10) +(num-test (gcd 1 2 -3 -362880) 1) +(num-test (gcd 1 3 10 500029) 1) +(num-test (gcd 1 10 -1234 1234000000) 1) +(num-test (gcd 1 1234 1234000000 -1234) 1) +(num-test (gcd 1 1234000000 -500029 -10) 1) +(num-test (gcd 1 500029 362880 3) 1) +(num-test (gcd 1 362880 0 2) 1) +(num-test (gcd 2 0 2 -2) 2) +(num-test (lcm 2 0 2 -2) 0) +(num-test (gcd 2 1 -3 -1) 1) +(num-test (lcm 2 1 -3 -1) 6) +(num-test (gcd 2 2 10 10) 2) +(num-test (lcm 2 2 10 10) 10) +(num-test (gcd 2 3 -1234 362880) 1) +(num-test (gcd 2 10 1234000000 -500029) 1) +(num-test (gcd 2 1234 -500029 -1234000000) 1) +(num-test (gcd 2 1234000000 362880 1234) 2) +(num-test (gcd 2 500029 0 10) 1) +(num-test (gcd 2 362880 1 -3) 1) +(num-test (gcd 3 0 -3 -3) 3) +(num-test (lcm 3 0 -3 -3) 0) +(num-test (gcd 3 1 10 2) 1) +(num-test (lcm 3 1 10 2) 30) +(num-test (gcd 3 2 -1234 1) 1) +(num-test (lcm 3 2 -1234 1) 3702) +(num-test (gcd 3 3 1234000000 -10) 1) +(num-test (gcd 3 10 -500029 -362880) 1) +(num-test (gcd 3 1234 362880 500029) 1) +(num-test (gcd 3 1234000000 0 1234000000) 1) +(num-test (gcd 3 500029 1 -1234) 1) +(num-test (gcd 3 362880 -2 -10) 1) +(num-test (gcd 10 0 10 10) 10) +(num-test (lcm 10 0 10 10) 0) +(num-test (gcd 10 1 -1234 3) 1) +(num-test (lcm 10 1 -1234 3) 18510) +(num-test (gcd 10 2 1234000000 -2) 2) +(num-test (gcd 10 3 -500029 -1) 1) +(num-test (gcd 10 10 362880 10) 10) +(num-test (gcd 10 1234 0 362880) 2) +(num-test (gcd 10 1234000000 1 -500029) 1) +(num-test (gcd 10 500029 -2 -1234000000) 1) +(num-test (gcd 10 362880 3 1234) 1) +(num-test (gcd 1234 0 -1234 1234) 1234) +(num-test (lcm 1234 0 -1234 1234) 0) +(num-test (gcd 1234 1 1234000000 -10) 1) +(num-test (gcd 1234 2 -500029 -3) 1) +(num-test (gcd 1234 3 362880 2) 1) +(num-test (gcd 1234 10 0 1) 1) +(num-test (lcm 1234 10 0 1) 0) +(num-test (gcd 1234 1234 1 -10) 1) +(num-test (lcm 1234 1234 1 -10) 6170) +(num-test (gcd 1234 1234000000 -2 -362880) 2) +(num-test (gcd 1234 500029 3 500029) 1) +(num-test (gcd 1234 362880 -10 1234000000) 2) +(num-test (gcd 1234000000 0 1234000000 -1234000000) 1234000000) +(num-test (gcd 1234000000 1 -500029 -1234) 1) +(num-test (gcd 1234000000 2 362880 10) 2) +(num-test (gcd 1234000000 3 0 3) 1) +(num-test (gcd 1234000000 10 1 -2) 1) +(num-test (gcd 1234000000 1234 -2 -1) 1) +(num-test (gcd 1234000000 1234000000 3 10) 1) +(num-test (gcd 1234000000 500029 -10 362880) 1) +(num-test (gcd 1234000000 362880 1234 -500029) 1) +(num-test (gcd 500029 0 -500029 -500029) 500029) +(num-test (gcd 500029 1 362880 1234000000) 1) +(num-test (gcd 500029 2 0 1234) 1) +(num-test (gcd 500029 3 1 -10) 1) +(num-test (gcd 500029 10 -2 -3) 1) +(num-test (gcd 500029 1234 3 2) 1) +(num-test (gcd 500029 1234000000 -10 1) 1) +(num-test (gcd 500029 500029 1234 -10) 1) +(num-test (gcd 500029 362880 -1234000000 -362880) 1) +(num-test (gcd 362880 0 362880 362880) 362880) +(num-test (gcd 362880 1 0 500029) 1) +(num-test (gcd 362880 2 1 -1234000000) 1) +(num-test (gcd 362880 3 -2 -1234) 1) +(num-test (gcd 362880 10 3 10) 1) +(num-test (gcd 362880 1234 -10 3) 1) +(num-test (gcd 362880 1234000000 1234 -2) 2) +(num-test (gcd 362880 500029 -1234000000 -1) 1) +(num-test (gcd 362880 362880 500029 10) 1) +(num-test (gcd 323 28747 27113) 19) +(num-test (lcm 323 28747 27113) 41021969) +(num-test (lcm (* 512 500057) (* 128 500057) (* 2048 500057)) 1024116736) +(num-test (gcd (* 512 500057) (* 128 500057) (* 2048 500057)) 64007296) +(num-test (gcd 91 -49) 7) +(num-test (lcm 14 35) 70) +(num-test (gcd (- (expt 2 11) 1) (- (expt 2 19) 1)) (- (expt 2 (gcd 11 19)) 1)) +(num-test (gcd (- (expt 2 11) 1) (- (expt 2 22) 1)) (- (expt 2 (gcd 11 22)) 1)) +(num-test (gcd (- (expt 2 12) 1) (- (expt 2 18) 1)) (- (expt 2 (gcd 12 18)) 1)) +(if (or with-bignums with-64-bit-ints) + (num-test (gcd (- (expt 2 52) 1) (- (expt 2 39) 1)) (- (expt 2 (gcd 52 39)) 1))) +(num-test (gcd (numerator 7/9) (denominator 7/9)) 1) +(num-test (gcd 0 4) 4 ) +(num-test (gcd -4 0) 4 ) +(num-test (gcd 32 -36) 4 ) +(num-test (gcd) 0 ) +(num-test (lcm 32 -36) 288 ) +(num-test (lcm) 1 ) +(num-test (gcd 2 0) 2) +(num-test (lcm 2 0) 0) + + +;; -------- real-part and imag-part +(num-test (real-part 1) 1) +(num-test (imag-part 1) 0.0) +(num-test (real-part 2.0) 2.0) +(num-test (imag-part -2.0) 0.0) +(num-test (real-part 2/3) 2/3) +(num-test (imag-part 1+i) 1.0) +(num-test (imag-part 0+i) 1.0) +(num-test (imag-part 1-i) -1.0) +(num-test (imag-part 2/3) 0.0) +(num-test (real-part 0.0+0.0i) 0.0) +(num-test (imag-part 0.0+0.0i) 0.0) +(num-test (real-part -0.0+0.00000001i) -0.0) +(num-test (imag-part -0.0+0.00000001i) 0.00000001) +(num-test (real-part 0.0-1.0i) 0.0) +(num-test (imag-part 0.0-1.0i) -1.0) +(num-test (real-part -0.0-3.14159265358979i) -0.0) +(num-test (imag-part -0.0-3.14159265358979i) -3.14159265358979) +(num-test (real-part 0.0+2.71828182845905i) 0.0) +(num-test (imag-part 0.0+2.71828182845905i) 2.71828182845905) +(num-test (real-part -0.0+1234.0i) -0.0) +(num-test (imag-part -0.0+1234.0i) 1234.0) +(num-test (real-part 0.0-1234000000.0i) 0.0) +(num-test (imag-part 0.0-1234000000.0i) -1234000000.0) +(num-test (real-part -0.00000001-0.0i) -0.00000001) +(num-test (imag-part -0.00000001-0.0i) -0.0) +(num-test (real-part 0.00000001+0.00000001i) 0.00000001) +(num-test (imag-part 0.00000001+0.00000001i) 0.00000001) +(num-test (real-part -0.00000001+1.0i) -0.00000001) +(num-test (imag-part -0.00000001+1.0i) 1.0) +(num-test (real-part 0.00000001-3.14159265358979i) 0.00000001) +(num-test (imag-part 0.00000001-3.14159265358979i) -3.14159265358979) +(num-test (real-part -0.00000001-2.71828182845905i) -0.00000001) +(num-test (imag-part -0.00000001-2.71828182845905i) -2.71828182845905) +(num-test (real-part 0.00000001+1234.0i) 0.00000001) +(num-test (imag-part 0.00000001+1234.0i) 1234.0) +(num-test (real-part -0.00000001+1234000000.0i) -0.00000001) +(num-test (imag-part -0.00000001+1234000000.0i) 1234000000.0) +(num-test (real-part 1.0-0.0i) 1.0) +(num-test (imag-part 1.0-0.0i) -0.0) +(num-test (real-part -1.0-0.00000001i) -1.0) +(num-test (imag-part -1.0-0.00000001i) -0.00000001) +(num-test (real-part 1.0+1.0i) 1.0) +(num-test (imag-part 1.0+1.0i) 1.0) +(num-test (real-part -1.0+3.14159265358979i) -1.0) +(num-test (imag-part -1.0+3.14159265358979i) 3.14159265358979) +(num-test (real-part 1.0-2.71828182845905i) 1.0) +(num-test (imag-part 1.0-2.71828182845905i) -2.71828182845905) +(num-test (real-part -1.0-1234.0i) -1.0) +(num-test (imag-part -1.0-1234.0i) -1234.0) +(num-test (real-part 1.0+1234000000.0i) 1.0) +(num-test (imag-part 1.0+1234000000.0i) 1234000000.0) +(num-test (real-part -3.14159265358979+0.0i) -3.14159265358979) +(num-test (imag-part -3.14159265358979+0.0i) 0.0) +(num-test (real-part 3.14159265358979-0.00000001i) 3.14159265358979) +(num-test (imag-part 3.14159265358979-0.00000001i) -0.00000001) +(num-test (real-part -3.14159265358979-1.0i) -3.14159265358979) +(num-test (imag-part -3.14159265358979-1.0i) -1.0) +(num-test (real-part 3.14159265358979+3.14159265358979i) 3.14159265358979) +(num-test (imag-part 3.14159265358979+3.14159265358979i) 3.14159265358979) +(num-test (real-part -3.14159265358979+2.71828182845905i) -3.14159265358979) +(num-test (imag-part -3.14159265358979+2.71828182845905i) 2.71828182845905) +(num-test (real-part 3.14159265358979-1234.0i) 3.14159265358979) +(num-test (imag-part 3.14159265358979-1234.0i) -1234.0) +(num-test (real-part -3.14159265358979-1234000000.0i) -3.14159265358979) +(num-test (imag-part -3.14159265358979-1234000000.0i) -1234000000.0) +(num-test (real-part 2.71828182845905+0.0i) 2.71828182845905) +(num-test (imag-part 2.71828182845905+0.0i) 0.0) +(num-test (real-part -2.71828182845905+0.00000001i) -2.71828182845905) +(num-test (imag-part -2.71828182845905+0.00000001i) 0.00000001) +(num-test (real-part 2.71828182845905-1.0i) 2.71828182845905) +(num-test (imag-part 2.71828182845905-1.0i) -1.0) +(num-test (real-part -2.71828182845905-3.14159265358979i) -2.71828182845905) +(num-test (imag-part -2.71828182845905-3.14159265358979i) -3.14159265358979) +(num-test (real-part 2.71828182845905+2.71828182845905i) 2.71828182845905) +(num-test (imag-part 2.71828182845905+2.71828182845905i) 2.71828182845905) +(num-test (real-part -2.71828182845905+1234.0i) -2.71828182845905) +(num-test (imag-part -2.71828182845905+1234.0i) 1234.0) +(num-test (real-part 2.71828182845905-1234000000.0i) 2.71828182845905) +(num-test (imag-part 2.71828182845905-1234000000.0i) -1234000000.0) +(num-test (real-part -1234.0-0.0i) -1234.0) +(num-test (imag-part -1234.0-0.0i) -0.0) +(num-test (real-part 1234.0+0.00000001i) 1234.0) +(num-test (imag-part 1234.0+0.00000001i) 0.00000001) +(num-test (real-part -1234.0+1.0i) -1234.0) +(num-test (imag-part -1234.0+1.0i) 1.0) +(num-test (real-part 1234.0-3.14159265358979i) 1234.0) +(num-test (imag-part 1234.0-3.14159265358979i) -3.14159265358979) +(num-test (real-part -1234.0-2.71828182845905i) -1234.0) +(num-test (imag-part -1234.0-2.71828182845905i) -2.71828182845905) +(num-test (real-part 1234.0+1234.0i) 1234.0) +(num-test (imag-part 1234.0+1234.0i) 1234.0) +(num-test (real-part -1234.0+1234000000.0i) -1234.0) +(num-test (imag-part -1234.0+1234000000.0i) 1234000000.0) +(num-test (real-part 1234000000.0-0.0i) 1234000000.0) +(num-test (imag-part 1234000000.0-0.0i) -0.0) +(num-test (real-part -1234000000.0-0.00000001i) -1234000000.0) +(num-test (imag-part -1234000000.0-0.00000001i) -0.00000001) +(num-test (real-part 1234000000.0+1.0i) 1234000000.0) +(num-test (imag-part 1234000000.0+1.0i) 1.0) +(num-test (real-part -1234000000.0+3.14159265358979i) -1234000000.0) +(num-test (imag-part -1234000000.0+3.14159265358979i) 3.14159265358979) +(num-test (real-part 1234000000.0-2.71828182845905i) 1234000000.0) +(num-test (imag-part 1234000000.0-2.71828182845905i) -2.71828182845905) +(num-test (real-part -1234000000.0-1234.0i) -1234000000.0) +(num-test (imag-part -1234000000.0-1234.0i) -1234.0) +(num-test (real-part 1234000000.0+1234000000.0i) 1234000000.0) +(num-test (imag-part 1234000000.0+1234000000.0i) 1234000000.0) +(num-test (real-part 5) 5) +(num-test (real-part 1.4+0.0i) 1.4) +(num-test (imag-part 5) 0.0) +(num-test (imag-part 1.4+0.0i) 0.0) + + +;; -------- numerator and denominator +(num-test (numerator 12/6000996) 1) +(num-test (denominator 12/6000996) 500083) +(num-test (numerator 1) 1) +(num-test (numerator 2/3) 2) +(num-test (numerator 2/4) 1) +(num-test (denominator 2/4) 2) +(num-test (numerator -2/6) -1) +(num-test (denominator -2/6) 3) +(num-test (numerator -2/3) -2) +(num-test (denominator -2/3) 3) +(num-test (denominator 1) 1) +(num-test (denominator 2/3) 3) +(num-test (numerator 0/1) 0) +(num-test (denominator 0/1) 1) +(num-test (numerator 0/2) 0) +(num-test (denominator 0/2) 1) +(num-test (numerator 0/3) 0) +(num-test (denominator 0/3) 1) +(num-test (numerator 0/10) 0) +(num-test (denominator 0/10) 1) +(num-test (numerator 0/1234) 0) +(num-test (denominator 0/1234) 1) +(num-test (numerator 0/1234000000) 0) +(num-test (denominator 0/1234000000) 1) +(num-test (numerator 0/500029) 0) +(num-test (denominator 0/500029) 1) +(num-test (numerator 0/362880) 0) +(num-test (denominator 0/362880) 1) +(num-test (numerator 1/1) 1) +(num-test (denominator 1/1) 1) +(num-test (numerator -1/2) -1) +(num-test (denominator -1/2) 2) +(num-test (numerator 1/3) 1) +(num-test (denominator 1/3) 3) +(num-test (numerator -1/10) -1) +(num-test (denominator -1/10) 10) +(num-test (numerator 1/1234) 1) +(num-test (denominator 1/1234) 1234) +(num-test (numerator -1/1234000000) -1) +(num-test (denominator -1/1234000000) 1234000000) +(num-test (numerator 1/500029) 1) +(num-test (denominator 1/500029) 500029) +(num-test (numerator -1/362880) -1) +(num-test (denominator -1/362880) 362880) +(num-test (numerator -2/1) -2) +(num-test (denominator -2/1) 1) +(num-test (numerator 2/2) 1) +(num-test (denominator 2/2) 1) +(num-test (numerator -2/3) -2) +(num-test (denominator -2/3) 3) +(num-test (numerator 2/10) 1) +(num-test (denominator 2/10) 5) +(num-test (numerator -2/1234) -1) +(num-test (denominator -2/1234) 617) +(num-test (numerator 2/1234000000) 1) +(num-test (denominator 2/1234000000) 617000000) +(num-test (numerator -2/500029) -2) +(num-test (denominator -2/500029) 500029) +(num-test (numerator 2/362880) 1) +(num-test (denominator 2/362880) 181440) +(num-test (numerator 3/1) 3) +(num-test (denominator 3/1) 1) +(num-test (numerator -3/2) -3) +(num-test (denominator -3/2) 2) +(num-test (numerator 3/3) 1) +(num-test (denominator 3/3) 1) +(num-test (numerator -3/10) -3) +(num-test (denominator -3/10) 10) +(num-test (numerator 3/1234) 3) +(num-test (denominator 3/1234) 1234) +(num-test (numerator -3/1234000000) -3) +(num-test (denominator -3/1234000000) 1234000000) +(num-test (numerator 3/500029) 3) +(num-test (denominator 3/500029) 500029) +(num-test (numerator -3/362880) -1) +(num-test (denominator -3/362880) 120960) +(num-test (numerator -10/1) -10) +(num-test (denominator -10/1) 1) +(num-test (numerator 10/2) 5) +(num-test (denominator 10/2) 1) +(num-test (numerator -10/3) -10) +(num-test (denominator -10/3) 3) +(num-test (numerator 10/10) 1) +(num-test (denominator 10/10) 1) +(num-test (numerator -10/1234) -5) +(num-test (denominator -10/1234) 617) +(num-test (numerator 10/1234000000) 1) +(num-test (denominator 10/1234000000) 123400000) +(num-test (numerator -10/500029) -10) +(num-test (denominator -10/500029) 500029) +(num-test (numerator 10/362880) 1) +(num-test (denominator 10/362880) 36288) +(num-test (numerator 1234/1) 1234) +(num-test (denominator 1234/1) 1) +(num-test (numerator -1234/2) -617) +(num-test (denominator -1234/2) 1) +(num-test (numerator 1234/3) 1234) +(num-test (denominator 1234/3) 3) +(num-test (numerator -1234/10) -617) +(num-test (denominator -1234/10) 5) +(num-test (numerator 1234/1234) 1) +(num-test (denominator 1234/1234) 1) +(num-test (numerator -1234/1234000000) -1) +(num-test (denominator -1234/1234000000) 1000000) +(num-test (numerator 1234/500029) 1234) +(num-test (denominator 1234/500029) 500029) +(num-test (numerator -1234/362880) -617) +(num-test (denominator -1234/362880) 181440) +(num-test (numerator -1234000000/1) -1234000000) +(num-test (denominator -1234000000/1) 1) +(num-test (numerator 1234000000/2) 617000000) +(num-test (denominator 1234000000/2) 1) +(num-test (numerator -1234000000/3) -1234000000) +(num-test (denominator -1234000000/3) 3) +(num-test (numerator 1234000000/10) 123400000) +(num-test (denominator 1234000000/10) 1) +(num-test (numerator -1234000000/1234) -1000000) +(num-test (denominator -1234000000/1234) 1) +(num-test (numerator 1234000000/1234000000) 1) +(num-test (denominator 1234000000/1234000000) 1) +(num-test (numerator -1234000000/500029) -1234000000) +(num-test (denominator -1234000000/500029) 500029) +(num-test (numerator 1234000000/362880) 1928125) +(num-test (denominator 1234000000/362880) 567) +(num-test (numerator 500029/1) 500029) +(num-test (denominator 500029/1) 1) +(num-test (numerator -500029/2) -500029) +(num-test (denominator -500029/2) 2) +(num-test (numerator 500029/3) 500029) +(num-test (denominator 500029/3) 3) +(num-test (numerator -500029/10) -500029) +(num-test (denominator -500029/10) 10) +(num-test (numerator 500029/1234) 500029) +(num-test (denominator 500029/1234) 1234) +(num-test (numerator -500029/1234000000) -500029) +(num-test (denominator -500029/1234000000) 1234000000) +(num-test (numerator 500029/500029) 1) +(num-test (denominator 500029/500029) 1) +(num-test (numerator -500029/362880) -500029) +(num-test (denominator -500029/362880) 362880) +(num-test (numerator -362880/1) -362880) +(num-test (denominator -362880/1) 1) +(num-test (numerator 362880/2) 181440) +(num-test (denominator 362880/2) 1) +(num-test (numerator -362880/3) -120960) +(num-test (denominator -362880/3) 1) +(num-test (numerator 362880/10) 36288) +(num-test (denominator 362880/10) 1) +(num-test (numerator -362880/1234) -181440) +(num-test (denominator -362880/1234) 617) +(num-test (numerator 362880/1234000000) 567) +(num-test (denominator 362880/1234000000) 1928125) +(num-test (numerator -362880/500029) -362880) +(num-test (denominator -362880/500029) 500029) +(num-test (numerator 362880/362880) 1) +(num-test (denominator 362880/362880) 1) +(num-test (numerator 5/2) 5) +(num-test (numerator (/ 8 -6)) -4) +(num-test (denominator 5/2) 2) +(num-test (denominator (/ 8 -6)) 3) + + +;; -------- modulo, remainder, quotient +;;; (modulo x 0) -> x? I seem to be getting errors instead; maxima returns x and refers to Section 3.4, of "Concrete Mathematics," by Graham, Knuth, and Patashnik +;;; (mod x 1.0) = sawtooth +(num-test (modulo 0 1) 0) +(num-test (modulo 3 1) 0) +(num-test (modulo -3 1) 0) +(num-test (modulo 3 -1) 0) +(num-test (remainder 0 1) 0) +(num-test (quotient 0 1) 0) +(num-test (modulo 0 1) 0) +(num-test (remainder 0 1) 0) +(num-test (quotient 0 1) 0) +(num-test (modulo 0 -1) 0) +(num-test (remainder 0 -1) 0) +(num-test (quotient 0 -1) 0) +(num-test (modulo 0 -1) 0) +(num-test (remainder 0 -1) 0) +(num-test (quotient 0 -1) 0) +(num-test (modulo 0 2) 0) +(num-test (remainder 0 2) 0) +(num-test (quotient 0 2) 0) +(num-test (modulo 0 2) 0) +(num-test (remainder 0 2) 0) +(num-test (quotient 0 2) 0) +(num-test (modulo 0 -2) 0) +(num-test (remainder 0 -2) 0) +(num-test (quotient 0 -2) 0) +(num-test (modulo 0 -2) 0) +(num-test (remainder 0 -2) 0) +(num-test (quotient 0 -2) 0) +(num-test (modulo 0 3) 0) +(num-test (remainder 0 3) 0) +(num-test (quotient 0 3) 0) +(num-test (modulo 0 3) 0) +(num-test (remainder 0 3) 0) +(num-test (quotient 0 3) 0) +(num-test (modulo 0 -3) 0) +(num-test (remainder 0 -3) 0) +(num-test (quotient 0 -3) 0) +(num-test (modulo 0 -3) 0) +(num-test (remainder 0 -3) 0) +(num-test (quotient 0 -3) 0) +(num-test (modulo 0 10) 0) +(num-test (remainder 0 10) 0) +(num-test (quotient 0 10) 0) +(num-test (modulo 0 10) 0) +(num-test (remainder 0 10) 0) +(num-test (quotient 0 10) 0) +(num-test (modulo 0 -10) 0) +(num-test (remainder 0 -10) 0) +(num-test (quotient 0 -10) 0) +(num-test (modulo 0 -10) 0) +(num-test (remainder 0 -10) 0) +(num-test (quotient 0 -10) 0) +(num-test (modulo 0 1234) 0) +(num-test (remainder 0 1234) 0) +(num-test (quotient 0 1234) 0) +(num-test (modulo 0 1234) 0) +(num-test (remainder 0 1234) 0) +(num-test (quotient 0 1234) 0) +(num-test (modulo 0 -1234) 0) +(num-test (remainder 0 -1234) 0) +(num-test (quotient 0 -1234) 0) +(num-test (modulo 0 -1234) 0) +(num-test (remainder 0 -1234) 0) +(num-test (quotient 0 -1234) 0) +(num-test (modulo 0 1234000000) 0) +(num-test (remainder 0 1234000000) 0) +(num-test (quotient 0 1234000000) 0) +(num-test (modulo 0 1234000000) 0) +(num-test (remainder 0 1234000000) 0) +(num-test (quotient 0 1234000000) 0) +(num-test (modulo 0 -1234000000) 0) +(num-test (remainder 0 -1234000000) 0) +(num-test (quotient 0 -1234000000) 0) +(num-test (modulo 0 -1234000000) 0) +(num-test (remainder 0 -1234000000) 0) +(num-test (quotient 0 -1234000000) 0) +(num-test (modulo 0 500029) 0) +(num-test (remainder 0 500029) 0) +(num-test (quotient 0 500029) 0) +(num-test (modulo 0 500029) 0) +(num-test (remainder 0 500029) 0) +(num-test (quotient 0 500029) 0) +(num-test (modulo 0 -500029) 0) +(num-test (remainder 0 -500029) 0) +(num-test (quotient 0 -500029) 0) +(num-test (modulo 0 -500029) 0) +(num-test (remainder 0 -500029) 0) +(num-test (quotient 0 -500029) 0) +(num-test (modulo 0 362880) 0) +(num-test (remainder 0 362880) 0) +(num-test (quotient 0 362880) 0) +(num-test (modulo 0 362880) 0) +(num-test (remainder 0 362880) 0) +(num-test (quotient 0 362880) 0) +(num-test (modulo 0 -362880) 0) +(num-test (remainder 0 -362880) 0) +(num-test (quotient 0 -362880) 0) +(num-test (modulo 0 -362880) 0) +(num-test (remainder 0 -362880) 0) +(num-test (quotient 0 -362880) 0) +(num-test (modulo 1 1) 0) +(num-test (remainder 1 1) 0) +(num-test (quotient 1 1) 1) +(num-test (modulo -1 1) 0) +(num-test (remainder -1 1) 0) +(num-test (quotient -1 1) -1) +(num-test (modulo 1 -1) 0) +(num-test (remainder 1 -1) 0) +(num-test (quotient 1 -1) -1) +(num-test (modulo -1 -1) 0) +(num-test (remainder -1 -1) 0) +(num-test (quotient -1 -1) 1) +(num-test (modulo 1 2) 1) +(num-test (remainder 1 2) 1) +(num-test (quotient 1 2) 0) +(num-test (modulo -1 2) 1) +(num-test (remainder -1 2) -1) +(num-test (quotient -1 2) 0) +(num-test (modulo 1 -2) -1) +(num-test (remainder 1 -2) 1) +(num-test (quotient 1 -2) 0) +(num-test (modulo -1 -2) -1) +(num-test (remainder -1 -2) -1) +(num-test (quotient -1 -2) 0) +(num-test (modulo 1 3) 1) +(num-test (remainder 1 3) 1) +(num-test (quotient 1 3) 0) +(num-test (modulo -1 3) 2) +(num-test (remainder -1 3) -1) +(num-test (quotient -1 3) 0) +(num-test (modulo 1 -3) -2) +(num-test (remainder 1 -3) 1) +(num-test (quotient 1 -3) 0) +(num-test (modulo -1 -3) -1) +(num-test (remainder -1 -3) -1) +(num-test (quotient -1 -3) 0) +(num-test (modulo 1 10) 1) +(num-test (remainder 1 10) 1) +(num-test (quotient 1 10) 0) +(num-test (modulo -1 10) 9) +(num-test (remainder -1 10) -1) +(num-test (quotient -1 10) 0) +(num-test (modulo 1 -10) -9) +(num-test (remainder 1 -10) 1) +(num-test (quotient 1 -10) 0) +(num-test (modulo -1 -10) -1) +(num-test (remainder -1 -10) -1) +(num-test (quotient -1 -10) 0) +(num-test (modulo 1 1234) 1) +(num-test (remainder 1 1234) 1) +(num-test (quotient 1 1234) 0) +(num-test (modulo -1 1234) 1233) +(num-test (remainder -1 1234) -1) +(num-test (quotient -1 1234) 0) +(num-test (modulo 1 -1234) -1233) +(num-test (remainder 1 -1234) 1) +(num-test (quotient 1 -1234) 0) +(num-test (modulo -1 -1234) -1) +(num-test (remainder -1 -1234) -1) +(num-test (quotient -1 -1234) 0) +(num-test (modulo 1 1234000000) 1) +(num-test (remainder 1 1234000000) 1) +(num-test (quotient 1 1234000000) 0) +(num-test (modulo -1 1234000000) 1233999999) +(num-test (remainder -1 1234000000) -1) +(num-test (quotient -1 1234000000) 0) +(num-test (modulo 1 -1234000000) -1233999999) +(num-test (remainder 1 -1234000000) 1) +(num-test (quotient 1 -1234000000) 0) +(num-test (modulo -1 -1234000000) -1) +(num-test (remainder -1 -1234000000) -1) +(num-test (quotient -1 -1234000000) 0) +(num-test (modulo 1 500029) 1) +(num-test (remainder 1 500029) 1) +(num-test (quotient 1 500029) 0) +(num-test (modulo -1 500029) 500028) +(num-test (remainder -1 500029) -1) +(num-test (quotient -1 500029) 0) +(num-test (modulo 1 -500029) -500028) +(num-test (remainder 1 -500029) 1) +(num-test (quotient 1 -500029) 0) +(num-test (modulo -1 -500029) -1) +(num-test (remainder -1 -500029) -1) +(num-test (quotient -1 -500029) 0) +(num-test (modulo 1 362880) 1) +(num-test (remainder 1 362880) 1) +(num-test (quotient 1 362880) 0) +(num-test (modulo -1 362880) 362879) +(num-test (remainder -1 362880) -1) +(num-test (quotient -1 362880) 0) +(num-test (modulo 1 -362880) -362879) +(num-test (remainder 1 -362880) 1) +(num-test (quotient 1 -362880) 0) +(num-test (modulo -1 -362880) -1) +(num-test (remainder -1 -362880) -1) +(num-test (quotient -1 -362880) 0) +(num-test (modulo 2 1) 0) +(num-test (remainder 2 1) 0) +(num-test (quotient 2 1) 2) +(num-test (modulo -2 1) 0) +(num-test (remainder -2 1) 0) +(num-test (quotient -2 1) -2) +(num-test (modulo 2 -1) 0) +(num-test (remainder 2 -1) 0) +(num-test (quotient 2 -1) -2) +(num-test (modulo -2 -1) 0) +(num-test (remainder -2 -1) 0) +(num-test (quotient -2 -1) 2) +(num-test (modulo 2 2) 0) +(num-test (remainder 2 2) 0) +(num-test (quotient 2 2) 1) +(num-test (modulo -2 2) 0) +(num-test (remainder -2 2) 0) +(num-test (quotient -2 2) -1) +(num-test (modulo 2 -2) 0) +(num-test (remainder 2 -2) 0) +(num-test (quotient 2 -2) -1) +(num-test (modulo -2 -2) 0) +(num-test (remainder -2 -2) 0) +(num-test (quotient -2 -2) 1) +(num-test (modulo 2 3) 2) +(num-test (remainder 2 3) 2) +(num-test (quotient 2 3) 0) +(num-test (modulo -2 3) 1) +(num-test (remainder -2 3) -2) +(num-test (quotient -2 3) 0) +(num-test (modulo 2 -3) -1) +(num-test (remainder 2 -3) 2) +(num-test (quotient 2 -3) 0) +(num-test (modulo -2 -3) -2) +(num-test (remainder -2 -3) -2) +(num-test (quotient -2 -3) 0) +(num-test (modulo 2 10) 2) +(num-test (remainder 2 10) 2) +(num-test (quotient 2 10) 0) +(num-test (modulo -2 10) 8) +(num-test (remainder -2 10) -2) +(num-test (quotient -2 10) 0) +(num-test (modulo 2 -10) -8) +(num-test (remainder 2 -10) 2) +(num-test (quotient 2 -10) 0) +(num-test (modulo -2 -10) -2) +(num-test (remainder -2 -10) -2) +(num-test (quotient -2 -10) 0) +(num-test (modulo 2 1234) 2) +(num-test (remainder 2 1234) 2) +(num-test (quotient 2 1234) 0) +(num-test (modulo -2 1234) 1232) +(num-test (remainder -2 1234) -2) +(num-test (quotient -2 1234) 0) +(num-test (modulo 2 -1234) -1232) +(num-test (remainder 2 -1234) 2) +(num-test (quotient 2 -1234) 0) +(num-test (modulo -2 -1234) -2) +(num-test (remainder -2 -1234) -2) +(num-test (quotient -2 -1234) 0) +(num-test (modulo 2 1234000000) 2) +(num-test (remainder 2 1234000000) 2) +(num-test (quotient 2 1234000000) 0) +(num-test (modulo -2 1234000000) 1233999998) +(num-test (remainder -2 1234000000) -2) +(num-test (quotient -2 1234000000) 0) +(num-test (modulo 2 -1234000000) -1233999998) +(num-test (remainder 2 -1234000000) 2) +(num-test (quotient 2 -1234000000) 0) +(num-test (modulo -2 -1234000000) -2) +(num-test (remainder -2 -1234000000) -2) +(num-test (quotient -2 -1234000000) 0) +(num-test (modulo 2 500029) 2) +(num-test (remainder 2 500029) 2) +(num-test (quotient 2 500029) 0) +(num-test (modulo -2 500029) 500027) +(num-test (remainder -2 500029) -2) +(num-test (quotient -2 500029) 0) +(num-test (modulo 2 -500029) -500027) +(num-test (remainder 2 -500029) 2) +(num-test (quotient 2 -500029) 0) +(num-test (modulo -2 -500029) -2) +(num-test (remainder -2 -500029) -2) +(num-test (quotient -2 -500029) 0) +(num-test (modulo 2 362880) 2) +(num-test (remainder 2 362880) 2) +(num-test (quotient 2 362880) 0) +(num-test (modulo -2 362880) 362878) +(num-test (remainder -2 362880) -2) +(num-test (quotient -2 362880) 0) +(num-test (modulo 2 -362880) -362878) +(num-test (remainder 2 -362880) 2) +(num-test (quotient 2 -362880) 0) +(num-test (modulo -2 -362880) -2) +(num-test (remainder -2 -362880) -2) +(num-test (quotient -2 -362880) 0) +(num-test (modulo 3 1) 0) +(num-test (remainder 3 1) 0) +(num-test (quotient 3 1) 3) +(num-test (modulo -3 1) 0) +(num-test (remainder -3 1) 0) +(num-test (quotient -3 1) -3) +(num-test (modulo 3 -1) 0) +(num-test (remainder 3 -1) 0) +(num-test (quotient 3 -1) -3) +(num-test (modulo -3 -1) 0) +(num-test (remainder -3 -1) 0) +(num-test (quotient -3 -1) 3) +(num-test (modulo 3 2) 1) +(num-test (remainder 3 2) 1) +(num-test (quotient 3 2) 1) +(num-test (modulo -3 2) 1) +(num-test (remainder -3 2) -1) +(num-test (quotient -3 2) -1) +(num-test (modulo 3 -2) -1) +(num-test (remainder 3 -2) 1) +(num-test (quotient 3 -2) -1) +(num-test (modulo -3 -2) -1) +(num-test (remainder -3 -2) -1) +(num-test (quotient -3 -2) 1) +(num-test (modulo 3 3) 0) +(num-test (remainder 3 3) 0) +(num-test (quotient 3 3) 1) +(num-test (modulo -3 3) 0) +(num-test (remainder -3 3) 0) +(num-test (quotient -3 3) -1) +(num-test (modulo 3 -3) 0) +(num-test (remainder 3 -3) 0) +(num-test (quotient 3 -3) -1) +(num-test (modulo -3 -3) 0) +(num-test (remainder -3 -3) 0) +(num-test (quotient -3 -3) 1) +(num-test (modulo 3 10) 3) +(num-test (remainder 3 10) 3) +(num-test (quotient 3 10) 0) +(num-test (modulo -3 10) 7) +(num-test (remainder -3 10) -3) +(num-test (quotient -3 10) 0) +(num-test (modulo 3 -10) -7) +(num-test (remainder 3 -10) 3) +(num-test (quotient 3 -10) 0) +(num-test (modulo -3 -10) -3) +(num-test (remainder -3 -10) -3) +(num-test (quotient -3 -10) 0) +(num-test (modulo 3 1234) 3) +(num-test (remainder 3 1234) 3) +(num-test (quotient 3 1234) 0) +(num-test (modulo -3 1234) 1231) +(num-test (remainder -3 1234) -3) +(num-test (quotient -3 1234) 0) +(num-test (modulo 3 -1234) -1231) +(num-test (remainder 3 -1234) 3) +(num-test (quotient 3 -1234) 0) +(num-test (modulo -3 -1234) -3) +(num-test (remainder -3 -1234) -3) +(num-test (quotient -3 -1234) 0) +(num-test (modulo 3 1234000000) 3) +(num-test (remainder 3 1234000000) 3) +(num-test (quotient 3 1234000000) 0) +(num-test (modulo -3 1234000000) 1233999997) +(num-test (remainder -3 1234000000) -3) +(num-test (quotient -3 1234000000) 0) +(num-test (modulo 3 -1234000000) -1233999997) +(num-test (remainder 3 -1234000000) 3) +(num-test (quotient 3 -1234000000) 0) +(num-test (modulo -3 -1234000000) -3) +(num-test (remainder -3 -1234000000) -3) +(num-test (quotient -3 -1234000000) 0) +(num-test (modulo 3 500029) 3) +(num-test (remainder 3 500029) 3) +(num-test (quotient 3 500029) 0) +(num-test (modulo -3 500029) 500026) +(num-test (remainder -3 500029) -3) +(num-test (quotient -3 500029) 0) +(num-test (modulo 3 -500029) -500026) +(num-test (remainder 3 -500029) 3) +(num-test (quotient 3 -500029) 0) +(num-test (modulo -3 -500029) -3) +(num-test (remainder -3 -500029) -3) +(num-test (quotient -3 -500029) 0) +(num-test (modulo 3 362880) 3) +(num-test (remainder 3 362880) 3) +(num-test (quotient 3 362880) 0) +(num-test (modulo -3 362880) 362877) +(num-test (remainder -3 362880) -3) +(num-test (quotient -3 362880) 0) +(num-test (modulo 3 -362880) -362877) +(num-test (remainder 3 -362880) 3) +(num-test (quotient 3 -362880) 0) +(num-test (modulo -3 -362880) -3) +(num-test (remainder -3 -362880) -3) +(num-test (quotient -3 -362880) 0) +(num-test (modulo 10 1) 0) +(num-test (remainder 10 1) 0) +(num-test (quotient 10 1) 10) +(num-test (modulo -10 1) 0) +(num-test (remainder -10 1) 0) +(num-test (quotient -10 1) -10) +(num-test (modulo 10 -1) 0) +(num-test (remainder 10 -1) 0) +(num-test (quotient 10 -1) -10) +(num-test (modulo -10 -1) 0) +(num-test (remainder -10 -1) 0) +(num-test (quotient -10 -1) 10) +(num-test (modulo 10 2) 0) +(num-test (remainder 10 2) 0) +(num-test (quotient 10 2) 5) +(num-test (modulo -10 2) 0) +(num-test (remainder -10 2) 0) +(num-test (quotient -10 2) -5) +(num-test (modulo 10 -2) 0) +(num-test (remainder 10 -2) 0) +(num-test (quotient 10 -2) -5) +(num-test (modulo -10 -2) 0) +(num-test (remainder -10 -2) 0) +(num-test (quotient -10 -2) 5) +(num-test (modulo 10 3) 1) +(num-test (remainder 10 3) 1) +(num-test (quotient 10 3) 3) +(num-test (modulo -10 3) 2) +(num-test (remainder -10 3) -1) +(num-test (quotient -10 3) -3) +(num-test (modulo 10 -3) -2) +(num-test (remainder 10 -3) 1) +(num-test (quotient 10 -3) -3) +(num-test (modulo -10 -3) -1) +(num-test (remainder -10 -3) -1) +(num-test (quotient -10 -3) 3) +(num-test (modulo 10 10) 0) +(num-test (remainder 10 10) 0) +(num-test (quotient 10 10) 1) +(num-test (modulo -10 10) 0) +(num-test (remainder -10 10) 0) +(num-test (quotient -10 10) -1) +(num-test (modulo 10 -10) 0) +(num-test (remainder 10 -10) 0) +(num-test (quotient 10 -10) -1) +(num-test (modulo -10 -10) 0) +(num-test (remainder -10 -10) 0) +(num-test (quotient -10 -10) 1) +(num-test (modulo 10 1234) 10) +(num-test (remainder 10 1234) 10) +(num-test (quotient 10 1234) 0) +(num-test (modulo -10 1234) 1224) +(num-test (remainder -10 1234) -10) +(num-test (quotient -10 1234) 0) +(num-test (modulo 10 -1234) -1224) +(num-test (remainder 10 -1234) 10) +(num-test (quotient 10 -1234) 0) +(num-test (modulo -10 -1234) -10) +(num-test (remainder -10 -1234) -10) +(num-test (quotient -10 -1234) 0) +(num-test (modulo 10 1234000000) 10) +(num-test (remainder 10 1234000000) 10) +(num-test (quotient 10 1234000000) 0) +(num-test (modulo -10 1234000000) 1233999990) +(num-test (remainder -10 1234000000) -10) +(num-test (quotient -10 1234000000) 0) +(num-test (modulo 10 -1234000000) -1233999990) +(num-test (remainder 10 -1234000000) 10) +(num-test (quotient 10 -1234000000) 0) +(num-test (modulo -10 -1234000000) -10) +(num-test (remainder -10 -1234000000) -10) +(num-test (quotient -10 -1234000000) 0) +(num-test (modulo 10 500029) 10) +(num-test (remainder 10 500029) 10) +(num-test (quotient 10 500029) 0) +(num-test (modulo -10 500029) 500019) +(num-test (remainder -10 500029) -10) +(num-test (quotient -10 500029) 0) +(num-test (modulo 10 -500029) -500019) +(num-test (remainder 10 -500029) 10) +(num-test (quotient 10 -500029) 0) +(num-test (modulo -10 -500029) -10) +(num-test (remainder -10 -500029) -10) +(num-test (quotient -10 -500029) 0) +(num-test (modulo 10 362880) 10) +(num-test (remainder 10 362880) 10) +(num-test (quotient 10 362880) 0) +(num-test (modulo -10 362880) 362870) +(num-test (remainder -10 362880) -10) +(num-test (quotient -10 362880) 0) +(num-test (modulo 10 -362880) -362870) +(num-test (remainder 10 -362880) 10) +(num-test (quotient 10 -362880) 0) +(num-test (modulo -10 -362880) -10) +(num-test (remainder -10 -362880) -10) +(num-test (quotient -10 -362880) 0) +(num-test (modulo 1234 1) 0) +(num-test (remainder 1234 1) 0) +(num-test (quotient 1234 1) 1234) +(num-test (modulo -1234 1) 0) +(num-test (remainder -1234 1) 0) +(num-test (quotient -1234 1) -1234) +(num-test (modulo 1234 -1) 0) +(num-test (remainder 1234 -1) 0) +(num-test (quotient 1234 -1) -1234) +(num-test (modulo -1234 -1) 0) +(num-test (remainder -1234 -1) 0) +(num-test (quotient -1234 -1) 1234) +(num-test (modulo 1234 2) 0) +(num-test (remainder 1234 2) 0) +(num-test (quotient 1234 2) 617) +(num-test (modulo -1234 2) 0) +(num-test (remainder -1234 2) 0) +(num-test (quotient -1234 2) -617) +(num-test (modulo 1234 -2) 0) +(num-test (remainder 1234 -2) 0) +(num-test (quotient 1234 -2) -617) +(num-test (modulo -1234 -2) 0) +(num-test (remainder -1234 -2) 0) +(num-test (quotient -1234 -2) 617) +(num-test (modulo 1234 3) 1) +(num-test (remainder 1234 3) 1) +(num-test (quotient 1234 3) 411) +(num-test (modulo -1234 3) 2) +(num-test (remainder -1234 3) -1) +(num-test (quotient -1234 3) -411) +(num-test (modulo 1234 -3) -2) +(num-test (remainder 1234 -3) 1) +(num-test (quotient 1234 -3) -411) +(num-test (modulo -1234 -3) -1) +(num-test (remainder -1234 -3) -1) +(num-test (quotient -1234 -3) 411) +(num-test (modulo 1234 10) 4) +(num-test (remainder 1234 10) 4) +(num-test (quotient 1234 10) 123) +(num-test (modulo -1234 10) 6) +(num-test (remainder -1234 10) -4) +(num-test (quotient -1234 10) -123) +(num-test (modulo 1234 -10) -6) +(num-test (remainder 1234 -10) 4) +(num-test (quotient 1234 -10) -123) +(num-test (modulo -1234 -10) -4) +(num-test (remainder -1234 -10) -4) +(num-test (quotient -1234 -10) 123) +(num-test (modulo 1234 1234) 0) +(num-test (remainder 1234 1234) 0) +(num-test (quotient 1234 1234) 1) +(num-test (modulo -1234 1234) 0) +(num-test (remainder -1234 1234) 0) +(num-test (quotient -1234 1234) -1) +(num-test (modulo 1234 -1234) 0) +(num-test (remainder 1234 -1234) 0) +(num-test (quotient 1234 -1234) -1) +(num-test (modulo -1234 -1234) 0) +(num-test (remainder -1234 -1234) 0) +(num-test (quotient -1234 -1234) 1) +(num-test (modulo 1234 1234000000) 1234) +(num-test (remainder 1234 1234000000) 1234) +(num-test (quotient 1234 1234000000) 0) +(num-test (modulo -1234 1234000000) 1233998766) +(num-test (remainder -1234 1234000000) -1234) +(num-test (quotient -1234 1234000000) 0) +(num-test (modulo 1234 -1234000000) -1233998766) +(num-test (remainder 1234 -1234000000) 1234) +(num-test (quotient 1234 -1234000000) 0) +(num-test (modulo -1234 -1234000000) -1234) +(num-test (remainder -1234 -1234000000) -1234) +(num-test (quotient -1234 -1234000000) 0) +(num-test (modulo 1234 500029) 1234) +(num-test (remainder 1234 500029) 1234) +(num-test (quotient 1234 500029) 0) +(num-test (modulo -1234 500029) 498795) +(num-test (remainder -1234 500029) -1234) +(num-test (quotient -1234 500029) 0) +(num-test (modulo 1234 -500029) -498795) +(num-test (remainder 1234 -500029) 1234) +(num-test (quotient 1234 -500029) 0) +(num-test (modulo -1234 -500029) -1234) +(num-test (remainder -1234 -500029) -1234) +(num-test (quotient -1234 -500029) 0) +(num-test (modulo 1234 362880) 1234) +(num-test (remainder 1234 362880) 1234) +(num-test (quotient 1234 362880) 0) +(num-test (modulo -1234 362880) 361646) +(num-test (remainder -1234 362880) -1234) +(num-test (quotient -1234 362880) 0) +(num-test (modulo 1234 -362880) -361646) +(num-test (remainder 1234 -362880) 1234) +(num-test (quotient 1234 -362880) 0) +(num-test (modulo -1234 -362880) -1234) +(num-test (remainder -1234 -362880) -1234) +(num-test (quotient -1234 -362880) 0) +(num-test (modulo 1234000000 1) 0) +(num-test (remainder 1234000000 1) 0) +(num-test (quotient 1234000000 1) 1234000000) +(num-test (modulo -1234000000 1) 0) +(num-test (remainder -1234000000 1) 0) +(num-test (quotient -1234000000 1) -1234000000) +(num-test (modulo 1234000000 -1) 0) +(num-test (remainder 1234000000 -1) 0) +(num-test (quotient 1234000000 -1) -1234000000) +(num-test (modulo -1234000000 -1) 0) +(num-test (remainder -1234000000 -1) 0) +(num-test (quotient -1234000000 -1) 1234000000) +(num-test (modulo 1234000000 2) 0) +(num-test (remainder 1234000000 2) 0) +(num-test (quotient 1234000000 2) 617000000) +(num-test (modulo -1234000000 2) 0) +(num-test (remainder -1234000000 2) 0) +(num-test (quotient -1234000000 2) -617000000) +(num-test (modulo 1234000000 -2) 0) +(num-test (remainder 1234000000 -2) 0) +(num-test (quotient 1234000000 -2) -617000000) +(num-test (modulo -1234000000 -2) 0) +(num-test (remainder -1234000000 -2) 0) +(num-test (quotient -1234000000 -2) 617000000) +(num-test (modulo 1234000000 3) 1) +(num-test (remainder 1234000000 3) 1) +(num-test (quotient 1234000000 3) 411333333) +(num-test (modulo -1234000000 3) 2) +(num-test (remainder -1234000000 3) -1) +(num-test (quotient -1234000000 3) -411333333) +(num-test (modulo 1234000000 -3) -2) +(num-test (remainder 1234000000 -3) 1) +(num-test (quotient 1234000000 -3) -411333333) +(num-test (modulo -1234000000 -3) -1) +(num-test (remainder -1234000000 -3) -1) +(num-test (quotient -1234000000 -3) 411333333) +(num-test (modulo 1234000000 10) 0) +(num-test (remainder 1234000000 10) 0) +(num-test (quotient 1234000000 10) 123400000) +(num-test (modulo -1234000000 10) 0) +(num-test (remainder -1234000000 10) 0) +(num-test (quotient -1234000000 10) -123400000) +(num-test (modulo 1234000000 -10) 0) +(num-test (remainder 1234000000 -10) 0) +(num-test (quotient 1234000000 -10) -123400000) +(num-test (modulo -1234000000 -10) 0) +(num-test (remainder -1234000000 -10) 0) +(num-test (quotient -1234000000 -10) 123400000) +(num-test (modulo 1234000000 1234) 0) +(num-test (remainder 1234000000 1234) 0) +(num-test (quotient 1234000000 1234) 1000000) +(num-test (modulo -1234000000 1234) 0) +(num-test (remainder -1234000000 1234) 0) +(num-test (quotient -1234000000 1234) -1000000) +(num-test (modulo 1234000000 -1234) 0) +(num-test (remainder 1234000000 -1234) 0) +(num-test (quotient 1234000000 -1234) -1000000) +(num-test (modulo -1234000000 -1234) 0) +(num-test (remainder -1234000000 -1234) 0) +(num-test (quotient -1234000000 -1234) 1000000) +(num-test (modulo 1234000000 1234000000) 0) +(num-test (remainder 1234000000 1234000000) 0) +(num-test (quotient 1234000000 1234000000) 1) +(num-test (modulo -1234000000 1234000000) 0) +(num-test (remainder -1234000000 1234000000) 0) +(num-test (quotient -1234000000 1234000000) -1) +(num-test (modulo 1234000000 -1234000000) 0) +(num-test (remainder 1234000000 -1234000000) 0) +(num-test (quotient 1234000000 -1234000000) -1) +(num-test (modulo -1234000000 -1234000000) 0) +(num-test (remainder -1234000000 -1234000000) 0) +(num-test (quotient -1234000000 -1234000000) 1) +(num-test (modulo 1234000000 500029) 428457) +(num-test (remainder 1234000000 500029) 428457) +(num-test (quotient 1234000000 500029) 2467) +(num-test (modulo -1234000000 500029) 71572) +(num-test (remainder -1234000000 500029) -428457) +(num-test (quotient -1234000000 500029) -2467) +(num-test (modulo 1234000000 -500029) -71572) +(num-test (remainder 1234000000 -500029) 428457) +(num-test (quotient 1234000000 -500029) -2467) +(num-test (modulo -1234000000 -500029) -428457) +(num-test (remainder -1234000000 -500029) -428457) +(num-test (quotient -1234000000 -500029) 2467) +(num-test (modulo 1234000000 362880) 208000) +(num-test (remainder 1234000000 362880) 208000) +(num-test (quotient 1234000000 362880) 3400) +(num-test (modulo -1234000000 362880) 154880) +(num-test (remainder -1234000000 362880) -208000) +(num-test (quotient -1234000000 362880) -3400) +(num-test (modulo 1234000000 -362880) -154880) +(num-test (remainder 1234000000 -362880) 208000) +(num-test (quotient 1234000000 -362880) -3400) +(num-test (modulo -1234000000 -362880) -208000) +(num-test (remainder -1234000000 -362880) -208000) +(num-test (quotient -1234000000 -362880) 3400) +(num-test (modulo 500029 1) 0) +(num-test (remainder 500029 1) 0) +(num-test (quotient 500029 1) 500029) +(num-test (modulo -500029 1) 0) +(num-test (remainder -500029 1) 0) +(num-test (quotient -500029 1) -500029) +(num-test (modulo 500029 -1) 0) +(num-test (remainder 500029 -1) 0) +(num-test (quotient 500029 -1) -500029) +(num-test (modulo -500029 -1) 0) +(num-test (remainder -500029 -1) 0) +(num-test (quotient -500029 -1) 500029) +(num-test (modulo 500029 2) 1) +(num-test (remainder 500029 2) 1) +(num-test (quotient 500029 2) 250014) +(num-test (modulo -500029 2) 1) +(num-test (remainder -500029 2) -1) +(num-test (quotient -500029 2) -250014) +(num-test (modulo 500029 -2) -1) +(num-test (remainder 500029 -2) 1) +(num-test (quotient 500029 -2) -250014) +(num-test (modulo -500029 -2) -1) +(num-test (remainder -500029 -2) -1) +(num-test (quotient -500029 -2) 250014) +(num-test (modulo 500029 3) 1) +(num-test (remainder 500029 3) 1) +(num-test (quotient 500029 3) 166676) +(num-test (modulo -500029 3) 2) +(num-test (remainder -500029 3) -1) +(num-test (quotient -500029 3) -166676) +(num-test (modulo 500029 -3) -2) +(num-test (remainder 500029 -3) 1) +(num-test (quotient 500029 -3) -166676) +(num-test (modulo -500029 -3) -1) +(num-test (remainder -500029 -3) -1) +(num-test (quotient -500029 -3) 166676) +(num-test (modulo 500029 10) 9) +(num-test (remainder 500029 10) 9) +(num-test (quotient 500029 10) 50002) +(num-test (modulo -500029 10) 1) +(num-test (remainder -500029 10) -9) +(num-test (quotient -500029 10) -50002) +(num-test (modulo 500029 -10) -1) +(num-test (remainder 500029 -10) 9) +(num-test (quotient 500029 -10) -50002) +(num-test (modulo -500029 -10) -9) +(num-test (remainder -500029 -10) -9) +(num-test (quotient -500029 -10) 50002) +(num-test (modulo 500029 1234) 259) +(num-test (remainder 500029 1234) 259) +(num-test (quotient 500029 1234) 405) +(num-test (modulo -500029 1234) 975) +(num-test (remainder -500029 1234) -259) +(num-test (quotient -500029 1234) -405) +(num-test (modulo 500029 -1234) -975) +(num-test (remainder 500029 -1234) 259) +(num-test (quotient 500029 -1234) -405) +(num-test (modulo -500029 -1234) -259) +(num-test (remainder -500029 -1234) -259) +(num-test (quotient -500029 -1234) 405) +(num-test (modulo 500029 1234000000) 500029) +(num-test (remainder 500029 1234000000) 500029) +(num-test (quotient 500029 1234000000) 0) +(num-test (modulo -500029 1234000000) 1233499971) +(num-test (remainder -500029 1234000000) -500029) +(num-test (quotient -500029 1234000000) 0) +(num-test (modulo 500029 -1234000000) -1233499971) +(num-test (remainder 500029 -1234000000) 500029) +(num-test (quotient 500029 -1234000000) 0) +(num-test (modulo -500029 -1234000000) -500029) +(num-test (remainder -500029 -1234000000) -500029) +(num-test (quotient -500029 -1234000000) 0) +(num-test (modulo 500029 500029) 0) +(num-test (remainder 500029 500029) 0) +(num-test (quotient 500029 500029) 1) +(num-test (modulo -500029 500029) 0) +(num-test (remainder -500029 500029) 0) +(num-test (quotient -500029 500029) -1) +(num-test (modulo 500029 -500029) 0) +(num-test (remainder 500029 -500029) 0) +(num-test (quotient 500029 -500029) -1) +(num-test (modulo -500029 -500029) 0) +(num-test (remainder -500029 -500029) 0) +(num-test (quotient -500029 -500029) 1) +(num-test (modulo 500029 362880) 137149) +(num-test (remainder 500029 362880) 137149) +(num-test (quotient 500029 362880) 1) +(num-test (modulo -500029 362880) 225731) +(num-test (remainder -500029 362880) -137149) +(num-test (quotient -500029 362880) -1) +(num-test (modulo 500029 -362880) -225731) +(num-test (remainder 500029 -362880) 137149) +(num-test (quotient 500029 -362880) -1) +(num-test (modulo -500029 -362880) -137149) +(num-test (remainder -500029 -362880) -137149) +(num-test (quotient -500029 -362880) 1) +(num-test (modulo 362880 1) 0) +(num-test (remainder 362880 1) 0) +(num-test (quotient 362880 1) 362880) +(num-test (modulo -362880 1) 0) +(num-test (remainder -362880 1) 0) +(num-test (quotient -362880 1) -362880) +(num-test (modulo 362880 -1) 0) +(num-test (remainder 362880 -1) 0) +(num-test (quotient 362880 -1) -362880) +(num-test (modulo -362880 -1) 0) +(num-test (remainder -362880 -1) 0) +(num-test (quotient -362880 -1) 362880) +(num-test (modulo 362880 2) 0) +(num-test (remainder 362880 2) 0) +(num-test (quotient 362880 2) 181440) +(num-test (modulo -362880 2) 0) +(num-test (remainder -362880 2) 0) +(num-test (quotient -362880 2) -181440) +(num-test (modulo 362880 -2) 0) +(num-test (remainder 362880 -2) 0) +(num-test (quotient 362880 -2) -181440) +(num-test (modulo -362880 -2) 0) +(num-test (remainder -362880 -2) 0) +(num-test (quotient -362880 -2) 181440) +(num-test (modulo 362880 3) 0) +(num-test (remainder 362880 3) 0) +(num-test (quotient 362880 3) 120960) +(num-test (modulo -362880 3) 0) +(num-test (remainder -362880 3) 0) +(num-test (quotient -362880 3) -120960) +(num-test (modulo 362880 -3) 0) +(num-test (remainder 362880 -3) 0) +(num-test (quotient 362880 -3) -120960) +(num-test (modulo -362880 -3) 0) +(num-test (remainder -362880 -3) 0) +(num-test (quotient -362880 -3) 120960) +(num-test (modulo 362880 10) 0) +(num-test (remainder 362880 10) 0) +(num-test (quotient 362880 10) 36288) +(num-test (modulo -362880 10) 0) +(num-test (remainder -362880 10) 0) +(num-test (quotient -362880 10) -36288) +(num-test (modulo 362880 -10) 0) +(num-test (remainder 362880 -10) 0) +(num-test (quotient 362880 -10) -36288) +(num-test (modulo -362880 -10) 0) +(num-test (remainder -362880 -10) 0) +(num-test (quotient -362880 -10) 36288) +(num-test (modulo 362880 1234) 84) +(num-test (remainder 362880 1234) 84) +(num-test (quotient 362880 1234) 294) +(num-test (modulo -362880 1234) 1150) +(num-test (remainder -362880 1234) -84) +(num-test (quotient -362880 1234) -294) +(num-test (modulo 362880 -1234) -1150) +(num-test (remainder 362880 -1234) 84) +(num-test (quotient 362880 -1234) -294) +(num-test (modulo -362880 -1234) -84) +(num-test (remainder -362880 -1234) -84) +(num-test (quotient -362880 -1234) 294) +(num-test (modulo 362880 1234000000) 362880) +(num-test (remainder 362880 1234000000) 362880) +(num-test (quotient 362880 1234000000) 0) +(num-test (modulo -362880 1234000000) 1233637120) +(num-test (remainder -362880 1234000000) -362880) +(num-test (quotient -362880 1234000000) 0) +(num-test (modulo 362880 -1234000000) -1233637120) +(num-test (remainder 362880 -1234000000) 362880) +(num-test (quotient 362880 -1234000000) 0) +(num-test (modulo -362880 -1234000000) -362880) +(num-test (remainder -362880 -1234000000) -362880) +(num-test (quotient -362880 -1234000000) 0) +(num-test (modulo 362880 500029) 362880) +(num-test (remainder 362880 500029) 362880) +(num-test (quotient 362880 500029) 0) +(num-test (modulo -362880 500029) 137149) +(num-test (remainder -362880 500029) -362880) +(num-test (quotient -362880 500029) 0) +(num-test (modulo 362880 -500029) -137149) +(num-test (remainder 362880 -500029) 362880) +(num-test (quotient 362880 -500029) 0) +(num-test (modulo -362880 -500029) -362880) +(num-test (remainder -362880 -500029) -362880) +(num-test (quotient -362880 -500029) 0) +(num-test (modulo 362880 362880) 0) +(num-test (remainder 362880 362880) 0) +(num-test (quotient 362880 362880) 1) +(num-test (modulo -362880 362880) 0) +(num-test (remainder -362880 362880) 0) +(num-test (quotient -362880 362880) -1) +(num-test (modulo 362880 -362880) 0) +(num-test (remainder 362880 -362880) 0) +(num-test (quotient 362880 -362880) -1) +(num-test (modulo -362880 -362880) 0) +(num-test (remainder -362880 -362880) 0) +(num-test (quotient -362880 -362880) 1) + +(num-test (modulo 13 4) 1) +(num-test (modulo -13 4) 3) +(num-test (quotient 35 7) 5 ) +(num-test (quotient -35 7) -5) +(num-test (quotient 35 -7) -5) +(num-test (quotient -35 -7) 5) +(num-test (modulo 13 4) 1) +(num-test (remainder 13 4) 1) +(num-test (modulo -13 4) 3) +(num-test (remainder -13 4) -1) +(num-test (modulo 13 -4) -3) +(num-test (remainder 13 -4) 1) +(num-test (modulo -13 -4) -1) +(num-test (remainder -13 -4) -1) +(num-test (modulo 0 86400) 0) +(num-test (modulo 0 -86400) 0) + +(let ((top-exp 60)) + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (inexact->exact (expt 2 i))) + (val2 (+ val1 1)) + (mv (modulo val2 2)) + (qv (quotient val2 2)) + (rv (remainder val2 2))) + (if (not (= mv 1)) + (begin (set! happy #f) (display "(modulo ") (display val2) (display " 2) = ") (display mv) (display "?") (newline))) + (if (not (= qv (/ val1 2))) + (begin (set! happy #f) (display "(quotient ") (display val2) (display " 2) = ") (display qv) (display "?") (newline))) + (if (not (= rv 1)) + (begin (set! happy #f) (display "(remainder ") (display val2) (display " 2) = ") (display rv) (display "?") (newline)))))) + ) + + +;; -------- abs and magnitude + +(num-test (abs 0) 0) +(num-test (abs -0) 0) +(num-test (magnitude 0) 0) +(num-test (magnitude -0) 0) +(num-test (abs 0/1) 0/1) +(num-test (abs -0/1) 0/1) +(num-test (magnitude 0/1) 0/1) +(num-test (magnitude -0/1) 0/1) +(num-test (abs 0/2) 0/2) +(num-test (abs -0/2) 0/2) +(num-test (magnitude 0/2) 0/2) +(num-test (magnitude -0/2) 0/2) +(num-test (abs 0/3) 0/3) +(num-test (abs -0/3) 0/3) +(num-test (magnitude 0/3) 0/3) +(num-test (magnitude -0/3) 0/3) +(num-test (abs 0/10) 0/10) +(num-test (abs -0/10) 0/10) +(num-test (magnitude 0/10) 0/10) +(num-test (magnitude -0/10) 0/10) +(num-test (abs 0/1234) 0/1234) +(num-test (abs -0/1234) 0/1234) +(num-test (magnitude 0/1234) 0/1234) +(num-test (magnitude -0/1234) 0/1234) +(num-test (abs 0/1234000000) 0/1234000000) +(num-test (abs -0/1234000000) 0/1234000000) +(num-test (magnitude 0/1234000000) 0/1234000000) +(num-test (magnitude -0/1234000000) 0/1234000000) +(num-test (abs 1) 1) +(num-test (abs -1) 1) +(num-test (magnitude 1) 1) +(num-test (magnitude -1) 1) +(num-test (abs 0/362880) 0/362880) +(num-test (abs -0/362880) 0/362880) +(num-test (magnitude 0/362880) 0/362880) +(num-test (magnitude -0/362880) 0/362880) +(num-test (abs 0/500029) 0/500029) +(num-test (abs -0/500029) 0/500029) +(num-test (magnitude 0/500029) 0/500029) +(num-test (magnitude -0/500029) 0/500029) +(num-test (abs 1/1) 1/1) +(num-test (abs -1/1) 1/1) +(num-test (magnitude 1/1) 1/1) +(num-test (magnitude -1/1) 1/1) +(num-test (abs 1/2) 1/2) +(num-test (abs -1/2) 1/2) +(num-test (magnitude 1/2) 1/2) +(num-test (magnitude -1/2) 1/2) +(num-test (abs 1/3) 1/3) +(num-test (abs -1/3) 1/3) +(num-test (magnitude 1/3) 1/3) +(num-test (magnitude -1/3) 1/3) +(num-test (abs 1/10) 1/10) +(num-test (abs -1/10) 1/10) +(num-test (magnitude 1/10) 1/10) +(num-test (magnitude -1/10) 1/10) +(num-test (abs 1/1234) 1/1234) +(num-test (abs -1/1234) 1/1234) +(num-test (magnitude 1/1234) 1/1234) +(num-test (magnitude -1/1234) 1/1234) +(num-test (abs 1/1234000000) 1/1234000000) +(num-test (abs -1/1234000000) 1/1234000000) +(num-test (magnitude 1/1234000000) 1/1234000000) +(num-test (magnitude -1/1234000000) 1/1234000000) +(num-test (abs 1/500029) 1/500029) +(num-test (abs -1/500029) 1/500029) +(num-test (magnitude 1/500029) 1/500029) +(num-test (magnitude -1/500029) 1/500029) +(num-test (abs 1/362880) 1/362880) +(num-test (abs -1/362880) 1/362880) +(num-test (magnitude 1/362880) 1/362880) +(num-test (magnitude -1/362880) 1/362880) +(num-test (abs 2) 2) +(num-test (abs -2) 2) +(num-test (magnitude 2) 2) +(num-test (magnitude -2) 2) +(num-test (abs 2/1) 2/1) +(num-test (abs -2/1) 2/1) +(num-test (magnitude 2/1) 2/1) +(num-test (magnitude -2/1) 2/1) +(num-test (abs 2/2) 2/2) +(num-test (abs -2/2) 2/2) +(num-test (magnitude 2/2) 2/2) +(num-test (magnitude -2/2) 2/2) +(num-test (abs 2/3) 2/3) +(num-test (abs -2/3) 2/3) +(num-test (magnitude 2/3) 2/3) +(num-test (magnitude -2/3) 2/3) +(num-test (abs 2/10) 2/10) +(num-test (abs -2/10) 2/10) +(num-test (magnitude 2/10) 2/10) +(num-test (magnitude -2/10) 2/10) +(num-test (abs 2/1234) 2/1234) +(num-test (abs -2/1234) 2/1234) +(num-test (magnitude 2/1234) 2/1234) +(num-test (magnitude -2/1234) 2/1234) +(num-test (abs 2/1234000000) 2/1234000000) +(num-test (abs -2/1234000000) 2/1234000000) +(num-test (magnitude 2/1234000000) 2/1234000000) +(num-test (magnitude -2/1234000000) 2/1234000000) +(num-test (abs 2/500029) 2/500029) +(num-test (abs -2/500029) 2/500029) +(num-test (magnitude 2/500029) 2/500029) +(num-test (magnitude -2/500029) 2/500029) +(num-test (abs 2/362880) 2/362880) +(num-test (abs -2/362880) 2/362880) +(num-test (magnitude 2/362880) 2/362880) +(num-test (magnitude -2/362880) 2/362880) +(num-test (abs 3) 3) +(num-test (abs -3) 3) +(num-test (magnitude 3) 3) +(num-test (magnitude -3) 3) +(num-test (abs 3/1) 3/1) +(num-test (abs -3/1) 3/1) +(num-test (magnitude 3/1) 3/1) +(num-test (magnitude -3/1) 3/1) +(num-test (abs 3/2) 3/2) +(num-test (abs -3/2) 3/2) +(num-test (magnitude 3/2) 3/2) +(num-test (magnitude -3/2) 3/2) +(num-test (abs 3/3) 3/3) +(num-test (abs -3/3) 3/3) +(num-test (magnitude 3/3) 3/3) +(num-test (magnitude -3/3) 3/3) +(num-test (abs 3/10) 3/10) +(num-test (abs -3/10) 3/10) +(num-test (magnitude 3/10) 3/10) +(num-test (magnitude -3/10) 3/10) +(num-test (abs 3/1234) 3/1234) +(num-test (abs -3/1234) 3/1234) +(num-test (magnitude 3/1234) 3/1234) +(num-test (magnitude -3/1234) 3/1234) +(num-test (abs 3/1234000000) 3/1234000000) +(num-test (abs -3/1234000000) 3/1234000000) +(num-test (magnitude 3/1234000000) 3/1234000000) +(num-test (magnitude -3/1234000000) 3/1234000000) +(num-test (abs 3/500029) 3/500029) +(num-test (abs -3/500029) 3/500029) +(num-test (magnitude 3/500029) 3/500029) +(num-test (magnitude -3/500029) 3/500029) +(num-test (abs 3/362880) 3/362880) +(num-test (abs -3/362880) 3/362880) +(num-test (magnitude 3/362880) 3/362880) +(num-test (magnitude -3/362880) 3/362880) +(num-test (abs 10) 10) +(num-test (abs -10) 10) +(num-test (magnitude 10) 10) +(num-test (magnitude -10) 10) +(num-test (abs 10/1) 10/1) +(num-test (abs -10/1) 10/1) +(num-test (magnitude 10/1) 10/1) +(num-test (magnitude -10/1) 10/1) +(num-test (abs 10/2) 10/2) +(num-test (abs -10/2) 10/2) +(num-test (magnitude 10/2) 10/2) +(num-test (magnitude -10/2) 10/2) +(num-test (abs 10/3) 10/3) +(num-test (abs -10/3) 10/3) +(num-test (magnitude 10/3) 10/3) +(num-test (magnitude -10/3) 10/3) +(num-test (abs 10/10) 10/10) +(num-test (abs -10/10) 10/10) +(num-test (magnitude 10/10) 10/10) +(num-test (magnitude -10/10) 10/10) +(num-test (abs 10/1234) 10/1234) +(num-test (abs -10/1234) 10/1234) +(num-test (magnitude 10/1234) 10/1234) +(num-test (magnitude -10/1234) 10/1234) +(num-test (abs 10/1234000000) 10/1234000000) +(num-test (abs -10/1234000000) 10/1234000000) +(num-test (magnitude 10/1234000000) 10/1234000000) +(num-test (magnitude -10/1234000000) 10/1234000000) +(num-test (abs 10/500029) 10/500029) +(num-test (abs -10/500029) 10/500029) +(num-test (magnitude 10/500029) 10/500029) +(num-test (magnitude -10/500029) 10/500029) +(num-test (abs 10/362880) 10/362880) +(num-test (abs -10/362880) 10/362880) +(num-test (magnitude 10/362880) 10/362880) +(num-test (magnitude -10/362880) 10/362880) +(num-test (abs 1234) 1234) +(num-test (abs -1234) 1234) +(num-test (magnitude 1234) 1234) +(num-test (magnitude -1234) 1234) +(num-test (abs 1234/1) 1234/1) +(num-test (abs -1234/1) 1234/1) +(num-test (magnitude 1234/1) 1234/1) +(num-test (magnitude -1234/1) 1234/1) +(num-test (abs 1234/2) 1234/2) +(num-test (abs -1234/2) 1234/2) +(num-test (magnitude 1234/2) 1234/2) +(num-test (magnitude -1234/2) 1234/2) +(num-test (abs 1234/3) 1234/3) +(num-test (abs -1234/3) 1234/3) +(num-test (magnitude 1234/3) 1234/3) +(num-test (magnitude -1234/3) 1234/3) +(num-test (abs 1234/10) 1234/10) +(num-test (abs -1234/10) 1234/10) +(num-test (magnitude 1234/10) 1234/10) +(num-test (magnitude -1234/10) 1234/10) +(num-test (abs 1234/1234) 1234/1234) +(num-test (abs -1234/1234) 1234/1234) +(num-test (magnitude 1234/1234) 1234/1234) +(num-test (magnitude -1234/1234) 1234/1234) +(num-test (abs 1234/1234000000) 1234/1234000000) +(num-test (abs -1234/1234000000) 1234/1234000000) +(num-test (magnitude 1234/1234000000) 1234/1234000000) +(num-test (magnitude -1234/1234000000) 1234/1234000000) +(num-test (abs 1234/500029) 1234/500029) +(num-test (abs -1234/500029) 1234/500029) +(num-test (magnitude 1234/500029) 1234/500029) +(num-test (magnitude -1234/500029) 1234/500029) +(num-test (abs 1234/362880) 1234/362880) +(num-test (abs -1234/362880) 1234/362880) +(num-test (magnitude 1234/362880) 1234/362880) +(num-test (magnitude -1234/362880) 1234/362880) +(num-test (abs 1234000000) 1234000000) +(num-test (abs -1234000000) 1234000000) +(num-test (magnitude 1234000000) 1234000000) +(num-test (magnitude -1234000000) 1234000000) +(num-test (abs 1234000000/1) 1234000000/1) +(num-test (abs -1234000000/1) 1234000000/1) +(num-test (magnitude 1234000000/1) 1234000000/1) +(num-test (magnitude -1234000000/1) 1234000000/1) +(num-test (abs 1234000000/2) 1234000000/2) +(num-test (abs -1234000000/2) 1234000000/2) +(num-test (magnitude 1234000000/2) 1234000000/2) +(num-test (magnitude -1234000000/2) 1234000000/2) +(num-test (abs 1234000000/3) 1234000000/3) +(num-test (abs -1234000000/3) 1234000000/3) +(num-test (magnitude 1234000000/3) 1234000000/3) +(num-test (magnitude -1234000000/3) 1234000000/3) +(num-test (abs 1234000000/10) 1234000000/10) +(num-test (abs -1234000000/10) 1234000000/10) +(num-test (magnitude 1234000000/10) 1234000000/10) +(num-test (magnitude -1234000000/10) 1234000000/10) +(num-test (abs 1234000000/1234) 1234000000/1234) +(num-test (abs -1234000000/1234) 1234000000/1234) +(num-test (magnitude 1234000000/1234) 1234000000/1234) +(num-test (magnitude -1234000000/1234) 1234000000/1234) +(num-test (abs 1234000000/1234000000) 1234000000/1234000000) +(num-test (abs -1234000000/1234000000) 1234000000/1234000000) +(num-test (magnitude 1234000000/1234000000) 1234000000/1234000000) +(num-test (magnitude -1234000000/1234000000) 1234000000/1234000000) +(num-test (abs 1234000000/500029) 1234000000/500029) +(num-test (abs -1234000000/500029) 1234000000/500029) +(num-test (magnitude 1234000000/500029) 1234000000/500029) +(num-test (magnitude -1234000000/500029) 1234000000/500029) +(num-test (abs 1234000000/362880) 1234000000/362880) +(num-test (abs -1234000000/362880) 1234000000/362880) +(num-test (magnitude 1234000000/362880) 1234000000/362880) +(num-test (magnitude -1234000000/362880) 1234000000/362880) +(num-test (abs 500029) 500029) +(num-test (abs -500029) 500029) +(num-test (magnitude 500029) 500029) +(num-test (magnitude -500029) 500029) +(num-test (abs 500029/1) 500029/1) +(num-test (abs -500029/1) 500029/1) +(num-test (magnitude 500029/1) 500029/1) +(num-test (magnitude -500029/1) 500029/1) +(num-test (abs 500029/2) 500029/2) +(num-test (abs -500029/2) 500029/2) +(num-test (magnitude 500029/2) 500029/2) +(num-test (magnitude -500029/2) 500029/2) +(num-test (abs 500029/3) 500029/3) +(num-test (abs -500029/3) 500029/3) +(num-test (magnitude 500029/3) 500029/3) +(num-test (magnitude -500029/3) 500029/3) +(num-test (abs 500029/10) 500029/10) +(num-test (abs -500029/10) 500029/10) +(num-test (magnitude 500029/10) 500029/10) +(num-test (magnitude -500029/10) 500029/10) +(num-test (abs 500029/1234) 500029/1234) +(num-test (abs -500029/1234) 500029/1234) +(num-test (magnitude 500029/1234) 500029/1234) +(num-test (magnitude -500029/1234) 500029/1234) +(num-test (abs 500029/1234000000) 500029/1234000000) +(num-test (abs -500029/1234000000) 500029/1234000000) +(num-test (magnitude 500029/1234000000) 500029/1234000000) +(num-test (magnitude -500029/1234000000) 500029/1234000000) +(num-test (abs 500029/500029) 500029/500029) +(num-test (abs -500029/500029) 500029/500029) +(num-test (magnitude 500029/500029) 500029/500029) +(num-test (magnitude -500029/500029) 500029/500029) +(num-test (abs 500029/362880) 500029/362880) +(num-test (abs -500029/362880) 500029/362880) +(num-test (magnitude 500029/362880) 500029/362880) +(num-test (magnitude -500029/362880) 500029/362880) +(num-test (abs 362880) 362880) +(num-test (abs -362880) 362880) +(num-test (magnitude 362880) 362880) +(num-test (magnitude -362880) 362880) +(num-test (abs 362880/1) 362880/1) +(num-test (abs -362880/1) 362880/1) +(num-test (magnitude 362880/1) 362880/1) +(num-test (magnitude -362880/1) 362880/1) +(num-test (abs 362880/2) 362880/2) +(num-test (abs -362880/2) 362880/2) +(num-test (magnitude 362880/2) 362880/2) +(num-test (magnitude -362880/2) 362880/2) +(num-test (abs 362880/3) 362880/3) +(num-test (abs -362880/3) 362880/3) +(num-test (magnitude 362880/3) 362880/3) +(num-test (magnitude -362880/3) 362880/3) +(num-test (abs 362880/10) 362880/10) +(num-test (abs -362880/10) 362880/10) +(num-test (magnitude 362880/10) 362880/10) +(num-test (magnitude -362880/10) 362880/10) +(num-test (abs 362880/1234) 362880/1234) +(num-test (abs -362880/1234) 362880/1234) +(num-test (magnitude 362880/1234) 362880/1234) +(num-test (magnitude -362880/1234) 362880/1234) +(num-test (abs 362880/1234000000) 362880/1234000000) +(num-test (abs -362880/1234000000) 362880/1234000000) +(num-test (magnitude 362880/1234000000) 362880/1234000000) +(num-test (magnitude -362880/1234000000) 362880/1234000000) +(num-test (abs 362880/500029) 362880/500029) +(num-test (abs -362880/500029) 362880/500029) +(num-test (magnitude 362880/500029) 362880/500029) +(num-test (magnitude -362880/500029) 362880/500029) +(num-test (abs 362880/362880) 362880/362880) +(num-test (abs -362880/362880) 362880/362880) +(num-test (magnitude 362880/362880) 362880/362880) +(num-test (magnitude -362880/362880) 362880/362880) +(num-test (abs 0.0) 0.0) +(num-test (abs -0.0) 0.0) +(num-test (magnitude 0.0) 0.0) +(num-test (magnitude -0.0) 0.0) +(num-test (abs 0.00000001) 0.00000001) +(num-test (abs -0.00000001) 0.00000001) +(num-test (magnitude 0.00000001) 0.00000001) +(num-test (magnitude -0.00000001) 0.00000001) +(num-test (abs 1.0) 1.0) +(num-test (abs -1.0) 1.0) +(num-test (magnitude 1.0) 1.0) +(num-test (magnitude -1.0) 1.0) +(num-test (abs our-pi) our-pi) +(num-test (abs -3.14159265358979) our-pi) +(num-test (magnitude our-pi) our-pi) +(num-test (magnitude -3.14159265358979) our-pi) +(num-test (abs 2.71828182845905) 2.71828182845905) +(num-test (abs -2.71828182845905) 2.71828182845905) +(num-test (magnitude 2.71828182845905) 2.71828182845905) +(num-test (magnitude -2.71828182845905) 2.71828182845905) +(num-test (abs 1234.0) 1234.0) +(num-test (abs -1234.0) 1234.0) +(num-test (magnitude 1234.0) 1234.0) +(num-test (magnitude -1234.0) 1234.0) +(num-test (abs 1234000000.0) 1234000000.0) +(num-test (abs -1234000000.0) 1234000000.0) +(num-test (magnitude 1234000000.0) 1234000000.0) +(num-test (magnitude -1234000000.0) 1234000000.0) +(num-test (abs 0) 0) +(num-test (abs 2) 2) +(num-test (abs -2) 2) +(num-test (abs 10) 10) +(num-test (abs -10) 10) +(num-test (abs 1234000000) 1234000000) +(num-test (abs -1234000000) 1234000000) +(num-test (abs 362880) 362880) +(num-test (abs -362880) 362880) +(num-test (abs 0/1) 0/1) +(num-test (abs 0/1) 0/1) +(num-test (abs 2/2) 2/2) +(num-test (abs -2/2) 2/2) +(num-test (abs 10/3) 10/3) +(num-test (abs -10/3) 10/3) +(num-test (abs 1234000000/10) 1234000000/10) +(num-test (abs -1234000000/10) 1234000000/10) +(num-test (abs 362880/1234) 362880/1234) +(num-test (abs -362880/1234) 362880/1234) +(num-test (abs 0.0) 0.0) +(num-test (abs -0.0) 0.0) +(num-test (abs 1.0) 1.0) +(num-test (abs -1.0) 1.0) +(num-test (abs 2.71828182845905) 2.71828182845905) +(num-test (abs -2.71828182845905) 2.71828182845905) +(num-test (abs 1234000000.0) 1234000000.0) +(num-test (abs -1234000000.0) 1234000000.0) +(num-test (abs 6) 6) +(num-test (abs -6) 6) +(num-test (abs -123456789) 123456789) +(num-test (abs -1234567890) 1234567890) +(num-test (abs -7) 7) +(num-test (abs 7) 7) +(num-test (abs 0) 0) +(num-test (magnitude 0.0+0.00000001i) 0.00000001) +(num-test (magnitude 0.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (magnitude 0.0e+00+1.19209289550781250e-07i) 1.1920928955078125e-7+0.0i) +(num-test (magnitude 0.0e+00-1.19209289550781250e-07i) 1.1920928955078125e-7+0.0i) +(num-test (magnitude 0.0e+00+5.0e-01i) 5e-1+0.0i) +(num-test (magnitude 0.0e+00-5.0e-01i) 5e-1+0.0i) +(num-test (magnitude 0.0e+00+1.0e+00i) 1e0+0.0i) +(num-test (magnitude 0.0e+00-1.0e+00i) 1e0+0.0i) +(num-test (magnitude 0.0e+00+2.0e+00i) 2e0+0.0i) +(num-test (magnitude 0.0e+00-2.0e+00i) 2e0+0.0i) +(num-test (magnitude 0.0e+00+8.3886080e+06i) 8.388608e6+0.0i) +(num-test (magnitude 0.0e+00-8.3886080e+06i) 8.388608e6+0.0i) +(num-test (magnitude 1.19209289550781250e-07+0.0e+00i) 1.1920928955078125e-7+0.0i) +(num-test (magnitude -1.19209289550781250e-07+0.0e+00i) 1.1920928955078125e-7+0.0i) +(num-test (magnitude 1.19209289550781250e-07+1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i) +(num-test (magnitude 1.19209289550781250e-07-1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i) +(num-test (magnitude -1.19209289550781250e-07+1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i) +(num-test (magnitude -1.19209289550781250e-07-1.19209289550781250e-07i) 1.6858739404357612715e-7+0.0i) +(num-test (magnitude 1.19209289550781250e-07+5.0e-01i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude 1.19209289550781250e-07-5.0e-01i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude -1.19209289550781250e-07+5.0e-01i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude -1.19209289550781250e-07-5.0e-01i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude 1.19209289550781250e-07+1.0e+00i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude 1.19209289550781250e-07-1.0e+00i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude -1.19209289550781250e-07+1.0e+00i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude -1.19209289550781250e-07-1.0e+00i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude 1.19209289550781250e-07+2.0e+00i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude 1.19209289550781250e-07-2.0e+00i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude -1.19209289550781250e-07+2.0e+00i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude -1.19209289550781250e-07-2.0e+00i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude 1.19209289550781250e-07+8.3886080e+06i) 8.3886080e6+0.0i) +(num-test (magnitude 1.19209289550781250e-07-8.3886080e+06i) 8.3886080e6+0.0i) +(num-test (magnitude -1.19209289550781250e-07+8.3886080e+06i) 8.3886080e6+0.0i) +(num-test (magnitude -1.19209289550781250e-07-8.3886080e+06i) 8.3886080e6+0.0i) +(num-test (magnitude 5.0e-01+0.0e+00i) 5e-1+0.0i) +(num-test (magnitude -5.0e-01+0.0e+00i) 5e-1+0.0i) +(num-test (magnitude 5.0e-01+1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude 5.0e-01-1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude -5.0e-01+1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude -5.0e-01-1.19209289550781250e-07i) 5.0000000000001421085e-1+0.0i) +(num-test (magnitude 5.0e-01+5.0e-01i) 7.0710678118654752440e-1+0.0i) +(num-test (magnitude 5.0e-01-5.0e-01i) 7.0710678118654752440e-1+0.0i) +(num-test (magnitude -5.0e-01+5.0e-01i) 7.0710678118654752440e-1+0.0i) +(num-test (magnitude -5.0e-01-5.0e-01i) 7.0710678118654752440e-1+0.0i) +(num-test (magnitude 5.0e-01+1.0e+00i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude 5.0e-01-1.0e+00i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude -5.0e-01+1.0e+00i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude -5.0e-01-1.0e+00i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude 5.0e-01+2.0e+00i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude 5.0e-01-2.0e+00i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude -5.0e-01+2.0e+00i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude -5.0e-01-2.0e+00i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude 5.0e-01+8.3886080e+06i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude 5.0e-01-8.3886080e+06i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude -5.0e-01+8.3886080e+06i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude -5.0e-01-8.3886080e+06i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude 1.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (magnitude -1.0e+00+0.0e+00i) 1e0+0.0i) +(num-test (magnitude 1.0e+00+1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude 1.0e+00-1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude -1.0e+00+1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude -1.0e+00-1.19209289550781250e-07i) 1.0000000000000071054e0+0.0i) +(num-test (magnitude 1.0e+00+5.0e-01i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude 1.0e+00-5.0e-01i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude -1.0e+00+5.0e-01i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude -1.0e+00-5.0e-01i) 1.1180339887498948482e0+0.0i) +(num-test (magnitude 1.0e+00+1.0e+00i) 1.4142135623730950488e0+0.0i) +(num-test (magnitude 1.0e+00-1.0e+00i) 1.4142135623730950488e0+0.0i) +(num-test (magnitude -1.0e+00+1.0e+00i) 1.4142135623730950488e0+0.0i) +(num-test (magnitude -1.0e+00-1.0e+00i) 1.4142135623730950488e0+0.0i) +(num-test (magnitude 1.0e+00+2.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude 1.0e+00-2.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude -1.0e+00+2.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude -1.0e+00-2.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude 1.0e+00+8.3886080e+06i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude 1.0e+00-8.3886080e+06i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude -1.0e+00+8.3886080e+06i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude -1.0e+00-8.3886080e+06i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude 2.0e+00+0.0e+00i) 2e0+0.0i) +(num-test (magnitude -2.0e+00+0.0e+00i) 2e0+0.0i) +(num-test (magnitude 2.0e+00+1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude 2.0e+00-1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude -2.0e+00+1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude -2.0e+00-1.19209289550781250e-07i) 2.0000000000000035527e0+0.0i) +(num-test (magnitude 2.0e+00+5.0e-01i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude 2.0e+00-5.0e-01i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude -2.0e+00+5.0e-01i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude -2.0e+00-5.0e-01i) 2.0615528128088302749e0+0.0i) +(num-test (magnitude 2.0e+00+1.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude 2.0e+00-1.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude -2.0e+00+1.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude -2.0e+00-1.0e+00i) 2.2360679774997896964e0+0.0i) +(num-test (magnitude 2.0e+00+2.0e+00i) 2.8284271247461900976e0+0.0i) +(num-test (magnitude 2.0e+00-2.0e+00i) 2.8284271247461900976e0+0.0i) +(num-test (magnitude -2.0e+00+2.0e+00i) 2.8284271247461900976e0+0.0i) +(num-test (magnitude -2.0e+00-2.0e+00i) 2.8284271247461900976e0+0.0i) +(num-test (magnitude 2.0e+00+8.3886080e+06i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude 2.0e+00-8.3886080e+06i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude -2.0e+00+8.3886080e+06i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude -2.0e+00-8.3886080e+06i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude 8.3886080e+06+0.0e+00i) 8.388608e6+0.0i) +(num-test (magnitude -8.3886080e+06+0.0e+00i) 8.388608e6+0.0i) +(num-test (magnitude 8.3886080e+06+1.19209289550781250e-07i) 8.3886080e6+0.0i) +(num-test (magnitude 8.3886080e+06-1.19209289550781250e-07i) 8.3886080e6+0.0i) +(num-test (magnitude -8.3886080e+06+1.19209289550781250e-07i) 8.3886080e6+0.0i) +(num-test (magnitude -8.3886080e+06-1.19209289550781250e-07i) 8.3886080e6+0.0i) +(num-test (magnitude 8.3886080e+06+5.0e-01i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude 8.3886080e+06-5.0e-01i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude -8.3886080e+06+5.0e-01i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude -8.3886080e+06-5.0e-01i) 8.3886080000000149012e6+0.0i) +(num-test (magnitude 8.3886080e+06+1.0e+00i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude 8.3886080e+06-1.0e+00i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude -8.3886080e+06+1.0e+00i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude -8.3886080e+06-1.0e+00i) 8.3886080000000596046e6+0.0i) +(num-test (magnitude 8.3886080e+06+2.0e+00i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude 8.3886080e+06-2.0e+00i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude -8.3886080e+06+2.0e+00i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude -8.3886080e+06-2.0e+00i) 8.3886080000002384186e6+0.0i) +(num-test (magnitude 8.3886080e+06+8.3886080e+06i) 1.1863283203031444111e7+0.0i) +(num-test (magnitude 8.3886080e+06-8.3886080e+06i) 1.1863283203031444111e7+0.0i) +(num-test (magnitude -8.3886080e+06+8.3886080e+06i) 1.1863283203031444111e7+0.0i) +(num-test (magnitude -8.3886080e+06-8.3886080e+06i) 1.1863283203031444111e7+0.0i) +(num-test (magnitude 0.0-0.00000001i) 0.00000001) +(num-test (magnitude -0.0+0.00000001i) 0.00000001) +(num-test (magnitude -0.0-0.00000001i) 0.00000001) +(num-test (magnitude 0.0+1.0i) 1.0) +(num-test (magnitude -0.0+1.0i) 1.0) +(num-test (magnitude 0.0-1.0i) 1.0) +(num-test (magnitude -0.0-1.0i) 1.0) +(num-test (magnitude 0.0+3.14159265358979i) 3.14159265358979) +(num-test (magnitude -0.0+3.14159265358979i) 3.14159265358979) +(num-test (magnitude 0.0-3.14159265358979i) 3.14159265358979) +(num-test (magnitude -0.0-3.14159265358979i) 3.14159265358979) +(num-test (magnitude 0.0+2.71828182845905i) 2.71828182845905) +(num-test (magnitude -0.0+2.71828182845905i) 2.71828182845905) +(num-test (magnitude 0.0-2.71828182845905i) 2.71828182845905) +(num-test (magnitude -0.0-2.71828182845905i) 2.71828182845905) +(num-test (magnitude 0.0+1234.0i) 1234.0) +(num-test (magnitude -0.0+1234.0i) 1234.0) +(num-test (magnitude 0.0-1234.0i) 1234.0) +(num-test (magnitude -0.0-1234.0i) 1234.0) +(num-test (magnitude 0.0+1234000000.0i) 1234000000.0) +(num-test (magnitude -0.0+1234000000.0i) 1234000000.0) +(num-test (magnitude 0.0-1234000000.0i) 1234000000.0) +(num-test (magnitude -0.0-1234000000.0i) 1234000000.0) +(num-test (magnitude 0.00000001+0.00000001i) 0.00000001414214) +(num-test (magnitude -0.00000001+0.00000001i) 0.00000001414214) +(num-test (magnitude 0.00000001-0.00000001i) 0.00000001414214) +(num-test (magnitude -0.00000001-0.00000001i) 0.00000001414214) +(num-test (magnitude 0.00000001+1.0i) 1.0) +(num-test (magnitude -0.00000001+1.0i) 1.0) +(num-test (magnitude 0.00000001-1.0i) 1.0) +(num-test (magnitude -0.00000001-1.0i) 1.0) +(num-test (magnitude 0.00000001+3.14159265358979i) our-pi) +(num-test (magnitude -0.00000001+3.14159265358979i) our-pi) +(num-test (magnitude 0.00000001-3.14159265358979i) our-pi) +(num-test (magnitude -0.00000001-3.14159265358979i) our-pi) +(num-test (magnitude 0.00000001+2.71828182845905i) 2.71828182845905) +(num-test (magnitude -0.00000001+2.71828182845905i) 2.71828182845905) +(num-test (magnitude 0.00000001-2.71828182845905i) 2.71828182845905) +(num-test (magnitude -0.00000001-2.71828182845905i) 2.71828182845905) +(num-test (magnitude 0.00000001+1234.0i) 1234.0) +(num-test (magnitude -0.00000001+1234.0i) 1234.0) +(num-test (magnitude 0.00000001-1234.0i) 1234.0) +(num-test (magnitude -0.00000001-1234.0i) 1234.0) +(num-test (magnitude 0.00000001+1234000000.0i) 1234000000.0) +(num-test (magnitude -0.00000001+1234000000.0i) 1234000000.0) +(num-test (magnitude 0.00000001-1234000000.0i) 1234000000.0) +(num-test (magnitude -0.00000001-1234000000.0i) 1234000000.0) +(num-test (magnitude 1.0+0.00000001i) 1.0) +(num-test (magnitude -1.0+0.00000001i) 1.0) +(num-test (magnitude 1.0-0.00000001i) 1.0) +(num-test (magnitude -1.0-0.00000001i) 1.0) +(num-test (magnitude 1.0+1.0i) 1.41421356237310) +(num-test (magnitude -1.0+1.0i) 1.41421356237310) +(num-test (magnitude 1.0-1.0i) 1.41421356237310) +(num-test (magnitude -1.0-1.0i) 1.41421356237310) +(num-test (magnitude 1.0+3.14159265358979i) 3.29690830947562) +(num-test (magnitude -1.0+3.14159265358979i) 3.29690830947562) +(num-test (magnitude 1.0-3.14159265358979i) 3.29690830947562) +(num-test (magnitude -1.0-3.14159265358979i) 3.29690830947562) +(num-test (magnitude 1.0+2.71828182845905i) 2.89638673159001) +(num-test (magnitude -1.0+2.71828182845905i) 2.89638673159001) +(num-test (magnitude 1.0-2.71828182845905i) 2.89638673159001) +(num-test (magnitude -1.0-2.71828182845905i) 2.89638673159001) +(num-test (magnitude 1.0+1234.0i) 1234.00040518631931) +(num-test (magnitude -1.0+1234.0i) 1234.00040518631931) +(num-test (magnitude 1.0-1234.0i) 1234.00040518631931) +(num-test (magnitude -1.0-1234.0i) 1234.00040518631931) +(num-test (magnitude 1.0+1234000000.0i) 1234000000.0) +(num-test (magnitude -1.0+1234000000.0i) 1234000000.0) +(num-test (magnitude 1.0-1234000000.0i) 1234000000.0) +(num-test (magnitude -1.0-1234000000.0i) 1234000000.0) +(num-test (magnitude 3.14159265358979+0.00000001i) our-pi) +(num-test (magnitude -3.14159265358979+0.00000001i) our-pi) +(num-test (magnitude 3.14159265358979-0.00000001i) our-pi) +(num-test (magnitude -3.14159265358979-0.00000001i) our-pi) +(num-test (magnitude 3.14159265358979+1.0i) 3.29690830947562) +(num-test (magnitude -3.14159265358979+1.0i) 3.29690830947562) +(num-test (magnitude 3.14159265358979-1.0i) 3.29690830947562) +(num-test (magnitude -3.14159265358979-1.0i) 3.29690830947562) +(num-test (magnitude 3.14159265358979+3.14159265358979i) 4.44288293815837) +(num-test (magnitude -3.14159265358979+3.14159265358979i) 4.44288293815837) +(num-test (magnitude 3.14159265358979-3.14159265358979i) 4.44288293815837) +(num-test (magnitude -3.14159265358979-3.14159265358979i) 4.44288293815837) +(num-test (magnitude 3.14159265358979+2.71828182845905i) 4.15435440231331) +(num-test (magnitude -3.14159265358979+2.71828182845905i) 4.15435440231331) +(num-test (magnitude 3.14159265358979-2.71828182845905i) 4.15435440231331) +(num-test (magnitude -3.14159265358979-2.71828182845905i) 4.15435440231331) +(num-test (magnitude 3.14159265358979+1234.0i) 1234.00399902285608) +(num-test (magnitude -3.14159265358979+1234.0i) 1234.00399902285608) +(num-test (magnitude 3.14159265358979-1234.0i) 1234.00399902285608) +(num-test (magnitude -3.14159265358979-1234.0i) 1234.00399902285608) +(num-test (magnitude 3.14159265358979+1234000000.0i) 1234000000.0) +(num-test (magnitude -3.14159265358979+1234000000.0i) 1234000000.0) +(num-test (magnitude 3.14159265358979-1234000000.0i) 1234000000.0) +(num-test (magnitude -3.14159265358979-1234000000.0i) 1234000000.0) +(num-test (magnitude 2.71828182845905+0.00000001i) 2.71828182845905) +(num-test (magnitude -2.71828182845905+0.00000001i) 2.71828182845905) +(num-test (magnitude 2.71828182845905-0.00000001i) 2.71828182845905) +(num-test (magnitude -2.71828182845905-0.00000001i) 2.71828182845905) +(num-test (magnitude 2.71828182845905+1.0i) 2.89638673159001) +(num-test (magnitude -2.71828182845905+1.0i) 2.89638673159001) +(num-test (magnitude 2.71828182845905-1.0i) 2.89638673159001) +(num-test (magnitude -2.71828182845905-1.0i) 2.89638673159001) +(num-test (magnitude 2.71828182845905+3.14159265358979i) 4.15435440231331) +(num-test (magnitude -2.71828182845905+3.14159265358979i) 4.15435440231331) +(num-test (magnitude 2.71828182845905-3.14159265358979i) 4.15435440231331) +(num-test (magnitude -2.71828182845905-3.14159265358979i) 4.15435440231331) +(num-test (magnitude 2.71828182845905+2.71828182845905i) 3.84423102815912) +(num-test (magnitude -2.71828182845905+2.71828182845905i) 3.84423102815912) +(num-test (magnitude 2.71828182845905-2.71828182845905i) 3.84423102815912) +(num-test (magnitude -2.71828182845905-2.71828182845905i) 3.84423102815912) +(num-test (magnitude 2.71828182845905+1234.0i) 1234.00299394130275) +(num-test (magnitude -2.71828182845905+1234.0i) 1234.00299394130275) +(num-test (magnitude 2.71828182845905-1234.0i) 1234.00299394130275) +(num-test (magnitude -2.71828182845905-1234.0i) 1234.00299394130275) +(num-test (magnitude 2.71828182845905+1234000000.0i) 1234000000.0) +(num-test (magnitude -2.71828182845905+1234000000.0i) 1234000000.0) +(num-test (magnitude 2.71828182845905-1234000000.0i) 1234000000.0) +(num-test (magnitude -2.71828182845905-1234000000.0i) 1234000000.0) +(num-test (magnitude 1234.0+0.00000001i) 1234.0) +(num-test (magnitude -1234.0+0.00000001i) 1234.0) +(num-test (magnitude 1234.0-0.00000001i) 1234.0) +(num-test (magnitude -1234.0-0.00000001i) 1234.0) +(num-test (magnitude 1234.0+1.0i) 1234.00040518631931) +(num-test (magnitude -1234.0+1.0i) 1234.00040518631931) +(num-test (magnitude 1234.0-1.0i) 1234.00040518631931) +(num-test (magnitude -1234.0-1.0i) 1234.00040518631931) +(num-test (magnitude 1234.0+3.14159265358979i) 1234.00399902285608) +(num-test (magnitude -1234.0+3.14159265358979i) 1234.00399902285608) +(num-test (magnitude 1234.0-3.14159265358979i) 1234.00399902285608) +(num-test (magnitude -1234.0-3.14159265358979i) 1234.00399902285608) +(num-test (magnitude 1234.0+2.71828182845905i) 1234.00299394130275) +(num-test (magnitude -1234.0+2.71828182845905i) 1234.00299394130275) +(num-test (magnitude 1234.0-2.71828182845905i) 1234.00299394130275) +(num-test (magnitude -1234.0-2.71828182845905i) 1234.00299394130275) +(num-test (magnitude 1234.0+1234.0i) 1745.13953596839929) +(num-test (magnitude -1234.0+1234.0i) 1745.13953596839929) +(num-test (magnitude 1234.0-1234.0i) 1745.13953596839929) +(num-test (magnitude -1234.0-1234.0i) 1745.13953596839929) +(num-test (magnitude 1234.0+1234000000.0i) 1234000000.00061702728271) +(num-test (magnitude -1234.0+1234000000.0i) 1234000000.00061702728271) +(num-test (magnitude 1234.0-1234000000.0i) 1234000000.00061702728271) +(num-test (magnitude -1234.0-1234000000.0i) 1234000000.00061702728271) +(num-test (magnitude 1234000000.0+0.00000001i) 1234000000.0) +(num-test (magnitude -1234000000.0+0.00000001i) 1234000000.0) +(num-test (magnitude 1234000000.0-0.00000001i) 1234000000.0) +(num-test (magnitude -1234000000.0-0.00000001i) 1234000000.0) +(num-test (magnitude 1234000000.0+1.0i) 1234000000.0) +(num-test (magnitude -1234000000.0+1.0i) 1234000000.0) +(num-test (magnitude 1234000000.0-1.0i) 1234000000.0) +(num-test (magnitude -1234000000.0-1.0i) 1234000000.0) +(num-test (magnitude 1234000000.0+3.14159265358979i) 1234000000.0) +(num-test (magnitude -1234000000.0+3.14159265358979i) 1234000000.0) +(num-test (magnitude 1234000000.0-3.14159265358979i) 1234000000.0) +(num-test (magnitude -1234000000.0-3.14159265358979i) 1234000000.0) +(num-test (magnitude 1234000000.0+2.71828182845905i) 1234000000.0) +(num-test (magnitude -1234000000.0+2.71828182845905i) 1234000000.0) +(num-test (magnitude 1234000000.0-2.71828182845905i) 1234000000.0) +(num-test (magnitude -1234000000.0-2.71828182845905i) 1234000000.0) +(num-test (magnitude 1234000000.0+1234.0i) 1234000000.00061702728271) +(num-test (magnitude -1234000000.0+1234.0i) 1234000000.00061702728271) +(num-test (magnitude 1234000000.0-1234.0i) 1234000000.00061702728271) +(num-test (magnitude -1234000000.0-1234.0i) 1234000000.00061702728271) +(num-test (magnitude 1234000000.0+1234000000.0i) 1745139535.96839928627014) +(num-test (magnitude -1234000000.0+1234000000.0i) 1745139535.96839928627014) +(num-test (magnitude 1234000000.0-1234000000.0i) 1745139535.96839928627014) +(num-test (magnitude -1234000000.0-1234000000.0i) 1745139535.96839928627014) +(num-test (magnitude 0.0+0.00000001i) 0.00000001) +(num-test (magnitude -0.0+0.00000001i) 0.00000001) +(num-test (magnitude 1.0+1.0i) 1.41421356237310) +(num-test (magnitude -1.0+1.0i) 1.41421356237310) +(num-test (magnitude 2.71828182845905+3.14159265358979i) 4.15435440231331) +(num-test (magnitude -2.71828182845905+3.14159265358979i) 4.15435440231331) +(num-test (magnitude 1234000000.0+2.71828182845905i) 1234000000.0) +(num-test (magnitude -1234000000.0+2.71828182845905i) 1234000000.0) +(num-test (magnitude 0) 0) + + +;; -------- make-polar and make-rectangular + +(num-test (make-rectangular 0 1) 0.0+1.0i) +(num-test (make-rectangular -0 1) -0.0+1.0i) +(num-test (make-rectangular 0 -1) 0.0-1.0i) +(num-test (make-rectangular -0 -1) -0.0-1.0i) +(num-test (make-polar 0 1) 0.0) +(num-test (make-polar -0 1) -0.0) +(num-test (make-polar 0 -1) 0.0) +(num-test (make-polar -0 -1) 0.0) +(num-test (make-rectangular 0 2) 0.0+2.0i) +(num-test (make-rectangular -0 2) -0.0+2.0i) +(num-test (make-rectangular 0 -2) 0.0-2.0i) +(num-test (make-rectangular -0 -2) -0.0-2.0i) +(num-test (make-polar 0 2) -0.0) +(num-test (make-polar -0 2) 0.0) +(num-test (make-polar 0 -2) 0.0) +(num-test (make-polar -0 -2) 0.0) +(num-test (make-rectangular 0 3) 0.0+3.0i) +(num-test (make-rectangular -0 3) -0.0+3.0i) +(num-test (make-rectangular 0 -3) 0.0-3.0i) +(num-test (make-rectangular -0 -3) -0.0-3.0i) +(num-test (make-polar 0 3) -0.0) +(num-test (make-polar -0 3) 0.0) +(num-test (make-polar 0 -3) 0.0) +(num-test (make-polar -0 -3) 0.0) +(num-test (make-rectangular 0 10) 0.0+10.0i) +(num-test (make-rectangular -0 10) -0.0+10.0i) +(num-test (make-rectangular 0 -10) 0.0-10.0i) +(num-test (make-rectangular -0 -10) -0.0-10.0i) +(num-test (make-polar 0 10) 0.0) +(num-test (make-polar -0 10) 0.0) +(num-test (make-polar 0 -10) -0.0) +(num-test (make-polar -0 -10) 0.0) +(num-test (make-rectangular 0 1234) 0.0+1234.0i) +(num-test (make-rectangular -0 1234) -0.0+1234.0i) +(num-test (make-rectangular 0 -1234) 0.0-1234.0i) +(num-test (make-rectangular -0 -1234) -0.0-1234.0i) +(num-test (make-polar 0 1234) -0.0) +(num-test (make-polar -0 1234) 0.0) +(num-test (make-polar 0 -1234) 0.0) +(num-test (make-polar -0 -1234) 0.0) +(num-test (make-rectangular 0 1234000000) 0.0+1234000000.0i) +(num-test (make-rectangular -0 1234000000) -0.0+1234000000.0i) +(num-test (make-rectangular 0 -1234000000) 0.0-1234000000.0i) +(num-test (make-rectangular -0 -1234000000) -0.0-1234000000.0i) +(num-test (make-polar 0 1234000000) 0.0) +(num-test (make-polar -0 1234000000) 0.0) +(num-test (make-polar 0 -1234000000) 0.0) +(num-test (make-polar -0 -1234000000) -0.0) +(num-test (make-rectangular 0 500029) 0.0+500029.0i) +(num-test (make-rectangular -0 500029) -0.0+500029.0i) +(num-test (make-rectangular 0 -500029) 0.0-500029.0i) +(num-test (make-rectangular -0 -500029) -0.0-500029.0i) +(num-test (make-polar 0 500029) 0.0) +(num-test (make-polar -0 500029) -0.0) +(num-test (make-polar 0 -500029) 0.0) +(num-test (make-polar -0 -500029) 0.0) +(num-test (make-rectangular 0 362880) 0.0+362880.0i) +(num-test (make-rectangular -0 362880) -0.0+362880.0i) +(num-test (make-rectangular 0 -362880) 0.0-362880.0i) +(num-test (make-rectangular -0 -362880) -0.0-362880.0i) +(num-test (make-polar 0 362880) 0.0) +(num-test (make-polar -0 362880) -0.0) +(num-test (make-polar 0 -362880) 0.0) +(num-test (make-polar -0 -362880) 0.0) +(num-test (make-rectangular 1 1) 1.0+1.0i) +(num-test (make-rectangular -1 1) -1.0+1.0i) +(num-test (make-rectangular 1 -1) 1.0-1.0i) +(num-test (make-rectangular -1 -1) -1.0-1.0i) +(num-test (make-polar 1 1) 0.54030230586814+0.84147098480790i) +(num-test (make-polar -1 1) -0.54030230586814-0.84147098480790i) +(num-test (make-polar 1 -1) 0.54030230586814-0.84147098480790i) +(num-test (make-polar -1 -1) -0.54030230586814+0.84147098480790i) +(num-test (make-rectangular 1 2) 1.0+2.0i) +(num-test (make-rectangular -1 2) -1.0+2.0i) +(num-test (make-rectangular 1 -2) 1.0-2.0i) +(num-test (make-rectangular -1 -2) -1.0-2.0i) +(num-test (make-polar 1 2) -0.41614683654714+0.90929742682568i) +(num-test (make-polar -1 2) 0.41614683654714-0.90929742682568i) +(num-test (make-polar 1 -2) -0.41614683654714-0.90929742682568i) +(num-test (make-polar -1 -2) 0.41614683654714+0.90929742682568i) +(num-test (make-rectangular 1 3) 1.0+3.0i) +(num-test (make-rectangular -1 3) -1.0+3.0i) +(num-test (make-rectangular 1 -3) 1.0-3.0i) +(num-test (make-rectangular -1 -3) -1.0-3.0i) +(num-test (make-polar 1 3) -0.98999249660045+0.14112000805987i) +(num-test (make-polar -1 3) 0.98999249660045-0.14112000805987i) +(num-test (make-polar 1 -3) -0.98999249660045-0.14112000805987i) +(num-test (make-polar -1 -3) 0.98999249660045+0.14112000805987i) +(num-test (make-rectangular 1 10) 1.0+10.0i) +(num-test (make-rectangular -1 10) -1.0+10.0i) +(num-test (make-rectangular 1 -10) 1.0-10.0i) +(num-test (make-rectangular -1 -10) -1.0-10.0i) +(num-test (make-polar 1 10) -0.83907152907645-0.54402111088937i) +(num-test (make-polar -1 10) 0.83907152907645+0.54402111088937i) +(num-test (make-polar 1 -10) -0.83907152907645+0.54402111088937i) +(num-test (make-polar -1 -10) 0.83907152907645-0.54402111088937i) +(num-test (make-rectangular 1 1234) 1.0+1234.0i) +(num-test (make-rectangular -1 1234) -1.0+1234.0i) +(num-test (make-rectangular 1 -1234) 1.0-1234.0i) +(num-test (make-rectangular -1 -1234) -1.0-1234.0i) +(num-test (make-polar 1 1234) -0.79855062358758+0.60192765476250i) +(num-test (make-polar -1 1234) 0.79855062358758-0.60192765476250i) +(num-test (make-polar 1 -1234) -0.79855062358758-0.60192765476250i) +(num-test (make-polar -1 -1234) 0.79855062358758+0.60192765476250i) +(num-test (make-rectangular 1 1234000000) 1.0+1234000000.0i) +(num-test (make-rectangular -1 1234000000) -1.0+1234000000.0i) +(num-test (make-rectangular 1 -1234000000) 1.0-1234000000.0i) +(num-test (make-rectangular -1 -1234000000) -1.0-1234000000.0i) +(num-test (make-polar 1 1234000000) 0.15890913095152-0.98729321283003i) +(num-test (make-polar -1 1234000000) -0.15890913095152+0.98729321283003i) +(num-test (make-polar 1 -1234000000) 0.15890913095152+0.98729321283003i) +(num-test (make-polar -1 -1234000000) -0.15890913095152-0.98729321283003i) +(num-test (make-rectangular 1 500029) 1.0+500029.0i) +(num-test (make-rectangular -1 500029) -1.0+500029.0i) +(num-test (make-rectangular 1 -500029) 1.0-500029.0i) +(num-test (make-rectangular -1 -500029) -1.0-500029.0i) +(num-test (make-polar 1 500029) 0.85414905629947+0.52002825848479i) +(num-test (make-polar -1 500029) -0.85414905629947-0.52002825848479i) +(num-test (make-polar 1 -500029) 0.85414905629947-0.52002825848479i) +(num-test (make-polar -1 -500029) -0.85414905629947+0.52002825848479i) +(num-test (make-rectangular 1 362880) 1.0+362880.0i) +(num-test (make-rectangular -1 362880) -1.0+362880.0i) +(num-test (make-rectangular 1 -362880) 1.0-362880.0i) +(num-test (make-rectangular -1 -362880) -1.0-362880.0i) +(num-test (make-polar 1 362880) 0.60918079547638+0.79303137291204i) +(num-test (make-polar -1 362880) -0.60918079547638-0.79303137291204i) +(num-test (make-polar 1 -362880) 0.60918079547638-0.79303137291204i) +(num-test (make-polar -1 -362880) -0.60918079547638+0.79303137291204i) +(num-test (make-rectangular 2 1) 2.0+1.0i) +(num-test (make-rectangular -2 1) -2.0+1.0i) +(num-test (make-rectangular 2 -1) 2.0-1.0i) +(num-test (make-rectangular -2 -1) -2.0-1.0i) +(num-test (make-polar 2 1) 1.08060461173628+1.68294196961579i) +(num-test (make-polar -2 1) -1.08060461173628-1.68294196961579i) +(num-test (make-polar 2 -1) 1.08060461173628-1.68294196961579i) +(num-test (make-polar -2 -1) -1.08060461173628+1.68294196961579i) +(num-test (make-rectangular 2 2) 2.0+2.0i) +(num-test (make-rectangular -2 2) -2.0+2.0i) +(num-test (make-rectangular 2 -2) 2.0-2.0i) +(num-test (make-rectangular -2 -2) -2.0-2.0i) +(num-test (make-polar 2 2) -0.83229367309428+1.81859485365136i) +(num-test (make-polar -2 2) 0.83229367309428-1.81859485365136i) +(num-test (make-polar 2 -2) -0.83229367309428-1.81859485365136i) +(num-test (make-polar -2 -2) 0.83229367309428+1.81859485365136i) +(num-test (make-rectangular 2 3) 2.0+3.0i) +(num-test (make-rectangular -2 3) -2.0+3.0i) +(num-test (make-rectangular 2 -3) 2.0-3.0i) +(num-test (make-rectangular -2 -3) -2.0-3.0i) +(num-test (make-polar 2 3) -1.97998499320089+0.28224001611973i) +(num-test (make-polar -2 3) 1.97998499320089-0.28224001611973i) +(num-test (make-polar 2 -3) -1.97998499320089-0.28224001611973i) +(num-test (make-polar -2 -3) 1.97998499320089+0.28224001611973i) +(num-test (make-rectangular 2 10) 2.0+10.0i) +(num-test (make-rectangular -2 10) -2.0+10.0i) +(num-test (make-rectangular 2 -10) 2.0-10.0i) +(num-test (make-rectangular -2 -10) -2.0-10.0i) +(num-test (make-polar 2 10) -1.67814305815290-1.08804222177874i) +(num-test (make-polar -2 10) 1.67814305815290+1.08804222177874i) +(num-test (make-polar 2 -10) -1.67814305815290+1.08804222177874i) +(num-test (make-polar -2 -10) 1.67814305815290-1.08804222177874i) +(num-test (make-rectangular 2 1234) 2.0+1234.0i) +(num-test (make-rectangular -2 1234) -2.0+1234.0i) +(num-test (make-rectangular 2 -1234) 2.0-1234.0i) +(num-test (make-rectangular -2 -1234) -2.0-1234.0i) +(num-test (make-polar 2 1234) -1.59710124717517+1.20385530952499i) +(num-test (make-polar -2 1234) 1.59710124717517-1.20385530952499i) +(num-test (make-polar 2 -1234) -1.59710124717517-1.20385530952499i) +(num-test (make-polar -2 -1234) 1.59710124717517+1.20385530952499i) +(num-test (make-rectangular 2 1234000000) 2.0+1234000000.0i) +(num-test (make-rectangular -2 1234000000) -2.0+1234000000.0i) +(num-test (make-rectangular 2 -1234000000) 2.0-1234000000.0i) +(num-test (make-rectangular -2 -1234000000) -2.0-1234000000.0i) +(num-test (make-polar 2 1234000000) 0.31781826190303-1.97458642566005i) +(num-test (make-polar -2 1234000000) -0.31781826190303+1.97458642566005i) +(num-test (make-polar 2 -1234000000) 0.31781826190303+1.97458642566005i) +(num-test (make-polar -2 -1234000000) -0.31781826190303-1.97458642566005i) +(num-test (make-rectangular 2 500029) 2.0+500029.0i) +(num-test (make-rectangular -2 500029) -2.0+500029.0i) +(num-test (make-rectangular 2 -500029) 2.0-500029.0i) +(num-test (make-rectangular -2 -500029) -2.0-500029.0i) +(num-test (make-polar 2 500029) 1.70829811259895+1.04005651696957i) +(num-test (make-polar -2 500029) -1.70829811259895-1.04005651696957i) +(num-test (make-polar 2 -500029) 1.70829811259895-1.04005651696957i) +(num-test (make-polar -2 -500029) -1.70829811259895+1.04005651696957i) +(num-test (make-rectangular 2 362880) 2.0+362880.0i) +(num-test (make-rectangular -2 362880) -2.0+362880.0i) +(num-test (make-rectangular 2 -362880) 2.0-362880.0i) +(num-test (make-rectangular -2 -362880) -2.0-362880.0i) +(num-test (make-polar 2 362880) 1.21836159095277+1.58606274582408i) +(num-test (make-polar -2 362880) -1.21836159095277-1.58606274582408i) +(num-test (make-polar 2 -362880) 1.21836159095277-1.58606274582408i) +(num-test (make-polar -2 -362880) -1.21836159095277+1.58606274582408i) +(num-test (make-rectangular 3 1) 3.0+1.0i) +(num-test (make-rectangular -3 1) -3.0+1.0i) +(num-test (make-rectangular 3 -1) 3.0-1.0i) +(num-test (make-rectangular -3 -1) -3.0-1.0i) +(num-test (make-polar 3 1) 1.62090691760442+2.52441295442369i) +(num-test (make-polar -3 1) -1.62090691760442-2.52441295442369i) +(num-test (make-polar 3 -1) 1.62090691760442-2.52441295442369i) +(num-test (make-polar -3 -1) -1.62090691760442+2.52441295442369i) +(num-test (make-rectangular 3 2) 3.0+2.0i) +(num-test (make-rectangular -3 2) -3.0+2.0i) +(num-test (make-rectangular 3 -2) 3.0-2.0i) +(num-test (make-rectangular -3 -2) -3.0-2.0i) +(num-test (make-polar 3 2) -1.24844050964143+2.72789228047704i) +(num-test (make-polar -3 2) 1.24844050964143-2.72789228047704i) +(num-test (make-polar 3 -2) -1.24844050964143-2.72789228047704i) +(num-test (make-polar -3 -2) 1.24844050964143+2.72789228047704i) +(num-test (make-rectangular 3 3) 3.0+3.0i) +(num-test (make-rectangular -3 3) -3.0+3.0i) +(num-test (make-rectangular 3 -3) 3.0-3.0i) +(num-test (make-rectangular -3 -3) -3.0-3.0i) +(num-test (make-polar 3 3) -2.96997748980134+0.42336002417960i) +(num-test (make-polar -3 3) 2.96997748980134-0.42336002417960i) +(num-test (make-polar 3 -3) -2.96997748980134-0.42336002417960i) +(num-test (make-polar -3 -3) 2.96997748980134+0.42336002417960i) +(num-test (make-rectangular 3 10) 3.0+10.0i) +(num-test (make-rectangular -3 10) -3.0+10.0i) +(num-test (make-rectangular 3 -10) 3.0-10.0i) +(num-test (make-rectangular -3 -10) -3.0-10.0i) +(num-test (make-polar 3 10) -2.51721458722936-1.63206333266811i) +(num-test (make-polar -3 10) 2.51721458722936+1.63206333266811i) +(num-test (make-polar 3 -10) -2.51721458722936+1.63206333266811i) +(num-test (make-polar -3 -10) 2.51721458722936-1.63206333266811i) +(num-test (make-rectangular 3 1234) 3.0+1234.0i) +(num-test (make-rectangular -3 1234) -3.0+1234.0i) +(num-test (make-rectangular 3 -1234) 3.0-1234.0i) +(num-test (make-rectangular -3 -1234) -3.0-1234.0i) +(num-test (make-polar 3 1234) -2.39565187076275+1.80578296428749i) +(num-test (make-polar -3 1234) 2.39565187076275-1.80578296428749i) +(num-test (make-polar 3 -1234) -2.39565187076275-1.80578296428749i) +(num-test (make-polar -3 -1234) 2.39565187076275+1.80578296428749i) +(num-test (make-rectangular 3 1234000000) 3.0+1234000000.0i) +(num-test (make-rectangular -3 1234000000) -3.0+1234000000.0i) +(num-test (make-rectangular 3 -1234000000) 3.0-1234000000.0i) +(num-test (make-rectangular -3 -1234000000) -3.0-1234000000.0i) +(num-test (make-polar 3 1234000000) 0.47672739285455-2.96187963849008i) +(num-test (make-polar -3 1234000000) -0.47672739285455+2.96187963849008i) +(num-test (make-polar 3 -1234000000) 0.47672739285455+2.96187963849008i) +(num-test (make-polar -3 -1234000000) -0.47672739285455-2.96187963849008i) +(num-test (make-rectangular 3 500029) 3.0+500029.0i) +(num-test (make-rectangular -3 500029) -3.0+500029.0i) +(num-test (make-rectangular 3 -500029) 3.0-500029.0i) +(num-test (make-rectangular -3 -500029) -3.0-500029.0i) +(num-test (make-polar 3 500029) 2.56244716889842+1.56008477545436i) +(num-test (make-polar -3 500029) -2.56244716889842-1.56008477545436i) +(num-test (make-polar 3 -500029) 2.56244716889842-1.56008477545436i) +(num-test (make-polar -3 -500029) -2.56244716889842+1.56008477545436i) +(num-test (make-rectangular 3 362880) 3.0+362880.0i) +(num-test (make-rectangular -3 362880) -3.0+362880.0i) +(num-test (make-rectangular 3 -362880) 3.0-362880.0i) +(num-test (make-rectangular -3 -362880) -3.0-362880.0i) +(num-test (make-polar 3 362880) 1.82754238642915+2.37909411873613i) +(num-test (make-polar -3 362880) -1.82754238642915-2.37909411873613i) +(num-test (make-polar 3 -362880) 1.82754238642915-2.37909411873613i) +(num-test (make-polar -3 -362880) -1.82754238642915+2.37909411873613i) +(num-test (make-rectangular 10 1) 10.0+1.0i) +(num-test (make-rectangular -10 1) -10.0+1.0i) +(num-test (make-rectangular 10 -1) 10.0-1.0i) +(num-test (make-rectangular -10 -1) -10.0-1.0i) +(num-test (make-polar 10 1) 5.40302305868140+8.41470984807897i) +(num-test (make-polar -10 1) -5.40302305868140-8.41470984807897i) +(num-test (make-polar 10 -1) 5.40302305868140-8.41470984807897i) +(num-test (make-polar -10 -1) -5.40302305868140+8.41470984807897i) +(num-test (make-rectangular 10 2) 10.0+2.0i) +(num-test (make-rectangular -10 2) -10.0+2.0i) +(num-test (make-rectangular 10 -2) 10.0-2.0i) +(num-test (make-rectangular -10 -2) -10.0-2.0i) +(num-test (make-polar 10 2) -4.16146836547142+9.09297426825682i) +(num-test (make-polar -10 2) 4.16146836547142-9.09297426825682i) +(num-test (make-polar 10 -2) -4.16146836547142-9.09297426825682i) +(num-test (make-polar -10 -2) 4.16146836547142+9.09297426825682i) +(num-test (make-rectangular 10 3) 10.0+3.0i) +(num-test (make-rectangular -10 3) -10.0+3.0i) +(num-test (make-rectangular 10 -3) 10.0-3.0i) +(num-test (make-rectangular -10 -3) -10.0-3.0i) +(num-test (make-polar 10 3) -9.89992496600445+1.41120008059867i) +(num-test (make-polar -10 3) 9.89992496600445-1.41120008059867i) +(num-test (make-polar 10 -3) -9.89992496600445-1.41120008059867i) +(num-test (make-polar -10 -3) 9.89992496600445+1.41120008059867i) +(num-test (make-rectangular 10 10) 10.0+10.0i) +(num-test (make-rectangular -10 10) -10.0+10.0i) +(num-test (make-rectangular 10 -10) 10.0-10.0i) +(num-test (make-rectangular -10 -10) -10.0-10.0i) +(num-test (make-polar 10 10) -8.39071529076452-5.44021110889370i) +(num-test (make-polar -10 10) 8.39071529076452+5.44021110889370i) +(num-test (make-polar 10 -10) -8.39071529076452+5.44021110889370i) +(num-test (make-polar -10 -10) 8.39071529076452-5.44021110889370i) +(num-test (make-rectangular 10 1234) 10.0+1234.0i) +(num-test (make-rectangular -10 1234) -10.0+1234.0i) +(num-test (make-rectangular 10 -1234) 10.0-1234.0i) +(num-test (make-rectangular -10 -1234) -10.0-1234.0i) +(num-test (make-polar 10 1234) -7.98550623587584+6.01927654762497i) +(num-test (make-polar -10 1234) 7.98550623587584-6.01927654762497i) +(num-test (make-polar 10 -1234) -7.98550623587584-6.01927654762497i) +(num-test (make-polar -10 -1234) 7.98550623587584+6.01927654762497i) +(num-test (make-rectangular 10 1234000000) 10.0+1234000000.0i) +(num-test (make-rectangular -10 1234000000) -10.0+1234000000.0i) +(num-test (make-rectangular 10 -1234000000) 10.0-1234000000.0i) +(num-test (make-rectangular -10 -1234000000) -10.0-1234000000.0i) +(num-test (make-polar 10 1234000000) 1.58909130951517-9.87293212830025i) +(num-test (make-polar -10 1234000000) -1.58909130951517+9.87293212830025i) +(num-test (make-polar 10 -1234000000) 1.58909130951517+9.87293212830025i) +(num-test (make-polar -10 -1234000000) -1.58909130951517-9.87293212830025i) +(num-test (make-rectangular 10 500029) 10.0+500029.0i) +(num-test (make-rectangular -10 500029) -10.0+500029.0i) +(num-test (make-rectangular 10 -500029) 10.0-500029.0i) +(num-test (make-rectangular -10 -500029) -10.0-500029.0i) +(num-test (make-polar 10 500029) 8.54149056299473+5.20028258484786i) +(num-test (make-polar -10 500029) -8.54149056299473-5.20028258484786i) +(num-test (make-polar 10 -500029) 8.54149056299473-5.20028258484786i) +(num-test (make-polar -10 -500029) -8.54149056299473+5.20028258484786i) +(num-test (make-rectangular 10 362880) 10.0+362880.0i) +(num-test (make-rectangular -10 362880) -10.0+362880.0i) +(num-test (make-rectangular 10 -362880) 10.0-362880.0i) +(num-test (make-rectangular -10 -362880) -10.0-362880.0i) +(num-test (make-polar 10 362880) 6.09180795476385+7.93031372912042i) +(num-test (make-polar -10 362880) -6.09180795476385-7.93031372912042i) +(num-test (make-polar 10 -362880) 6.09180795476385-7.93031372912042i) +(num-test (make-polar -10 -362880) -6.09180795476385+7.93031372912042i) +(num-test (make-rectangular 1234 1) 1234.0+1.0i) +(num-test (make-rectangular -1234 1) -1234.0+1.0i) +(num-test (make-rectangular 1234 -1) 1234.0-1.0i) +(num-test (make-rectangular -1234 -1) -1234.0-1.0i) +(num-test (make-polar 1234 1) 666.73304544128450+1038.37519525294420i) +(num-test (make-polar -1234 1) -666.73304544128450-1038.37519525294420i) +(num-test (make-polar 1234 -1) 666.73304544128450-1038.37519525294420i) +(num-test (make-polar -1234 -1) -666.73304544128450+1038.37519525294420i) +(num-test (make-rectangular 1234 2) 1234.0+2.0i) +(num-test (make-rectangular -1234 2) -1234.0+2.0i) +(num-test (make-rectangular 1234 -2) 1234.0-2.0i) +(num-test (make-rectangular -1234 -2) -1234.0-2.0i) +(num-test (make-polar 1234 2) -513.52519629917379+1122.07302470289119i) +(num-test (make-polar -1234 2) 513.52519629917379-1122.07302470289119i) +(num-test (make-polar 1234 -2) -513.52519629917379-1122.07302470289119i) +(num-test (make-polar -1234 -2) 513.52519629917379+1122.07302470289119i) +(num-test (make-rectangular 1234 3) 1234.0+3.0i) +(num-test (make-rectangular -1234 3) -1234.0+3.0i) +(num-test (make-rectangular 1234 -3) 1234.0-3.0i) +(num-test (make-rectangular -1234 -3) -1234.0-3.0i) +(num-test (make-polar 1234 3) -1221.65074080494969+174.14208994587614i) +(num-test (make-polar -1234 3) 1221.65074080494969-174.14208994587614i) +(num-test (make-polar 1234 -3) -1221.65074080494969-174.14208994587614i) +(num-test (make-polar -1234 -3) 1221.65074080494969+174.14208994587614i) +(num-test (make-rectangular 1234 10) 1234.0+10.0i) +(num-test (make-rectangular -1234 10) -1234.0+10.0i) +(num-test (make-rectangular 1234 -10) 1234.0-10.0i) +(num-test (make-rectangular -1234 -10) -1234.0-10.0i) +(num-test (make-polar 1234 10) -1035.41426688034221-671.32205083748227i) +(num-test (make-polar -1234 10) 1035.41426688034221+671.32205083748227i) +(num-test (make-polar 1234 -10) -1035.41426688034221+671.32205083748227i) +(num-test (make-polar -1234 -10) 1035.41426688034221-671.32205083748227i) +(num-test (make-rectangular 1234 1234) 1234.0+1234.0i) +(num-test (make-rectangular -1234 1234) -1234.0+1234.0i) +(num-test (make-rectangular 1234 -1234) 1234.0-1234.0i) +(num-test (make-rectangular -1234 -1234) -1234.0-1234.0i) +(num-test (make-polar 1234 1234) -985.41146950707912+742.77872597692169i) +(num-test (make-polar -1234 1234) 985.41146950707912-742.77872597692169i) +(num-test (make-polar 1234 -1234) -985.41146950707912-742.77872597692169i) +(num-test (make-polar -1234 -1234) 985.41146950707912+742.77872597692169i) +(num-test (make-rectangular 1234 1234000000) 1234.0+1234000000.0i) +(num-test (make-rectangular -1234 1234000000) -1234.0+1234000000.0i) +(num-test (make-rectangular 1234 -1234000000) 1234.0-1234000000.0i) +(num-test (make-rectangular -1234 -1234000000) -1234.0-1234000000.0i) +(num-test (make-polar 1234 1234000000) 196.09386759417183-1218.31982463225131i) +(num-test (make-polar -1234 1234000000) -196.09386759417183+1218.31982463225131i) +(num-test (make-polar 1234 -1234000000) 196.09386759417183+1218.31982463225131i) +(num-test (make-polar -1234 -1234000000) -196.09386759417183-1218.31982463225131i) +(num-test (make-rectangular 1234 500029) 1234.0+500029.0i) +(num-test (make-rectangular -1234 500029) -1234.0+500029.0i) +(num-test (make-rectangular 1234 -500029) 1234.0-500029.0i) +(num-test (make-rectangular -1234 -500029) -1234.0-500029.0i) +(num-test (make-polar 1234 500029) 1054.01993547355005+641.71487097022577i) +(num-test (make-polar -1234 500029) -1054.01993547355005-641.71487097022577i) +(num-test (make-polar 1234 -500029) 1054.01993547355005-641.71487097022577i) +(num-test (make-polar -1234 -500029) -1054.01993547355005+641.71487097022577i) +(num-test (make-rectangular 1234 362880) 1234.0+362880.0i) +(num-test (make-rectangular -1234 362880) -1234.0+362880.0i) +(num-test (make-rectangular 1234 -362880) 1234.0-362880.0i) +(num-test (make-rectangular -1234 -362880) -1234.0-362880.0i) +(num-test (make-polar 1234 362880) 751.72910161785899+978.60071417346035i) +(num-test (make-polar -1234 362880) -751.72910161785899-978.60071417346035i) +(num-test (make-polar 1234 -362880) 751.72910161785899-978.60071417346035i) +(num-test (make-polar -1234 -362880) -751.72910161785899+978.60071417346035i) +(num-test (make-rectangular 1234000000 1) 1234000000.0+1.0i) +(num-test (make-rectangular -1234000000 1) -1234000000.0+1.0i) +(num-test (make-rectangular 1234000000 -1) 1234000000.0-1.0i) +(num-test (make-rectangular -1234000000 -1) -1234000000.0-1.0i) +(num-test (make-polar 1234000000 1) 666733045.44128441810608+1038375195.25294423103333i) +(num-test (make-polar -1234000000 1) -666733045.44128441810608-1038375195.25294423103333i) +(num-test (make-polar 1234000000 -1) 666733045.44128441810608-1038375195.25294423103333i) +(num-test (make-polar -1234000000 -1) -666733045.44128441810608+1038375195.25294423103333i) +(num-test (make-rectangular 1234000000 2) 1234000000.0+2.0i) +(num-test (make-rectangular -1234000000 2) -1234000000.0+2.0i) +(num-test (make-rectangular 1234000000 -2) 1234000000.0-2.0i) +(num-test (make-rectangular -1234000000 -2) -1234000000.0-2.0i) +(num-test (make-polar 1234000000 2) -513525196.29917371273041+1122073024.70289111137390i) +(num-test (make-polar -1234000000 2) 513525196.29917371273041-1122073024.70289111137390i) +(num-test (make-polar 1234000000 -2) -513525196.29917371273041-1122073024.70289111137390i) +(num-test (make-polar -1234000000 -2) 513525196.29917371273041+1122073024.70289111137390i) +(num-test (make-rectangular 1234000000 3) 1234000000.0+3.0i) +(num-test (make-rectangular -1234000000 3) -1234000000.0+3.0i) +(num-test (make-rectangular 1234000000 -3) 1234000000.0-3.0i) +(num-test (make-rectangular -1234000000 -3) -1234000000.0-3.0i) +(num-test (make-polar 1234000000 3) -1221650740.80494976043701+174142089.94587615132332i) +(num-test (make-polar -1234000000 3) 1221650740.80494976043701-174142089.94587615132332i) +(num-test (make-polar 1234000000 -3) -1221650740.80494976043701-174142089.94587615132332i) +(num-test (make-polar -1234000000 -3) 1221650740.80494976043701+174142089.94587615132332i) +(num-test (make-rectangular 1234000000 10) 1234000000.0+10.0i) +(num-test (make-rectangular -1234000000 10) -1234000000.0+10.0i) +(num-test (make-rectangular 1234000000 -10) 1234000000.0-10.0i) +(num-test (make-rectangular -1234000000 -10) -1234000000.0-10.0i) +(num-test (make-polar 1234000000 10) -1035414266.88034236431122-671322050.83748233318329i) +(num-test (make-polar -1234000000 10) 1035414266.88034236431122+671322050.83748233318329i) +(num-test (make-polar 1234000000 -10) -1035414266.88034236431122+671322050.83748233318329i) +(num-test (make-polar -1234000000 -10) 1035414266.88034236431122-671322050.83748233318329i) +(num-test (make-rectangular 1234000000 1234) 1234000000.0+1234.0i) +(num-test (make-rectangular -1234000000 1234) -1234000000.0+1234.0i) +(num-test (make-rectangular 1234000000 -1234) 1234000000.0-1234.0i) +(num-test (make-rectangular -1234000000 -1234) -1234000000.0-1234.0i) +(num-test (make-polar 1234000000 1234) -985411469.50707900524139+742778725.97692167758942i) +(num-test (make-polar -1234000000 1234) 985411469.50707900524139-742778725.97692167758942i) +(num-test (make-polar 1234000000 -1234) -985411469.50707900524139-742778725.97692167758942i) +(num-test (make-polar -1234000000 -1234) 985411469.50707900524139+742778725.97692167758942i) +(num-test (make-rectangular 1234000000 1234000000) 1234000000.0+1234000000.0i) +(num-test (make-rectangular -1234000000 1234000000) -1234000000.0+1234000000.0i) +(num-test (make-rectangular 1234000000 -1234000000) 1234000000.0-1234000000.0i) +(num-test (make-rectangular -1234000000 -1234000000) -1234000000.0-1234000000.0i) +(num-test (make-polar 1234000000 1234000000) 196093867.59417182207108-1218319824.63225126266479i) +(num-test (make-polar -1234000000 1234000000) -196093867.59417182207108+1218319824.63225126266479i) +(num-test (make-polar 1234000000 -1234000000) 196093867.59417182207108+1218319824.63225126266479i) +(num-test (make-polar -1234000000 -1234000000) -196093867.59417182207108-1218319824.63225126266479i) +(num-test (make-rectangular 1234000000 500029) 1234000000.0+500029.0i) +(num-test (make-rectangular -1234000000 500029) -1234000000.0+500029.0i) +(num-test (make-rectangular 1234000000 -500029) 1234000000.0-500029.0i) +(num-test (make-rectangular -1234000000 -500029) -1234000000.0-500029.0i) +(num-test (make-polar 1234000000 500029) 1054019935.47354996204376+641714870.97022569179535i) +(num-test (make-polar -1234000000 500029) -1054019935.47354996204376-641714870.97022569179535i) +(num-test (make-polar 1234000000 -500029) 1054019935.47354996204376-641714870.97022569179535i) +(num-test (make-polar -1234000000 -500029) -1054019935.47354996204376+641714870.97022569179535i) +(num-test (make-rectangular 1234000000 362880) 1234000000.0+362880.0i) +(num-test (make-rectangular -1234000000 362880) -1234000000.0+362880.0i) +(num-test (make-rectangular 1234000000 -362880) 1234000000.0-362880.0i) +(num-test (make-rectangular -1234000000 -362880) -1234000000.0-362880.0i) +(num-test (make-polar 1234000000 362880) 751729101.61785900592804+978600714.17346036434174i) +(num-test (make-polar -1234000000 362880) -751729101.61785900592804-978600714.17346036434174i) +(num-test (make-polar 1234000000 -362880) 751729101.61785900592804-978600714.17346036434174i) +(num-test (make-polar -1234000000 -362880) -751729101.61785900592804+978600714.17346036434174i) +(num-test (make-rectangular 500029 1) 500029.0+1.0i) +(num-test (make-rectangular -500029 1) -500029.0+1.0i) +(num-test (make-rectangular 500029 -1) 500029.0-1.0i) +(num-test (make-rectangular -500029 -1) -500029.0-1.0i) +(num-test (make-polar 500029 1) 270166.82170094008325+420759.89506250765407i) +(num-test (make-polar -500029 1) -270166.82170094008325-420759.89506250765407i) +(num-test (make-polar 500029 -1) 270166.82170094008325-420759.89506250765407i) +(num-test (make-polar -500029 -1) -270166.82170094008325+420759.89506250765407i) +(num-test (make-rectangular 500029 2) 500029.0+2.0i) +(num-test (make-rectangular -500029 2) -500029.0+2.0i) +(num-test (make-rectangular 500029 -2) 500029.0-2.0i) +(num-test (make-rectangular -500029 -2) -500029.0-2.0i) +(num-test (make-polar 500029 2) -208085.48653183106217+454675.08303821878508i) +(num-test (make-polar -500029 2) 208085.48653183106217-454675.08303821878508i) +(num-test (make-polar 500029 -2) -208085.48653183106217-454675.08303821878508i) +(num-test (make-polar -500029 -2) 208085.48653183106217+454675.08303821878508i) +(num-test (make-rectangular 500029 3) 500029.0+3.0i) +(num-test (make-rectangular -500029 3) -500029.0+3.0i) +(num-test (make-rectangular 500029 -3) 500029.0-3.0i) +(num-test (make-rectangular -500029 -3) -500029.0-3.0i) +(num-test (make-polar 500029 3) -495024.95808262412902+70564.09651016735006i) +(num-test (make-polar -500029 3) 495024.95808262412902-70564.09651016735006i) +(num-test (make-polar 500029 -3) -495024.95808262412902-70564.09651016735006i) +(num-test (make-polar -500029 -3) 495024.95808262412902+70564.09651016735006i) +(num-test (make-rectangular 500029 10) 500029.0+10.0i) +(num-test (make-rectangular -500029 10) -500029.0+10.0i) +(num-test (make-rectangular 500029 -10) 500029.0-10.0i) +(num-test (make-rectangular -500029 -10) -500029.0-10.0i) +(num-test (make-polar 500029 10) -419560.09761256945785-272026.33205690066097i) +(num-test (make-polar -500029 10) 419560.09761256945785+272026.33205690066097i) +(num-test (make-polar 500029 -10) -419560.09761256945785+272026.33205690066097i) +(num-test (make-polar -500029 -10) 419560.09761256945785-272026.33205690066097i) +(num-test (make-rectangular 500029 1234) 500029.0+1234.0i) +(num-test (make-rectangular -500029 1234) -500029.0+1234.0i) +(num-test (make-rectangular 500029 -1234) 500029.0-1234.0i) +(num-test (make-rectangular -500029 -1234) -500029.0-1234.0i) +(num-test (make-polar 500029 1234) -399298.46976187621476+300981.28328323678579i) +(num-test (make-polar -500029 1234) 399298.46976187621476-300981.28328323678579i) +(num-test (make-polar 500029 -1234) -399298.46976187621476-300981.28328323678579i) +(num-test (make-polar -500029 -1234) 399298.46976187621476+300981.28328323678579i) +(num-test (make-rectangular 500029 1234000000) 500029.0+1234000000.0i) +(num-test (make-rectangular -500029 1234000000) -500029.0+1234000000.0i) +(num-test (make-rectangular 500029 -1234000000) 500029.0-1234000000.0i) +(num-test (make-rectangular -500029 -1234000000) -500029.0-1234000000.0i) +(num-test (make-polar 500029 1234000000) 79459.17384055603179-493675.23791818472091i) +(num-test (make-polar -500029 1234000000) -79459.17384055603179+493675.23791818472091i) +(num-test (make-polar 500029 -1234000000) 79459.17384055603179+493675.23791818472091i) +(num-test (make-polar -500029 -1234000000) -79459.17384055603179-493675.23791818472091i) +(num-test (make-rectangular 500029 500029) 500029.0+500029.0i) +(num-test (make-rectangular -500029 500029) -500029.0+500029.0i) +(num-test (make-rectangular 500029 -500029) 500029.0-500029.0i) +(num-test (make-rectangular -500029 -500029) -500029.0-500029.0i) +(num-test (make-polar 500029 500029) 427099.29847236932255+260029.21006188896718i) +(num-test (make-polar -500029 500029) -427099.29847236932255-260029.21006188896718i) +(num-test (make-polar 500029 -500029) 427099.29847236932255-260029.21006188896718i) +(num-test (make-polar -500029 -500029) -427099.29847236932255+260029.21006188896718i) +(num-test (make-rectangular 500029 362880) 500029.0+362880.0i) +(num-test (make-rectangular -500029 362880) -500029.0+362880.0i) +(num-test (make-rectangular 500029 -362880) 500029.0-362880.0i) +(num-test (make-rectangular -500029 -362880) -500029.0-362880.0i) +(num-test (make-polar 500029 362880) 304608.06398126127897+396538.68436583562288i) +(num-test (make-polar -500029 362880) -304608.06398126127897-396538.68436583562288i) +(num-test (make-polar 500029 -362880) 304608.06398126127897-396538.68436583562288i) +(num-test (make-polar -500029 -362880) -304608.06398126127897+396538.68436583562288i) +(num-test (make-rectangular 362880 1) 362880.0+1.0i) +(num-test (make-rectangular -362880 1) -362880.0+1.0i) +(num-test (make-rectangular 362880 -1) 362880.0-1.0i) +(num-test (make-rectangular -362880 -1) -362880.0-1.0i) +(num-test (make-polar 362880 1) 196064.90075343055651+305352.99096708948491i) +(num-test (make-polar -362880 1) -196064.90075343055651-305352.99096708948491i) +(num-test (make-polar 362880 -1) 196064.90075343055651-305352.99096708948491i) +(num-test (make-polar -362880 -1) -196064.90075343055651+305352.99096708948491i) +(num-test (make-rectangular 362880 2) 362880.0+2.0i) +(num-test (make-rectangular -362880 2) -362880.0+2.0i) +(num-test (make-rectangular 362880 -2) 362880.0-2.0i) +(num-test (make-rectangular -362880 -2) -362880.0-2.0i) +(num-test (make-polar 362880 2) -151011.36404622704140+329965.85024650336709i) +(num-test (make-polar -362880 2) 151011.36404622704140-329965.85024650336709i) +(num-test (make-polar 362880 -2) -151011.36404622704140-329965.85024650336709i) +(num-test (make-polar -362880 -2) 151011.36404622704140+329965.85024650336709i) +(num-test (make-rectangular 362880 3) 362880.0+3.0i) +(num-test (make-rectangular -362880 3) -362880.0+3.0i) +(num-test (make-rectangular 362880 -3) 362880.0-3.0i) +(num-test (make-rectangular -362880 -3) -362880.0-3.0i) +(num-test (make-polar 362880 3) -359248.47716636961559+51209.62852476461558i) +(num-test (make-polar -362880 3) 359248.47716636961559-51209.62852476461558i) +(num-test (make-polar 362880 -3) -359248.47716636961559-51209.62852476461558i) +(num-test (make-polar -362880 -3) 359248.47716636961559+51209.62852476461558i) +(num-test (make-rectangular 362880 10) 362880.0+10.0i) +(num-test (make-rectangular -362880 10) -362880.0+10.0i) +(num-test (make-rectangular 362880 -10) 362880.0-10.0i) +(num-test (make-rectangular -362880 -10) -362880.0-10.0i) +(num-test (make-polar 362880 10) -304482.27647126308875-197414.38071953449980i) +(num-test (make-polar -362880 10) 304482.27647126308875+197414.38071953449980i) +(num-test (make-polar 362880 -10) -304482.27647126308875+197414.38071953449980i) +(num-test (make-polar -362880 -10) 304482.27647126308875-197414.38071953449980i) +(num-test (make-rectangular 362880 1234) 362880.0+1234.0i) +(num-test (make-rectangular -362880 1234) -362880.0+1234.0i) +(num-test (make-rectangular 362880 -1234) 362880.0-1234.0i) +(num-test (make-rectangular -362880 -1234) -362880.0-1234.0i) +(num-test (make-polar 362880 1234) -289778.05028746259632+218427.50736021503690i) +(num-test (make-polar -362880 1234) 289778.05028746259632-218427.50736021503690i) +(num-test (make-polar 362880 -1234) -289778.05028746259632-218427.50736021503690i) +(num-test (make-polar -362880 -1234) 289778.05028746259632+218427.50736021503690i) +(num-test (make-rectangular 362880 1234000000) 362880.0+1234000000.0i) +(num-test (make-rectangular -362880 1234000000) -362880.0+1234000000.0i) +(num-test (make-rectangular 362880 -1234000000) 362880.0-1234000000.0i) +(num-test (make-rectangular -362880 -1234000000) -362880.0-1234000000.0i) +(num-test (make-polar 362880 1234000000) 57664.94543968644575-358268.96107175957877i) +(num-test (make-polar -362880 1234000000) -57664.94543968644575+358268.96107175957877i) +(num-test (make-polar 362880 -1234000000) 57664.94543968644575+358268.96107175957877i) +(num-test (make-polar -362880 -1234000000) -57664.94543968644575-358268.96107175957877i) +(num-test (make-rectangular 362880 500029) 362880.0+500029.0i) +(num-test (make-rectangular -362880 500029) -362880.0+500029.0i) +(num-test (make-rectangular 362880 -500029) 362880.0-500029.0i) +(num-test (make-rectangular -362880 -500029) -362880.0-500029.0i) +(num-test (make-polar 362880 500029) 309953.60954995284555+188707.85443895909702i) +(num-test (make-polar -362880 500029) -309953.60954995284555-188707.85443895909702i) +(num-test (make-polar 362880 -500029) 309953.60954995284555-188707.85443895909702i) +(num-test (make-polar -362880 -500029) -309953.60954995284555+188707.85443895909702i) +(num-test (make-rectangular 362880 362880) 362880.0+362880.0i) +(num-test (make-rectangular -362880 362880) -362880.0+362880.0i) +(num-test (make-rectangular 362880 -362880) 362880.0-362880.0i) +(num-test (make-rectangular -362880 -362880) -362880.0-362880.0i) +(num-test (make-polar 362880 362880) 221059.52706247055903+287775.22460232191952i) +(num-test (make-polar -362880 362880) -221059.52706247055903-287775.22460232191952i) +(num-test (make-polar 362880 -362880) 221059.52706247055903-287775.22460232191952i) +(num-test (make-polar -362880 -362880) -221059.52706247055903+287775.22460232191952i) +(num-test (make-rectangular 0.0 0.00000001) 0.0+0.00000001i) +(num-test (make-rectangular -0.0 0.00000001) -0.0+0.00000001i) +(num-test (make-rectangular 0.0 -0.00000001) 0.0-0.00000001i) +(num-test (make-rectangular -0.0 -0.00000001) -0.0-0.00000001i) +(num-test (make-polar 0.0 0.00000001) 0.0) +(num-test (make-polar -0.0 0.00000001) -0.0) +(num-test (make-polar 0.0 -0.00000001) 0.0) +(num-test (make-polar -0.0 -0.00000001) 0.0) +(num-test (make-rectangular 0.0 1.0) 0.0+1.0i) +(num-test (make-rectangular -0.0 1.0) -0.0+1.0i) +(num-test (make-rectangular 0.0 -1.0) 0.0-1.0i) +(num-test (make-rectangular -0.0 -1.0) -0.0-1.0i) +(num-test (make-polar 0.0 1.0) 0.0) +(num-test (make-polar -0.0 1.0) -0.0) +(num-test (make-polar 0.0 -1.0) 0.0) +(num-test (make-polar -0.0 -1.0) 0.0) +(num-test (make-rectangular 0.0 our-pi) 0.0+3.14159265358979i) +(num-test (make-rectangular -0.0 our-pi) -0.0+3.14159265358979i) +(num-test (make-rectangular 0.0 -3.14159265358979) 0.0-3.14159265358979i) +(num-test (make-rectangular -0.0 -3.14159265358979) -0.0-3.14159265358979i) +(num-test (make-polar 0.0 our-pi) -0.0) +(num-test (make-polar -0.0 our-pi) 0.0) +(num-test (make-polar 0.0 -3.14159265358979) 0.0) +(num-test (make-polar -0.0 -3.14159265358979) 0.0) +(num-test (make-rectangular 0.0 2.71828182845905) 0.0+2.71828182845905i) +(num-test (make-rectangular -0.0 2.71828182845905) -0.0+2.71828182845905i) +(num-test (make-rectangular 0.0 -2.71828182845905) 0.0-2.71828182845905i) +(num-test (make-rectangular -0.0 -2.71828182845905) -0.0-2.71828182845905i) +(num-test (make-polar 0.0 2.71828182845905) -0.0) +(num-test (make-polar -0.0 2.71828182845905) 0.0) +(num-test (make-polar 0.0 -2.71828182845905) 0.0) +(num-test (make-polar -0.0 -2.71828182845905) 0.0) +(num-test (make-rectangular 0.0 1234.0) 0.0+1234.0i) +(num-test (make-rectangular -0.0 1234.0) -0.0+1234.0i) +(num-test (make-rectangular 0.0 -1234.0) 0.0-1234.0i) +(num-test (make-rectangular -0.0 -1234.0) -0.0-1234.0i) +(num-test (make-polar 0.0 1234.0) -0.0) +(num-test (make-polar -0.0 1234.0) 0.0) +(num-test (make-polar 0.0 -1234.0) 0.0) +(num-test (make-polar -0.0 -1234.0) 0.0) +(num-test (make-rectangular 0.0 1234000000.0) 0.0+1234000000.0i) +(num-test (make-rectangular -0.0 1234000000.0) -0.0+1234000000.0i) +(num-test (make-rectangular 0.0 -1234000000.0) 0.0-1234000000.0i) +(num-test (make-rectangular -0.0 -1234000000.0) -0.0-1234000000.0i) +(num-test (make-polar 0.0 1234000000.0) 0.0) +(num-test (make-polar -0.0 1234000000.0) 0.0) +(num-test (make-polar 0.0 -1234000000.0) 0.0) +(num-test (make-polar -0.0 -1234000000.0) -0.0) +(num-test (make-rectangular 0.00000001 0.00000001) 0.00000001+0.00000001i) +(num-test (make-rectangular -0.00000001 0.00000001) -0.00000001+0.00000001i) +(num-test (make-rectangular 0.00000001 -0.00000001) 0.00000001-0.00000001i) +(num-test (make-rectangular -0.00000001 -0.00000001) -0.00000001-0.00000001i) +(num-test (make-polar 0.00000001 0.00000001) 0.00000001+1e-16i) +(num-test (make-polar -0.00000001 0.00000001) -0.00000001-1e-16i) +(num-test (make-polar 0.00000001 -0.00000001) 0.00000001-1e-16i) +(num-test (make-polar -0.00000001 -0.00000001) -0.00000001+1e-16i) +(num-test (make-rectangular 0.00000001 1.0) 0.00000001+1.0i) +(num-test (make-rectangular -0.00000001 1.0) -0.00000001+1.0i) +(num-test (make-rectangular 0.00000001 -1.0) 0.00000001-1.0i) +(num-test (make-rectangular -0.00000001 -1.0) -0.00000001-1.0i) +(num-test (make-polar 0.00000001 1.0) 0.00000000540302+0.00000000841471i) +(num-test (make-polar -0.00000001 1.0) -0.00000000540302-0.00000000841471i) +(num-test (make-polar 0.00000001 -1.0) 0.00000000540302-0.00000000841471i) +(num-test (make-polar -0.00000001 -1.0) -0.00000000540302+0.00000000841471i) +(num-test (make-rectangular 0.00000001 our-pi) 0.00000001+3.14159265358979i) +(num-test (make-rectangular -0.00000001 our-pi) -0.00000001+3.14159265358979i) +(num-test (make-rectangular 0.00000001 -3.14159265358979) 0.00000001-3.14159265358979i) +(num-test (make-rectangular -0.00000001 -3.14159265358979) -0.00000001-3.14159265358979i) +(num-test (make-polar 0.00000001 our-pi) -0.00000001+0.0i) +(num-test (make-polar -0.00000001 our-pi) 0.00000001-0.0i) +(num-test (make-polar 0.00000001 -3.14159265358979) -0.00000001-0.0i) +(num-test (make-polar -0.00000001 -3.14159265358979) 0.00000001+0.0i) +(num-test (make-rectangular 0.00000001 2.71828182845905) 0.00000001+2.71828182845905i) +(num-test (make-rectangular -0.00000001 2.71828182845905) -0.00000001+2.71828182845905i) +(num-test (make-rectangular 0.00000001 -2.71828182845905) 0.00000001-2.71828182845905i) +(num-test (make-rectangular -0.00000001 -2.71828182845905) -0.00000001-2.71828182845905i) +(num-test (make-polar 0.00000001 2.71828182845905) -0.00000000911734+0.00000000410781i) +(num-test (make-polar -0.00000001 2.71828182845905) 0.00000000911734-0.00000000410781i) +(num-test (make-polar 0.00000001 -2.71828182845905) -0.00000000911734-0.00000000410781i) +(num-test (make-polar -0.00000001 -2.71828182845905) 0.00000000911734+0.00000000410781i) +(num-test (make-rectangular 0.00000001 1234.0) 0.00000001+1234.0i) +(num-test (make-rectangular -0.00000001 1234.0) -0.00000001+1234.0i) +(num-test (make-rectangular 0.00000001 -1234.0) 0.00000001-1234.0i) +(num-test (make-rectangular -0.00000001 -1234.0) -0.00000001-1234.0i) +(num-test (make-polar 0.00000001 1234.0) -0.00000000798551+0.00000000601928i) +(num-test (make-polar -0.00000001 1234.0) 0.00000000798551-0.00000000601928i) +(num-test (make-polar 0.00000001 -1234.0) -0.00000000798551-0.00000000601928i) +(num-test (make-polar -0.00000001 -1234.0) 0.00000000798551+0.00000000601928i) +(num-test (make-rectangular 0.00000001 1234000000.0) 0.00000001+1234000000.0i) +(num-test (make-rectangular -0.00000001 1234000000.0) -0.00000001+1234000000.0i) +(num-test (make-rectangular 0.00000001 -1234000000.0) 0.00000001-1234000000.0i) +(num-test (make-rectangular -0.00000001 -1234000000.0) -0.00000001-1234000000.0i) +(num-test (make-polar 0.00000001 1234000000.0) 0.00000000158909-0.00000000987293i) +(num-test (make-polar -0.00000001 1234000000.0) -0.00000000158909+0.00000000987293i) +(num-test (make-polar 0.00000001 -1234000000.0) 0.00000000158909+0.00000000987293i) +(num-test (make-polar -0.00000001 -1234000000.0) -0.00000000158909-0.00000000987293i) +(num-test (make-rectangular 1.0 0.00000001) 1.0+0.00000001i) +(num-test (make-rectangular -1.0 0.00000001) -1.0+0.00000001i) +(num-test (make-rectangular 1.0 -0.00000001) 1.0-0.00000001i) +(num-test (make-rectangular -1.0 -0.00000001) -1.0-0.00000001i) +(num-test (make-polar 1.0 0.00000001) 1.0+0.00000001i) +(num-test (make-polar -1.0 0.00000001) -1.0-0.00000001i) +(num-test (make-polar 1.0 -0.00000001) 1.0-0.00000001i) +(num-test (make-polar -1.0 -0.00000001) -1.0+0.00000001i) +(num-test (make-rectangular 1.0 1.0) 1.0+1.0i) +(num-test (make-rectangular -1.0 1.0) -1.0+1.0i) +(num-test (make-rectangular 1.0 -1.0) 1.0-1.0i) +(num-test (make-rectangular -1.0 -1.0) -1.0-1.0i) +(num-test (make-polar 1.0 1.0) 0.54030230586814+0.84147098480790i) +(num-test (make-polar -1.0 1.0) -0.54030230586814-0.84147098480790i) +(num-test (make-polar 1.0 -1.0) 0.54030230586814-0.84147098480790i) +(num-test (make-polar -1.0 -1.0) -0.54030230586814+0.84147098480790i) +(num-test (make-rectangular 1.0 our-pi) 1.0+3.14159265358979i) +(num-test (make-rectangular -1.0 our-pi) -1.0+3.14159265358979i) +(num-test (make-rectangular 1.0 -3.14159265358979) 1.0-3.14159265358979i) +(num-test (make-rectangular -1.0 -3.14159265358979) -1.0-3.14159265358979i) +(num-test (make-polar 1.0 our-pi) -1.0+0.0i) +(num-test (make-polar -1.0 our-pi) 1.0-0.0i) +(num-test (make-polar 1.0 -3.14159265358979) -1.0-0.0i) +(num-test (make-polar -1.0 -3.14159265358979) 1.0+0.0i) +(num-test (make-rectangular 1.0 2.71828182845905) 1.0+2.71828182845905i) +(num-test (make-rectangular -1.0 2.71828182845905) -1.0+2.71828182845905i) +(num-test (make-rectangular 1.0 -2.71828182845905) 1.0-2.71828182845905i) +(num-test (make-rectangular -1.0 -2.71828182845905) -1.0-2.71828182845905i) +(num-test (make-polar 1.0 2.71828182845905) -0.91173391478697+0.41078129050291i) +(num-test (make-polar -1.0 2.71828182845905) 0.91173391478697-0.41078129050291i) +(num-test (make-polar 1.0 -2.71828182845905) -0.91173391478697-0.41078129050291i) +(num-test (make-polar -1.0 -2.71828182845905) 0.91173391478697+0.41078129050291i) +(num-test (make-rectangular 1.0 1234.0) 1.0+1234.0i) +(num-test (make-rectangular -1.0 1234.0) -1.0+1234.0i) +(num-test (make-rectangular 1.0 -1234.0) 1.0-1234.0i) +(num-test (make-rectangular -1.0 -1234.0) -1.0-1234.0i) +(num-test (make-polar 1.0 1234.0) -0.79855062358758+0.60192765476250i) +(num-test (make-polar -1.0 1234.0) 0.79855062358758-0.60192765476250i) +(num-test (make-polar 1.0 -1234.0) -0.79855062358758-0.60192765476250i) +(num-test (make-polar -1.0 -1234.0) 0.79855062358758+0.60192765476250i) +(num-test (make-rectangular 1.0 1234000000.0) 1.0+1234000000.0i) +(num-test (make-rectangular -1.0 1234000000.0) -1.0+1234000000.0i) +(num-test (make-rectangular 1.0 -1234000000.0) 1.0-1234000000.0i) +(num-test (make-rectangular -1.0 -1234000000.0) -1.0-1234000000.0i) +(num-test (make-polar 1.0 1234000000.0) 0.15890913095152-0.98729321283003i) +(num-test (make-polar -1.0 1234000000.0) -0.15890913095152+0.98729321283003i) +(num-test (make-polar 1.0 -1234000000.0) 0.15890913095152+0.98729321283003i) +(num-test (make-polar -1.0 -1234000000.0) -0.15890913095152-0.98729321283003i) +(num-test (make-rectangular 3.14159265358979 0.00000001) 3.14159265358979+0.00000001i) +(num-test (make-rectangular -3.14159265358979 0.00000001) -3.14159265358979+0.00000001i) +(num-test (make-rectangular 3.14159265358979 -0.00000001) 3.14159265358979-0.00000001i) +(num-test (make-rectangular -3.14159265358979 -0.00000001) -3.14159265358979-0.00000001i) +(num-test (make-polar 3.14159265358979 0.00000001) 3.14159265358979+0.00000003141593i) +(num-test (make-polar -3.14159265358979 0.00000001) -3.14159265358979-0.00000003141593i) +(num-test (make-polar 3.14159265358979 -0.00000001) 3.14159265358979-0.00000003141593i) +(num-test (make-polar -3.14159265358979 -0.00000001) -3.14159265358979+0.00000003141593i) +(num-test (make-rectangular 3.14159265358979 1.0) 3.14159265358979+1.0i) +(num-test (make-rectangular -3.14159265358979 1.0) -3.14159265358979+1.0i) +(num-test (make-rectangular 3.14159265358979 -1.0) 3.14159265358979-1.0i) +(num-test (make-rectangular -3.14159265358979 -1.0) -3.14159265358979-1.0i) +(num-test (make-polar 3.14159265358979 1.0) 1.69740975483297+2.64355906408146i) +(num-test (make-polar -3.14159265358979 1.0) -1.69740975483297-2.64355906408146i) +(num-test (make-polar 3.14159265358979 -1.0) 1.69740975483297-2.64355906408146i) +(num-test (make-polar -3.14159265358979 -1.0) -1.69740975483297+2.64355906408146i) +(num-test (make-rectangular 3.14159265358979 our-pi) 3.14159265358979+3.14159265358979i) +(num-test (make-rectangular -3.14159265358979 our-pi) -3.14159265358979+3.14159265358979i) +(num-test (make-rectangular 3.14159265358979 -3.14159265358979) 3.14159265358979-3.14159265358979i) +(num-test (make-rectangular -3.14159265358979 -3.14159265358979) -3.14159265358979-3.14159265358979i) +(num-test (make-polar 3.14159265358979 our-pi) -3.14159265358979+0.0i) +(num-test (make-polar -3.14159265358979 our-pi) 3.14159265358979-0.0i) +(num-test (make-polar 3.14159265358979 -3.14159265358979) -3.14159265358979-0.0i) +(num-test (make-polar -3.14159265358979 -3.14159265358979) 3.14159265358979+0.0i) +(num-test (make-rectangular 3.14159265358979 2.71828182845905) 3.14159265358979+2.71828182845905i) +(num-test (make-rectangular -3.14159265358979 2.71828182845905) -3.14159265358979+2.71828182845905i) +(num-test (make-rectangular 3.14159265358979 -2.71828182845905) 3.14159265358979-2.71828182845905i) +(num-test (make-rectangular -3.14159265358979 -2.71828182845905) -3.14159265358979-2.71828182845905i) +(num-test (make-polar 3.14159265358979 2.71828182845905) -2.86429656872339+1.29050748447607i) +(num-test (make-polar -3.14159265358979 2.71828182845905) 2.86429656872339-1.29050748447607i) +(num-test (make-polar 3.14159265358979 -2.71828182845905) -2.86429656872339-1.29050748447607i) +(num-test (make-polar -3.14159265358979 -2.71828182845905) 2.86429656872339+1.29050748447607i) +(num-test (make-rectangular 3.14159265358979 1234.0) 3.14159265358979+1234.0i) +(num-test (make-rectangular -3.14159265358979 1234.0) -3.14159265358979+1234.0i) +(num-test (make-rectangular 3.14159265358979 -1234.0) 3.14159265358979-1234.0i) +(num-test (make-rectangular -3.14159265358979 -1234.0) -3.14159265358979-1234.0i) +(num-test (make-polar 3.14159265358979 1234.0) -2.50872077258230+1.89101149819439i) +(num-test (make-polar -3.14159265358979 1234.0) 2.50872077258230-1.89101149819439i) +(num-test (make-polar 3.14159265358979 -1234.0) -2.50872077258230-1.89101149819439i) +(num-test (make-polar -3.14159265358979 -1234.0) 2.50872077258230+1.89101149819439i) +(num-test (make-rectangular 3.14159265358979 1234000000.0) 3.14159265358979+1234000000.0i) +(num-test (make-rectangular -3.14159265358979 1234000000.0) -3.14159265358979+1234000000.0i) +(num-test (make-rectangular 3.14159265358979 -1234000000.0) 3.14159265358979-1234000000.0i) +(num-test (make-rectangular -3.14159265358979 -1234000000.0) -3.14159265358979-1234000000.0i) +(num-test (make-polar 3.14159265358979 1234000000.0) 0.49922775838562-3.10167310436587i) +(num-test (make-polar -3.14159265358979 1234000000.0) -0.49922775838562+3.10167310436587i) +(num-test (make-polar 3.14159265358979 -1234000000.0) 0.49922775838562+3.10167310436587i) +(num-test (make-polar -3.14159265358979 -1234000000.0) -0.49922775838562-3.10167310436587i) +(num-test (make-rectangular 2.71828182845905 0.00000001) 2.71828182845905+0.00000001i) +(num-test (make-rectangular -2.71828182845905 0.00000001) -2.71828182845905+0.00000001i) +(num-test (make-rectangular 2.71828182845905 -0.00000001) 2.71828182845905-0.00000001i) +(num-test (make-rectangular -2.71828182845905 -0.00000001) -2.71828182845905-0.00000001i) +(num-test (make-polar 2.71828182845905 0.00000001) 2.71828182845905+0.00000002718282i) +(num-test (make-polar -2.71828182845905 0.00000001) -2.71828182845905-0.00000002718282i) +(num-test (make-polar 2.71828182845905 -0.00000001) 2.71828182845905-0.00000002718282i) +(num-test (make-polar -2.71828182845905 -0.00000001) -2.71828182845905+0.00000002718282i) +(num-test (make-rectangular 2.71828182845905 1.0) 2.71828182845905+1.0i) +(num-test (make-rectangular -2.71828182845905 1.0) -2.71828182845905+1.0i) +(num-test (make-rectangular 2.71828182845905 -1.0) 2.71828182845905-1.0i) +(num-test (make-rectangular -2.71828182845905 -1.0) -2.71828182845905-1.0i) +(num-test (make-polar 2.71828182845905 1.0) 1.46869393991589+2.28735528717884i) +(num-test (make-polar -2.71828182845905 1.0) -1.46869393991589-2.28735528717884i) +(num-test (make-polar 2.71828182845905 -1.0) 1.46869393991589-2.28735528717884i) +(num-test (make-polar -2.71828182845905 -1.0) -1.46869393991589+2.28735528717884i) +(num-test (make-rectangular 2.71828182845905 our-pi) 2.71828182845905+3.14159265358979i) +(num-test (make-rectangular -2.71828182845905 our-pi) -2.71828182845905+3.14159265358979i) +(num-test (make-rectangular 2.71828182845905 -3.14159265358979) 2.71828182845905-3.14159265358979i) +(num-test (make-rectangular -2.71828182845905 -3.14159265358979) -2.71828182845905-3.14159265358979i) +(num-test (make-polar 2.71828182845905 our-pi) -2.71828182845905+0.0i) +(num-test (make-polar -2.71828182845905 our-pi) 2.71828182845905-0.0i) +(num-test (make-polar 2.71828182845905 -3.14159265358979) -2.71828182845905-0.0i) +(num-test (make-polar -2.71828182845905 -3.14159265358979) 2.71828182845905+0.0i) +(num-test (make-rectangular 2.71828182845905 2.71828182845905) 2.71828182845905+2.71828182845905i) +(num-test (make-rectangular -2.71828182845905 2.71828182845905) -2.71828182845905+2.71828182845905i) +(num-test (make-rectangular 2.71828182845905 -2.71828182845905) 2.71828182845905-2.71828182845905i) +(num-test (make-rectangular -2.71828182845905 -2.71828182845905) -2.71828182845905-2.71828182845905i) +(num-test (make-polar 2.71828182845905 2.71828182845905) -2.47834973295523+1.11661931744501i) +(num-test (make-polar -2.71828182845905 2.71828182845905) 2.47834973295523-1.11661931744501i) +(num-test (make-polar 2.71828182845905 -2.71828182845905) -2.47834973295523-1.11661931744501i) +(num-test (make-polar -2.71828182845905 -2.71828182845905) 2.47834973295523+1.11661931744501i) +(num-test (make-rectangular 2.71828182845905 1234.0) 2.71828182845905+1234.0i) +(num-test (make-rectangular -2.71828182845905 1234.0) -2.71828182845905+1234.0i) +(num-test (make-rectangular 2.71828182845905 -1234.0) 2.71828182845905-1234.0i) +(num-test (make-rectangular -2.71828182845905 -1234.0) -2.71828182845905-1234.0i) +(num-test (make-polar 2.71828182845905 1234.0) -2.17068564920277+1.63620900598787i) +(num-test (make-polar -2.71828182845905 1234.0) 2.17068564920277-1.63620900598787i) +(num-test (make-polar 2.71828182845905 -1234.0) -2.17068564920277-1.63620900598787i) +(num-test (make-polar -2.71828182845905 -1234.0) 2.17068564920277+1.63620900598787i) +(num-test (make-rectangular 2.71828182845905 1234000000.0) 2.71828182845905+1234000000.0i) +(num-test (make-rectangular -2.71828182845905 1234000000.0) -2.71828182845905+1234000000.0i) +(num-test (make-rectangular 2.71828182845905 -1234000000.0) 2.71828182845905-1234000000.0i) +(num-test (make-rectangular -2.71828182845905 -1234000000.0) -2.71828182845905-1234000000.0i) +(num-test (make-polar 2.71828182845905 1234000000.0) 0.43195980304173-2.68374119979681i) +(num-test (make-polar -2.71828182845905 1234000000.0) -0.43195980304173+2.68374119979681i) +(num-test (make-polar 2.71828182845905 -1234000000.0) 0.43195980304173+2.68374119979681i) +(num-test (make-polar -2.71828182845905 -1234000000.0) -0.43195980304173-2.68374119979681i) +(num-test (make-rectangular 1234.0 0.00000001) 1234.0+0.00000001i) +(num-test (make-rectangular -1234.0 0.00000001) -1234.0+0.00000001i) +(num-test (make-rectangular 1234.0 -0.00000001) 1234.0-0.00000001i) +(num-test (make-rectangular -1234.0 -0.00000001) -1234.0-0.00000001i) +(num-test (make-polar 1234.0 0.00000001) 1234.0+0.00001234000000i) +(num-test (make-polar -1234.0 0.00000001) -1234.0-0.00001234000000i) +(num-test (make-polar 1234.0 -0.00000001) 1234.0-0.00001234000000i) +(num-test (make-polar -1234.0 -0.00000001) -1234.0+0.00001234000000i) +(num-test (make-rectangular 1234.0 1.0) 1234.0+1.0i) +(num-test (make-rectangular -1234.0 1.0) -1234.0+1.0i) +(num-test (make-rectangular 1234.0 -1.0) 1234.0-1.0i) +(num-test (make-rectangular -1234.0 -1.0) -1234.0-1.0i) +(num-test (make-polar 1234.0 1.0) 666.73304544128450+1038.37519525294420i) +(num-test (make-polar -1234.0 1.0) -666.73304544128450-1038.37519525294420i) +(num-test (make-polar 1234.0 -1.0) 666.73304544128450-1038.37519525294420i) +(num-test (make-polar -1234.0 -1.0) -666.73304544128450+1038.37519525294420i) +(num-test (make-rectangular 1234.0 our-pi) 1234.0+3.14159265358979i) +(num-test (make-rectangular -1234.0 our-pi) -1234.0+3.14159265358979i) +(num-test (make-rectangular 1234.0 -3.14159265358979) 1234.0-3.14159265358979i) +(num-test (make-rectangular -1234.0 -3.14159265358979) -1234.0-3.14159265358979i) +(num-test (make-polar 1234.0 our-pi) -1234.0+0.00000000000015i) +(num-test (make-polar -1234.0 our-pi) 1234.0-0.00000000000015i) +(num-test (make-polar 1234.0 -3.14159265358979) -1234.0-0.00000000000015i) +(num-test (make-polar -1234.0 -3.14159265358979) 1234.0+0.00000000000015i) +(num-test (make-rectangular 1234.0 2.71828182845905) 1234.0+2.71828182845905i) +(num-test (make-rectangular -1234.0 2.71828182845905) -1234.0+2.71828182845905i) +(num-test (make-rectangular 1234.0 -2.71828182845905) 1234.0-2.71828182845905i) +(num-test (make-rectangular -1234.0 -2.71828182845905) -1234.0-2.71828182845905i) +(num-test (make-polar 1234.0 2.71828182845905) -1125.07965084711486+506.90411248058950i) +(num-test (make-polar -1234.0 2.71828182845905) 1125.07965084711486-506.90411248058950i) +(num-test (make-polar 1234.0 -2.71828182845905) -1125.07965084711486-506.90411248058950i) +(num-test (make-polar -1234.0 -2.71828182845905) 1125.07965084711486+506.90411248058950i) +(num-test (make-rectangular 1234.0 1234.0) 1234.0+1234.0i) +(num-test (make-rectangular -1234.0 1234.0) -1234.0+1234.0i) +(num-test (make-rectangular 1234.0 -1234.0) 1234.0-1234.0i) +(num-test (make-rectangular -1234.0 -1234.0) -1234.0-1234.0i) +(num-test (make-polar 1234.0 1234.0) -985.41146950707912+742.77872597692169i) +(num-test (make-polar -1234.0 1234.0) 985.41146950707912-742.77872597692169i) +(num-test (make-polar 1234.0 -1234.0) -985.41146950707912-742.77872597692169i) +(num-test (make-polar -1234.0 -1234.0) 985.41146950707912+742.77872597692169i) +(num-test (make-rectangular 1234.0 1234000000.0) 1234.0+1234000000.0i) +(num-test (make-rectangular -1234.0 1234000000.0) -1234.0+1234000000.0i) +(num-test (make-rectangular 1234.0 -1234000000.0) 1234.0-1234000000.0i) +(num-test (make-rectangular -1234.0 -1234000000.0) -1234.0-1234000000.0i) +(num-test (make-polar 1234.0 1234000000.0) 196.09386759417183-1218.31982463225131i) +(num-test (make-polar -1234.0 1234000000.0) -196.09386759417183+1218.31982463225131i) +(num-test (make-polar 1234.0 -1234000000.0) 196.09386759417183+1218.31982463225131i) +(num-test (make-polar -1234.0 -1234000000.0) -196.09386759417183-1218.31982463225131i) +(num-test (make-rectangular 1234000000.0 0.00000001) 1234000000.0+0.00000001i) +(num-test (make-rectangular -1234000000.0 0.00000001) -1234000000.0+0.00000001i) +(num-test (make-rectangular 1234000000.0 -0.00000001) 1234000000.0-0.00000001i) +(num-test (make-rectangular -1234000000.0 -0.00000001) -1234000000.0-0.00000001i) +(num-test (make-polar 1234000000.0 0.00000001) 1234000000.0+12.34000000000000i) +(num-test (make-polar -1234000000.0 0.00000001) -1234000000.0-12.34000000000000i) +(num-test (make-polar 1234000000.0 -0.00000001) 1234000000.0-12.34000000000000i) +(num-test (make-polar -1234000000.0 -0.00000001) -1234000000.0+12.34000000000000i) +(num-test (make-rectangular 1234000000.0 1.0) 1234000000.0+1.0i) +(num-test (make-rectangular -1234000000.0 1.0) -1234000000.0+1.0i) +(num-test (make-rectangular 1234000000.0 -1.0) 1234000000.0-1.0i) +(num-test (make-rectangular -1234000000.0 -1.0) -1234000000.0-1.0i) +(num-test (make-polar 1234000000.0 1.0) 666733045.44128441810608+1038375195.25294423103333i) +(num-test (make-polar -1234000000.0 1.0) -666733045.44128441810608-1038375195.25294423103333i) +(num-test (make-polar 1234000000.0 -1.0) 666733045.44128441810608-1038375195.25294423103333i) +(num-test (make-polar -1234000000.0 -1.0) -666733045.44128441810608+1038375195.25294423103333i) +(num-test (make-rectangular 1234000000.0 our-pi) 1234000000.0+3.14159265358979i) +(num-test (make-rectangular -1234000000.0 our-pi) -1234000000.0+3.14159265358979i) +(num-test (make-rectangular 1234000000.0 -3.14159265358979) 1234000000.0-3.14159265358979i) +(num-test (make-rectangular -1234000000.0 -3.14159265358979) -1234000000.0-3.14159265358979i) +(num-test (make-polar 1234000000.0 our-pi) -1234000000.0+0.00000015111642i) +(num-test (make-polar -1234000000.0 our-pi) 1234000000.0-0.00000015111642i) +(num-test (make-polar 1234000000.0 -3.14159265358979) -1234000000.0-0.00000015111642i) +(num-test (make-polar -1234000000.0 -3.14159265358979) 1234000000.0+0.00000015111642i) +(num-test (make-rectangular 1234000000.0 2.71828182845905) 1234000000.0+2.71828182845905i) +(num-test (make-rectangular -1234000000.0 2.71828182845905) -1234000000.0+2.71828182845905i) +(num-test (make-rectangular 1234000000.0 -2.71828182845905) 1234000000.0-2.71828182845905i) +(num-test (make-rectangular -1234000000.0 -2.71828182845905) -1234000000.0-2.71828182845905i) +(num-test (make-polar 1234000000.0 2.71828182845905) -1125079650.84711480140686+506904112.48058950901031i) +(num-test (make-polar -1234000000.0 2.71828182845905) 1125079650.84711480140686-506904112.48058950901031i) +(num-test (make-polar 1234000000.0 -2.71828182845905) -1125079650.84711480140686-506904112.48058950901031i) +(num-test (make-polar -1234000000.0 -2.71828182845905) 1125079650.84711480140686+506904112.48058950901031i) +(num-test (make-rectangular 1234000000.0 1234.0) 1234000000.0+1234.0i) +(num-test (make-rectangular -1234000000.0 1234.0) -1234000000.0+1234.0i) +(num-test (make-rectangular 1234000000.0 -1234.0) 1234000000.0-1234.0i) +(num-test (make-rectangular -1234000000.0 -1234.0) -1234000000.0-1234.0i) +(num-test (make-polar 1234000000.0 1234.0) -985411469.50707900524139+742778725.97692167758942i) +(num-test (make-polar -1234000000.0 1234.0) 985411469.50707900524139-742778725.97692167758942i) +(num-test (make-polar 1234000000.0 -1234.0) -985411469.50707900524139-742778725.97692167758942i) +(num-test (make-polar -1234000000.0 -1234.0) 985411469.50707900524139+742778725.97692167758942i) +(num-test (make-rectangular 1234000000.0 1234000000.0) 1234000000.0+1234000000.0i) +(num-test (make-rectangular -1234000000.0 1234000000.0) -1234000000.0+1234000000.0i) +(num-test (make-rectangular 1234000000.0 -1234000000.0) 1234000000.0-1234000000.0i) +(num-test (make-rectangular -1234000000.0 -1234000000.0) -1234000000.0-1234000000.0i) +(num-test (make-polar 1234000000.0 1234000000.0) 196093867.59417182207108-1218319824.63225126266479i) +(num-test (make-polar -1234000000.0 1234000000.0) -196093867.59417182207108+1218319824.63225126266479i) +(num-test (make-polar 1234000000.0 -1234000000.0) 196093867.59417182207108+1218319824.63225126266479i) +(num-test (make-polar -1234000000.0 -1234000000.0) -196093867.59417182207108-1218319824.63225126266479i) +(num-test (make-polar 0 0) 0) +(num-test (make-polar 0.0 0.0) 0.0) +(num-test (make-rectangular 0 0) 0) +(num-test (make-rectangular 0.0 0.0) 0.0) + + +;; -------- angle +(num-test (angle 1) 0) +(num-test (angle -1) our-pi) +(num-test (angle 1/1) 0) +(num-test (angle -1/1) our-pi) +(num-test (angle 1/2) 0) +(num-test (angle -1/2) our-pi) +(num-test (angle 1/3) 0) +(num-test (angle -1/3) our-pi) +(num-test (angle 1/10) 0) +(num-test (angle -1/10) our-pi) +(num-test (angle 1/1234) 0) +(num-test (angle -1/1234) our-pi) +(num-test (angle 1/1234000000) 0) +(num-test (angle -1/1234000000) our-pi) +(num-test (angle 1/500029) 0) +(num-test (angle -1/500029) our-pi) +(num-test (angle 1/362880) 0) +(num-test (angle -1/362880) our-pi) +(num-test (angle 2) 0) +(num-test (angle -2) our-pi) +(num-test (angle 2/1) 0) +(num-test (angle -2/1) our-pi) +(num-test (angle 2/2) 0) +(num-test (angle -2/2) our-pi) +(num-test (angle 2/3) 0) +(num-test (angle -2/3) our-pi) +(num-test (angle 2/10) 0) +(num-test (angle -2/10) our-pi) +(num-test (angle 2/1234) 0) +(num-test (angle -2/1234) our-pi) +(num-test (angle 2/1234000000) 0) +(num-test (angle -2/1234000000) our-pi) +(num-test (angle 2/500029) 0) +(num-test (angle -2/500029) our-pi) +(num-test (angle 2/362880) 0) +(num-test (angle -2/362880) our-pi) +(num-test (angle 3) 0) +(num-test (angle -3) our-pi) +(num-test (angle 3/1) 0) +(num-test (angle -3/1) our-pi) +(num-test (angle 3/2) 0) +(num-test (angle -3/2) our-pi) +(num-test (angle 3/3) 0) +(num-test (angle -3/3) our-pi) +(num-test (angle 3/10) 0) +(num-test (angle -3/10) our-pi) +(num-test (angle 3/1234) 0) +(num-test (angle -3/1234) our-pi) +(num-test (angle 3/1234000000) 0) +(num-test (angle -3/1234000000) our-pi) +(num-test (angle 3/500029) 0) +(num-test (angle -3/500029) our-pi) +(num-test (angle 3/362880) 0) +(num-test (angle -3/362880) our-pi) +(num-test (angle 10) 0) +(num-test (angle -10) our-pi) +(num-test (angle 10/1) 0) +(num-test (angle -10/1) our-pi) +(num-test (angle 10/2) 0) +(num-test (angle -10/2) our-pi) +(num-test (angle 10/3) 0) +(num-test (angle -10/3) our-pi) +(num-test (angle 10/10) 0) +(num-test (angle -10/10) our-pi) +(num-test (angle 10/1234) 0) +(num-test (angle -10/1234) our-pi) +(num-test (angle 10/1234000000) 0) +(num-test (angle -10/1234000000) our-pi) +(num-test (angle 10/500029) 0) +(num-test (angle -10/500029) our-pi) +(num-test (angle 10/362880) 0) +(num-test (angle -10/362880) our-pi) +(num-test (angle 1234) 0) +(num-test (angle -1234) our-pi) +(num-test (angle 1234/1) 0) +(num-test (angle -1234/1) our-pi) +(num-test (angle 1234/2) 0) +(num-test (angle -1234/2) our-pi) +(num-test (angle 1234/3) 0) +(num-test (angle -1234/3) our-pi) +(num-test (angle 1234/10) 0) +(num-test (angle -1234/10) our-pi) +(num-test (angle 1234/1234) 0) +(num-test (angle -1234/1234) our-pi) +(num-test (angle 1234/1234000000) 0) +(num-test (angle -1234/1234000000) our-pi) +(num-test (angle 1234/500029) 0) +(num-test (angle -1234/500029) our-pi) +(num-test (angle 1234/362880) 0) +(num-test (angle -1234/362880) our-pi) +(num-test (angle 1234000000) 0) +(num-test (angle -1234000000) our-pi) +(num-test (angle 1234000000/1) 0) +(num-test (angle -1234000000/1) our-pi) +(num-test (angle 1234000000/2) 0) +(num-test (angle -1234000000/2) our-pi) +(num-test (angle 1234000000/3) 0) +(num-test (angle -1234000000/3) our-pi) +(num-test (angle 1234000000/10) 0) +(num-test (angle -1234000000/10) our-pi) +(num-test (angle 1234000000/1234) 0) +(num-test (angle -1234000000/1234) our-pi) +(num-test (angle 1234000000/1234000000) 0) +(num-test (angle -1234000000/1234000000) our-pi) +(num-test (angle 1234000000/500029) 0) +(num-test (angle -1234000000/500029) our-pi) +(num-test (angle 1234000000/362880) 0) +(num-test (angle -1234000000/362880) our-pi) +(num-test (angle 500029) 0) +(num-test (angle -500029) our-pi) +(num-test (angle 500029/1) 0) +(num-test (angle -500029/1) our-pi) +(num-test (angle 500029/2) 0) +(num-test (angle -500029/2) our-pi) +(num-test (angle 500029/3) 0) +(num-test (angle -500029/3) our-pi) +(num-test (angle 500029/10) 0) +(num-test (angle -500029/10) our-pi) +(num-test (angle 500029/1234) 0) +(num-test (angle -500029/1234) our-pi) +(num-test (angle 500029/1234000000) 0) +(num-test (angle -500029/1234000000) our-pi) +(num-test (angle 500029/500029) 0) +(num-test (angle -500029/500029) our-pi) +(num-test (angle 500029/362880) 0) +(num-test (angle -500029/362880) our-pi) +(num-test (angle 362880) 0) +(num-test (angle -362880) our-pi) +(num-test (angle 362880/1) 0) +(num-test (angle -362880/1) our-pi) +(num-test (angle 362880/2) 0) +(num-test (angle -362880/2) our-pi) +(num-test (angle 362880/3) 0) +(num-test (angle -362880/3) our-pi) +(num-test (angle 362880/10) 0) +(num-test (angle -362880/10) our-pi) +(num-test (angle 362880/1234) 0) +(num-test (angle -362880/1234) our-pi) +(num-test (angle 362880/1234000000) 0) +(num-test (angle -362880/1234000000) our-pi) +(num-test (angle 362880/500029) 0) +(num-test (angle -362880/500029) our-pi) +(num-test (angle 362880/362880) 0) +(num-test (angle -362880/362880) our-pi) +(num-test (angle 0.0+0.00000001i) 1.57079632679490) +(num-test (angle -0.0+0.00000001i) 1.57079632679490) +(num-test (angle 0.0-0.00000001i) -1.57079632679490) +(num-test (angle -0.0-0.00000001i) -1.57079632679490) +(num-test (angle 0.0+1.0i) 1.57079632679490) +(num-test (angle -0.0+1.0i) 1.57079632679490) +(num-test (angle 0.0-1.0i) -1.57079632679490) +(num-test (angle -0.0-1.0i) -1.57079632679490) +(num-test (angle 0.0+3.14159265358979i) 1.57079632679490) +(num-test (angle -0.0+3.14159265358979i) 1.57079632679490) +(num-test (angle 0.0-3.14159265358979i) -1.57079632679490) +(num-test (angle -0.0-3.14159265358979i) -1.57079632679490) +(num-test (angle 0.0+2.71828182845905i) 1.57079632679490) +(num-test (angle -0.0+2.71828182845905i) 1.57079632679490) +(num-test (angle 0.0-2.71828182845905i) -1.57079632679490) +(num-test (angle -0.0-2.71828182845905i) -1.57079632679490) +(num-test (angle 0.0+1234.0i) 1.57079632679490) +(num-test (angle -0.0+1234.0i) 1.57079632679490) +(num-test (angle 0.0-1234.0i) -1.57079632679490) +(num-test (angle -0.0-1234.0i) -1.57079632679490) +(num-test (angle 0.0+1234000000.0i) 1.57079632679490) +(num-test (angle -0.0+1234000000.0i) 1.57079632679490) +(num-test (angle 0.0-1234000000.0i) -1.57079632679490) +(num-test (angle -0.0-1234000000.0i) -1.57079632679490) +(num-test (angle 0.00000001) 0.0) +(num-test (angle -0.00000001) our-pi) +(num-test (angle 0.00000001+0.00000001i) 0.78539816339745) +(num-test (angle -0.00000001+0.00000001i) 2.35619449019234) +(num-test (angle 0.00000001-0.00000001i) -0.78539816339745) +(num-test (angle -0.00000001-0.00000001i) -2.35619449019234) +(num-test (angle 0.00000001+1.0i) 1.57079631679490) +(num-test (angle -0.00000001+1.0i) 1.57079633679490) +(num-test (angle 0.00000001-1.0i) -1.57079631679490) +(num-test (angle -0.00000001-1.0i) -1.57079633679490) +(num-test (angle 0.00000001+3.14159265358979i) 1.57079632361180) +(num-test (angle -0.00000001+3.14159265358979i) 1.57079632997800) +(num-test (angle 0.00000001-3.14159265358979i) -1.57079632361180) +(num-test (angle -0.00000001-3.14159265358979i) -1.57079632997800) +(num-test (angle 0.00000001+2.71828182845905i) 1.57079632311610) +(num-test (angle -0.00000001+2.71828182845905i) 1.57079633047369) +(num-test (angle 0.00000001-2.71828182845905i) -1.57079632311610) +(num-test (angle -0.00000001-2.71828182845905i) -1.57079633047369) +(num-test (angle 0.00000001+1234.0i) 1.57079632678679) +(num-test (angle -0.00000001+1234.0i) 1.57079632680300) +(num-test (angle 0.00000001-1234.0i) -1.57079632678679) +(num-test (angle -0.00000001-1234.0i) -1.57079632680300) +(num-test (angle 0.00000001+1234000000.0i) 1.57079632679490) +(num-test (angle -0.00000001+1234000000.0i) 1.57079632679490) +(num-test (angle 0.00000001-1234000000.0i) -1.57079632679490) +(num-test (angle -0.00000001-1234000000.0i) -1.57079632679490) +(num-test (angle 1.0) 0.0) +(num-test (angle -1.0) our-pi) +(num-test (angle 1.0+0.00000001i) 0.00000001) +(num-test (angle -1.0+0.00000001i) 3.14159264358979) +(num-test (angle 1.0-0.00000001i) -0.00000001) +(num-test (angle -1.0-0.00000001i) -3.14159264358979) +(num-test (angle 1.0+1.0i) 0.78539816339745) +(num-test (angle -1.0+1.0i) 2.35619449019234) +(num-test (angle 1.0-1.0i) -0.78539816339745) +(num-test (angle -1.0-1.0i) -2.35619449019234) +(num-test (angle 1.0+3.14159265358979i) 1.26262725567891) +(num-test (angle -1.0+3.14159265358979i) 1.87896539791088) +(num-test (angle 1.0-3.14159265358979i) -1.26262725567891) +(num-test (angle -1.0-3.14159265358979i) -1.87896539791088) +(num-test (angle 1.0+2.71828182845905i) 1.21828290501728) +(num-test (angle -1.0+2.71828182845905i) 1.92330974857252) +(num-test (angle 1.0-2.71828182845905i) -1.21828290501728) +(num-test (angle -1.0-2.71828182845905i) -1.92330974857252) +(num-test (angle 1.0+1234.0i) 1.56998595420081) +(num-test (angle -1.0+1234.0i) 1.57160669938898) +(num-test (angle 1.0-1234.0i) -1.56998595420081) +(num-test (angle -1.0-1234.0i) -1.57160669938898) +(num-test (angle 1.0+1234000000.0i) 1.57079632598452) +(num-test (angle -1.0+1234000000.0i) 1.57079632760527) +(num-test (angle 1.0-1234000000.0i) -1.57079632598452) +(num-test (angle -1.0-1234000000.0i) -1.57079632760527) +(num-test (angle our-pi) 0.0) +(num-test (angle -3.14159265358979) our-pi) +(num-test (angle 3.14159265358979+0.00000001i) 0.00000000318310) +(num-test (angle -3.14159265358979+0.00000001i) 3.14159265040669) +(num-test (angle 3.14159265358979-0.00000001i) -0.00000000318310) +(num-test (angle -3.14159265358979-0.00000001i) -3.14159265040669) +(num-test (angle 3.14159265358979+1.0i) 0.30816907111598) +(num-test (angle -3.14159265358979+1.0i) 2.83342358247381) +(num-test (angle 3.14159265358979-1.0i) -0.30816907111598) +(num-test (angle -3.14159265358979-1.0i) -2.83342358247381) +(num-test (angle 3.14159265358979+3.14159265358979i) 0.78539816339745) +(num-test (angle -3.14159265358979+3.14159265358979i) 2.35619449019234) +(num-test (angle 3.14159265358979-3.14159265358979i) -0.78539816339745) +(num-test (angle -3.14159265358979-3.14159265358979i) -2.35619449019234) +(num-test (angle 3.14159265358979+2.71828182845905i) 0.71328454043905) +(num-test (angle -3.14159265358979+2.71828182845905i) 2.42830811315074) +(num-test (angle 3.14159265358979-2.71828182845905i) -0.71328454043905) +(num-test (angle -3.14159265358979-2.71828182845905i) -2.42830811315074) +(num-test (angle 3.14159265358979+1234.0i) 1.56825047114960) +(num-test (angle -3.14159265358979+1234.0i) 1.57334218244020) +(num-test (angle 3.14159265358979-1234.0i) -1.56825047114960) +(num-test (angle -3.14159265358979-1234.0i) -1.57334218244020) +(num-test (angle 3.14159265358979+1234000000.0i) 1.57079632424904) +(num-test (angle -3.14159265358979+1234000000.0i) 1.57079632934076) +(num-test (angle 3.14159265358979-1234000000.0i) -1.57079632424904) +(num-test (angle -3.14159265358979-1234000000.0i) -1.57079632934076) +(num-test (angle 2.71828182845905) 0.0) +(num-test (angle -2.71828182845905) our-pi) +(num-test (angle 2.71828182845905+0.00000001i) 0.00000000367879) +(num-test (angle -2.71828182845905+0.00000001i) 3.14159264991100) +(num-test (angle 2.71828182845905-0.00000001i) -0.00000000367879) +(num-test (angle -2.71828182845905-0.00000001i) -3.14159264991100) +(num-test (angle 2.71828182845905+1.0i) 0.35251342177762) +(num-test (angle -2.71828182845905+1.0i) 2.78907923181217) +(num-test (angle 2.71828182845905-1.0i) -0.35251342177762) +(num-test (angle -2.71828182845905-1.0i) -2.78907923181217) +(num-test (angle 2.71828182845905+3.14159265358979i) 0.85751178635585) +(num-test (angle -2.71828182845905+3.14159265358979i) 2.28408086723395) +(num-test (angle 2.71828182845905-3.14159265358979i) -0.85751178635585) +(num-test (angle -2.71828182845905-3.14159265358979i) -2.28408086723395) +(num-test (angle 2.71828182845905+2.71828182845905i) 0.78539816339745) +(num-test (angle -2.71828182845905+2.71828182845905i) 2.35619449019234) +(num-test (angle 2.71828182845905-2.71828182845905i) -0.78539816339745) +(num-test (angle -2.71828182845905-2.71828182845905i) -2.35619449019234) +(num-test (angle 2.71828182845905+1234.0i) 1.56859350877892) +(num-test (angle -2.71828182845905+1234.0i) 1.57299914481088) +(num-test (angle 2.71828182845905-1234.0i) -1.56859350877892) +(num-test (angle -2.71828182845905-1234.0i) -1.57299914481088) +(num-test (angle 2.71828182845905+1234000000.0i) 1.57079632459208) +(num-test (angle -2.71828182845905+1234000000.0i) 1.57079632899772) +(num-test (angle 2.71828182845905-1234000000.0i) -1.57079632459208) +(num-test (angle -2.71828182845905-1234000000.0i) -1.57079632899772) +(num-test (angle 1234.0) 0.0) +(num-test (angle -1234.0) our-pi) +(num-test (angle 1234.0+0.00000001i) 0.00000000000810) +(num-test (angle -1234.0+0.00000001i) 3.14159265358169) +(num-test (angle 1234.0-0.00000001i) -0.00000000000810) +(num-test (angle -1234.0-0.00000001i) -3.14159265358169) +(num-test (angle 1234.0+1.0i) 0.00081037259408) +(num-test (angle -1234.0+1.0i) 3.14078228099571) +(num-test (angle 1234.0-1.0i) -0.00081037259408) +(num-test (angle -1234.0-1.0i) -3.14078228099571) +(num-test (angle 1234.0+3.14159265358979i) 0.00254585564530) +(num-test (angle -1234.0+3.14159265358979i) 3.13904679794449) +(num-test (angle 1234.0-3.14159265358979i) -0.00254585564530) +(num-test (angle -1234.0-3.14159265358979i) -3.13904679794449) +(num-test (angle 1234.0+2.71828182845905i) 0.00220281801598) +(num-test (angle -1234.0+2.71828182845905i) 3.13938983557381) +(num-test (angle 1234.0-2.71828182845905i) -0.00220281801598) +(num-test (angle -1234.0-2.71828182845905i) -3.13938983557381) +(num-test (angle 1234.0+1234.0i) 0.78539816339745) +(num-test (angle -1234.0+1234.0i) 2.35619449019234) +(num-test (angle 1234.0-1234.0i) -0.78539816339745) +(num-test (angle -1234.0-1234.0i) -2.35619449019234) +(num-test (angle 1234.0+1234000000.0i) 1.57079532679490) +(num-test (angle -1234.0+1234000000.0i) 1.57079732679490) +(num-test (angle 1234.0-1234000000.0i) -1.57079532679490) +(num-test (angle -1234.0-1234000000.0i) -1.57079732679490) +(num-test (angle 1234000000.0) 0.0) +(num-test (angle -1234000000.0) our-pi) +(num-test (angle 1234000000.0+0.00000001i) 0.0) +(num-test (angle -1234000000.0+0.00000001i) our-pi) +(num-test (angle 1234000000.0-0.00000001i) -0.0) +(num-test (angle -1234000000.0-0.00000001i) -3.14159265358979) +(num-test (angle 1234000000.0+1.0i) 0.00000000081037) +(num-test (angle -1234000000.0+1.0i) 3.14159265277942) +(num-test (angle 1234000000.0-1.0i) -0.00000000081037) +(num-test (angle -1234000000.0-1.0i) -3.14159265277942) +(num-test (angle 1234000000.0+3.14159265358979i) 0.00000000254586) +(num-test (angle -1234000000.0+3.14159265358979i) 3.14159265104393) +(num-test (angle 1234000000.0-3.14159265358979i) -0.00000000254586) +(num-test (angle -1234000000.0-3.14159265358979i) -3.14159265104393) +(num-test (angle 1234000000.0+2.71828182845905i) 0.00000000220282) +(num-test (angle -1234000000.0+2.71828182845905i) 3.14159265138697) +(num-test (angle 1234000000.0-2.71828182845905i) -0.00000000220282) +(num-test (angle -1234000000.0-2.71828182845905i) -3.14159265138697) +(num-test (angle 1234000000.0+1234.0i) 0.00000100000000) +(num-test (angle -1234000000.0+1234.0i) 3.14159165358979) +(num-test (angle 1234000000.0-1234.0i) -0.00000100000000) +(num-test (angle -1234000000.0-1234.0i) -3.14159165358979) +(num-test (angle 1234000000.0+1234000000.0i) 0.78539816339745) +(num-test (angle -1234000000.0+1234000000.0i) 2.35619449019234) +(num-test (angle 1234000000.0-1234000000.0i) -0.78539816339745) +(num-test (angle -1234000000.0-1234000000.0i) -2.35619449019234) +(num-test (angle 0.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (angle 0.0e+00+1.19209289550781250e-07i) 1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00-1.19209289550781250e-07i) -1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00+5.0e-01i) 1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00-5.0e-01i) -1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00+1.0e+00i) 1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00-1.0e+00i) -1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00+2.0e+00i) 1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00-2.0e+00i) -1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00+8.3886080e+06i) 1.5707963267948966192e0+0.0i) +(num-test (angle 0.0e+00-8.3886080e+06i) -1.5707963267948966192e0+0.0i) +(num-test (angle 1.19209289550781250e-07+0.0e+00i) 0e0+0.0i) +(num-test (angle -1.19209289550781250e-07+0.0e+00i) 3.1415926535897932385e0+0.0i) +(num-test (angle 1.19209289550781250e-07+1.19209289550781250e-07i) 7.8539816339744830962e-1+0.0i) +(num-test (angle 1.19209289550781250e-07-1.19209289550781250e-07i) -7.8539816339744830962e-1+0.0i) +(num-test (angle -1.19209289550781250e-07+1.19209289550781250e-07i) 2.3561944901923449288e0+0.0i) +(num-test (angle -1.19209289550781250e-07-1.19209289550781250e-07i) -2.3561944901923449288e0+0.0i) +(num-test (angle 1.19209289550781250e-07+5.0e-01i) 1.5707960883763175177e0+0.0i) +(num-test (angle 1.19209289550781250e-07-5.0e-01i) -1.5707960883763175177e0+0.0i) +(num-test (angle -1.19209289550781250e-07+5.0e-01i) 1.5707965652134757208e0+0.0i) +(num-test (angle -1.19209289550781250e-07-5.0e-01i) -1.5707965652134757208e0+0.0i) +(num-test (angle 1.19209289550781250e-07+1.0e+00i) 1.5707962075856070685e0+0.0i) +(num-test (angle 1.19209289550781250e-07-1.0e+00i) -1.5707962075856070685e0+0.0i) +(num-test (angle -1.19209289550781250e-07+1.0e+00i) 1.570796446004186170e0+0.0i) +(num-test (angle -1.19209289550781250e-07-1.0e+00i) -1.570796446004186170e0+0.0i) +(num-test (angle 1.19209289550781250e-07+2.0e+00i) 1.5707962671902518438e0+0.0i) +(num-test (angle 1.19209289550781250e-07-2.0e+00i) -1.5707962671902518438e0+0.0i) +(num-test (angle -1.19209289550781250e-07+2.0e+00i) 1.5707963863995413946e0+0.0i) +(num-test (angle -1.19209289550781250e-07-2.0e+00i) -1.5707963863995413946e0+0.0i) +(num-test (angle 1.19209289550781250e-07+8.3886080e+06i) 1.5707963267948824084e0+0.0i) +(num-test (angle 1.19209289550781250e-07-8.3886080e+06i) -1.5707963267948824084e0+0.0i) +(num-test (angle -1.19209289550781250e-07+8.3886080e+06i) 1.5707963267949108301e0+0.0i) +(num-test (angle -1.19209289550781250e-07-8.3886080e+06i) -1.5707963267949108301e0+0.0i) +(num-test (angle 5.0e-01+0.0e+00i) 0e0+0.0i) +(num-test (angle -5.0e-01+0.0e+00i) 3.1415926535897932385e0+0.0i) +(num-test (angle 5.0e-01+1.19209289550781250e-07i) 2.3841857910155798249e-7+0.0i) +(num-test (angle 5.0e-01-1.19209289550781250e-07i) -2.3841857910155798249e-7+0.0i) +(num-test (angle -5.0e-01+1.19209289550781250e-07i) 3.1415924151712141369e0+0.0i) +(num-test (angle -5.0e-01-1.19209289550781250e-07i) -3.1415924151712141369e0+0.0i) +(num-test (angle 5.0e-01+5.0e-01i) 7.8539816339744830962e-1+0.0i) +(num-test (angle 5.0e-01-5.0e-01i) -7.8539816339744830962e-1+0.0i) +(num-test (angle -5.0e-01+5.0e-01i) 2.3561944901923449288e0+0.0i) +(num-test (angle -5.0e-01-5.0e-01i) -2.3561944901923449288e0+0.0i) +(num-test (angle 5.0e-01+1.0e+00i) 1.1071487177940905030e0+0.0i) +(num-test (angle 5.0e-01-1.0e+00i) -1.1071487177940905030e0+0.0i) +(num-test (angle -5.0e-01+1.0e+00i) 2.0344439357957027354e0+0.0i) +(num-test (angle -5.0e-01-1.0e+00i) -2.0344439357957027354e0+0.0i) +(num-test (angle 5.0e-01+2.0e+00i) 1.3258176636680324651e0+0.0i) +(num-test (angle 5.0e-01-2.0e+00i) -1.3258176636680324651e0+0.0i) +(num-test (angle -5.0e-01+2.0e+00i) 1.8157749899217607734e0+0.0i) +(num-test (angle -5.0e-01-2.0e+00i) -1.8157749899217607734e0+0.0i) +(num-test (angle 5.0e-01+8.3886080e+06i) 1.5707962671902518438e0+0.0i) +(num-test (angle 5.0e-01-8.3886080e+06i) -1.5707962671902518438e0+0.0i) +(num-test (angle -5.0e-01+8.3886080e+06i) 1.5707963863995413946e0+0.0i) +(num-test (angle -5.0e-01-8.3886080e+06i) -1.5707963863995413946e0+0.0i) +(num-test (angle 1.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (angle -1.0e+00+0.0e+00i) 3.1415926535897932385e0+0.0i) +(num-test (angle 1.0e+00+1.19209289550781250e-07i) 1.1920928955078068531e-7+0.0i) +(num-test (angle 1.0e+00-1.19209289550781250e-07i) -1.1920928955078068531e-7+0.0i) +(num-test (angle -1.0e+00+1.19209289550781250e-07i) 3.1415925343805036877e0+0.0i) +(num-test (angle -1.0e+00-1.19209289550781250e-07i) -3.1415925343805036877e0+0.0i) +(num-test (angle 1.0e+00+5.0e-01i) 4.6364760900080611621e-1+0.0i) +(num-test (angle 1.0e+00-5.0e-01i) -4.6364760900080611621e-1+0.0i) +(num-test (angle -1.0e+00+5.0e-01i) 2.6779450445889871222e0+0.0i) +(num-test (angle -1.0e+00-5.0e-01i) -2.6779450445889871222e0+0.0i) +(num-test (angle 1.0e+00+1.0e+00i) 7.8539816339744830962e-1+0.0i) +(num-test (angle 1.0e+00-1.0e+00i) -7.8539816339744830962e-1+0.0i) +(num-test (angle -1.0e+00+1.0e+00i) 2.3561944901923449288e0+0.0i) +(num-test (angle -1.0e+00-1.0e+00i) -2.3561944901923449288e0+0.0i) +(num-test (angle 1.0e+00+2.0e+00i) 1.1071487177940905030e0+0.0i) +(num-test (angle 1.0e+00-2.0e+00i) -1.1071487177940905030e0+0.0i) +(num-test (angle -1.0e+00+2.0e+00i) 2.0344439357957027354e0+0.0i) +(num-test (angle -1.0e+00-2.0e+00i) -2.0344439357957027354e0+0.0i) +(num-test (angle 1.0e+00+8.3886080e+06i) 1.5707962075856070685e0+0.0i) +(num-test (angle 1.0e+00-8.3886080e+06i) -1.5707962075856070685e0+0.0i) +(num-test (angle -1.0e+00+8.3886080e+06i) 1.570796446004186170e0+0.0i) +(num-test (angle -1.0e+00-8.3886080e+06i) -1.570796446004186170e0+0.0i) +(num-test (angle 2.0e+00+0.0e+00i) 0e0+0.0i) +(num-test (angle -2.0e+00+0.0e+00i) 3.1415926535897932385e0+0.0i) +(num-test (angle 2.0e+00+1.19209289550781250e-07i) 5.9604644775390554414e-8+0.0i) +(num-test (angle 2.0e+00-1.19209289550781250e-07i) -5.9604644775390554414e-8+0.0i) +(num-test (angle -2.0e+00+1.19209289550781250e-07i) 3.1415925939851484631e0+0.0i) +(num-test (angle -2.0e+00-1.19209289550781250e-07i) -3.1415925939851484631e0+0.0i) +(num-test (angle 2.0e+00+5.0e-01i) 2.4497866312686415417e-1+0.0i) +(num-test (angle 2.0e+00-5.0e-01i) -2.4497866312686415417e-1+0.0i) +(num-test (angle -2.0e+00+5.0e-01i) 2.8966139904629290843e0+0.0i) +(num-test (angle -2.0e+00-5.0e-01i) -2.8966139904629290843e0+0.0i) +(num-test (angle 2.0e+00+1.0e+00i) 4.6364760900080611621e-1+0.0i) +(num-test (angle 2.0e+00-1.0e+00i) -4.6364760900080611621e-1+0.0i) +(num-test (angle -2.0e+00+1.0e+00i) 2.6779450445889871222e0+0.0i) +(num-test (angle -2.0e+00-1.0e+00i) -2.6779450445889871222e0+0.0i) +(num-test (angle 2.0e+00+2.0e+00i) 7.8539816339744830962e-1+0.0i) +(num-test (angle 2.0e+00-2.0e+00i) -7.8539816339744830962e-1+0.0i) +(num-test (angle -2.0e+00+2.0e+00i) 2.3561944901923449288e0+0.0i) +(num-test (angle -2.0e+00-2.0e+00i) -2.3561944901923449288e0+0.0i) +(num-test (angle 2.0e+00+8.3886080e+06i) 1.5707960883763175177e0+0.0i) +(num-test (angle 2.0e+00-8.3886080e+06i) -1.5707960883763175177e0+0.0i) +(num-test (angle -2.0e+00+8.3886080e+06i) 1.5707965652134757208e0+0.0i) +(num-test (angle -2.0e+00-8.3886080e+06i) -1.5707965652134757208e0+0.0i) +(num-test (angle 8.3886080e+06+0.0e+00i) 0e0+0.0i) +(num-test (angle -8.3886080e+06+0.0e+00i) 3.1415926535897932385e0+0.0i) +(num-test (angle 8.3886080e+06+1.19209289550781250e-07i) 1.4210854715202003717e-14+0.0i) +(num-test (angle 8.3886080e+06-1.19209289550781250e-07i) -1.4210854715202003717e-14+0.0i) +(num-test (angle -8.3886080e+06+1.19209289550781250e-07i) 3.1415926535897790276e0+0.0i) +(num-test (angle -8.3886080e+06-1.19209289550781250e-07i) -3.1415926535897790276e0+0.0i) +(num-test (angle 8.3886080e+06+5.0e-01i) 5.9604644775390554414e-8+0.0i) +(num-test (angle 8.3886080e+06-5.0e-01i) -5.9604644775390554414e-8+0.0i) +(num-test (angle -8.3886080e+06+5.0e-01i) 3.1415925939851484631e0+0.0i) +(num-test (angle -8.3886080e+06-5.0e-01i) -3.1415925939851484631e0+0.0i) +(num-test (angle 8.3886080e+06+1.0e+00i) 1.1920928955078068531e-7+0.0i) +(num-test (angle 8.3886080e+06-1.0e+00i) -1.1920928955078068531e-7+0.0i) +(num-test (angle -8.3886080e+06+1.0e+00i) 3.1415925343805036877e0+0.0i) +(num-test (angle -8.3886080e+06-1.0e+00i) -3.1415925343805036877e0+0.0i) +(num-test (angle 8.3886080e+06+2.0e+00i) 2.3841857910155798249e-7+0.0i) +(num-test (angle 8.3886080e+06-2.0e+00i) -2.3841857910155798249e-7+0.0i) +(num-test (angle -8.3886080e+06+2.0e+00i) 3.1415924151712141369e0+0.0i) +(num-test (angle -8.3886080e+06-2.0e+00i) -3.1415924151712141369e0+0.0i) +(num-test (angle 8.3886080e+06+8.3886080e+06i) 7.8539816339744830962e-1+0.0i) +(num-test (angle 8.3886080e+06-8.3886080e+06i) -7.8539816339744830962e-1+0.0i) +(num-test (angle -8.3886080e+06+8.3886080e+06i) 2.3561944901923449288e0+0.0i) +(num-test (angle -8.3886080e+06-8.3886080e+06i) -2.3561944901923449288e0+0.0i) +(num-test (angle -0) 0) +(num-test (angle 0) 0) +(num-test (angle 0.0) 0.0) + + +;; -------- floor, ceiling, truncate, round + +(num-test (truncate 19) 19) +(num-test (truncate 2/3) 0) +(num-test (truncate -2/3) 0) +(num-test (truncate 17.3) 17) +(num-test (truncate -17/2) -8) +(num-test (truncate -0.1) 0) +(num-test (truncate -0.9) 0) +(num-test (truncate -1.1) -1) +(num-test (truncate -1.9) -1) +(num-test (truncate -1/10) 0) +(num-test (truncate -9/10) 0) +(num-test (truncate -11/10) -1) +(num-test (truncate -19/10) -1) +(num-test (truncate -1/2) 0) +(num-test (truncate -3/2) -1) +(num-test (truncate 0.1) 0) +(num-test (truncate 0.9) 0) +(num-test (truncate 1.1) 1) +(num-test (truncate 1.9) 1) +(num-test (truncate 1/10) 0) +(num-test (truncate 9/10) 0) +(num-test (truncate 11/10) 1) +(num-test (truncate 19/10) 1) +(num-test (truncate 1/2) 0) +(num-test (truncate 3/2) 1) + +(num-test (floor (+ 1 (expt 2 30))) 1073741825) +(num-test (floor 19) 19) +(num-test (floor 2/3) 0) +(num-test (floor -2/3) -1) +(num-test (floor 17.3) 17) +(num-test (floor -17/2) -9) +(num-test (floor -0.1) -1) +(num-test (floor -0.9) -1) +(num-test (floor -1.1) -2) +(num-test (floor -1.9) -2) +(num-test (floor -1/10) -1) +(num-test (floor -9/10) -1) +(num-test (floor -11/10) -2) +(num-test (floor -19/10) -2) +(num-test (floor -1/2) -1) +(num-test (floor -3/2) -2) +(num-test (floor 0.1) 0) +(num-test (floor 0.9) 0) +(num-test (floor 1.1) 1) +(num-test (floor 1.9) 1) +(num-test (floor 1/10) 0) +(num-test (floor 9/10) 0) +(num-test (floor 11/10) 1) +(num-test (floor 19/10) 1) +(num-test (floor 1/2) 0) +(num-test (floor 3/2) 1) + +(num-test (ceiling 19) 19) +(num-test (ceiling 2/3) 1) +(num-test (ceiling -2/3) 0) +(num-test (ceiling 17.3) 18) +(num-test (ceiling -17/2) -8) +(num-test (ceiling -0.1) 0) +(num-test (ceiling -0.9) 0) +(num-test (ceiling -1.1) -1) +(num-test (ceiling -1.9) -1) +(num-test (ceiling -1/10) 0) +(num-test (ceiling -9/10) 0) +(num-test (ceiling -11/10) -1) +(num-test (ceiling -19/10) -1) +(num-test (ceiling -1/2) 0) +(num-test (ceiling -3/2) -1) +(num-test (ceiling 0.1) 1) +(num-test (ceiling 0.9) 1) +(num-test (ceiling 1.1) 2) +(num-test (ceiling 1.9) 2) +(num-test (ceiling 1/10) 1) +(num-test (ceiling 9/10) 1) +(num-test (ceiling 11/10) 2) +(num-test (ceiling 19/10) 2) +(num-test (ceiling 1/2) 1) +(num-test (ceiling 3/2) 2) + +(num-test (round 19) 19) +(num-test (round 2/3) 1) +(num-test (round -2/3) -1) +(num-test (round 17.3) 17) +(num-test (round -17/2) -8) +(num-test (round 2.5) 2) +(num-test (round 3.5) 4) +(num-test (round -0.1) 0) +(num-test (round -0.9) -1) +(num-test (round -1.1) -1) +(num-test (round -1.9) -2) +(num-test (round -1/10) 0) +(num-test (round -9/10) -1) +(num-test (round -11/10) -1) +(num-test (round -19/10) -2) +(num-test (round -1/2) 0) +(num-test (round -3/2) -2) +(num-test (round 0.1) 0) +(num-test (round 0.9) 1) +(num-test (round 1.1) 1) +(num-test (round 1.9) 2) +(num-test (round 1/10) 0) +(num-test (round 9/10) 1) +(num-test (round 11/10) 1) +(num-test (round 19/10) 2) +(num-test (round 1/2) 0) +(num-test (round 3/2) 2) + +(test (equal? (let ((vals '())) + (do ((k 1/3 (+ k 1/3))) ((> k 2) (reverse vals)) + (set! vals (cons (round k) vals)))) + (list 0 1 1 1 2 2)) + #t) +(test (equal? (let ((vals '())) + (do ((k 1/3 (+ k 1/3))) ((> k 2) (reverse vals)) + (set! vals (cons (round (- k)) vals)))) + (list 0 -1 -1 -1 -2 -2)) + #t) +(test (equal? (let ((vals '())) + (do ((k 1/2 (+ k 1/2))) ((> k 3) (reverse vals)) + (set! vals (cons (round k) vals)))) + (list 0 1 2 2 2 3)) + #t) +(test (equal? (let ((vals '())) + (do ((k 1/2 (+ k 1/2))) ((> k 3) (reverse vals)) + (set! vals (cons (round (- k)) vals)))) + (list 0 -1 -2 -2 -2 -3)) + #t) + +(num-test (floor 0) 0) +(num-test (round 0) 0) +(num-test (ceiling 0) 0) +(num-test (truncate 0) 0) +(num-test (floor -0) 0) +(num-test (round -0) 0) +(num-test (ceiling -0) 0) +(num-test (truncate -0) 0) +(num-test (floor 0.0) 0) +(num-test (round 0.0) 0) +(num-test (ceiling 0.0) 0) +(num-test (truncate 0.0) 0) +(num-test (floor -0.0) 0) +(num-test (round -0.0) 0) +(num-test (ceiling -0.0) 0) +(num-test (truncate -0.0) 0) +(num-test (floor -1) -1) +(num-test (round -1) -1) +(num-test (ceiling -1) -1) +(num-test (truncate -1) -1) +(num-test (floor 1) 1) +(num-test (round 1) 1) +(num-test (ceiling 1) 1) +(num-test (truncate 1) 1) + +(num-test (floor 1/123400000) 0) +(num-test (round 1/123400000) 0) +(num-test (ceiling 1/123400000) 1) +(num-test (truncate 1/123400000) 0) +(num-test (floor -1/123400000) -1) +(num-test (round -1/123400000) 0) +(num-test (ceiling -1/123400000) 0) +(num-test (truncate -1/123400000) 0) + +(num-test (floor (- 1 1/123400000)) 0) +(num-test (round (- 1 1/123400000)) 1) +(num-test (ceiling (- 1 1/123400000)) 1) +(num-test (truncate (- 1 1/123400000)) 0) +(num-test (floor (- (+ 1 -1/123400000))) -1) +(num-test (round (- (+ 1 -1/123400000))) -1) +(num-test (ceiling (- (+ 1 -1/123400000))) 0) +(num-test (truncate (- (+ 1 -1/123400000))) 0) + +(num-test (floor 2.6) 2) +(num-test (floor 2.5) 2) +(num-test (ceiling 2.6) 3) +(num-test (ceiling 2.5) 3) +(num-test (ceiling 2.4) 3) +(num-test (truncate 2.6) 2) +(num-test (truncate 2.5) 2) +(num-test (truncate 2.4) 2) +(num-test (round 2.6) 3) +(num-test (round 2.5) 2) +(num-test (round 2.4) 2) + +(let ((top-exp 60)) + (if with-bignums + (set! top-exp 150) + (if (not with-64-bit-ints) + (set! top-exp 30))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (/ (- (expt 2 i) 1) 2)) + (val2 (expt 2 (- i 1))) + (fv (floor val1)) + (rv (round val1)) + (cv (ceiling val1)) + (tv (truncate val1))) + (if (not (= fv (- val2 1))) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline))) + (if (not (= cv val2)) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline))) + (if (not (= tv (- val2 1))) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline))) + (if (not (= rv val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (/ (+ (expt 2 i) 1) 2)) + (val2 (expt 2 (- i 1))) + (fv (floor val1)) + (rv (round val1)) + (cv (ceiling val1)) + (tv (truncate val1))) + (if (not (= fv val2)) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline))) + (if (not (= cv (+ val2 1))) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline))) + (if (not (= tv val2)) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline))) + (if (not (= rv val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (expt 2 i)) + (val2 (- val1 1))) + (if (= (floor val1) (floor val2)) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline))) + (if (= (ceiling val1) (ceiling val2)) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline))) + (if (= (truncate val1) (truncate val2)) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline))) + (if (= (round val1) (round val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (/ (- (expt 2 i) 1) 2)) + (val2 (/ (- (expt 2 i) 3) 2))) + (if (= (floor val1) (floor val2)) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline))) + (if (= (ceiling val1) (ceiling val2)) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline))) + (if (= (truncate val1) (truncate val2)) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline))) + (if (= (round val1) (round val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline)))))) + + (let ((happy #t) + (off-by 1/3)) + (do ((i 2 (+ i 1))) + ((or (not happy) (>= i top-exp))) + (let* ((val1 (/ (expt 2 i) 3)) + (fv (floor val1)) + (cv (ceiling val1)) + (tv (truncate val1)) + (rv (round val1))) + (if (not (= fv (- val1 off-by))) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline))) + (if (not (= cv (+ val1 (- 1 off-by)))) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline))) + (if (not (= tv (- val1 off-by))) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline))) + (if (= off-by 1/3) + (if (not (= rv (- val1 off-by))) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))) + (if (not (= rv (+ val1 (- 1 off-by)))) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))) + (if (= off-by 1/3) + (set! off-by 2/3) + (set! off-by 1/3))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (- (/ (- (expt 2 i) 1) 2))) + (val2 (- (expt 2 (- i 1)))) + (fv (floor val1)) + (rv (round val1)) + (cv (ceiling val1)) + (tv (truncate val1))) + (if (not (= fv val2)) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline))) + (if (not (= cv (+ val2 1))) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline))) + (if (not (= tv (+ val2 1))) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline))) + (if (not (= rv val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (- (/ (+ (expt 2 i) 1) 2))) + (val2 (- (expt 2 (- i 1)))) + (fv (floor val1)) + (rv (round val1)) + (cv (ceiling val1)) + (tv (truncate val1))) + (if (not (= fv (- val2 1))) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline))) + (if (not (= cv val2)) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline))) + (if (not (= tv val2)) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline))) + (if (not (= rv val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (- (expt 2 i))) + (val2 (+ val1 1))) + (if (= (floor val1) (floor val2)) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline))) + (if (= (ceiling val1) (ceiling val2)) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline))) + (if (= (truncate val1) (truncate val2)) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline))) + (if (= (round val1) (round val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (- (/ (- (expt 2 i) 1) 2))) + (val2 (- (/ (- (expt 2 i) 3) 2)))) + (if (= (floor val1) (floor val2)) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = (floor ") (display val2) (display ")?") (newline))) + (if (= (ceiling val1) (ceiling val2)) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = (ceiling ") (display val2) (display ")?") (newline))) + (if (= (truncate val1) (truncate val2)) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = (truncate ") (display val2) (display ")?") (newline))) + (if (= (round val1) (round val2)) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = (round ") (display val2) (display ")?") (newline)))))) + + (let ((happy #t) + (off-by 2/3)) + (do ((i 2 (+ i 1))) + ((or (not happy) (>= i top-exp))) + (let* ((val1 (- (/ (expt 2 i) 3))) + (fv (floor val1)) + (cv (ceiling val1)) + (tv (truncate val1)) + (rv (round val1))) + (if (not (= fv (- val1 off-by))) + (begin (set! happy #f) (display "(floor ") (display val1) (display ") = ") (display fv) (display "?") (newline))) + (if (not (= cv (+ val1 (- 1 off-by)))) + (begin (set! happy #f) (display "(ceiling ") (display val1) (display ") = ") (display cv) (display "?") (newline))) + (if (not (= tv (+ val1 (- 1 off-by)))) + (begin (set! happy #f) (display "(truncate ") (display val1) (display ") = ") (display tv) (display "?") (newline))) + (if (= off-by 1/3) + (if (not (= rv (- val1 off-by))) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline))) + (if (not (= rv (+ val1 (- 1 off-by)))) + (begin (set! happy #f) (display "(round ") (display val1) (display ") = ") (display rv) (display "?") (newline)))) + (if (= off-by 1/3) + (set! off-by 2/3) + (set! off-by 1/3))))) + ) + + +;; -------- negative?, positive?, zero? + +(test (zero? 0) #t ) +(test (zero? -0) #t ) +(test (zero? -0.0) #t ) +(test (zero? 0.0) #t ) +(test (zero? 1) #f ) +(test (zero? -1) #f ) +(test (zero? -100) #f ) +(test (positive? 4) #t ) +(test (positive? -4) #f ) +(test (positive? 0) #f ) +(test (negative? 4) #f ) +(test (negative? -4) #t ) +(test (negative? 0) #f ) +(test (negative? -0) #f ) +(test (negative? 0.0) #f ) +(test (negative? -0.0) #f ) + +(for-each + (lambda (n) + (if (not (positive? n)) + (begin (display "(positive? ") (display n) (display ") returned #f?") (newline)))) + (list 1 123 123456123 1.4 0.001 1/2 124124124.2)) + +(for-each + (lambda (n) + (if (negative? n) + (begin (display "(negative? ") (display n) (display ") returned #t?") (newline)))) + (list 1 123 123456123 1.4 0.001 1/2 12341243124.2)) + +(for-each + (lambda (n) + (if (positive? n) + (begin (display "(positive? ") (display n) (display ") returned #t?") (newline)))) + (list -1 -123 -123456123 -3/2 -0.00001 -1.4 -123124124.1)) + +(for-each + (lambda (n) + (if (not (negative? n)) + (begin (display "(negative? ") (display n) (display ") returned #f?") (newline)))) + (list -1 -123 -123456123 -2/3 -0.00001 -1.4 -123124124.1)) + +(for-each + (lambda (n) + (if (not (zero? n)) + (begin (display "(zero? ") (display n) (display ") returned #f?") (newline)))) + (list 0 0.0 0+0i 0/1 0.0-0.0i)) + +(for-each + (lambda (n) + (if (zero? n) + (begin (display "(zero? ") (display n) (display ") returned #t?") (newline)))) + (list 1 1/100 -0.001 0.0+1.0i)) + + +;; -------- even?, odd? + +(test (odd? 3) #t ) +(test (odd? 2) #f ) +(test (odd? -4) #f ) +(test (odd? -1) #t ) +(test (even? 3) #f ) +(test (even? 2) #t ) +(test (even? -4) #t ) +(test (even? -1) #f ) + +(for-each + (lambda (n) + (if (not (even? n)) + (begin (display "(even? ") (display n) (display ") returned #f?") (newline)))) + (list 0 2 1234 -4 -10000002 1000000006)) + +(for-each + (lambda (n) + (if (odd? n) + (begin (display "(odd? ") (display n) (display ") returned #t?") (newline)))) + (list 0 2 1234 -4 -10000002 1000000006)) + +(for-each + (lambda (n) + (if (even? n) + (begin (display "(even? ") (display n) (display ") returned #t?") (newline)))) + (list 1 -1 31 50001 543321)) + +(for-each + (lambda (n) + (if (not (odd? n)) + (begin (display "(odd? ") (display n) (display ") returned #f?") (newline)))) + (list 1 -1 31 50001 543321)) + +(let ((top-exp 60)) + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (+ 2 (inexact->exact (expt 2 i)))) + (val2 (- val1 1)) + (ev1 (even? val1)) + (ov1 (odd? val1)) + (ev2 (even? val2)) + (ov2 (odd? val2))) + (if (not ev1) + (begin (set! happy #f) (display "not (even? ") (display val1) (display ")?") (newline))) + (if ev2 + (begin (set! happy #f) (display "(even? ") (display val2) (display ")?") (newline))) + (if ov1 + (begin (set! happy #f) (display "(odd? ") (display val1) (display ")?") (newline))) + (if (not ov2) + (begin (set! happy #f) (display "not (odd? ") (display val2) (display ")?") (newline))))))) + + +;; -------- real?, complex?, number?, integer?, rational? + +(test (number? -) #f) +(test (number? +) #f) +(test (number? 12) #t) +(test (number? (expt 2 130)) #t) +(test (number? 5/3+7.2i) #t) +(test (number? #f) #f) +(test (number? (cons 1 2)) #f) +(test (number? 2.5-.5i) #t) + +(test (real? (+ 1+i 1-i)) #t) +(test (real? (- 1+i 1+i)) #t) +(test (real? (+ 1+i -1-i)) #t) +(test (real? (/ 1+i 1+i)) #t) +(test (real? (* 0+i 0+i)) #t) +(test (real? (magnitude 1+i)) #t) +(test (real? (string->number "1+0i")) #t) +(test (real? (make-rectangular 1 0)) #t) +(test (real? (make-rectangular 0 0)) #t) +(test (real? (make-polar 0 0)) #t) +(test (real? (make-polar 1 0)) #t) +(test (real? (angle 1+i)) #t) +(test (real? (real-part 1+i)) #t) +(test (real? (imag-part 1+i)) #t) +(test (real? (expt 0+i 0+i)) #t) + +(test (number? 3) #t ) +(test (complex? 3) #t ) +(test (real? 3) #t ) +(test (rational? 3) #t ) +(test (integer? 3) #t ) + +(for-each + (lambda (op opname) + (for-each + (lambda (arg) + (if (op arg) + (begin (display "(") (display opname) (display " ") (display arg) (display ") returned #t?") (newline)))) + (list "hi" (integer->char 65) #f #t '(1 2) 'a-symbol (cons 1 2) (make-vector 3) abs))) + (list number? complex? real? rational? integer?) + (list 'number? 'complex? 'real? 'rational? 'integer?)) + +(for-each + (lambda (arg) + (if (not (complex? arg)) + (begin (display "(complex? ") (display arg) (display ") returned #f?") (newline)))) + (list 1 1.0 1.0+0.5i 1/2)) + +(if (not (integer? 1234)) (display ";1234 is not an integer?~%")) +(for-each + (lambda (arg) + (if (integer? arg) + (begin (display "(integer? ") (display arg) (display ") returned #t?") (newline)))) + (list 1.5 1.0+0.5i 1/2)) + +(if (real? 1.0+1.0i) (display ";1.0+1.0i is real?~%")) +(for-each + (lambda (arg) + (if (not (real? arg)) + (begin (display "(real? ") (display arg) (display ") returned #f?") (newline)))) + (list 1 1.0 1/2)) + +(if (not (rational? 1/2)) + (begin (display "(rational? 1/2) is #f?") (newline))) + +(if (not (rational? 2)) + (begin (display "(rational? 2) is #f?") (newline))) + + + +;; -------- exact?, inexact?, inexact->exact, exact->inexact + +(test (exact? 3) #t ) +(test (inexact? 3) #f) +(test (exact? 3.123) #f) +(test (inexact? 3.123) #t) +(test (exact? -0) #t) +(test (inexact? -1) #f) +(test (exact? 1/2) #t) +(test (inexact? 1/2) #f) +(test (exact? 1.5+0.123i) #f) +(test (inexact? 1.5+0.123i) #t) + +(num-test (inexact->exact 1.5) 3/2) +(num-test (exact->inexact 3/2) 1.5) +(num-test (inexact->exact 1) 1) +(num-test (exact->inexact 1) 1.0) +(num-test (exact->inexact 1.0) 1.0) + + +;; -------- min, max + +(num-test (max 3/2 1/2) 3/2) +(num-test (max -3/2 1/2) 1/2) +(num-test (max 3/2 -1/2) 3/2) +(num-test (max -3/2 -1/2) -1/2) +(num-test (max 1 1/2) 1) +(num-test (max -1 1/2) 1/2) +(num-test (max 1 -1/2) 1) +(num-test (max -1 -1/2) -1/2) +(num-test (max 1/2 1) 1) +(num-test (max -1/2 1) 1) +(num-test (max 1/2 -1) 1/2) +(num-test (max -1/2 -1) -1/2) +(num-test (min 3/2 1/2) 1/2) +(num-test (min -3/2 1/2) -3/2) +(num-test (min 3/2 -1/2) -1/2) +(num-test (min -3/2 -1/2) -3/2) +(num-test (min 1 1/2) 1/2) +(num-test (min -1 1/2) -1) +(num-test (min 1 -1/2) -1/2) +(num-test (min -1 -1/2) -1) +(num-test (min 1/2 1) 1/2) +(num-test (min -1/2 1) -1/2) +(num-test (min 1/2 -1) -1) +(num-test (min -1/2 -1) -1) + +(num-test (max 3/2 6/5) 3/2) +(num-test (max -3/2 6/5) 6/5) +(num-test (max 3/2 -6/5) 3/2) +(num-test (max -3/2 -6/5) -6/5) +(num-test (min 3/2 6/5) 6/5) +(num-test (min -3/2 6/5) -3/2) +(num-test (min 3/2 -6/5) -6/5) +(num-test (min -3/2 -6/5) -3/2) + +(let ((top-exp 60)) + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (+ 2 (expt 2 i))) + (val2 (- val1 1))) + (if (not (= val1 (max val1 val2))) + (begin (set! happy #f) (display "(max ") (display val1) (display " ") (display val2) (display ") -> ") (display (max val1 val2)) (display "?") (newline))) + (if (not (= val2 (min val1 val2))) + (begin (set! happy #f) (display "(min ") (display val1) (display " ") (display val2) (display ") -> ") (display (min val1 val2)) (display "?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (/ (expt 2 i) 3)) + (val2 (/ (+ 1 (expt 2 i)) 3))) + (if (not (= val2 (max val1 val2))) + (begin (set! happy #f) (display "(max ") (display val1) (display " ") (display val2) (display ") -> ") (display (max val1 val2)) (display "?") (newline))) + (if (not (= val2 (max val2 val1))) + (begin (set! happy #f) (display "(max ") (display val1) (display " ") (display val2) (display ") -> ") (display (max val2 val1)) (display "?") (newline))) + (if (not (= val1 (min val1 val2))) + (begin (set! happy #f) (display "(min ") (display val1) (display " ") (display val2) (display ") -> ") (display (min val1 val2)) (display "?") (newline))) + (if (not (= val1 (min val2 val1))) + (begin (set! happy #f) (display "(min ") (display val1) (display " ") (display val2) (display ") -> ") (display (min val2 val1)) (display "?") (newline))) + )))) + +(num-test (min 0) 0) +(num-test (min 2) 2) +(num-test (min -2) -2) +(num-test (min 10) 10) +(num-test (min -10) -10) +(num-test (min 1234000000) 1234000000) +(num-test (min -1234000000) -1234000000) +(num-test (min 362880) 362880) +(num-test (min -362880) -362880) +(num-test (min 0/1) 0/1) +(num-test (min 0/1) 0/1) +(num-test (min 2/2) 2/2) +(num-test (min -2/2) -2/2) +(num-test (min 10/3) 10/3) +(num-test (min -10/3) -10/3) +(num-test (min 1234000000/10) 1234000000/10) +(num-test (min -1234000000/10) -1234000000/10) +(num-test (min 362880/1234) 362880/1234) +(num-test (min -362880/1234) -362880/1234) +(num-test (min 0.0) 0.0) +(num-test (min -0.0) -0.0) +(num-test (min 1.0) 1.0) +(num-test (min -1.0) -1.0) +(num-test (min 2.71828182845905) 2.71828182845905) +(num-test (min -2.71828182845905) -2.71828182845905) +(num-test (min 1234000000.0) 1234000000.0) +(num-test (min -1234000000.0) -1234000000.0) +(num-test (min 1 1) 1) +(num-test (min 1 1.0) 1.0) +(num-test (min 1 1/1) 1) +(num-test (min 1 1234) 1) +(num-test (min 1 123.4) 1.0) +(num-test (min 1 1234/11) 1) +(num-test (min 1.0 1) 1.0) +(num-test (min 1.0 1.0) 1.0) +(num-test (min 1.0 1/1) 1.0) +(num-test (min 1.0 1234) 1.0) +(num-test (min 1.0 123.4) 1.0) +(num-test (min 1.0 1234/11) 1.0) +(num-test (min 1/1 1) 1) +(num-test (min 1/1 1.0) 1.0) +(num-test (min 1/1 1/1) 1) +(num-test (min 1/1 1234) 1) +(num-test (min 1/1 123.4) 1.0) +(num-test (min 1/1 1234/11) 1) +(num-test (min 0 1) 0) +(num-test (min 0 1.0) 0.0) +(num-test (min 0 1/1) 0) +(num-test (min 0 1234) 0) +(num-test (min 0 123.4) 0.0) +(num-test (min 0 1234/11) 0) +(num-test (min 0.0 1) 0.0) +(num-test (min 0.0 1.0) 0.0) +(num-test (min 0.0 1/1) 0.0) +(num-test (min 0.0 1234) 0.0) +(num-test (min 0.0 123.4) 0.0) +(num-test (min 0.0 1234/11) 0.0) +(num-test (min 1234 1) 1) +(num-test (min 1234 1.0) 1.0) +(num-test (min 1234 1/1) 1) +(num-test (min 1234 1234) 1234) +(num-test (min 1234 123.4) 123.4) +(num-test (min 1234 1234/11) 1234/11) +(num-test (min 123.4 1) 1.0) +(num-test (min 123.4 1.0) 1.0) +(num-test (min 123.4 1/1) 1.0) +(num-test (min 123.4 1234) 123.4) +(num-test (min 123.4 123.4) 123.4) +(num-test (min 123.4 1234/11) 112.18181818181819) +(num-test (min 1234/11 1) 1) +(num-test (min 1234/11 1.0) 1.0) +(num-test (min 1234/11 1/1) 1) +(num-test (min 1234/11 1234) 1234/11) +(num-test (min 1234/11 123.4) 112.18181818181819) +(num-test (min 1234/11 1234/11) 1234/11) +(num-test (min 1 1 1) 1) +(num-test (min 1 1 1.0) 1.0) +(num-test (min 1 1 1/1) 1) +(num-test (min 1 1 1234) 1) +(num-test (min 1 1 123.4) 1.0) +(num-test (min 1 1 1234/11) 1) +(num-test (min 1 1.0 1) 1.0) +(num-test (min 1 1.0 1.0) 1.0) +(num-test (min 1 1.0 1/1) 1.0) +(num-test (min 1 1.0 1234) 1.0) +(num-test (min 1 1.0 123.4) 1.0) +(num-test (min 1 1.0 1234/11) 1.0) +(num-test (min 1 1/1 1) 1) +(num-test (min 1 1/1 1.0) 1.0) +(num-test (min 1 1/1 1/1) 1) +(num-test (min 1 1/1 1234) 1) +(num-test (min 1 1/1 123.4) 1.0) +(num-test (min 1 1/1 1234/11) 1) +(num-test (min 1 1234 1) 1) +(num-test (min 1 1234 1.0) 1.0) +(num-test (min 1 1234 1/1) 1) +(num-test (min 1 1234 1234) 1) +(num-test (min 1 1234 123.4) 1.0) +(num-test (min 1 1234 1234/11) 1) +(num-test (min 1 123.4 1) 1.0) +(num-test (min 1 123.4 1.0) 1.0) +(num-test (min 1 123.4 1/1) 1.0) +(num-test (min 1 123.4 1234) 1.0) +(num-test (min 1 123.4 123.4) 1.0) +(num-test (min 1 123.4 1234/11) 1.0) +(num-test (min 1 1234/11 1) 1) +(num-test (min 1 1234/11 1.0) 1.0) +(num-test (min 1 1234/11 1/1) 1) +(num-test (min 1 1234/11 1234) 1) +(num-test (min 1 1234/11 123.4) 1.0) +(num-test (min 1 1234/11 1234/11) 1) +(num-test (min 1.0 1 1) 1.0) +(num-test (min 1.0 1 1.0) 1.0) +(num-test (min 1.0 1 1/1) 1.0) +(num-test (min 1.0 1 1234) 1.0) +(num-test (min 1.0 1 123.4) 1.0) +(num-test (min 1.0 1 1234/11) 1.0) +(num-test (min 1.0 1.0 1) 1.0) +(num-test (min 1.0 1.0 1.0) 1.0) +(num-test (min 1.0 1.0 1/1) 1.0) +(num-test (min 1.0 1.0 1234) 1.0) +(num-test (min 1.0 1.0 123.4) 1.0) +(num-test (min 1.0 1.0 1234/11) 1.0) +(num-test (min 1.0 1/1 1) 1.0) +(num-test (min 1.0 1/1 1.0) 1.0) +(num-test (min 1.0 1/1 1/1) 1.0) +(num-test (min 1.0 1/1 1234) 1.0) +(num-test (min 1.0 1/1 123.4) 1.0) +(num-test (min 1.0 1/1 1234/11) 1.0) +(num-test (min 1.0 1234 1) 1.0) +(num-test (min 1.0 1234 1.0) 1.0) +(num-test (min 1.0 1234 1/1) 1.0) +(num-test (min 1.0 1234 1234) 1.0) +(num-test (min 1.0 1234 123.4) 1.0) +(num-test (min 1.0 1234 1234/11) 1.0) +(num-test (min 1.0 123.4 1) 1.0) +(num-test (min 1.0 123.4 1.0) 1.0) +(num-test (min 1.0 123.4 1/1) 1.0) +(num-test (min 1.0 123.4 1234) 1.0) +(num-test (min 1.0 123.4 123.4) 1.0) +(num-test (min 1.0 123.4 1234/11) 1.0) +(num-test (min 1.0 1234/11 1) 1.0) +(num-test (min 1.0 1234/11 1.0) 1.0) +(num-test (min 1.0 1234/11 1/1) 1.0) +(num-test (min 1.0 1234/11 1234) 1.0) +(num-test (min 1.0 1234/11 123.4) 1.0) +(num-test (min 1.0 1234/11 1234/11) 1.0) +(num-test (min 1/1 1 1) 1) +(num-test (min 1/1 1 1.0) 1.0) +(num-test (min 1/1 1 1/1) 1) +(num-test (min 1/1 1 1234) 1) +(num-test (min 1/1 1 123.4) 1.0) +(num-test (min 1/1 1 1234/11) 1) +(num-test (min 1/1 1.0 1) 1.0) +(num-test (min 1/1 1.0 1.0) 1.0) +(num-test (min 1/1 1.0 1/1) 1.0) +(num-test (min 1/1 1.0 1234) 1.0) +(num-test (min 1/1 1.0 123.4) 1.0) +(num-test (min 1/1 1.0 1234/11) 1.0) +(num-test (min 1/1 1/1 1) 1) +(num-test (min 1/1 1/1 1.0) 1.0) +(num-test (min 1/1 1/1 1/1) 1) +(num-test (min 1/1 1/1 1234) 1) +(num-test (min 1/1 1/1 123.4) 1.0) +(num-test (min 1/1 1/1 1234/11) 1) +(num-test (min 1/1 1234 1) 1) +(num-test (min 1/1 1234 1.0) 1.0) +(num-test (min 1/1 1234 1/1) 1) +(num-test (min 1/1 1234 1234) 1) +(num-test (min 1/1 1234 123.4) 1.0) +(num-test (min 1/1 1234 1234/11) 1) +(num-test (min 1/1 123.4 1) 1.0) +(num-test (min 1/1 123.4 1.0) 1.0) +(num-test (min 1/1 123.4 1/1) 1.0) +(num-test (min 1/1 123.4 1234) 1.0) +(num-test (min 1/1 123.4 123.4) 1.0) +(num-test (min 1/1 123.4 1234/11) 1.0) +(num-test (min 1/1 1234/11 1) 1) +(num-test (min 1/1 1234/11 1.0) 1.0) +(num-test (min 1/1 1234/11 1/1) 1) +(num-test (min 1/1 1234/11 1234) 1) +(num-test (min 1/1 1234/11 123.4) 1.0) +(num-test (min 1/1 1234/11 1234/11) 1) +(num-test (min 0 1 1) 0) +(num-test (min 0 1 1.0) 0.0) +(num-test (min 0 1 1/1) 0) +(num-test (min 0 1 1234) 0) +(num-test (min 0 1 123.4) 0.0) +(num-test (min 0 1 1234/11) 0) +(num-test (min 0 1.0 1) 0.0) +(num-test (min 0 1.0 1.0) 0.0) +(num-test (min 0 1.0 1/1) 0.0) +(num-test (min 0 1.0 1234) 0.0) +(num-test (min 0 1.0 123.4) 0.0) +(num-test (min 0 1.0 1234/11) 0.0) +(num-test (min 0 1/1 1) 0) +(num-test (min 0 1/1 1.0) 0.0) +(num-test (min 0 1/1 1/1) 0) +(num-test (min 0 1/1 1234) 0) +(num-test (min 0 1/1 123.4) 0.0) +(num-test (min 0 1/1 1234/11) 0) +(num-test (min 0 1234 1) 0) +(num-test (min 0 1234 1.0) 0.0) +(num-test (min 0 1234 1/1) 0) +(num-test (min 0 1234 1234) 0) +(num-test (min 0 1234 123.4) 0.0) +(num-test (min 0 1234 1234/11) 0) +(num-test (min 0 123.4 1) 0.0) +(num-test (min 0 123.4 1.0) 0.0) +(num-test (min 0 123.4 1/1) 0.0) +(num-test (min 0 123.4 1234) 0.0) +(num-test (min 0 123.4 123.4) 0.0) +(num-test (min 0 123.4 1234/11) 0.0) +(num-test (min 0 1234/11 1) 0) +(num-test (min 0 1234/11 1.0) 0.0) +(num-test (min 0 1234/11 1/1) 0) +(num-test (min 0 1234/11 1234) 0) +(num-test (min 0 1234/11 123.4) 0.0) +(num-test (min 0 1234/11 1234/11) 0) +(num-test (min 0.0 1 1) 0.0) +(num-test (min 0.0 1 1.0) 0.0) +(num-test (min 0.0 1 1/1) 0.0) +(num-test (min 0.0 1 1234) 0.0) +(num-test (min 0.0 1 123.4) 0.0) +(num-test (min 0.0 1 1234/11) 0.0) +(num-test (min 0.0 1.0 1) 0.0) +(num-test (min 0.0 1.0 1.0) 0.0) +(num-test (min 0.0 1.0 1/1) 0.0) +(num-test (min 0.0 1.0 1234) 0.0) +(num-test (min 0.0 1.0 123.4) 0.0) +(num-test (min 0.0 1.0 1234/11) 0.0) +(num-test (min 0.0 1/1 1) 0.0) +(num-test (min 0.0 1/1 1.0) 0.0) +(num-test (min 0.0 1/1 1/1) 0.0) +(num-test (min 0.0 1/1 1234) 0.0) +(num-test (min 0.0 1/1 123.4) 0.0) +(num-test (min 0.0 1/1 1234/11) 0.0) +(num-test (min 0.0 1234 1) 0.0) +(num-test (min 0.0 1234 1.0) 0.0) +(num-test (min 0.0 1234 1/1) 0.0) +(num-test (min 0.0 1234 1234) 0.0) +(num-test (min 0.0 1234 123.4) 0.0) +(num-test (min 0.0 1234 1234/11) 0.0) +(num-test (min 0.0 123.4 1) 0.0) +(num-test (min 0.0 123.4 1.0) 0.0) +(num-test (min 0.0 123.4 1/1) 0.0) +(num-test (min 0.0 123.4 1234) 0.0) +(num-test (min 0.0 123.4 123.4) 0.0) +(num-test (min 0.0 123.4 1234/11) 0.0) +(num-test (min 0.0 1234/11 1) 0.0) +(num-test (min 0.0 1234/11 1.0) 0.0) +(num-test (min 0.0 1234/11 1/1) 0.0) +(num-test (min 0.0 1234/11 1234) 0.0) +(num-test (min 0.0 1234/11 123.4) 0.0) +(num-test (min 0.0 1234/11 1234/11) 0.0) +(num-test (min 1234 1 1) 1) +(num-test (min 1234 1 1.0) 1.0) +(num-test (min 1234 1 1/1) 1) +(num-test (min 1234 1 1234) 1) +(num-test (min 1234 1 123.4) 1.0) +(num-test (min 1234 1 1234/11) 1) +(num-test (min 1234 1.0 1) 1.0) +(num-test (min 1234 1.0 1.0) 1.0) +(num-test (min 1234 1.0 1/1) 1.0) +(num-test (min 1234 1.0 1234) 1.0) +(num-test (min 1234 1.0 123.4) 1.0) +(num-test (min 1234 1.0 1234/11) 1.0) +(num-test (min 1234 1/1 1) 1) +(num-test (min 1234 1/1 1.0) 1.0) +(num-test (min 1234 1/1 1/1) 1) +(num-test (min 1234 1/1 1234) 1) +(num-test (min 1234 1/1 123.4) 1.0) +(num-test (min 1234 1/1 1234/11) 1) +(num-test (min 1234 1234 1) 1) +(num-test (min 1234 1234 1.0) 1.0) +(num-test (min 1234 1234 1/1) 1) +(num-test (min 1234 1234 1234) 1234) +(num-test (min 1234 1234 123.4) 123.4) +(num-test (min 1234 1234 1234/11) 1234/11) +(num-test (min 1234 123.4 1) 1.0) +(num-test (min 1234 123.4 1.0) 1.0) +(num-test (min 1234 123.4 1/1) 1.0) +(num-test (min 1234 123.4 1234) 123.4) +(num-test (min 1234 123.4 123.4) 123.4) +(num-test (min 1234 123.4 1234/11) 112.18181818181819) +(num-test (min 1234 1234/11 1) 1) +(num-test (min 1234 1234/11 1.0) 1.0) +(num-test (min 1234 1234/11 1/1) 1) +(num-test (min 1234 1234/11 1234) 1234/11) +(num-test (min 1234 1234/11 123.4) 112.18181818181819) +(num-test (min 1234 1234/11 1234/11) 1234/11) +(num-test (min 123.4 1 1) 1.0) +(num-test (min 123.4 1 1.0) 1.0) +(num-test (min 123.4 1 1/1) 1.0) +(num-test (min 123.4 1 1234) 1.0) +(num-test (min 123.4 1 123.4) 1.0) +(num-test (min 123.4 1 1234/11) 1.0) +(num-test (min 123.4 1.0 1) 1.0) +(num-test (min 123.4 1.0 1.0) 1.0) +(num-test (min 123.4 1.0 1/1) 1.0) +(num-test (min 123.4 1.0 1234) 1.0) +(num-test (min 123.4 1.0 123.4) 1.0) +(num-test (min 123.4 1.0 1234/11) 1.0) +(num-test (min 123.4 1/1 1) 1.0) +(num-test (min 123.4 1/1 1.0) 1.0) +(num-test (min 123.4 1/1 1/1) 1.0) +(num-test (min 123.4 1/1 1234) 1.0) +(num-test (min 123.4 1/1 123.4) 1.0) +(num-test (min 123.4 1/1 1234/11) 1.0) +(num-test (min 123.4 1234 1) 1.0) +(num-test (min 123.4 1234 1.0) 1.0) +(num-test (min 123.4 1234 1/1) 1.0) +(num-test (min 123.4 1234 1234) 123.4) +(num-test (min 123.4 1234 123.4) 123.4) +(num-test (min 123.4 1234 1234/11) 112.18181818181819) +(num-test (min 123.4 123.4 1) 1.0) +(num-test (min 123.4 123.4 1.0) 1.0) +(num-test (min 123.4 123.4 1/1) 1.0) +(num-test (min 123.4 123.4 1234) 123.4) +(num-test (min 123.4 123.4 123.4) 123.4) +(num-test (min 123.4 123.4 1234/11) 112.18181818181819) +(num-test (min 123.4 1234/11 1) 1.0) +(num-test (min 123.4 1234/11 1.0) 1.0) +(num-test (min 123.4 1234/11 1/1) 1.0) +(num-test (min 123.4 1234/11 1234) 112.18181818181819) +(num-test (min 123.4 1234/11 123.4) 112.18181818181819) +(num-test (min 123.4 1234/11 1234/11) 112.18181818181819) +(num-test (min 1234/11 1 1) 1) +(num-test (min 1234/11 1 1.0) 1.0) +(num-test (min 1234/11 1 1/1) 1) +(num-test (min 1234/11 1 1234) 1) +(num-test (min 1234/11 1 123.4) 1.0) +(num-test (min 1234/11 1 1234/11) 1) +(num-test (min 1234/11 1.0 1) 1.0) +(num-test (min 1234/11 1.0 1.0) 1.0) +(num-test (min 1234/11 1.0 1/1) 1.0) +(num-test (min 1234/11 1.0 1234) 1.0) +(num-test (min 1234/11 1.0 123.4) 1.0) +(num-test (min 1234/11 1.0 1234/11) 1.0) +(num-test (min 1234/11 1/1 1) 1) +(num-test (min 1234/11 1/1 1.0) 1.0) +(num-test (min 1234/11 1/1 1/1) 1) +(num-test (min 1234/11 1/1 1234) 1) +(num-test (min 1234/11 1/1 123.4) 1.0) +(num-test (min 1234/11 1/1 1234/11) 1) +(num-test (min 1234/11 1234 1) 1) +(num-test (min 1234/11 1234 1.0) 1.0) +(num-test (min 1234/11 1234 1/1) 1) +(num-test (min 1234/11 1234 1234) 1234/11) +(num-test (min 1234/11 1234 123.4) 112.18181818181819) +(num-test (min 1234/11 1234 1234/11) 1234/11) +(num-test (min 1234/11 123.4 1) 1.0) +(num-test (min 1234/11 123.4 1.0) 1.0) +(num-test (min 1234/11 123.4 1/1) 1.0) +(num-test (min 1234/11 123.4 1234) 112.18181818181819) +(num-test (min 1234/11 123.4 123.4) 112.18181818181819) +(num-test (min 1234/11 123.4 1234/11) 112.18181818181819) +(num-test (min 1234/11 1234/11 1) 1) +(num-test (min 1234/11 1234/11 1.0) 1.0) +(num-test (min 1234/11 1234/11 1/1) 1) +(num-test (min 1234/11 1234/11 1234) 1234/11) +(num-test (min 1234/11 1234/11 123.4) 112.18181818181819) +(num-test (min 1234/11 1234/11 1234/11) 1234/11) +(num-test (min 3) 3) +(num-test (min 6 12) 6) +(num-test (min -6 -12) -12) +(num-test (min 1 3 2 -7) -7) +(num-test (min -2 3 0 7) -2) +(num-test (min 5.0 2) 2.0) ; why not 2? +(num-test (min 3.0 7 1) 1.0) +(num-test (min 3 5 5 330 4 -24) -24 ) + +(num-test (max 0) 0) +(num-test (max 2) 2) +(num-test (max -2) -2) +(num-test (max 10) 10) +(num-test (max -10) -10) +(num-test (max 1234000000) 1234000000) +(num-test (max -1234000000) -1234000000) +(num-test (max 362880) 362880) +(num-test (max -362880) -362880) +(num-test (max 0/1) 0/1) +(num-test (max 0/1) 0/1) +(num-test (max 2/2) 2/2) +(num-test (max -2/2) -2/2) +(num-test (max 10/3) 10/3) +(num-test (max -10/3) -10/3) +(num-test (max 1234000000/10) 1234000000/10) +(num-test (max -1234000000/10) -1234000000/10) +(num-test (max 362880/1234) 362880/1234) +(num-test (max -362880/1234) -362880/1234) +(num-test (max 0.0) 0.0) +(num-test (max -0.0) -0.0) +(num-test (max 1.0) 1.0) +(num-test (max -1.0) -1.0) +(num-test (max 2.71828182845905) 2.71828182845905) +(num-test (max -2.71828182845905) -2.71828182845905) +(num-test (max 1234000000.0) 1234000000.0) +(num-test (max -1234000000.0) -1234000000.0) +(num-test (max 1 1) 1) +(num-test (max 1 1.0) 1.0) +(num-test (max 1 1/1) 1) +(num-test (max 1 1234) 1234) +(num-test (max 1 123.4) 123.4) +(num-test (max 1 1234/11) 1234/11) +(num-test (max 1.0 1) 1.0) +(num-test (max 1.0 1.0) 1.0) +(num-test (max 1.0 1/1) 1.0) +(num-test (max 1.0 1234) 1234.0) +(num-test (max 1.0 123.4) 123.4) +(num-test (max 1.0 1234/11) 112.18181818181819) +(num-test (max 1/1 1) 1) +(num-test (max 1/1 1.0) 1.0) +(num-test (max 1/1 1/1) 1) +(num-test (max 1/1 1234) 1234) +(num-test (max 1/1 123.4) 123.4) +(num-test (max 1/1 1234/11) 1234/11) +(num-test (max 0 1) 1) +(num-test (max 0 1.0) 1.0) +(num-test (max 0 1/1) 1) +(num-test (max 0 1234) 1234) +(num-test (max 0 123.4) 123.4) +(num-test (max 0 1234/11) 1234/11) +(num-test (max 0.0 1) 1.0) +(num-test (max 0.0 1.0) 1.0) +(num-test (max 0.0 1/1) 1.0) +(num-test (max 0.0 1234) 1234.0) +(num-test (max 0.0 123.4) 123.4) +(num-test (max 0.0 1234/11) 112.18181818181819) +(num-test (max 1234 1) 1234) +(num-test (max 1234 1.0) 1234.0) +(num-test (max 1234 1/1) 1234) +(num-test (max 1234 1234) 1234) +(num-test (max 1234 123.4) 1234.0) +(num-test (max 1234 1234/11) 1234) +(num-test (max 123.4 1) 123.4) +(num-test (max 123.4 1.0) 123.4) +(num-test (max 123.4 1/1) 123.4) +(num-test (max 123.4 1234) 1234.0) +(num-test (max 123.4 123.4) 123.4) +(num-test (max 123.4 1234/11) 123.4) +(num-test (max 1234/11 1) 1234/11) +(num-test (max 1234/11 1.0) 112.18181818181819) +(num-test (max 1234/11 1/1) 1234/11) +(num-test (max 1234/11 1234) 1234) +(num-test (max 1234/11 123.4) 123.4) +(num-test (max 1234/11 1234/11) 1234/11) +(num-test (max 1 1 1) 1) +(num-test (max 1 1 1.0) 1.0) +(num-test (max 1 1 1/1) 1) +(num-test (max 1 1 1234) 1234) +(num-test (max 1 1 123.4) 123.4) +(num-test (max 1 1 1234/11) 1234/11) +(num-test (max 1 1.0 1) 1.0) +(num-test (max 1 1.0 1.0) 1.0) +(num-test (max 1 1.0 1/1) 1.0) +(num-test (max 1 1.0 1234) 1234.0) +(num-test (max 1 1.0 123.4) 123.4) +(num-test (max 1 1.0 1234/11) 112.18181818181819) +(num-test (max 1 1/1 1) 1) +(num-test (max 1 1/1 1.0) 1.0) +(num-test (max 1 1/1 1/1) 1) +(num-test (max 1 1/1 1234) 1234) +(num-test (max 1 1/1 123.4) 123.4) +(num-test (max 1 1/1 1234/11) 1234/11) +(num-test (max 1 1234 1) 1234) +(num-test (max 1 1234 1.0) 1234.0) +(num-test (max 1 1234 1/1) 1234) +(num-test (max 1 1234 1234) 1234) +(num-test (max 1 1234 123.4) 1234.0) +(num-test (max 1 1234 1234/11) 1234) +(num-test (max 1 123.4 1) 123.4) +(num-test (max 1 123.4 1.0) 123.4) +(num-test (max 1 123.4 1/1) 123.4) +(num-test (max 1 123.4 1234) 1234.0) +(num-test (max 1 123.4 123.4) 123.4) +(num-test (max 1 123.4 1234/11) 123.4) +(num-test (max 1 1234/11 1) 1234/11) +(num-test (max 1 1234/11 1.0) 112.18181818181819) +(num-test (max 1 1234/11 1/1) 1234/11) +(num-test (max 1 1234/11 1234) 1234) +(num-test (max 1 1234/11 123.4) 123.4) +(num-test (max 1 1234/11 1234/11) 1234/11) +(num-test (max 1.0 1 1) 1.0) +(num-test (max 1.0 1 1.0) 1.0) +(num-test (max 1.0 1 1/1) 1.0) +(num-test (max 1.0 1 1234) 1234.0) +(num-test (max 1.0 1 123.4) 123.4) +(num-test (max 1.0 1 1234/11) 112.18181818181819) +(num-test (max 1.0 1.0 1) 1.0) +(num-test (max 1.0 1.0 1.0) 1.0) +(num-test (max 1.0 1.0 1/1) 1.0) +(num-test (max 1.0 1.0 1234) 1234.0) +(num-test (max 1.0 1.0 123.4) 123.4) +(num-test (max 1.0 1.0 1234/11) 112.18181818181819) +(num-test (max 1.0 1/1 1) 1.0) +(num-test (max 1.0 1/1 1.0) 1.0) +(num-test (max 1.0 1/1 1/1) 1.0) +(num-test (max 1.0 1/1 1234) 1234.0) +(num-test (max 1.0 1/1 123.4) 123.4) +(num-test (max 1.0 1/1 1234/11) 112.18181818181819) +(num-test (max 1.0 1234 1) 1234.0) +(num-test (max 1.0 1234 1.0) 1234.0) +(num-test (max 1.0 1234 1/1) 1234.0) +(num-test (max 1.0 1234 1234) 1234.0) +(num-test (max 1.0 1234 123.4) 1234.0) +(num-test (max 1.0 1234 1234/11) 1234.0) +(num-test (max 1.0 123.4 1) 123.4) +(num-test (max 1.0 123.4 1.0) 123.4) +(num-test (max 1.0 123.4 1/1) 123.4) +(num-test (max 1.0 123.4 1234) 1234.0) +(num-test (max 1.0 123.4 123.4) 123.4) +(num-test (max 1.0 123.4 1234/11) 123.4) +(num-test (max 1.0 1234/11 1) 112.18181818181819) +(num-test (max 1.0 1234/11 1.0) 112.18181818181819) +(num-test (max 1.0 1234/11 1/1) 112.18181818181819) +(num-test (max 1.0 1234/11 1234) 1234.0) +(num-test (max 1.0 1234/11 123.4) 123.4) +(num-test (max 1.0 1234/11 1234/11) 112.18181818181819) +(num-test (max 1/1 1 1) 1) +(num-test (max 1/1 1 1.0) 1.0) +(num-test (max 1/1 1 1/1) 1) +(num-test (max 1/1 1 1234) 1234) +(num-test (max 1/1 1 123.4) 123.4) +(num-test (max 1/1 1 1234/11) 1234/11) +(num-test (max 1/1 1.0 1) 1.0) +(num-test (max 1/1 1.0 1.0) 1.0) +(num-test (max 1/1 1.0 1/1) 1.0) +(num-test (max 1/1 1.0 1234) 1234.0) +(num-test (max 1/1 1.0 123.4) 123.4) +(num-test (max 1/1 1.0 1234/11) 112.18181818181819) +(num-test (max 1/1 1/1 1) 1) +(num-test (max 1/1 1/1 1.0) 1.0) +(num-test (max 1/1 1/1 1/1) 1) +(num-test (max 1/1 1/1 1234) 1234) +(num-test (max 1/1 1/1 123.4) 123.4) +(num-test (max 1/1 1/1 1234/11) 1234/11) +(num-test (max 1/1 1234 1) 1234) +(num-test (max 1/1 1234 1.0) 1234.0) +(num-test (max 1/1 1234 1/1) 1234) +(num-test (max 1/1 1234 1234) 1234) +(num-test (max 1/1 1234 123.4) 1234.0) +(num-test (max 1/1 1234 1234/11) 1234) +(num-test (max 1/1 123.4 1) 123.4) +(num-test (max 1/1 123.4 1.0) 123.4) +(num-test (max 1/1 123.4 1/1) 123.4) +(num-test (max 1/1 123.4 1234) 1234.0) +(num-test (max 1/1 123.4 123.4) 123.4) +(num-test (max 1/1 123.4 1234/11) 123.4) +(num-test (max 1/1 1234/11 1) 1234/11) +(num-test (max 1/1 1234/11 1.0) 112.18181818181819) +(num-test (max 1/1 1234/11 1/1) 1234/11) +(num-test (max 1/1 1234/11 1234) 1234) +(num-test (max 1/1 1234/11 123.4) 123.4) +(num-test (max 1/1 1234/11 1234/11) 1234/11) +(num-test (max 0 1 1) 1) +(num-test (max 0 1 1.0) 1.0) +(num-test (max 0 1 1/1) 1) +(num-test (max 0 1 1234) 1234) +(num-test (max 0 1 123.4) 123.4) +(num-test (max 0 1 1234/11) 1234/11) +(num-test (max 0 1.0 1) 1.0) +(num-test (max 0 1.0 1.0) 1.0) +(num-test (max 0 1.0 1/1) 1.0) +(num-test (max 0 1.0 1234) 1234.0) +(num-test (max 0 1.0 123.4) 123.4) +(num-test (max 0 1.0 1234/11) 112.18181818181819) +(num-test (max 0 1/1 1) 1) +(num-test (max 0 1/1 1.0) 1.0) +(num-test (max 0 1/1 1/1) 1) +(num-test (max 0 1/1 1234) 1234) +(num-test (max 0 1/1 123.4) 123.4) +(num-test (max 0 1/1 1234/11) 1234/11) +(num-test (max 0 1234 1) 1234) +(num-test (max 0 1234 1.0) 1234.0) +(num-test (max 0 1234 1/1) 1234) +(num-test (max 0 1234 1234) 1234) +(num-test (max 0 1234 123.4) 1234.0) +(num-test (max 0 1234 1234/11) 1234) +(num-test (max 0 123.4 1) 123.4) +(num-test (max 0 123.4 1.0) 123.4) +(num-test (max 0 123.4 1/1) 123.4) +(num-test (max 0 123.4 1234) 1234.0) +(num-test (max 0 123.4 123.4) 123.4) +(num-test (max 0 123.4 1234/11) 123.4) +(num-test (max 0 1234/11 1) 1234/11) +(num-test (max 0 1234/11 1.0) 112.18181818181819) +(num-test (max 0 1234/11 1/1) 1234/11) +(num-test (max 0 1234/11 1234) 1234) +(num-test (max 0 1234/11 123.4) 123.4) +(num-test (max 0 1234/11 1234/11) 1234/11) +(num-test (max 0.0 1 1) 1.0) +(num-test (max 0.0 1 1.0) 1.0) +(num-test (max 0.0 1 1/1) 1.0) +(num-test (max 0.0 1 1234) 1234.0) +(num-test (max 0.0 1 123.4) 123.4) +(num-test (max 0.0 1 1234/11) 112.18181818181819) +(num-test (max 0.0 1.0 1) 1.0) +(num-test (max 0.0 1.0 1.0) 1.0) +(num-test (max 0.0 1.0 1/1) 1.0) +(num-test (max 0.0 1.0 1234) 1234.0) +(num-test (max 0.0 1.0 123.4) 123.4) +(num-test (max 0.0 1.0 1234/11) 112.18181818181819) +(num-test (max 0.0 1/1 1) 1.0) +(num-test (max 0.0 1/1 1.0) 1.0) +(num-test (max 0.0 1/1 1/1) 1.0) +(num-test (max 0.0 1/1 1234) 1234.0) +(num-test (max 0.0 1/1 123.4) 123.4) +(num-test (max 0.0 1/1 1234/11) 112.18181818181819) +(num-test (max 0.0 1234 1) 1234.0) +(num-test (max 0.0 1234 1.0) 1234.0) +(num-test (max 0.0 1234 1/1) 1234.0) +(num-test (max 0.0 1234 1234) 1234.0) +(num-test (max 0.0 1234 123.4) 1234.0) +(num-test (max 0.0 1234 1234/11) 1234.0) +(num-test (max 0.0 123.4 1) 123.4) +(num-test (max 0.0 123.4 1.0) 123.4) +(num-test (max 0.0 123.4 1/1) 123.4) +(num-test (max 0.0 123.4 1234) 1234.0) +(num-test (max 0.0 123.4 123.4) 123.4) +(num-test (max 0.0 123.4 1234/11) 123.4) +(num-test (max 0.0 1234/11 1) 112.18181818181819) +(num-test (max 0.0 1234/11 1.0) 112.18181818181819) +(num-test (max 0.0 1234/11 1/1) 112.18181818181819) +(num-test (max 0.0 1234/11 1234) 1234.0) +(num-test (max 0.0 1234/11 123.4) 123.4) +(num-test (max 0.0 1234/11 1234/11) 112.18181818181819) +(num-test (max 1234 1 1) 1234) +(num-test (max 1234 1 1.0) 1234.0) +(num-test (max 1234 1 1/1) 1234) +(num-test (max 1234 1 1234) 1234) +(num-test (max 1234 1 123.4) 1234.0) +(num-test (max 1234 1 1234/11) 1234) +(num-test (max 1234 1.0 1) 1234.0) +(num-test (max 1234 1.0 1.0) 1234.0) +(num-test (max 1234 1.0 1/1) 1234.0) +(num-test (max 1234 1.0 1234) 1234.0) +(num-test (max 1234 1.0 123.4) 1234.0) +(num-test (max 1234 1.0 1234/11) 1234.0) +(num-test (max 1234 1/1 1) 1234) +(num-test (max 1234 1/1 1.0) 1234.0) +(num-test (max 1234 1/1 1/1) 1234) +(num-test (max 1234 1/1 1234) 1234) +(num-test (max 1234 1/1 123.4) 1234.0) +(num-test (max 1234 1/1 1234/11) 1234) +(num-test (max 1234 1234 1) 1234) +(num-test (max 1234 1234 1.0) 1234.0) +(num-test (max 1234 1234 1/1) 1234) +(num-test (max 1234 1234 1234) 1234) +(num-test (max 1234 1234 123.4) 1234.0) +(num-test (max 1234 1234 1234/11) 1234) +(num-test (max 1234 123.4 1) 1234.0) +(num-test (max 1234 123.4 1.0) 1234.0) +(num-test (max 1234 123.4 1/1) 1234.0) +(num-test (max 1234 123.4 1234) 1234.0) +(num-test (max 1234 123.4 123.4) 1234.0) +(num-test (max 1234 123.4 1234/11) 1234.0) +(num-test (max 1234 1234/11 1) 1234) +(num-test (max 1234 1234/11 1.0) 1234.0) +(num-test (max 1234 1234/11 1/1) 1234) +(num-test (max 1234 1234/11 1234) 1234) +(num-test (max 1234 1234/11 123.4) 1234.0) +(num-test (max 1234 1234/11 1234/11) 1234) +(num-test (max 123.4 1 1) 123.4) +(num-test (max 123.4 1 1.0) 123.4) +(num-test (max 123.4 1 1/1) 123.4) +(num-test (max 123.4 1 1234) 1234.0) +(num-test (max 123.4 1 123.4) 123.4) +(num-test (max 123.4 1 1234/11) 123.4) +(num-test (max 123.4 1.0 1) 123.4) +(num-test (max 123.4 1.0 1.0) 123.4) +(num-test (max 123.4 1.0 1/1) 123.4) +(num-test (max 123.4 1.0 1234) 1234.0) +(num-test (max 123.4 1.0 123.4) 123.4) +(num-test (max 123.4 1.0 1234/11) 123.4) +(num-test (max 123.4 1/1 1) 123.4) +(num-test (max 123.4 1/1 1.0) 123.4) +(num-test (max 123.4 1/1 1/1) 123.4) +(num-test (max 123.4 1/1 1234) 1234.0) +(num-test (max 123.4 1/1 123.4) 123.4) +(num-test (max 123.4 1/1 1234/11) 123.4) +(num-test (max 123.4 1234 1) 1234.0) +(num-test (max 123.4 1234 1.0) 1234.0) +(num-test (max 123.4 1234 1/1) 1234.0) +(num-test (max 123.4 1234 1234) 1234.0) +(num-test (max 123.4 1234 123.4) 1234.0) +(num-test (max 123.4 1234 1234/11) 1234.0) +(num-test (max 123.4 123.4 1) 123.4) +(num-test (max 123.4 123.4 1.0) 123.4) +(num-test (max 123.4 123.4 1/1) 123.4) +(num-test (max 123.4 123.4 1234) 1234.0) +(num-test (max 123.4 123.4 123.4) 123.4) +(num-test (max 123.4 123.4 1234/11) 123.4) +(num-test (max 123.4 1234/11 1) 123.4) +(num-test (max 123.4 1234/11 1.0) 123.4) +(num-test (max 123.4 1234/11 1/1) 123.4) +(num-test (max 123.4 1234/11 1234) 1234.0) +(num-test (max 123.4 1234/11 123.4) 123.4) +(num-test (max 123.4 1234/11 1234/11) 123.4) +(num-test (max 1234/11 1 1) 1234/11) +(num-test (max 1234/11 1 1.0) 112.18181818181819) +(num-test (max 1234/11 1 1/1) 1234/11) +(num-test (max 1234/11 1 1234) 1234) +(num-test (max 1234/11 1 123.4) 123.4) +(num-test (max 1234/11 1 1234/11) 1234/11) +(num-test (max 1234/11 1.0 1) 112.18181818181819) +(num-test (max 1234/11 1.0 1.0) 112.18181818181819) +(num-test (max 1234/11 1.0 1/1) 112.18181818181819) +(num-test (max 1234/11 1.0 1234) 1234.0) +(num-test (max 1234/11 1.0 123.4) 123.4) +(num-test (max 1234/11 1.0 1234/11) 112.18181818181819) +(num-test (max 1234/11 1/1 1) 1234/11) +(num-test (max 1234/11 1/1 1.0) 112.18181818181819) +(num-test (max 1234/11 1/1 1/1) 1234/11) +(num-test (max 1234/11 1/1 1234) 1234) +(num-test (max 1234/11 1/1 123.4) 123.4) +(num-test (max 1234/11 1/1 1234/11) 1234/11) +(num-test (max 1234/11 1234 1) 1234) +(num-test (max 1234/11 1234 1.0) 1234.0) +(num-test (max 1234/11 1234 1/1) 1234) +(num-test (max 1234/11 1234 1234) 1234) +(num-test (max 1234/11 1234 123.4) 1234.0) +(num-test (max 1234/11 1234 1234/11) 1234) +(num-test (max 1234/11 123.4 1) 123.4) +(num-test (max 1234/11 123.4 1.0) 123.4) +(num-test (max 1234/11 123.4 1/1) 123.4) +(num-test (max 1234/11 123.4 1234) 1234.0) +(num-test (max 1234/11 123.4 123.4) 123.4) +(num-test (max 1234/11 123.4 1234/11) 123.4) +(num-test (max 1234/11 1234/11 1) 1234/11) +(num-test (max 1234/11 1234/11 1.0) 112.18181818181819) +(num-test (max 1234/11 1234/11 1/1) 1234/11) +(num-test (max 1234/11 1234/11 1234) 1234) +(num-test (max 1234/11 1234/11 123.4) 123.4) +(num-test (max 1234/11 1234/11 1234/11) 1234/11) +(num-test (max 3) 3) +(num-test (max 6 12) 12) +(num-test (max -6 -12) -6) +(num-test (max 1 3 2 -7) 3) +(num-test (max -2 3 0 7) 7) +(num-test (max 5.0 2) 5.0) +(num-test (max 3.0 7 1) 7.0) +(num-test (max 1 3 2 -7) 3) +(num-test (max 34 5 7 38 6) 38 ) + + +;; -------- = < > <= >= + - / * + +(test (= 22 22 22) #t ) +(test (= 22 22) #t ) +(test (= 34 34 35) #f ) +(test (= 34 35) #f ) +(test (> 3 -6246) #t ) +(test (> 9 9 -2424) #f ) +(test (>= 3 -4 -6246) #t ) +(test (>= 9 9) #t ) +(test (>= 8 9) #f ) +(test (< -1 2 3 4 5 6 7 8) #t ) +(test (< -1 2 3 4 4 5 6 7) #f ) +(test (<= -1 2 3 4 5 6 7 8) #t ) +(test (<= -1 2 3 4 4 5 6 7) #t ) +(test (< 1 3 2) #f ) +(test (>= 1 3 2) #f ) +(test (< 0 -0) #f) +(test (< -0 0) #f) +(test (= -0 0) #t) +(test (< 0.0 -0.0) #f) +(test (< -0.0 0.0) #f) +(test (= -0.0 0.0) #t) +(test (= 1+0i 1-0i) #t) +(test (< 1 1 2) #f) +(test (>= 1 1 2) #f) +(test (> 2 2 1) #f) +(test (<= 2 2 1) #f) + +(num-test (+ 0) 0) +(num-test (- 0) 0) +(num-test (* 0) 0) +(num-test (- 0) 0) +(num-test (* 0) 0) +(num-test (+ 2) 2) +(num-test (- 2) -2) +(num-test (* 2) 2) +(num-test (/ 2) 1/2) +(num-test (+ -2) -2) +(num-test (- -2) 2) +(num-test (* -2) -2) +(num-test (/ -2) -1/2) +(num-test (+ 10) 10) +(num-test (- 10) -10) +(num-test (* 10) 10) +(num-test (/ 10) 1/10) +(num-test (+ -10) -10) +(num-test (- -10) 10) +(num-test (* -10) -10) +(num-test (/ -10) -1/10) +(num-test (+ 1234000000) 1234000000) +(num-test (- 1234000000) -1234000000) +(num-test (* 1234000000) 1234000000) +(num-test (/ 1234000000) 1/1234000000) +(num-test (+ -1234000000) -1234000000) +(num-test (- -1234000000) 1234000000) +(num-test (* -1234000000) -1234000000) +(num-test (/ -1234000000) -1/1234000000) +(num-test (+ 362880) 362880) +(num-test (- 362880) -362880) +(num-test (* 362880) 362880) +(num-test (/ 362880) 1/362880) +(num-test (+ -362880) -362880) +(num-test (- -362880) 362880) +(num-test (* -362880) -362880) +(num-test (/ -362880) -1/362880) +(num-test (+ 0/1) 0/1) +(num-test (- 0/1) 0/1) +(num-test (* 0/1) 0/1) +(num-test (+ 0/1) 0/1) +(num-test (- 0/1) 0/1) +(num-test (* 0/1) 0/1) +(num-test (+ 2/2) 2/2) +(num-test (- 2/2) -2/2) +(num-test (* 2/2) 2/2) +(num-test (/ 2/2) 2/2) +(num-test (+ -2/2) -2/2) +(num-test (- -2/2) 2/2) +(num-test (* -2/2) -2/2) +(num-test (/ -2/2) -2/2) +(num-test (+ 10/3) 10/3) +(num-test (- 10/3) -10/3) +(num-test (* 10/3) 10/3) +(num-test (/ 10/3) 3/10) +(num-test (+ -10/3) -10/3) +(num-test (- -10/3) 10/3) +(num-test (* -10/3) -10/3) +(num-test (/ -10/3) -3/10) +(num-test (+ 1234000000/10) 1234000000/10) +(num-test (- 1234000000/10) -1234000000/10) +(num-test (* 1234000000/10) 1234000000/10) +(num-test (/ 1234000000/10) 10/1234000000) +(num-test (+ -1234000000/10) -1234000000/10) +(num-test (- -1234000000/10) 1234000000/10) +(num-test (* -1234000000/10) -1234000000/10) +(num-test (/ -1234000000/10) -10/1234000000) +(num-test (+ 362880/1234) 362880/1234) +(num-test (- 362880/1234) -362880/1234) +(num-test (* 362880/1234) 362880/1234) +(num-test (/ 362880/1234) 1234/362880) +(num-test (+ -362880/1234) -362880/1234) +(num-test (- -362880/1234) 362880/1234) +(num-test (* -362880/1234) -362880/1234) +(num-test (/ -362880/1234) -1234/362880) +(num-test (+ 0.0) 0.0) +(num-test (- 0.0) -0.0) +(num-test (* 0.0) 0.0) +(num-test (+ -0.0) -0.0) +(num-test (- -0.0) 0.0) +(num-test (* -0.0) -0.0) +(num-test (+ 1.0) 1.0) +(num-test (- 1.0) -1.0) +(num-test (* 1.0) 1.0) +(num-test (/ 1.0) 1.0) +(num-test (+ -1.0) -1.0) +(num-test (- -1.0) 1.0) +(num-test (* -1.0) -1.0) +(num-test (/ -1.0) -1.0) +(num-test (+ 2.71828182845905) 2.71828182845905) +(num-test (- 2.71828182845905) -2.71828182845905) +(num-test (* 2.71828182845905) 2.71828182845905) +(num-test (/ 2.71828182845905) 0.36787944117144) +(num-test (+ -2.71828182845905) -2.71828182845905) +(num-test (- -2.71828182845905) 2.71828182845905) +(num-test (* -2.71828182845905) -2.71828182845905) +(num-test (/ -2.71828182845905) -0.36787944117144) +(num-test (+ 1234000000.0) 1234000000.0) +(num-test (- 1234000000.0) -1234000000.0) +(num-test (* 1234000000.0) 1234000000.0) +(num-test (/ 1234000000.0) 0.00000000081037) +(num-test (+ -1234000000.0) -1234000000.0) +(num-test (- -1234000000.0) 1234000000.0) +(num-test (* -1234000000.0) -1234000000.0) +(num-test (/ -1234000000.0) -0.00000000081037) +(num-test (+ 0.0+0.00000001i) 0.0+0.00000001i) +(num-test (- 0.0+0.00000001i) -0.0-0.00000001i) +(num-test (- 0.0-0.00000001i) -0.0+0.00000001i) +(num-test (* 0.0+0.00000001i) 0.0+0.00000001i) +(num-test (/ 0.0+0.00000001i) 0.0-100000000.0i) +(num-test (+ -0.0+0.00000001i) -0.0+0.00000001i) +(num-test (- -0.0+0.00000001i) 0.0-0.00000001i) +(num-test (* -0.0+0.00000001i) -0.0+0.00000001i) +(num-test (/ -0.0+0.00000001i) 0.0-100000000.0i) +(num-test (+ 1.0+1.0i) 1.0+1.0i) +(num-test (- 1.0+1.0i) -1.0-1.0i) +(num-test (* 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1.0+1.0i) 0.5-0.5i) +(num-test (+ -1.0+1.0i) -1.0+1.0i) +(num-test (- -1.0+1.0i) 1.0-1.0i) +(num-test (* -1.0+1.0i) -1.0+1.0i) +(num-test (/ -1.0+1.0i) -0.5-0.5i) +(num-test (+ 2.71828182845905+3.14159265358979i) 2.71828182845905+3.14159265358979i) +(num-test (+ 2.71828182845905-3.14159265358979i) 2.71828182845905-3.14159265358979i) +(num-test (- 2.71828182845905+3.14159265358979i) -2.71828182845905-3.14159265358979i) +(num-test (- 2.71828182845905-3.14159265358979i) -2.71828182845905+3.14159265358979i) +(num-test (* 2.71828182845905+3.14159265358979i) 2.71828182845905+3.14159265358979i) +(num-test (/ 2.71828182845905+3.14159265358979i) 0.15750247989732-0.18202992367723i) +(num-test (+ -2.71828182845905+3.14159265358979i) -2.71828182845905+3.14159265358979i) +(num-test (- -2.71828182845905+3.14159265358979i) 2.71828182845905-3.14159265358979i) +(num-test (- -2.71828182845905-3.14159265358979i) 2.71828182845905+3.14159265358979i) +(num-test (* -2.71828182845905+3.14159265358979i) -2.71828182845905+3.14159265358979i) +(num-test (/ -2.71828182845905+3.14159265358979i) -0.15750247989732-0.18202992367723i) +(num-test (+ 1234000000.0+2.71828182845905i) 1234000000.0+2.71828182845905i) +(num-test (+ 1234000000.0-2.71828182845905i) 1234000000.0-2.71828182845905i) +(num-test (- 1234000000.0+2.71828182845905i) -1234000000.0-2.71828182845905i) +(num-test (- 1234000000.0-2.71828182845905i) -1234000000.0+2.71828182845905i) +(num-test (* 1234000000.0+2.71828182845905i) 1234000000.0+2.71828182845905i) +(num-test (/ 1234000000.0+2.71828182845905i) 0.00000000081037-0.0i) +(num-test (+ -1234000000.0+2.71828182845905i) -1234000000.0+2.71828182845905i) +(num-test (- -1234000000.0+2.71828182845905i) 1234000000.0-2.71828182845905i) +(num-test (* -1234000000.0+2.71828182845905i) -1234000000.0+2.71828182845905i) +(num-test (/ -1234000000.0+2.71828182845905i) -0.00000000081037-0.0i) + +(num-test (+ 1 1) 2) +(num-test (- 1 1) 0) +(num-test (* 1 1) 1) +(num-test (/ 1 1) 1) +(num-test (= 1 1) #t) +(num-test (< 1 1) #f) +(num-test (<= 1 1) #t) +(num-test (> 1 1) #f) +(num-test (>= 1 1) #t) +(num-test (+ 1 1.0) 2.0) +(num-test (- 1 1.0) 0.0) +(num-test (* 1 1.0) 1.0) +(num-test (/ 1 1.0) 1.0) +(num-test (= 1 1.0) #t) +(num-test (< 1 1.0) #f) +(num-test (<= 1 1.0) #t) +(num-test (> 1 1.0) #f) +(num-test (>= 1 1.0) #t) +(num-test (+ 1 1/1) 2) +(num-test (- 1 1/1) 0) +(num-test (* 1 1/1) 1) +(num-test (/ 1 1/1) 1) +(num-test (= 1 1/1) #t) +(num-test (< 1 1/1) #f) +(num-test (<= 1 1/1) #t) +(num-test (> 1 1/1) #f) +(num-test (>= 1 1/1) #t) +(num-test (+ 1 1.0+1.0i) 2.0+1.0i) +(num-test (- 1 1.0+1.0i) 0.0-1.0i) +(num-test (* 1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1 1.0+1.0i) #f) +(num-test (+ 1 0) 1) +(num-test (- 1 0) 1) +(num-test (* 1 0) 0) +(num-test (+ 1 0.0) 1.0) +(num-test (- 1 0.0) 1.0) +(num-test (* 1 0.0) 0.0) +(num-test (+ 1 1234) 1235) +(num-test (- 1 1234) -1233) +(num-test (* 1 1234) 1234) +(num-test (/ 1 1234) 1/1234) +(num-test (= 1 1234) #f) +(num-test (< 1 1234) #t) +(num-test (<= 1 1234) #t) +(num-test (> 1 1234) #f) +(num-test (>= 1 1234) #f) +(num-test (+ 1 123.4) 124.4) +(num-test (- 1 123.4) -122.4) +(num-test (* 1 123.4) 123.4) +(num-test (/ 1 123.4) 0.00810372771475) +(num-test (= 1 123.4) #f) +(num-test (< 1 123.4) #t) +(num-test (<= 1 123.4) #t) +(num-test (> 1 123.4) #f) +(num-test (>= 1 123.4) #f) +(num-test (+ 1 1234/11) 1245/11) +(num-test (- 1 1234/11) -1223/11) +(num-test (* 1 1234/11) 1234/11) +(num-test (/ 1 1234/11) 11/1234) +(num-test (= 1 1234/11) #f) +(num-test (< 1 1234/11) #t) +(num-test (<= 1 1234/11) #t) +(num-test (> 1 1234/11) #f) +(num-test (>= 1 1234/11) #f) +(num-test (+ 1 1.234+1.234i) 2.234+1.234i) +(num-test (- 1 1.234+1.234i) -0.234-1.234i) +(num-test (* 1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1.234+1.234i) #f) +(num-test (+ 1 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1 -1.0+1.0i) #f) +(num-test (+ 1 0.0+1.0i) 1.0+1.0i) +(num-test (- 1 0.0+1.0i) 1.0-1.0i) +(num-test (* 1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1 0.0+1.0i) #f) +(num-test (+ 1.0 1) 2.0) +(num-test (- 1.0 1) 0.0) +(num-test (* 1.0 1) 1.0) +(num-test (/ 1.0 1) 1.0) +(num-test (= 1.0 1) #t) +(num-test (< 1.0 1) #f) +(num-test (<= 1.0 1) #t) +(num-test (> 1.0 1) #f) +(num-test (>= 1.0 1) #t) +(num-test (+ 1.0 1.0) 2.0) +(num-test (- 1.0 1.0) 0.0) +(num-test (* 1.0 1.0) 1.0) +(num-test (/ 1.0 1.0) 1.0) +(num-test (= 1.0 1.0) #t) +(num-test (< 1.0 1.0) #f) +(num-test (<= 1.0 1.0) #t) +(num-test (> 1.0 1.0) #f) +(num-test (>= 1.0 1.0) #t) +(num-test (+ 1.0 1/1) 2.0) +(num-test (- 1.0 1/1) 0.0) +(num-test (* 1.0 1/1) 1.0) +(num-test (/ 1.0 1/1) 1.0) +(num-test (= 1.0 1/1) #t) +(num-test (< 1.0 1/1) #f) +(num-test (<= 1.0 1/1) #t) +(num-test (> 1.0 1/1) #f) +(num-test (>= 1.0 1/1) #t) +(num-test (+ 1.0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1.0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1.0 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1.0 1.0+1.0i) 0.5-0.5i) +(num-test (= 1.0 1.0+1.0i) #f) +(num-test (+ 1.0 0) 1.0) +(num-test (- 1.0 0) 1.0) +(num-test (* 1.0 0) 0.0) +(num-test (+ 1.0 0.0) 1.0) +(num-test (- 1.0 0.0) 1.0) +(num-test (* 1.0 0.0) 0.0) +(num-test (+ 1.0 1234) 1235.0) +(num-test (- 1.0 1234) -1233.0) +(num-test (* 1.0 1234) 1234.0) +(num-test (/ 1.0 1234) 0.00081037277147) +(num-test (= 1.0 1234) #f) +(num-test (< 1.0 1234) #t) +(num-test (<= 1.0 1234) #t) +(num-test (> 1.0 1234) #f) +(num-test (>= 1.0 1234) #f) +(num-test (+ 1.0 123.4) 124.4) +(num-test (- 1.0 123.4) -122.4) +(num-test (* 1.0 123.4) 123.4) +(num-test (/ 1.0 123.4) 0.00810372771475) +(num-test (= 1.0 123.4) #f) +(num-test (< 1.0 123.4) #t) +(num-test (<= 1.0 123.4) #t) +(num-test (> 1.0 123.4) #f) +(num-test (>= 1.0 123.4) #f) +(num-test (+ 1.0 1234/11) 113.18181818181819) +(num-test (- 1.0 1234/11) -111.18181818181819) +(num-test (* 1.0 1234/11) 112.18181818181819) +(num-test (/ 1.0 1234/11) 0.00891410048622) +(num-test (= 1.0 1234/11) #f) +(num-test (< 1.0 1234/11) #t) +(num-test (<= 1.0 1234/11) #t) +(num-test (> 1.0 1234/11) #f) +(num-test (>= 1.0 1234/11) #f) +(num-test (+ 1.0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1.0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1.0 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1.234+1.234i) #f) +(num-test (+ 1.0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1.0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1.0 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0 -1.0+1.0i) #f) +(num-test (+ 1.0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1.0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1.0 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (= 1.0 0.0+1.0i) #f) +(num-test (+ 1/1 1) 2) +(num-test (- 1/1 1) 0) +(num-test (* 1/1 1) 1) +(num-test (/ 1/1 1) 1) +(num-test (= 1/1 1) #t) +(num-test (< 1/1 1) #f) +(num-test (<= 1/1 1) #t) +(num-test (> 1/1 1) #f) +(num-test (>= 1/1 1) #t) +(num-test (+ 1/1 1.0) 2.0) +(num-test (- 1/1 1.0) 0.0) +(num-test (* 1/1 1.0) 1.0) +(num-test (/ 1/1 1.0) 1.0) +(num-test (= 1/1 1.0) #t) +(num-test (< 1/1 1.0) #f) +(num-test (<= 1/1 1.0) #t) +(num-test (> 1/1 1.0) #f) +(num-test (>= 1/1 1.0) #t) +(num-test (+ 1/1 1/1) 2) +(num-test (- 1/1 1/1) 0) +(num-test (* 1/1 1/1) 1) +(num-test (/ 1/1 1/1) 1) +(num-test (= 1/1 1/1) #t) +(num-test (< 1/1 1/1) #f) +(num-test (<= 1/1 1/1) #t) +(num-test (> 1/1 1/1) #f) +(num-test (>= 1/1 1/1) #t) +(num-test (+ 1/1 1.0+1.0i) 2.0+1.0i) +(num-test (- 1/1 1.0+1.0i) 0.0-1.0i) +(num-test (* 1/1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1/1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1/1 1.0+1.0i) #f) +(num-test (+ 1/1 0) 1) +(num-test (- 1/1 0) 1) +(num-test (* 1/1 0) 0) +(num-test (+ 1/1 0.0) 1.0) +(num-test (- 1/1 0.0) 1.0) +(num-test (* 1/1 0.0) 0.0) +(num-test (+ 1/1 1234) 1235) +(num-test (- 1/1 1234) -1233) +(num-test (* 1/1 1234) 1234) +(num-test (/ 1/1 1234) 1/1234) +(num-test (= 1/1 1234) #f) +(num-test (< 1/1 1234) #t) +(num-test (<= 1/1 1234) #t) +(num-test (> 1/1 1234) #f) +(num-test (>= 1/1 1234) #f) +(num-test (+ 1/1 123.4) 124.4) +(num-test (- 1/1 123.4) -122.4) +(num-test (* 1/1 123.4) 123.4) +(num-test (/ 1/1 123.4) 0.00810372771475) +(num-test (= 1/1 123.4) #f) +(num-test (< 1/1 123.4) #t) +(num-test (<= 1/1 123.4) #t) +(num-test (> 1/1 123.4) #f) +(num-test (>= 1/1 123.4) #f) +(num-test (+ 1/1 1234/11) 1245/11) +(num-test (- 1/1 1234/11) -1223/11) +(num-test (* 1/1 1234/11) 1234/11) +(num-test (/ 1/1 1234/11) 11/1234) +(num-test (= 1/1 1234/11) #f) +(num-test (< 1/1 1234/11) #t) +(num-test (<= 1/1 1234/11) #t) +(num-test (> 1/1 1234/11) #f) +(num-test (>= 1/1 1234/11) #f) +(num-test (+ 1/1 1.234+1.234i) 2.234+1.234i) +(num-test (- 1/1 1.234+1.234i) -0.234-1.234i) +(num-test (* 1/1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1.234+1.234i) #f) +(num-test (+ 1/1 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1/1 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1/1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1/1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1/1 -1.0+1.0i) #f) +(num-test (+ 1/1 0.0+1.0i) 1.0+1.0i) +(num-test (- 1/1 0.0+1.0i) 1.0-1.0i) +(num-test (* 1/1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1/1 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1) 2.0+1.0i) +(num-test (- 1.0+1.0i 1) 0.0+1.0i) +(num-test (* 1.0+1.0i 1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1) #f) +(num-test (+ 1.0+1.0i 1.0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1.0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1.0) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1.0) 1.0+1.0i) +(num-test (= 1.0+1.0i 1.0) #f) +(num-test (+ 1.0+1.0i 1/1) 2.0+1.0i) +(num-test (- 1.0+1.0i 1/1) 0.0+1.0i) +(num-test (* 1.0+1.0i 1/1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1/1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1/1) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i) 2.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i) 0.0) +(num-test (* 1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i) 1.0) +(num-test (= 1.0+1.0i 1.0+1.0i) #t) +(num-test (+ 1.0+1.0i 0) 1.0+1.0i) +(num-test (- 1.0+1.0i 0) 1.0+1.0i) +(num-test (* 1.0+1.0i 0) 0.0) +(num-test (+ 1.0+1.0i 0.0) 1.0+1.0i) +(num-test (- 1.0+1.0i 0.0) 1.0+1.0i) +(num-test (* 1.0+1.0i 0.0) 0.0) +(num-test (+ 1.0+1.0i 1234) 1235.0+1.0i) +(num-test (- 1.0+1.0i 1234) -1233.0+1.0i) +(num-test (* 1.0+1.0i 1234) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1234) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1234) #f) +(num-test (+ 1.0+1.0i 123.4) 124.4+1.0i) +(num-test (- 1.0+1.0i 123.4) -122.4+1.0i) +(num-test (* 1.0+1.0i 123.4) 123.4+123.4i) +(num-test (/ 1.0+1.0i 123.4) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 123.4) #f) +(num-test (+ 1.0+1.0i 1234/11) 113.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11) -111.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1234/11) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1234/11) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i) 2.234+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i) -0.234-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1.234+1.234i) 0.81037277147488) +(num-test (= 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i) 0.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i) 2.0) +(num-test (* 1.0+1.0i -1.0+1.0i) -2.0) +(num-test (/ 1.0+1.0i -1.0+1.0i) -0.0-1.0i) +(num-test (= 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i) 1.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i) 1.0) +(num-test (* 1.0+1.0i 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i) 1.0-1.0i) +(num-test (= 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0 1) 1) +(num-test (- 0 1) -1) +(num-test (* 0 1) 0) +(num-test (/ 0 1) 0) +(num-test (= 0 1) #f) +(num-test (< 0 1) #t) +(num-test (<= 0 1) #t) +(num-test (> 0 1) #f) +(num-test (>= 0 1) #f) +(num-test (+ 0 1.0) 1.0) +(num-test (- 0 1.0) -1.0) +(num-test (* 0 1.0) 0.0) +(num-test (/ 0 1.0) 0.0) +(num-test (= 0 1.0) #f) +(num-test (< 0 1.0) #t) +(num-test (<= 0 1.0) #t) +(num-test (> 0 1.0) #f) +(num-test (>= 0 1.0) #f) +(num-test (+ 0 1/1) 1) +(num-test (- 0 1/1) -1) +(num-test (* 0 1/1) 0) +(num-test (/ 0 1/1) 0) +(num-test (= 0 1/1) #f) +(num-test (< 0 1/1) #t) +(num-test (<= 0 1/1) #t) +(num-test (> 0 1/1) #f) +(num-test (>= 0 1/1) #f) +(num-test (+ 0 1.0+1.0i) 1.0+1.0i) +(num-test (- 0 1.0+1.0i) -1.0-1.0i) +(num-test (* 0 1.0+1.0i) 0.0) +(num-test (/ 0 1.0+1.0i) 0.0) +(num-test (= 0 1.0+1.0i) #f) +(num-test (+ 0 0) 0) +(num-test (- 0 0) 0) +(num-test (* 0 0) 0) +(num-test (+ 0 0.0) 0.0) +(num-test (- 0 0.0) 0.0) +(num-test (* 0 0.0) 0.0) +(num-test (+ 0 1234) 1234) +(num-test (- 0 1234) -1234) +(num-test (* 0 1234) 0) +(num-test (/ 0 1234) 0) +(num-test (= 0 1234) #f) +(num-test (< 0 1234) #t) +(num-test (<= 0 1234) #t) +(num-test (> 0 1234) #f) +(num-test (>= 0 1234) #f) +(num-test (+ 0 123.4) 123.4) +(num-test (- 0 123.4) -123.4) +(num-test (* 0 123.4) 0.0) +(num-test (/ 0 123.4) 0.0) +(num-test (= 0 123.4) #f) +(num-test (< 0 123.4) #t) +(num-test (<= 0 123.4) #t) +(num-test (> 0 123.4) #f) +(num-test (>= 0 123.4) #f) +(num-test (+ 0 1234/11) 1234/11) +(num-test (- 0 1234/11) -1234/11) +(num-test (* 0 1234/11) 0) +(num-test (/ 0 1234/11) 0) +(num-test (= 0 1234/11) #f) +(num-test (< 0 1234/11) #t) +(num-test (<= 0 1234/11) #t) +(num-test (> 0 1234/11) #f) +(num-test (>= 0 1234/11) #f) +(num-test (+ 0 1.234+1.234i) 1.234+1.234i) +(num-test (- 0 1.234+1.234i) -1.234-1.234i) +(num-test (* 0 1.234+1.234i) 0.0) +(num-test (/ 0 1.234+1.234i) 0.0) +(num-test (= 0 1.234+1.234i) #f) +(num-test (+ 0 -1.0+1.0i) -1.0+1.0i) +(num-test (- 0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 0 -1.0+1.0i) -0.0) +(num-test (/ 0 -1.0+1.0i) -0.0) +(num-test (= 0 -1.0+1.0i) #f) +(num-test (+ 0 0.0+1.0i) 0.0+1.0i) +(num-test (- 0 0.0+1.0i) 0.0-1.0i) +(num-test (* 0 0.0+1.0i) 0.0) +(num-test (/ 0 0.0+1.0i) 0.0) +(num-test (= 0 0.0+1.0i) #f) +(num-test (+ 0.0 1) 1.0) +(num-test (- 0.0 1) -1.0) +(num-test (* 0.0 1) 0.0) +(num-test (/ 0.0 1) 0.0) +(num-test (= 0.0 1) #f) +(num-test (< 0.0 1) #t) +(num-test (<= 0.0 1) #t) +(num-test (> 0.0 1) #f) +(num-test (>= 0.0 1) #f) +(num-test (+ 0.0 1.0) 1.0) +(num-test (- 0.0 1.0) -1.0) +(num-test (* 0.0 1.0) 0.0) +(num-test (/ 0.0 1.0) 0.0) +(num-test (= 0.0 1.0) #f) +(num-test (< 0.0 1.0) #t) +(num-test (<= 0.0 1.0) #t) +(num-test (> 0.0 1.0) #f) +(num-test (>= 0.0 1.0) #f) +(num-test (+ 0.0 1/1) 1.0) +(num-test (- 0.0 1/1) -1.0) +(num-test (* 0.0 1/1) 0.0) +(num-test (/ 0.0 1/1) 0.0) +(num-test (= 0.0 1/1) #f) +(num-test (< 0.0 1/1) #t) +(num-test (<= 0.0 1/1) #t) +(num-test (> 0.0 1/1) #f) +(num-test (>= 0.0 1/1) #f) +(num-test (+ 0.0 1.0+1.0i) 1.0+1.0i) +(num-test (- 0.0 1.0+1.0i) -1.0-1.0i) +(num-test (* 0.0 1.0+1.0i) 0.0) +(num-test (/ 0.0 1.0+1.0i) 0.0) +(num-test (= 0.0 1.0+1.0i) #f) +(num-test (+ 0.0 0) 0.0) +(num-test (- 0.0 0) 0.0) +(num-test (* 0.0 0) 0.0) +(num-test (+ 0.0 0.0) 0.0) +(num-test (- 0.0 0.0) 0.0) +(num-test (* 0.0 0.0) 0.0) +(num-test (+ 0.0 1234) 1234.0) +(num-test (- 0.0 1234) -1234.0) +(num-test (* 0.0 1234) 0.0) +(num-test (/ 0.0 1234) 0.0) +(num-test (= 0.0 1234) #f) +(num-test (< 0.0 1234) #t) +(num-test (<= 0.0 1234) #t) +(num-test (> 0.0 1234) #f) +(num-test (>= 0.0 1234) #f) +(num-test (+ 0.0 123.4) 123.4) +(num-test (- 0.0 123.4) -123.4) +(num-test (* 0.0 123.4) 0.0) +(num-test (/ 0.0 123.4) 0.0) +(num-test (= 0.0 123.4) #f) +(num-test (< 0.0 123.4) #t) +(num-test (<= 0.0 123.4) #t) +(num-test (> 0.0 123.4) #f) +(num-test (>= 0.0 123.4) #f) +(num-test (+ 0.0 1234/11) 112.18181818181819) +(num-test (- 0.0 1234/11) -112.18181818181819) +(num-test (* 0.0 1234/11) 0.0) +(num-test (/ 0.0 1234/11) 0.0) +(num-test (= 0.0 1234/11) #f) +(num-test (< 0.0 1234/11) #t) +(num-test (<= 0.0 1234/11) #t) +(num-test (> 0.0 1234/11) #f) +(num-test (>= 0.0 1234/11) #f) +(num-test (+ 0.0 1.234+1.234i) 1.234+1.234i) +(num-test (- 0.0 1.234+1.234i) -1.234-1.234i) +(num-test (* 0.0 1.234+1.234i) 0.0) +(num-test (/ 0.0 1.234+1.234i) 0.0) +(num-test (= 0.0 1.234+1.234i) #f) +(num-test (+ 0.0 -1.0+1.0i) -1.0+1.0i) +(num-test (- 0.0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 0.0 -1.0+1.0i) -0.0) +(num-test (/ 0.0 -1.0+1.0i) -0.0) +(num-test (= 0.0 -1.0+1.0i) #f) +(num-test (+ 0.0 0.0+1.0i) 0.0+1.0i) +(num-test (- 0.0 0.0+1.0i) 0.0-1.0i) +(num-test (* 0.0 0.0+1.0i) 0.0) +(num-test (/ 0.0 0.0+1.0i) 0.0) +(num-test (= 0.0 0.0+1.0i) #f) +(num-test (+ 1234 1) 1235) +(num-test (- 1234 1) 1233) +(num-test (* 1234 1) 1234) +(num-test (/ 1234 1) 1234) +(num-test (= 1234 1) #f) +(num-test (< 1234 1) #f) +(num-test (<= 1234 1) #f) +(num-test (> 1234 1) #t) +(num-test (>= 1234 1) #t) +(num-test (+ 1234 1.0) 1235.0) +(num-test (- 1234 1.0) 1233.0) +(num-test (* 1234 1.0) 1234.0) +(num-test (/ 1234 1.0) 1234.0) +(num-test (= 1234 1.0) #f) +(num-test (< 1234 1.0) #f) +(num-test (<= 1234 1.0) #f) +(num-test (> 1234 1.0) #t) +(num-test (>= 1234 1.0) #t) +(num-test (+ 1234 1/1) 1235) +(num-test (- 1234 1/1) 1233) +(num-test (* 1234 1/1) 1234) +(num-test (/ 1234 1/1) 1234) +(num-test (= 1234 1/1) #f) +(num-test (< 1234 1/1) #f) +(num-test (<= 1234 1/1) #f) +(num-test (> 1234 1/1) #t) +(num-test (>= 1234 1/1) #t) +(num-test (+ 1234 1.0+1.0i) 1235.0+1.0i) +(num-test (- 1234 1.0+1.0i) 1233.0-1.0i) +(num-test (* 1234 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1234 1.0+1.0i) 617.0-617.0i) +(num-test (= 1234 1.0+1.0i) #f) +(num-test (+ 1234 0) 1234) +(num-test (- 1234 0) 1234) +(num-test (* 1234 0) 0) +(num-test (+ 1234 0.0) 1234.0) +(num-test (- 1234 0.0) 1234.0) +(num-test (* 1234 0.0) 0.0) +(num-test (+ 1234 1234) 2468) +(num-test (- 1234 1234) 0) +(num-test (* 1234 1234) 1522756) +(num-test (/ 1234 1234) 1) +(num-test (= 1234 1234) #t) +(num-test (< 1234 1234) #f) +(num-test (<= 1234 1234) #t) +(num-test (> 1234 1234) #f) +(num-test (>= 1234 1234) #t) +(num-test (+ 1234 123.4) 1357.4) +(num-test (- 1234 123.4) 1110.59999999999991) +(num-test (* 1234 123.4) 152275.60000000000582) +(num-test (/ 1234 123.4) 10.0) +(num-test (= 1234 123.4) #f) +(num-test (< 1234 123.4) #f) +(num-test (<= 1234 123.4) #f) +(num-test (> 1234 123.4) #t) +(num-test (>= 1234 123.4) #t) +(num-test (+ 1234 1234/11) 14808/11) +(num-test (- 1234 1234/11) 12340/11) +(num-test (* 1234 1234/11) 1522756/11) +(num-test (/ 1234 1234/11) 11) +(num-test (= 1234 1234/11) #f) +(num-test (< 1234 1234/11) #f) +(num-test (<= 1234 1234/11) #f) +(num-test (> 1234 1234/11) #t) +(num-test (>= 1234 1234/11) #t) +(num-test (+ 1234 1.234+1.234i) 1235.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i) 1232.766-1.234i) +(num-test (* 1234 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1234 1.234+1.234i) 500.0-500.0i) +(num-test (= 1234 1.234+1.234i) #f) +(num-test (+ 1234 -1.0+1.0i) 1233.0+1.0i) +(num-test (- 1234 -1.0+1.0i) 1235.0-1.0i) +(num-test (* 1234 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1234 -1.0+1.0i) -617.0-617.0i) +(num-test (= 1234 -1.0+1.0i) #f) +(num-test (+ 1234 0.0+1.0i) 1234.0+1.0i) +(num-test (- 1234 0.0+1.0i) 1234.0-1.0i) +(num-test (* 1234 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1234 0.0+1.0i) 0.0-1234.0i) +(num-test (= 1234 0.0+1.0i) #f) +(num-test (+ 123.4 1) 124.4) +(num-test (- 123.4 1) 122.4) +(num-test (* 123.4 1) 123.4) +(num-test (/ 123.4 1) 123.4) +(num-test (= 123.4 1) #f) +(num-test (< 123.4 1) #f) +(num-test (<= 123.4 1) #f) +(num-test (> 123.4 1) #t) +(num-test (>= 123.4 1) #t) +(num-test (+ 123.4 1.0) 124.4) +(num-test (- 123.4 1.0) 122.4) +(num-test (* 123.4 1.0) 123.4) +(num-test (/ 123.4 1.0) 123.4) +(num-test (= 123.4 1.0) #f) +(num-test (< 123.4 1.0) #f) +(num-test (<= 123.4 1.0) #f) +(num-test (> 123.4 1.0) #t) +(num-test (>= 123.4 1.0) #t) +(num-test (+ 123.4 1/1) 124.4) +(num-test (- 123.4 1/1) 122.4) +(num-test (* 123.4 1/1) 123.4) +(num-test (/ 123.4 1/1) 123.4) +(num-test (= 123.4 1/1) #f) +(num-test (< 123.4 1/1) #f) +(num-test (<= 123.4 1/1) #f) +(num-test (> 123.4 1/1) #t) +(num-test (>= 123.4 1/1) #t) +(num-test (+ 123.4 1.0+1.0i) 124.4+1.0i) +(num-test (- 123.4 1.0+1.0i) 122.4-1.0i) +(num-test (* 123.4 1.0+1.0i) 123.4+123.4i) +(num-test (/ 123.4 1.0+1.0i) 61.7-61.7i) +(num-test (= 123.4 1.0+1.0i) #f) +(num-test (+ 123.4 0) 123.4) +(num-test (- 123.4 0) 123.4) +(num-test (* 123.4 0) 0.0) +(num-test (+ 123.4 0.0) 123.4) +(num-test (- 123.4 0.0) 123.4) +(num-test (* 123.4 0.0) 0.0) +(num-test (+ 123.4 1234) 1357.4) +(num-test (- 123.4 1234) -1110.59999999999991) +(num-test (* 123.4 1234) 152275.60000000000582) +(num-test (/ 123.4 1234) 0.1) +(num-test (= 123.4 1234) #f) +(num-test (< 123.4 1234) #t) +(num-test (<= 123.4 1234) #t) +(num-test (> 123.4 1234) #f) +(num-test (>= 123.4 1234) #f) +(num-test (+ 123.4 123.4) 246.8) +(num-test (- 123.4 123.4) 0.0) +(num-test (* 123.4 123.4) 15227.56000000000131) +(num-test (/ 123.4 123.4) 1.0) +(num-test (= 123.4 123.4) #t) +(num-test (< 123.4 123.4) #f) +(num-test (<= 123.4 123.4) #t) +(num-test (> 123.4 123.4) #f) +(num-test (>= 123.4 123.4) #t) +(num-test (+ 123.4 1234/11) 235.58181818181819) +(num-test (- 123.4 1234/11) 11.21818181818182) +(num-test (* 123.4 1234/11) 13843.23636363636433) +(num-test (/ 123.4 1234/11) 1.10000000000000) +(num-test (= 123.4 1234/11) #f) +(num-test (< 123.4 1234/11) #f) +(num-test (<= 123.4 1234/11) #f) +(num-test (> 123.4 1234/11) #t) +(num-test (>= 123.4 1234/11) #t) +(num-test (+ 123.4 1.234+1.234i) 124.634+1.234i) +(num-test (- 123.4 1.234+1.234i) 122.16600000000001-1.234i) +(num-test (* 123.4 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 123.4 1.234+1.234i) 50.0-50.0i) +(num-test (= 123.4 1.234+1.234i) #f) +(num-test (+ 123.4 -1.0+1.0i) 122.4+1.0i) +(num-test (- 123.4 -1.0+1.0i) 124.4-1.0i) +(num-test (* 123.4 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 123.4 -1.0+1.0i) -61.7-61.7i) +(num-test (= 123.4 -1.0+1.0i) #f) +(num-test (+ 123.4 0.0+1.0i) 123.4+1.0i) +(num-test (- 123.4 0.0+1.0i) 123.4-1.0i) +(num-test (* 123.4 0.0+1.0i) 0.0+123.4i) +(num-test (/ 123.4 0.0+1.0i) 0.0-123.4i) +(num-test (= 123.4 0.0+1.0i) #f) +(num-test (+ 1234/11 1) 1245/11) +(num-test (- 1234/11 1) 1223/11) +(num-test (* 1234/11 1) 1234/11) +(num-test (/ 1234/11 1) 1234/11) +(num-test (= 1234/11 1) #f) +(num-test (< 1234/11 1) #f) +(num-test (<= 1234/11 1) #f) +(num-test (> 1234/11 1) #t) +(num-test (>= 1234/11 1) #t) +(num-test (+ 1234/11 1.0) 113.18181818181819) +(num-test (- 1234/11 1.0) 111.18181818181819) +(num-test (* 1234/11 1.0) 112.18181818181819) +(num-test (/ 1234/11 1.0) 112.18181818181819) +(num-test (= 1234/11 1.0) #f) +(num-test (< 1234/11 1.0) #f) +(num-test (<= 1234/11 1.0) #f) +(num-test (> 1234/11 1.0) #t) +(num-test (>= 1234/11 1.0) #t) +(num-test (+ 1234/11 1/1) 1245/11) +(num-test (- 1234/11 1/1) 1223/11) +(num-test (* 1234/11 1/1) 1234/11) +(num-test (/ 1234/11 1/1) 1234/11) +(num-test (= 1234/11 1/1) #f) +(num-test (< 1234/11 1/1) #f) +(num-test (<= 1234/11 1/1) #f) +(num-test (> 1234/11 1/1) #t) +(num-test (>= 1234/11 1/1) #t) +(num-test (+ 1234/11 1.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i) 111.18181818181819-1.0i) +(num-test (* 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0+1.0i) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0+1.0i) #f) +(num-test (+ 1234/11 0) 1234/11) +(num-test (- 1234/11 0) 1234/11) +(num-test (* 1234/11 0) 0) +(num-test (+ 1234/11 0.0) 112.18181818181819) +(num-test (- 1234/11 0.0) 112.18181818181819) +(num-test (* 1234/11 0.0) 0.0) +(num-test (+ 1234/11 1234) 14808/11) +(num-test (- 1234/11 1234) -12340/11) +(num-test (* 1234/11 1234) 1522756/11) +(num-test (/ 1234/11 1234) 1/11) +(num-test (= 1234/11 1234) #f) +(num-test (< 1234/11 1234) #t) +(num-test (<= 1234/11 1234) #t) +(num-test (> 1234/11 1234) #f) +(num-test (>= 1234/11 1234) #f) +(num-test (+ 1234/11 123.4) 235.58181818181819) +(num-test (- 1234/11 123.4) -11.21818181818182) +(num-test (* 1234/11 123.4) 13843.23636363636433) +(num-test (/ 1234/11 123.4) 0.90909090909091) +(num-test (= 1234/11 123.4) #f) +(num-test (< 1234/11 123.4) #t) +(num-test (<= 1234/11 123.4) #t) +(num-test (> 1234/11 123.4) #f) +(num-test (>= 1234/11 123.4) #f) +(num-test (+ 1234/11 1234/11) 2468/11) +(num-test (- 1234/11 1234/11) 0) +(num-test (* 1234/11 1234/11) 1522756/121) +(num-test (/ 1234/11 1234/11) 1) +(num-test (= 1234/11 1234/11) #t) +(num-test (< 1234/11 1234/11) #f) +(num-test (<= 1234/11 1234/11) #t) +(num-test (> 1234/11 1234/11) #f) +(num-test (>= 1234/11 1234/11) #t) +(num-test (+ 1234/11 1.234+1.234i) 113.41581818181818+1.234i) +(num-test (- 1234/11 1.234+1.234i) 110.94781818181819-1.234i) +(num-test (* 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1.234+1.234i) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1.234+1.234i) #f) +(num-test (+ 1234/11 -1.0+1.0i) 111.18181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i) 113.18181818181819-1.0i) +(num-test (* 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 -1.0+1.0i) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 -1.0+1.0i) #f) +(num-test (+ 1234/11 0.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i) 112.18181818181819-1.0i) +(num-test (* 1234/11 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1234/11 0.0+1.0i) 0.0-112.18181818181819i) +(num-test (= 1234/11 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1) 2.234+1.234i) +(num-test (- 1.234+1.234i 1) 0.234+1.234i) +(num-test (* 1.234+1.234i 1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1) #f) +(num-test (+ 1.234+1.234i 1.0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1.0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1.0) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1.0) 1.234+1.234i) +(num-test (= 1.234+1.234i 1.0) #f) +(num-test (+ 1.234+1.234i 1/1) 2.234+1.234i) +(num-test (- 1.234+1.234i 1/1) 0.234+1.234i) +(num-test (* 1.234+1.234i 1/1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1/1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1/1) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i) 2.234+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i) 0.234+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1.0+1.0i) 1.234) +(num-test (= 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 0) 1.234+1.234i) +(num-test (- 1.234+1.234i 0) 1.234+1.234i) +(num-test (* 1.234+1.234i 0) 0.0) +(num-test (+ 1.234+1.234i 0.0) 1.234+1.234i) +(num-test (- 1.234+1.234i 0.0) 1.234+1.234i) +(num-test (* 1.234+1.234i 0.0) 0.0) +(num-test (+ 1.234+1.234i 1234) 1235.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234) -1232.766+1.234i) +(num-test (* 1.234+1.234i 1234) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1234) 0.001+0.001i) +(num-test (= 1.234+1.234i 1234) #f) +(num-test (+ 1.234+1.234i 123.4) 124.634+1.234i) +(num-test (- 1.234+1.234i 123.4) -122.16600000000001+1.234i) +(num-test (* 1.234+1.234i 123.4) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 123.4) 0.01+0.01i) +(num-test (= 1.234+1.234i 123.4) #f) +(num-test (+ 1.234+1.234i 1234/11) 113.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1234/11) -110.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1234/11) 0.011+0.011i) +(num-test (= 1.234+1.234i 1234/11) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i) 2.468+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i) 0.0) +(num-test (* 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.234+1.234i) 1.0) +(num-test (= 1.234+1.234i 1.234+1.234i) #t) +(num-test (+ 1.234+1.234i -1.0+1.0i) 0.234+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i) 2.234+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i) -2.468) +(num-test (/ 1.234+1.234i -1.0+1.0i) -0.0-1.234i) +(num-test (= 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i) 1.234+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i) 1.234+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1.234+1.234i 0.0+1.0i) 1.234-1.234i) +(num-test (= 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1) 0.0+1.0i) +(num-test (- -1.0+1.0i 1) -2.0+1.0i) +(num-test (* -1.0+1.0i 1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1) #f) +(num-test (+ -1.0+1.0i 1.0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1.0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1.0) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1.0) -1.0+1.0i) +(num-test (= -1.0+1.0i 1.0) #f) +(num-test (+ -1.0+1.0i 1/1) 0.0+1.0i) +(num-test (- -1.0+1.0i 1/1) -2.0+1.0i) +(num-test (* -1.0+1.0i 1/1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1/1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1/1) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i) -2.0) +(num-test (* -1.0+1.0i 1.0+1.0i) -2.0) +(num-test (/ -1.0+1.0i 1.0+1.0i) 0.0+1.0i) +(num-test (= -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 0) -1.0+1.0i) +(num-test (- -1.0+1.0i 0) -1.0+1.0i) +(num-test (* -1.0+1.0i 0) -0.0) +(num-test (+ -1.0+1.0i 0.0) -1.0+1.0i) +(num-test (- -1.0+1.0i 0.0) -1.0+1.0i) +(num-test (* -1.0+1.0i 0.0) -0.0) +(num-test (+ -1.0+1.0i 1234) 1233.0+1.0i) +(num-test (- -1.0+1.0i 1234) -1235.0+1.0i) +(num-test (* -1.0+1.0i 1234) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1234) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1234) #f) +(num-test (+ -1.0+1.0i 123.4) 122.4+1.0i) +(num-test (- -1.0+1.0i 123.4) -124.4+1.0i) +(num-test (* -1.0+1.0i 123.4) -123.4+123.4i) +(num-test (/ -1.0+1.0i 123.4) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 123.4) #f) +(num-test (+ -1.0+1.0i 1234/11) 111.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11) -113.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1234/11) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1234/11) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i) 0.234+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i) -2.234-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i) -2.468) +(num-test (/ -1.0+1.0i 1.234+1.234i) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i) -2.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i) 0.0) +(num-test (* -1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i) 1.0) +(num-test (= -1.0+1.0i -1.0+1.0i) #t) +(num-test (+ -1.0+1.0i 0.0+1.0i) -1.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i) -1.0) +(num-test (* -1.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i) 1.0+1.0i) +(num-test (= -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1) 1.0+1.0i) +(num-test (- 0.0+1.0i 1) -1.0+1.0i) +(num-test (* 0.0+1.0i 1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1) #f) +(num-test (+ 0.0+1.0i 1.0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1.0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1.0) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1.0) 0.0+1.0i) +(num-test (= 0.0+1.0i 1.0) #f) +(num-test (+ 0.0+1.0i 1/1) 1.0+1.0i) +(num-test (- 0.0+1.0i 1/1) -1.0+1.0i) +(num-test (* 0.0+1.0i 1/1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1/1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1/1) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i) 1.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i) -1.0) +(num-test (* 0.0+1.0i 1.0+1.0i) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i) 0.5+0.5i) +(num-test (= 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 0) 0.0+1.0i) +(num-test (- 0.0+1.0i 0) 0.0+1.0i) +(num-test (* 0.0+1.0i 0) 0.0) +(num-test (+ 0.0+1.0i 0.0) 0.0+1.0i) +(num-test (- 0.0+1.0i 0.0) 0.0+1.0i) +(num-test (* 0.0+1.0i 0.0) 0.0) +(num-test (+ 0.0+1.0i 1234) 1234.0+1.0i) +(num-test (- 0.0+1.0i 1234) -1234.0+1.0i) +(num-test (* 0.0+1.0i 1234) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1234) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1234) #f) +(num-test (+ 0.0+1.0i 123.4) 123.4+1.0i) +(num-test (- 0.0+1.0i 123.4) -123.4+1.0i) +(num-test (* 0.0+1.0i 123.4) 0.0+123.4i) +(num-test (/ 0.0+1.0i 123.4) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 123.4) #f) +(num-test (+ 0.0+1.0i 1234/11) 112.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11) -112.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1234/11) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1234/11) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i) 1.234+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i) -1.234-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1.234+1.234i) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i) -1.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i) 1.0) +(num-test (* 0.0+1.0i -1.0+1.0i) -1.0-1.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i) 0.5-0.5i) +(num-test (= 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i) 0.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i) 0.0) +(num-test (* 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (/ 0.0+1.0i 0.0+1.0i) 1.0) +(num-test (= 0.0+1.0i 0.0+1.0i) #t) +(num-test (+ 1 1 1) 3) +(num-test (- 1 1 1) -1) +(num-test (* 1 1 1) 1) +(num-test (/ 1 1 1) 1) +(num-test (= 1 1 1) #t) +(num-test (< 1 1 1) #f) +(num-test (<= 1 1 1) #t) +(num-test (> 1 1 1) #f) +(num-test (>= 1 1 1) #t) +(num-test (+ 1 1 1.0) 3.0) +(num-test (- 1 1 1.0) -1.0) +(num-test (* 1 1 1.0) 1.0) +(num-test (/ 1 1 1.0) 1.0) +(num-test (= 1 1 1.0) #t) +(num-test (< 1 1 1.0) #f) +(num-test (<= 1 1 1.0) #t) +(num-test (> 1 1 1.0) #f) +(num-test (>= 1 1 1.0) #t) +(num-test (+ 1 1 1/1) 3) +(num-test (- 1 1 1/1) -1) +(num-test (* 1 1 1/1) 1) +(num-test (/ 1 1 1/1) 1) +(num-test (= 1 1 1/1) #t) +(num-test (< 1 1 1/1) #f) +(num-test (<= 1 1 1/1) #t) +(num-test (> 1 1 1/1) #f) +(num-test (>= 1 1 1/1) #t) +(num-test (+ 1 1 1.0+1.0i) 3.0+1.0i) +(num-test (- 1 1 1.0+1.0i) -1.0-1.0i) +(num-test (* 1 1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1 1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1 1 1.0+1.0i) #f) +(num-test (+ 1 1 0) 2) +(num-test (- 1 1 0) 0) +(num-test (* 1 1 0) 0) +(num-test (+ 1 1 0.0) 2.0) +(num-test (- 1 1 0.0) 0.0) +(num-test (* 1 1 0.0) 0.0) +(num-test (+ 1 1 1234) 1236) +(num-test (- 1 1 1234) -1234) +(num-test (* 1 1 1234) 1234) +(num-test (/ 1 1 1234) 1/1234) +(num-test (= 1 1 1234) #f) +(num-test (< 1 1 1234) #f) +(num-test (<= 1 1 1234) #t) +(num-test (> 1 1 1234) #f) +(num-test (>= 1 1 1234) #f) +(num-test (+ 1 1 123.4) 125.4) +(num-test (- 1 1 123.4) -123.4) +(num-test (* 1 1 123.4) 123.4) +(num-test (/ 1 1 123.4) 0.00810372771475) +(num-test (= 1 1 123.4) #f) +(num-test (< 1 1 123.4) #f) +(num-test (<= 1 1 123.4) #t) +(num-test (> 1 1 123.4) #f) +(num-test (>= 1 1 123.4) #f) +(num-test (+ 1 1 1234/11) 1256/11) +(num-test (- 1 1 1234/11) -1234/11) +(num-test (* 1 1 1234/11) 1234/11) +(num-test (/ 1 1 1234/11) 11/1234) +(num-test (= 1 1 1234/11) #f) +(num-test (< 1 1 1234/11) #f) +(num-test (<= 1 1 1234/11) #t) +(num-test (> 1 1 1234/11) #f) +(num-test (>= 1 1 1234/11) #f) +(num-test (+ 1 1 1.234+1.234i) 3.234+1.234i) +(num-test (- 1 1 1.234+1.234i) -1.234-1.234i) +(num-test (* 1 1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1 1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1 1.234+1.234i) #f) +(num-test (+ 1 1 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1 1 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1 1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1 1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1 1 -1.0+1.0i) #f) +(num-test (+ 1 1 0.0+1.0i) 2.0+1.0i) +(num-test (- 1 1 0.0+1.0i) 0.0-1.0i) +(num-test (* 1 1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1 1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1 1 0.0+1.0i) #f) +(num-test (+ 1 1.0 1) 3.0) +(num-test (- 1 1.0 1) -1.0) +(num-test (* 1 1.0 1) 1.0) +(num-test (/ 1 1.0 1) 1.0) +(num-test (= 1 1.0 1) #t) +(num-test (< 1 1.0 1) #f) +(num-test (<= 1 1.0 1) #t) +(num-test (> 1 1.0 1) #f) +(num-test (>= 1 1.0 1) #t) +(num-test (+ 1 1.0 1.0) 3.0) +(num-test (- 1 1.0 1.0) -1.0) +(num-test (* 1 1.0 1.0) 1.0) +(num-test (/ 1 1.0 1.0) 1.0) +(num-test (= 1 1.0 1.0) #t) +(num-test (< 1 1.0 1.0) #f) +(num-test (<= 1 1.0 1.0) #t) +(num-test (> 1 1.0 1.0) #f) +(num-test (>= 1 1.0 1.0) #t) +(num-test (+ 1 1.0 1/1) 3.0) +(num-test (- 1 1.0 1/1) -1.0) +(num-test (* 1 1.0 1/1) 1.0) +(num-test (/ 1 1.0 1/1) 1.0) +(num-test (= 1 1.0 1/1) #t) +(num-test (< 1 1.0 1/1) #f) +(num-test (<= 1 1.0 1/1) #t) +(num-test (> 1 1.0 1/1) #f) +(num-test (>= 1 1.0 1/1) #t) +(num-test (+ 1 1.0 1.0+1.0i) 3.0+1.0i) +(num-test (- 1 1.0 1.0+1.0i) -1.0-1.0i) +(num-test (* 1 1.0 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1 1.0 1.0+1.0i) 0.5-0.5i) +(num-test (= 1 1.0 1.0+1.0i) #f) +(num-test (+ 1 1.0 0) 2.0) +(num-test (- 1 1.0 0) 0.0) +(num-test (* 1 1.0 0) 0.0) +(num-test (+ 1 1.0 0.0) 2.0) +(num-test (- 1 1.0 0.0) 0.0) +(num-test (* 1 1.0 0.0) 0.0) +(num-test (+ 1 1.0 1234) 1236.0) +(num-test (- 1 1.0 1234) -1234.0) +(num-test (* 1 1.0 1234) 1234.0) +(num-test (/ 1 1.0 1234) 0.00081037277147) +(num-test (= 1 1.0 1234) #f) +(num-test (< 1 1.0 1234) #f) +(num-test (<= 1 1.0 1234) #t) +(num-test (> 1 1.0 1234) #f) +(num-test (>= 1 1.0 1234) #f) +(num-test (+ 1 1.0 123.4) 125.4) +(num-test (- 1 1.0 123.4) -123.4) +(num-test (* 1 1.0 123.4) 123.4) +(num-test (/ 1 1.0 123.4) 0.00810372771475) +(num-test (= 1 1.0 123.4) #f) +(num-test (< 1 1.0 123.4) #f) +(num-test (<= 1 1.0 123.4) #t) +(num-test (> 1 1.0 123.4) #f) +(num-test (>= 1 1.0 123.4) #f) +(num-test (+ 1 1.0 1234/11) 114.18181818181819) +(num-test (- 1 1.0 1234/11) -112.18181818181819) +(num-test (* 1 1.0 1234/11) 112.18181818181819) +(num-test (/ 1 1.0 1234/11) 0.00891410048622) +(num-test (= 1 1.0 1234/11) #f) +(num-test (< 1 1.0 1234/11) #f) +(num-test (<= 1 1.0 1234/11) #t) +(num-test (> 1 1.0 1234/11) #f) +(num-test (>= 1 1.0 1234/11) #f) +(num-test (+ 1 1.0 1.234+1.234i) 3.234+1.234i) +(num-test (- 1 1.0 1.234+1.234i) -1.234-1.234i) +(num-test (* 1 1.0 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1.0 1.234+1.234i) #f) +(num-test (+ 1 1.0 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1 1.0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1 1.0 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1 1.0 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1 1.0 -1.0+1.0i) #f) +(num-test (+ 1 1.0 0.0+1.0i) 2.0+1.0i) +(num-test (- 1 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (* 1 1.0 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (= 1 1.0 0.0+1.0i) #f) +(num-test (+ 1 1/1 1) 3) +(num-test (- 1 1/1 1) -1) +(num-test (* 1 1/1 1) 1) +(num-test (/ 1 1/1 1) 1) +(num-test (= 1 1/1 1) #t) +(num-test (< 1 1/1 1) #f) +(num-test (<= 1 1/1 1) #t) +(num-test (> 1 1/1 1) #f) +(num-test (>= 1 1/1 1) #t) +(num-test (+ 1 1/1 1.0) 3.0) +(num-test (- 1 1/1 1.0) -1.0) +(num-test (* 1 1/1 1.0) 1.0) +(num-test (/ 1 1/1 1.0) 1.0) +(num-test (= 1 1/1 1.0) #t) +(num-test (< 1 1/1 1.0) #f) +(num-test (<= 1 1/1 1.0) #t) +(num-test (> 1 1/1 1.0) #f) +(num-test (>= 1 1/1 1.0) #t) +(num-test (+ 1 1/1 1/1) 3) +(num-test (- 1 1/1 1/1) -1) +(num-test (* 1 1/1 1/1) 1) +(num-test (/ 1 1/1 1/1) 1) +(num-test (= 1 1/1 1/1) #t) +(num-test (< 1 1/1 1/1) #f) +(num-test (<= 1 1/1 1/1) #t) +(num-test (> 1 1/1 1/1) #f) +(num-test (>= 1 1/1 1/1) #t) +(num-test (+ 1 1/1 1.0+1.0i) 3.0+1.0i) +(num-test (- 1 1/1 1.0+1.0i) -1.0-1.0i) +(num-test (* 1 1/1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1 1/1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1 1/1 1.0+1.0i) #f) +(num-test (+ 1 1/1 0) 2) +(num-test (- 1 1/1 0) 0) +(num-test (* 1 1/1 0) 0) +(num-test (+ 1 1/1 0.0) 2.0) +(num-test (- 1 1/1 0.0) 0.0) +(num-test (* 1 1/1 0.0) 0.0) +(num-test (+ 1 1/1 1234) 1236) +(num-test (- 1 1/1 1234) -1234) +(num-test (* 1 1/1 1234) 1234) +(num-test (/ 1 1/1 1234) 1/1234) +(num-test (= 1 1/1 1234) #f) +(num-test (< 1 1/1 1234) #f) +(num-test (<= 1 1/1 1234) #t) +(num-test (> 1 1/1 1234) #f) +(num-test (>= 1 1/1 1234) #f) +(num-test (+ 1 1/1 123.4) 125.4) +(num-test (- 1 1/1 123.4) -123.4) +(num-test (* 1 1/1 123.4) 123.4) +(num-test (/ 1 1/1 123.4) 0.00810372771475) +(num-test (= 1 1/1 123.4) #f) +(num-test (< 1 1/1 123.4) #f) +(num-test (<= 1 1/1 123.4) #t) +(num-test (> 1 1/1 123.4) #f) +(num-test (>= 1 1/1 123.4) #f) +(num-test (+ 1 1/1 1234/11) 1256/11) +(num-test (- 1 1/1 1234/11) -1234/11) +(num-test (* 1 1/1 1234/11) 1234/11) +(num-test (/ 1 1/1 1234/11) 11/1234) +(num-test (= 1 1/1 1234/11) #f) +(num-test (< 1 1/1 1234/11) #f) +(num-test (<= 1 1/1 1234/11) #t) +(num-test (> 1 1/1 1234/11) #f) +(num-test (>= 1 1/1 1234/11) #f) +(num-test (+ 1 1/1 1.234+1.234i) 3.234+1.234i) +(num-test (- 1 1/1 1.234+1.234i) -1.234-1.234i) +(num-test (* 1 1/1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1/1 1.234+1.234i) #f) +(num-test (+ 1 1/1 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1 1/1 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1 1/1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1 1/1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1 1/1 -1.0+1.0i) #f) +(num-test (+ 1 1/1 0.0+1.0i) 2.0+1.0i) +(num-test (- 1 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (* 1 1/1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1 1/1 0.0+1.0i) #f) +(num-test (+ 1 1.0+1.0i 1) 3.0+1.0i) +(num-test (- 1 1.0+1.0i 1) -1.0-1.0i) +(num-test (* 1 1.0+1.0i 1) 1.0+1.0i) +(num-test (/ 1 1.0+1.0i 1) 0.5-0.5i) +(num-test (= 1 1.0+1.0i 1) #f) +(num-test (+ 1 1.0+1.0i 1.0) 3.0+1.0i) +(num-test (- 1 1.0+1.0i 1.0) -1.0-1.0i) +(num-test (* 1 1.0+1.0i 1.0) 1.0+1.0i) +(num-test (/ 1 1.0+1.0i 1.0) 0.5-0.5i) +(num-test (= 1 1.0+1.0i 1.0) #f) +(num-test (+ 1 1.0+1.0i 1/1) 3.0+1.0i) +(num-test (- 1 1.0+1.0i 1/1) -1.0-1.0i) +(num-test (* 1 1.0+1.0i 1/1) 1.0+1.0i) +(num-test (/ 1 1.0+1.0i 1/1) 0.5-0.5i) +(num-test (= 1 1.0+1.0i 1/1) #f) +(num-test (+ 1 1.0+1.0i 1.0+1.0i) 3.0+2.0i) +(num-test (- 1 1.0+1.0i 1.0+1.0i) -1.0-2.0i) +(num-test (* 1 1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1 1.0+1.0i 1.0+1.0i) 0.0-0.5i) +(num-test (= 1 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1 1.0+1.0i 0) 2.0+1.0i) +(num-test (- 1 1.0+1.0i 0) 0.0-1.0i) +(num-test (* 1 1.0+1.0i 0) 0.0) +(num-test (+ 1 1.0+1.0i 0.0) 2.0+1.0i) +(num-test (- 1 1.0+1.0i 0.0) 0.0-1.0i) +(num-test (* 1 1.0+1.0i 0.0) 0.0) +(num-test (+ 1 1.0+1.0i 1234) 1236.0+1.0i) +(num-test (- 1 1.0+1.0i 1234) -1234.0-1.0i) +(num-test (* 1 1.0+1.0i 1234) 1234.0+1234.0i) +(num-test (/ 1 1.0+1.0i 1234) 0.00040518638574-0.00040518638574i) +(num-test (= 1 1.0+1.0i 1234) #f) +(num-test (+ 1 1.0+1.0i 123.4) 125.4+1.0i) +(num-test (- 1 1.0+1.0i 123.4) -123.4-1.0i) +(num-test (* 1 1.0+1.0i 123.4) 123.4+123.4i) +(num-test (/ 1 1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i) +(num-test (= 1 1.0+1.0i 123.4) #f) +(num-test (+ 1 1.0+1.0i 1234/11) 114.18181818181819+1.0i) +(num-test (- 1 1.0+1.0i 1234/11) -112.18181818181819-1.0i) +(num-test (* 1 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1 1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i) +(num-test (= 1 1.0+1.0i 1234/11) #f) +(num-test (+ 1 1.0+1.0i 1.234+1.234i) 3.234+2.234i) +(num-test (- 1 1.0+1.0i 1.234+1.234i) -1.234-2.234i) +(num-test (* 1 1.0+1.0i 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1 1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i) +(num-test (= 1 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1 1.0+1.0i -1.0+1.0i) 1.0+2.0i) +(num-test (- 1 1.0+1.0i -1.0+1.0i) 1.0-2.0i) +(num-test (* 1 1.0+1.0i -1.0+1.0i) -2.0) +(num-test (/ 1 1.0+1.0i -1.0+1.0i) -0.5) +(num-test (= 1 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1 1.0+1.0i 0.0+1.0i) 2.0+2.0i) +(num-test (- 1 1.0+1.0i 0.0+1.0i) 0.0-2.0i) +(num-test (* 1 1.0+1.0i 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1 1.0+1.0i 0.0+1.0i) -0.5-0.5i) +(num-test (= 1 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1 0 1) 2) +(num-test (- 1 0 1) 0) +(num-test (* 1 0 1) 0) +(num-test (+ 1 0 1.0) 2.0) +(num-test (- 1 0 1.0) 0.0) +(num-test (* 1 0 1.0) 0.0) +(num-test (+ 1 0 1/1) 2) +(num-test (- 1 0 1/1) 0) +(num-test (* 1 0 1/1) 0) +(num-test (+ 1 0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1 0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1 0 1.0+1.0i) 0.0) +(num-test (+ 1 0 0) 1) +(num-test (- 1 0 0) 1) +(num-test (* 1 0 0) 0) +(num-test (+ 1 0 0.0) 1.0) +(num-test (- 1 0 0.0) 1.0) +(num-test (* 1 0 0.0) 0.0) +(num-test (+ 1 0 1234) 1235) +(num-test (- 1 0 1234) -1233) +(num-test (* 1 0 1234) 0) +(num-test (+ 1 0 123.4) 124.4) +(num-test (- 1 0 123.4) -122.4) +(num-test (* 1 0 123.4) 0.0) +(num-test (+ 1 0 1234/11) 1245/11) +(num-test (- 1 0 1234/11) -1223/11) +(num-test (* 1 0 1234/11) 0) +(num-test (+ 1 0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1 0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1 0 1.234+1.234i) 0.0) +(num-test (+ 1 0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1 0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1 0 -1.0+1.0i) -0.0) +(num-test (+ 1 0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1 0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1 0 0.0+1.0i) 0.0) +(num-test (+ 1 0.0 1) 2.0) +(num-test (- 1 0.0 1) 0.0) +(num-test (* 1 0.0 1) 0.0) +(num-test (+ 1 0.0 1.0) 2.0) +(num-test (- 1 0.0 1.0) 0.0) +(num-test (* 1 0.0 1.0) 0.0) +(num-test (+ 1 0.0 1/1) 2.0) +(num-test (- 1 0.0 1/1) 0.0) +(num-test (* 1 0.0 1/1) 0.0) +(num-test (+ 1 0.0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1 0.0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1 0.0 1.0+1.0i) 0.0) +(num-test (+ 1 0.0 0) 1.0) +(num-test (- 1 0.0 0) 1.0) +(num-test (* 1 0.0 0) 0.0) +(num-test (+ 1 0.0 0.0) 1.0) +(num-test (- 1 0.0 0.0) 1.0) +(num-test (* 1 0.0 0.0) 0.0) +(num-test (+ 1 0.0 1234) 1235.0) +(num-test (- 1 0.0 1234) -1233.0) +(num-test (* 1 0.0 1234) 0.0) +(num-test (+ 1 0.0 123.4) 124.4) +(num-test (- 1 0.0 123.4) -122.4) +(num-test (* 1 0.0 123.4) 0.0) +(num-test (+ 1 0.0 1234/11) 113.18181818181819) +(num-test (- 1 0.0 1234/11) -111.18181818181819) +(num-test (* 1 0.0 1234/11) 0.0) +(num-test (+ 1 0.0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1 0.0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1 0.0 1.234+1.234i) 0.0) +(num-test (+ 1 0.0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1 0.0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1 0.0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1 0.0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1 0.0 0.0+1.0i) 0.0) +(num-test (+ 1 1234 1) 1236) +(num-test (- 1 1234 1) -1234) +(num-test (* 1 1234 1) 1234) +(num-test (/ 1 1234 1) 1/1234) +(num-test (= 1 1234 1) #f) +(num-test (< 1 1234 1) #f) +(num-test (<= 1 1234 1) #f) +(num-test (> 1 1234 1) #f) +(num-test (>= 1 1234 1) #f) +(num-test (+ 1 1234 1.0) 1236.0) +(num-test (- 1 1234 1.0) -1234.0) +(num-test (* 1 1234 1.0) 1234.0) +(num-test (/ 1 1234 1.0) 0.00081037277147) +(num-test (= 1 1234 1.0) #f) +(num-test (< 1 1234 1.0) #f) +(num-test (<= 1 1234 1.0) #f) +(num-test (> 1 1234 1.0) #f) +(num-test (>= 1 1234 1.0) #f) +(num-test (+ 1 1234 1/1) 1236) +(num-test (- 1 1234 1/1) -1234) +(num-test (* 1 1234 1/1) 1234) +(num-test (/ 1 1234 1/1) 1/1234) +(num-test (= 1 1234 1/1) #f) +(num-test (< 1 1234 1/1) #f) +(num-test (<= 1 1234 1/1) #f) +(num-test (> 1 1234 1/1) #f) +(num-test (>= 1 1234 1/1) #f) +(num-test (+ 1 1234 1.0+1.0i) 1236.0+1.0i) +(num-test (- 1 1234 1.0+1.0i) -1234.0-1.0i) +(num-test (* 1 1234 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1 1234 1.0+1.0i) 0.00040518638574-0.00040518638574i) +(num-test (= 1 1234 1.0+1.0i) #f) +(num-test (+ 1 1234 0) 1235) +(num-test (- 1 1234 0) -1233) +(num-test (* 1 1234 0) 0) +(num-test (+ 1 1234 0.0) 1235.0) +(num-test (- 1 1234 0.0) -1233.0) +(num-test (* 1 1234 0.0) 0.0) +(num-test (+ 1 1234 1234) 2469) +(num-test (- 1 1234 1234) -2467) +(num-test (* 1 1234 1234) 1522756) +(num-test (/ 1 1234 1234) 1/1522756) +(num-test (= 1 1234 1234) #f) +(num-test (< 1 1234 1234) #f) +(num-test (<= 1 1234 1234) #t) +(num-test (> 1 1234 1234) #f) +(num-test (>= 1 1234 1234) #f) +(num-test (+ 1 1234 123.4) 1358.4) +(num-test (- 1 1234 123.4) -1356.4) +(num-test (* 1 1234 123.4) 152275.60000000000582) +(num-test (/ 1 1234 123.4) 0.00000656704029) +(num-test (= 1 1234 123.4) #f) +(num-test (< 1 1234 123.4) #f) +(num-test (<= 1 1234 123.4) #f) +(num-test (> 1 1234 123.4) #f) +(num-test (>= 1 1234 123.4) #f) +(num-test (+ 1 1234 1234/11) 14819/11) +(num-test (- 1 1234 1234/11) -14797/11) +(num-test (* 1 1234 1234/11) 1522756/11) +(num-test (/ 1 1234 1234/11) 11/1522756) +(num-test (= 1 1234 1234/11) #f) +(num-test (< 1 1234 1234/11) #f) +(num-test (<= 1 1234 1234/11) #f) +(num-test (> 1 1234 1234/11) #f) +(num-test (>= 1 1234 1234/11) #f) +(num-test (+ 1 1234 1.234+1.234i) 1236.23399999999992+1.234i) +(num-test (- 1 1234 1.234+1.234i) -1234.23399999999992-1.234i) +(num-test (* 1 1234 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1 1234 1.234+1.234i) 0.00032835201437-0.00032835201437i) +(num-test (= 1 1234 1.234+1.234i) #f) +(num-test (+ 1 1234 -1.0+1.0i) 1234.0+1.0i) +(num-test (- 1 1234 -1.0+1.0i) -1232.0-1.0i) +(num-test (* 1 1234 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1 1234 -1.0+1.0i) -0.00040518638574-0.00040518638574i) +(num-test (= 1 1234 -1.0+1.0i) #f) +(num-test (+ 1 1234 0.0+1.0i) 1235.0+1.0i) +(num-test (- 1 1234 0.0+1.0i) -1233.0-1.0i) +(num-test (* 1 1234 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1 1234 0.0+1.0i) 0.0-0.00081037277147i) +(num-test (= 1 1234 0.0+1.0i) #f) +(num-test (+ 1 123.4 1) 125.4) +(num-test (- 1 123.4 1) -123.4) +(num-test (* 1 123.4 1) 123.4) +(num-test (/ 1 123.4 1) 0.00810372771475) +(num-test (= 1 123.4 1) #f) +(num-test (< 1 123.4 1) #f) +(num-test (<= 1 123.4 1) #f) +(num-test (> 1 123.4 1) #f) +(num-test (>= 1 123.4 1) #f) +(num-test (+ 1 123.4 1.0) 125.4) +(num-test (- 1 123.4 1.0) -123.4) +(num-test (* 1 123.4 1.0) 123.4) +(num-test (/ 1 123.4 1.0) 0.00810372771475) +(num-test (= 1 123.4 1.0) #f) +(num-test (< 1 123.4 1.0) #f) +(num-test (<= 1 123.4 1.0) #f) +(num-test (> 1 123.4 1.0) #f) +(num-test (>= 1 123.4 1.0) #f) +(num-test (+ 1 123.4 1/1) 125.4) +(num-test (- 1 123.4 1/1) -123.4) +(num-test (* 1 123.4 1/1) 123.4) +(num-test (/ 1 123.4 1/1) 0.00810372771475) +(num-test (= 1 123.4 1/1) #f) +(num-test (< 1 123.4 1/1) #f) +(num-test (<= 1 123.4 1/1) #f) +(num-test (> 1 123.4 1/1) #f) +(num-test (>= 1 123.4 1/1) #f) +(num-test (+ 1 123.4 1.0+1.0i) 125.4+1.0i) +(num-test (- 1 123.4 1.0+1.0i) -123.4-1.0i) +(num-test (* 1 123.4 1.0+1.0i) 123.4+123.4i) +(num-test (/ 1 123.4 1.0+1.0i) 0.00405186385737-0.00405186385737i) +(num-test (= 1 123.4 1.0+1.0i) #f) +(num-test (+ 1 123.4 0) 124.4) +(num-test (- 1 123.4 0) -122.4) +(num-test (* 1 123.4 0) 0.0) +(num-test (+ 1 123.4 0.0) 124.4) +(num-test (- 1 123.4 0.0) -122.4) +(num-test (* 1 123.4 0.0) 0.0) +(num-test (+ 1 123.4 1234) 1358.4) +(num-test (- 1 123.4 1234) -1356.4) +(num-test (* 1 123.4 1234) 152275.60000000000582) +(num-test (/ 1 123.4 1234) 0.00000656704029) +(num-test (= 1 123.4 1234) #f) +(num-test (< 1 123.4 1234) #t) +(num-test (<= 1 123.4 1234) #t) +(num-test (> 1 123.4 1234) #f) +(num-test (>= 1 123.4 1234) #f) +(num-test (+ 1 123.4 123.4) 247.8) +(num-test (- 1 123.4 123.4) -245.8) +(num-test (* 1 123.4 123.4) 15227.56000000000131) +(num-test (/ 1 123.4 123.4) 0.00006567040287) +(num-test (= 1 123.4 123.4) #f) +(num-test (< 1 123.4 123.4) #f) +(num-test (<= 1 123.4 123.4) #t) +(num-test (> 1 123.4 123.4) #f) +(num-test (>= 1 123.4 123.4) #f) +(num-test (+ 1 123.4 1234/11) 236.58181818181819) +(num-test (- 1 123.4 1234/11) -234.58181818181819) +(num-test (* 1 123.4 1234/11) 13843.23636363636433) +(num-test (/ 1 123.4 1234/11) 0.00007223744316) +(num-test (= 1 123.4 1234/11) #f) +(num-test (< 1 123.4 1234/11) #f) +(num-test (<= 1 123.4 1234/11) #f) +(num-test (> 1 123.4 1234/11) #f) +(num-test (>= 1 123.4 1234/11) #f) +(num-test (+ 1 123.4 1.234+1.234i) 125.634+1.234i) +(num-test (- 1 123.4 1.234+1.234i) -123.634-1.234i) +(num-test (* 1 123.4 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 1 123.4 1.234+1.234i) 0.00328352014374-0.00328352014374i) +(num-test (= 1 123.4 1.234+1.234i) #f) +(num-test (+ 1 123.4 -1.0+1.0i) 123.4+1.0i) +(num-test (- 1 123.4 -1.0+1.0i) -121.4-1.0i) +(num-test (* 1 123.4 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 1 123.4 -1.0+1.0i) -0.00405186385737-0.00405186385737i) +(num-test (= 1 123.4 -1.0+1.0i) #f) +(num-test (+ 1 123.4 0.0+1.0i) 124.4+1.0i) +(num-test (- 1 123.4 0.0+1.0i) -122.4-1.0i) +(num-test (* 1 123.4 0.0+1.0i) 0.0+123.4i) +(num-test (/ 1 123.4 0.0+1.0i) 0.0-0.00810372771475i) +(num-test (= 1 123.4 0.0+1.0i) #f) +(num-test (+ 1 1234/11 1) 1256/11) +(num-test (- 1 1234/11 1) -1234/11) +(num-test (* 1 1234/11 1) 1234/11) +(num-test (/ 1 1234/11 1) 11/1234) +(num-test (= 1 1234/11 1) #f) +(num-test (< 1 1234/11 1) #f) +(num-test (<= 1 1234/11 1) #f) +(num-test (> 1 1234/11 1) #f) +(num-test (>= 1 1234/11 1) #f) +(num-test (+ 1 1234/11 1.0) 114.18181818181819) +(num-test (- 1 1234/11 1.0) -112.18181818181819) +(num-test (* 1 1234/11 1.0) 112.18181818181819) +(num-test (/ 1 1234/11 1.0) 0.00891410048622) +(num-test (= 1 1234/11 1.0) #f) +(num-test (< 1 1234/11 1.0) #f) +(num-test (<= 1 1234/11 1.0) #f) +(num-test (> 1 1234/11 1.0) #f) +(num-test (>= 1 1234/11 1.0) #f) +(num-test (+ 1 1234/11 1/1) 1256/11) +(num-test (- 1 1234/11 1/1) -1234/11) +(num-test (* 1 1234/11 1/1) 1234/11) +(num-test (/ 1 1234/11 1/1) 11/1234) +(num-test (= 1 1234/11 1/1) #f) +(num-test (< 1 1234/11 1/1) #f) +(num-test (<= 1 1234/11 1/1) #f) +(num-test (> 1 1234/11 1/1) #f) +(num-test (>= 1 1234/11 1/1) #f) +(num-test (+ 1 1234/11 1.0+1.0i) 114.18181818181819+1.0i) +(num-test (- 1 1234/11 1.0+1.0i) -112.18181818181819-1.0i) +(num-test (* 1 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1 1234/11 1.0+1.0i) 0.00445705024311-0.00445705024311i) +(num-test (= 1 1234/11 1.0+1.0i) #f) +(num-test (+ 1 1234/11 0) 1245/11) +(num-test (- 1 1234/11 0) -1223/11) +(num-test (* 1 1234/11 0) 0) +(num-test (+ 1 1234/11 0.0) 113.18181818181819) +(num-test (- 1 1234/11 0.0) -111.18181818181819) +(num-test (* 1 1234/11 0.0) 0.0) +(num-test (+ 1 1234/11 1234) 14819/11) +(num-test (- 1 1234/11 1234) -14797/11) +(num-test (* 1 1234/11 1234) 1522756/11) +(num-test (/ 1 1234/11 1234) 11/1522756) +(num-test (= 1 1234/11 1234) #f) +(num-test (< 1 1234/11 1234) #t) +(num-test (<= 1 1234/11 1234) #t) +(num-test (> 1 1234/11 1234) #f) +(num-test (>= 1 1234/11 1234) #f) +(num-test (+ 1 1234/11 123.4) 236.58181818181819) +(num-test (- 1 1234/11 123.4) -234.58181818181819) +(num-test (* 1 1234/11 123.4) 13843.23636363636433) +(num-test (/ 1 1234/11 123.4) 0.00007223744316) +(num-test (= 1 1234/11 123.4) #f) +(num-test (< 1 1234/11 123.4) #t) +(num-test (<= 1 1234/11 123.4) #t) +(num-test (> 1 1234/11 123.4) #f) +(num-test (>= 1 1234/11 123.4) #f) +(num-test (+ 1 1234/11 1234/11) 2479/11) +(num-test (- 1 1234/11 1234/11) -2457/11) +(num-test (* 1 1234/11 1234/11) 1522756/121) +(num-test (/ 1 1234/11 1234/11) 121/1522756) +(num-test (= 1 1234/11 1234/11) #f) +(num-test (< 1 1234/11 1234/11) #f) +(num-test (<= 1 1234/11 1234/11) #t) +(num-test (> 1 1234/11 1234/11) #f) +(num-test (>= 1 1234/11 1234/11) #f) +(num-test (+ 1 1234/11 1.234+1.234i) 114.41581818181818+1.234i) +(num-test (- 1 1234/11 1.234+1.234i) -112.41581818181818-1.234i) +(num-test (* 1 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1 1234/11 1.234+1.234i) 0.00361187215811-0.00361187215811i) +(num-test (= 1 1234/11 1.234+1.234i) #f) +(num-test (+ 1 1234/11 -1.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1 1234/11 -1.0+1.0i) -110.18181818181819-1.0i) +(num-test (* 1 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1 1234/11 -1.0+1.0i) -0.00445705024311-0.00445705024311i) +(num-test (= 1 1234/11 -1.0+1.0i) #f) +(num-test (+ 1 1234/11 0.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1 1234/11 0.0+1.0i) -111.18181818181819-1.0i) +(num-test (* 1 1234/11 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1 1234/11 0.0+1.0i) 0.0-0.00891410048622i) +(num-test (= 1 1234/11 0.0+1.0i) #f) +(num-test (+ 1 1.234+1.234i 1) 3.234+1.234i) +(num-test (- 1 1.234+1.234i 1) -1.234-1.234i) +(num-test (* 1 1.234+1.234i 1) 1.234+1.234i) +(num-test (/ 1 1.234+1.234i 1) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1.234+1.234i 1) #f) +(num-test (+ 1 1.234+1.234i 1.0) 3.234+1.234i) +(num-test (- 1 1.234+1.234i 1.0) -1.234-1.234i) +(num-test (* 1 1.234+1.234i 1.0) 1.234+1.234i) +(num-test (/ 1 1.234+1.234i 1.0) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1.234+1.234i 1.0) #f) +(num-test (+ 1 1.234+1.234i 1/1) 3.234+1.234i) +(num-test (- 1 1.234+1.234i 1/1) -1.234-1.234i) +(num-test (* 1 1.234+1.234i 1/1) 1.234+1.234i) +(num-test (/ 1 1.234+1.234i 1/1) 0.40518638573744-0.40518638573744i) +(num-test (= 1 1.234+1.234i 1/1) #f) +(num-test (+ 1 1.234+1.234i 1.0+1.0i) 3.234+2.234i) +(num-test (- 1 1.234+1.234i 1.0+1.0i) -1.234-2.234i) +(num-test (* 1 1.234+1.234i 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1 1.234+1.234i 1.0+1.0i) 0.0-0.40518638573744i) +(num-test (= 1 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1 1.234+1.234i 0) 2.234+1.234i) +(num-test (- 1 1.234+1.234i 0) -0.234-1.234i) +(num-test (* 1 1.234+1.234i 0) 0.0) +(num-test (+ 1 1.234+1.234i 0.0) 2.234+1.234i) +(num-test (- 1 1.234+1.234i 0.0) -0.234-1.234i) +(num-test (* 1 1.234+1.234i 0.0) 0.0) +(num-test (+ 1 1.234+1.234i 1234) 1236.23399999999992+1.234i) +(num-test (- 1 1.234+1.234i 1234) -1234.23399999999992-1.234i) +(num-test (* 1 1.234+1.234i 1234) 1522.756+1522.756i) +(num-test (/ 1 1.234+1.234i 1234) 0.00032835201437-0.00032835201437i) +(num-test (= 1 1.234+1.234i 1234) #f) +(num-test (+ 1 1.234+1.234i 123.4) 125.634+1.234i) +(num-test (- 1 1.234+1.234i 123.4) -123.634-1.234i) +(num-test (* 1 1.234+1.234i 123.4) 152.2756+152.2756i) +(num-test (/ 1 1.234+1.234i 123.4) 0.00328352014374-0.00328352014374i) +(num-test (= 1 1.234+1.234i 123.4) #f) +(num-test (+ 1 1.234+1.234i 1234/11) 114.41581818181818+1.234i) +(num-test (- 1 1.234+1.234i 1234/11) -112.41581818181818-1.234i) +(num-test (* 1 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1 1.234+1.234i 1234/11) 0.00361187215811-0.00361187215811i) +(num-test (= 1 1.234+1.234i 1234/11) #f) +(num-test (+ 1 1.234+1.234i 1.234+1.234i) 3.468+2.468i) +(num-test (- 1 1.234+1.234i 1.234+1.234i) -1.468-2.468i) +(num-test (* 1 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1 1.234+1.234i 1.234+1.234i) 0.0-0.32835201437394i) +(num-test (= 1 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 1 1.234+1.234i -1.0+1.0i) 1.234+2.234i) +(num-test (- 1 1.234+1.234i -1.0+1.0i) 0.766-2.234i) +(num-test (* 1 1.234+1.234i -1.0+1.0i) -2.468) +(num-test (/ 1 1.234+1.234i -1.0+1.0i) -0.40518638573744) +(num-test (= 1 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1 1.234+1.234i 0.0+1.0i) 2.234+2.234i) +(num-test (- 1 1.234+1.234i 0.0+1.0i) -0.234-2.234i) +(num-test (* 1 1.234+1.234i 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1 1.234+1.234i 0.0+1.0i) -0.40518638573744-0.40518638573744i) +(num-test (= 1 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1 -1.0+1.0i 1) 1.0+1.0i) +(num-test (- 1 -1.0+1.0i 1) 1.0-1.0i) +(num-test (* 1 -1.0+1.0i 1) -1.0+1.0i) +(num-test (/ 1 -1.0+1.0i 1) -0.5-0.5i) +(num-test (= 1 -1.0+1.0i 1) #f) +(num-test (+ 1 -1.0+1.0i 1.0) 1.0+1.0i) +(num-test (- 1 -1.0+1.0i 1.0) 1.0-1.0i) +(num-test (* 1 -1.0+1.0i 1.0) -1.0+1.0i) +(num-test (/ 1 -1.0+1.0i 1.0) -0.5-0.5i) +(num-test (= 1 -1.0+1.0i 1.0) #f) +(num-test (+ 1 -1.0+1.0i 1/1) 1.0+1.0i) +(num-test (- 1 -1.0+1.0i 1/1) 1.0-1.0i) +(num-test (* 1 -1.0+1.0i 1/1) -1.0+1.0i) +(num-test (/ 1 -1.0+1.0i 1/1) -0.5-0.5i) +(num-test (= 1 -1.0+1.0i 1/1) #f) +(num-test (+ 1 -1.0+1.0i 1.0+1.0i) 1.0+2.0i) +(num-test (- 1 -1.0+1.0i 1.0+1.0i) 1.0-2.0i) +(num-test (* 1 -1.0+1.0i 1.0+1.0i) -2.0) +(num-test (/ 1 -1.0+1.0i 1.0+1.0i) -0.5) +(num-test (= 1 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1 -1.0+1.0i 0) 0.0+1.0i) +(num-test (- 1 -1.0+1.0i 0) 2.0-1.0i) +(num-test (* 1 -1.0+1.0i 0) -0.0) +(num-test (+ 1 -1.0+1.0i 0.0) 0.0+1.0i) +(num-test (- 1 -1.0+1.0i 0.0) 2.0-1.0i) +(num-test (* 1 -1.0+1.0i 0.0) -0.0) +(num-test (+ 1 -1.0+1.0i 1234) 1234.0+1.0i) +(num-test (- 1 -1.0+1.0i 1234) -1232.0-1.0i) +(num-test (* 1 -1.0+1.0i 1234) -1234.0+1234.0i) +(num-test (/ 1 -1.0+1.0i 1234) -0.00040518638574-0.00040518638574i) +(num-test (= 1 -1.0+1.0i 1234) #f) +(num-test (+ 1 -1.0+1.0i 123.4) 123.4+1.0i) +(num-test (- 1 -1.0+1.0i 123.4) -121.4-1.0i) +(num-test (* 1 -1.0+1.0i 123.4) -123.4+123.4i) +(num-test (/ 1 -1.0+1.0i 123.4) -0.00405186385737-0.00405186385737i) +(num-test (= 1 -1.0+1.0i 123.4) #f) +(num-test (+ 1 -1.0+1.0i 1234/11) 112.18181818181819+1.0i) +(num-test (- 1 -1.0+1.0i 1234/11) -110.18181818181819-1.0i) +(num-test (* 1 -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ 1 -1.0+1.0i 1234/11) -0.00445705024311-0.00445705024311i) +(num-test (= 1 -1.0+1.0i 1234/11) #f) +(num-test (+ 1 -1.0+1.0i 1.234+1.234i) 1.234+2.234i) +(num-test (- 1 -1.0+1.0i 1.234+1.234i) 0.766-2.234i) +(num-test (* 1 -1.0+1.0i 1.234+1.234i) -2.468) +(num-test (/ 1 -1.0+1.0i 1.234+1.234i) -0.40518638573744) +(num-test (= 1 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1 -1.0+1.0i -1.0+1.0i) -1.0+2.0i) +(num-test (- 1 -1.0+1.0i -1.0+1.0i) 3.0-2.0i) +(num-test (* 1 -1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (/ 1 -1.0+1.0i -1.0+1.0i) -0.0+0.5i) +(num-test (= 1 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1 -1.0+1.0i 0.0+1.0i) 0.0+2.0i) +(num-test (- 1 -1.0+1.0i 0.0+1.0i) 2.0-2.0i) +(num-test (* 1 -1.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (/ 1 -1.0+1.0i 0.0+1.0i) -0.5+0.5i) +(num-test (= 1 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1 0.0+1.0i 1) 2.0+1.0i) +(num-test (- 1 0.0+1.0i 1) 0.0-1.0i) +(num-test (* 1 0.0+1.0i 1) 0.0+1.0i) +(num-test (/ 1 0.0+1.0i 1) 0.0-1.0i) +(num-test (= 1 0.0+1.0i 1) #f) +(num-test (+ 1 0.0+1.0i 1.0) 2.0+1.0i) +(num-test (- 1 0.0+1.0i 1.0) 0.0-1.0i) +(num-test (* 1 0.0+1.0i 1.0) 0.0+1.0i) +(num-test (/ 1 0.0+1.0i 1.0) 0.0-1.0i) +(num-test (= 1 0.0+1.0i 1.0) #f) +(num-test (+ 1 0.0+1.0i 1/1) 2.0+1.0i) +(num-test (- 1 0.0+1.0i 1/1) 0.0-1.0i) +(num-test (* 1 0.0+1.0i 1/1) 0.0+1.0i) +(num-test (/ 1 0.0+1.0i 1/1) 0.0-1.0i) +(num-test (= 1 0.0+1.0i 1/1) #f) +(num-test (+ 1 0.0+1.0i 1.0+1.0i) 2.0+2.0i) +(num-test (- 1 0.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (* 1 0.0+1.0i 1.0+1.0i) -1.0+1.0i) +(num-test (/ 1 0.0+1.0i 1.0+1.0i) -0.5-0.5i) +(num-test (= 1 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1 0.0+1.0i 0) 1.0+1.0i) +(num-test (- 1 0.0+1.0i 0) 1.0-1.0i) +(num-test (* 1 0.0+1.0i 0) 0.0) +(num-test (+ 1 0.0+1.0i 0.0) 1.0+1.0i) +(num-test (- 1 0.0+1.0i 0.0) 1.0-1.0i) +(num-test (* 1 0.0+1.0i 0.0) 0.0) +(num-test (+ 1 0.0+1.0i 1234) 1235.0+1.0i) +(num-test (- 1 0.0+1.0i 1234) -1233.0-1.0i) +(num-test (* 1 0.0+1.0i 1234) 0.0+1234.0i) +(num-test (/ 1 0.0+1.0i 1234) 0.0-0.00081037277147i) +(num-test (= 1 0.0+1.0i 1234) #f) +(num-test (+ 1 0.0+1.0i 123.4) 124.4+1.0i) +(num-test (- 1 0.0+1.0i 123.4) -122.4-1.0i) +(num-test (* 1 0.0+1.0i 123.4) 0.0+123.4i) +(num-test (/ 1 0.0+1.0i 123.4) 0.0-0.00810372771475i) +(num-test (= 1 0.0+1.0i 123.4) #f) +(num-test (+ 1 0.0+1.0i 1234/11) 113.18181818181819+1.0i) +(num-test (- 1 0.0+1.0i 1234/11) -111.18181818181819-1.0i) +(num-test (* 1 0.0+1.0i 1234/11) 0.0+112.18181818181819i) +(num-test (/ 1 0.0+1.0i 1234/11) 0.0-0.00891410048622i) +(num-test (= 1 0.0+1.0i 1234/11) #f) +(num-test (+ 1 0.0+1.0i 1.234+1.234i) 2.234+2.234i) +(num-test (- 1 0.0+1.0i 1.234+1.234i) -0.234-2.234i) +(num-test (* 1 0.0+1.0i 1.234+1.234i) -1.234+1.234i) +(num-test (/ 1 0.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i) +(num-test (= 1 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1 0.0+1.0i -1.0+1.0i) 0.0+2.0i) +(num-test (- 1 0.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (* 1 0.0+1.0i -1.0+1.0i) -1.0-1.0i) +(num-test (/ 1 0.0+1.0i -1.0+1.0i) -0.5+0.5i) +(num-test (= 1 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1 0.0+1.0i 0.0+1.0i) 1.0+2.0i) +(num-test (- 1 0.0+1.0i 0.0+1.0i) 1.0-2.0i) +(num-test (* 1 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (/ 1 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (= 1 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.0 1 1) 3.0) +(num-test (- 1.0 1 1) -1.0) +(num-test (* 1.0 1 1) 1.0) +(num-test (/ 1.0 1 1) 1.0) +(num-test (= 1.0 1 1) #t) +(num-test (< 1.0 1 1) #f) +(num-test (<= 1.0 1 1) #t) +(num-test (> 1.0 1 1) #f) +(num-test (>= 1.0 1 1) #t) +(num-test (+ 1.0 1 1.0) 3.0) +(num-test (- 1.0 1 1.0) -1.0) +(num-test (* 1.0 1 1.0) 1.0) +(num-test (/ 1.0 1 1.0) 1.0) +(num-test (= 1.0 1 1.0) #t) +(num-test (< 1.0 1 1.0) #f) +(num-test (<= 1.0 1 1.0) #t) +(num-test (> 1.0 1 1.0) #f) +(num-test (>= 1.0 1 1.0) #t) +(num-test (+ 1.0 1 1/1) 3.0) +(num-test (- 1.0 1 1/1) -1.0) +(num-test (* 1.0 1 1/1) 1.0) +(num-test (/ 1.0 1 1/1) 1.0) +(num-test (= 1.0 1 1/1) #t) +(num-test (< 1.0 1 1/1) #f) +(num-test (<= 1.0 1 1/1) #t) +(num-test (> 1.0 1 1/1) #f) +(num-test (>= 1.0 1 1/1) #t) +(num-test (+ 1.0 1 1.0+1.0i) 3.0+1.0i) +(num-test (- 1.0 1 1.0+1.0i) -1.0-1.0i) +(num-test (* 1.0 1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1.0 1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1.0 1 1.0+1.0i) #f) +(num-test (+ 1.0 1 0) 2.0) +(num-test (- 1.0 1 0) 0.0) +(num-test (* 1.0 1 0) 0.0) +(num-test (+ 1.0 1 0.0) 2.0) +(num-test (- 1.0 1 0.0) 0.0) +(num-test (* 1.0 1 0.0) 0.0) +(num-test (+ 1.0 1 1234) 1236.0) +(num-test (- 1.0 1 1234) -1234.0) +(num-test (* 1.0 1 1234) 1234.0) +(num-test (/ 1.0 1 1234) 0.00081037277147) +(num-test (= 1.0 1 1234) #f) +(num-test (< 1.0 1 1234) #f) +(num-test (<= 1.0 1 1234) #t) +(num-test (> 1.0 1 1234) #f) +(num-test (>= 1.0 1 1234) #f) +(num-test (+ 1.0 1 123.4) 125.4) +(num-test (- 1.0 1 123.4) -123.4) +(num-test (* 1.0 1 123.4) 123.4) +(num-test (/ 1.0 1 123.4) 0.00810372771475) +(num-test (= 1.0 1 123.4) #f) +(num-test (< 1.0 1 123.4) #f) +(num-test (<= 1.0 1 123.4) #t) +(num-test (> 1.0 1 123.4) #f) +(num-test (>= 1.0 1 123.4) #f) +(num-test (+ 1.0 1 1234/11) 114.18181818181819) +(num-test (- 1.0 1 1234/11) -112.18181818181819) +(num-test (* 1.0 1 1234/11) 112.18181818181819) +(num-test (/ 1.0 1 1234/11) 0.00891410048622) +(num-test (= 1.0 1 1234/11) #f) +(num-test (< 1.0 1 1234/11) #f) +(num-test (<= 1.0 1 1234/11) #t) +(num-test (> 1.0 1 1234/11) #f) +(num-test (>= 1.0 1 1234/11) #f) +(num-test (+ 1.0 1 1.234+1.234i) 3.234+1.234i) +(num-test (- 1.0 1 1.234+1.234i) -1.234-1.234i) +(num-test (* 1.0 1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1.0 1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1 1.234+1.234i) #f) +(num-test (+ 1.0 1 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1.0 1 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1.0 1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0 1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0 1 -1.0+1.0i) #f) +(num-test (+ 1.0 1 0.0+1.0i) 2.0+1.0i) +(num-test (- 1.0 1 0.0+1.0i) 0.0-1.0i) +(num-test (* 1.0 1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1.0 1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1.0 1 0.0+1.0i) #f) +(num-test (+ 1.0 1.0 1) 3.0) +(num-test (- 1.0 1.0 1) -1.0) +(num-test (* 1.0 1.0 1) 1.0) +(num-test (/ 1.0 1.0 1) 1.0) +(num-test (= 1.0 1.0 1) #t) +(num-test (< 1.0 1.0 1) #f) +(num-test (<= 1.0 1.0 1) #t) +(num-test (> 1.0 1.0 1) #f) +(num-test (>= 1.0 1.0 1) #t) +(num-test (+ 1.0 1.0 1.0) 3.0) +(num-test (- 1.0 1.0 1.0) -1.0) +(num-test (* 1.0 1.0 1.0) 1.0) +(num-test (/ 1.0 1.0 1.0) 1.0) +(num-test (= 1.0 1.0 1.0) #t) +(num-test (< 1.0 1.0 1.0) #f) +(num-test (<= 1.0 1.0 1.0) #t) +(num-test (> 1.0 1.0 1.0) #f) +(num-test (>= 1.0 1.0 1.0) #t) +(num-test (+ 1.0 1.0 1/1) 3.0) +(num-test (- 1.0 1.0 1/1) -1.0) +(num-test (* 1.0 1.0 1/1) 1.0) +(num-test (/ 1.0 1.0 1/1) 1.0) +(num-test (= 1.0 1.0 1/1) #t) +(num-test (< 1.0 1.0 1/1) #f) +(num-test (<= 1.0 1.0 1/1) #t) +(num-test (> 1.0 1.0 1/1) #f) +(num-test (>= 1.0 1.0 1/1) #t) +(num-test (+ 1.0 1.0 1.0+1.0i) 3.0+1.0i) +(num-test (- 1.0 1.0 1.0+1.0i) -1.0-1.0i) +(num-test (* 1.0 1.0 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1.0 1.0 1.0+1.0i) 0.5-0.5i) +(num-test (= 1.0 1.0 1.0+1.0i) #f) +(num-test (+ 1.0 1.0 0) 2.0) +(num-test (- 1.0 1.0 0) 0.0) +(num-test (* 1.0 1.0 0) 0.0) +(num-test (+ 1.0 1.0 0.0) 2.0) +(num-test (- 1.0 1.0 0.0) 0.0) +(num-test (* 1.0 1.0 0.0) 0.0) +(num-test (+ 1.0 1.0 1234) 1236.0) +(num-test (- 1.0 1.0 1234) -1234.0) +(num-test (* 1.0 1.0 1234) 1234.0) +(num-test (/ 1.0 1.0 1234) 0.00081037277147) +(num-test (= 1.0 1.0 1234) #f) +(num-test (< 1.0 1.0 1234) #f) +(num-test (<= 1.0 1.0 1234) #t) +(num-test (> 1.0 1.0 1234) #f) +(num-test (>= 1.0 1.0 1234) #f) +(num-test (+ 1.0 1.0 123.4) 125.4) +(num-test (- 1.0 1.0 123.4) -123.4) +(num-test (* 1.0 1.0 123.4) 123.4) +(num-test (/ 1.0 1.0 123.4) 0.00810372771475) +(num-test (= 1.0 1.0 123.4) #f) +(num-test (< 1.0 1.0 123.4) #f) +(num-test (<= 1.0 1.0 123.4) #t) +(num-test (> 1.0 1.0 123.4) #f) +(num-test (>= 1.0 1.0 123.4) #f) +(num-test (+ 1.0 1.0 1234/11) 114.18181818181819) +(num-test (- 1.0 1.0 1234/11) -112.18181818181819) +(num-test (* 1.0 1.0 1234/11) 112.18181818181819) +(num-test (/ 1.0 1.0 1234/11) 0.00891410048622) +(num-test (= 1.0 1.0 1234/11) #f) +(num-test (< 1.0 1.0 1234/11) #f) +(num-test (<= 1.0 1.0 1234/11) #t) +(num-test (> 1.0 1.0 1234/11) #f) +(num-test (>= 1.0 1.0 1234/11) #f) +(num-test (+ 1.0 1.0 1.234+1.234i) 3.234+1.234i) +(num-test (- 1.0 1.0 1.234+1.234i) -1.234-1.234i) +(num-test (* 1.0 1.0 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1.0 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1.0 1.234+1.234i) #f) +(num-test (+ 1.0 1.0 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1.0 1.0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1.0 1.0 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0 1.0 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0 1.0 -1.0+1.0i) #f) +(num-test (+ 1.0 1.0 0.0+1.0i) 2.0+1.0i) +(num-test (- 1.0 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (* 1.0 1.0 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1.0 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (= 1.0 1.0 0.0+1.0i) #f) +(num-test (+ 1.0 1/1 1) 3.0) +(num-test (- 1.0 1/1 1) -1.0) +(num-test (* 1.0 1/1 1) 1.0) +(num-test (/ 1.0 1/1 1) 1.0) +(num-test (= 1.0 1/1 1) #t) +(num-test (< 1.0 1/1 1) #f) +(num-test (<= 1.0 1/1 1) #t) +(num-test (> 1.0 1/1 1) #f) +(num-test (>= 1.0 1/1 1) #t) +(num-test (+ 1.0 1/1 1.0) 3.0) +(num-test (- 1.0 1/1 1.0) -1.0) +(num-test (* 1.0 1/1 1.0) 1.0) +(num-test (/ 1.0 1/1 1.0) 1.0) +(num-test (= 1.0 1/1 1.0) #t) +(num-test (< 1.0 1/1 1.0) #f) +(num-test (<= 1.0 1/1 1.0) #t) +(num-test (> 1.0 1/1 1.0) #f) +(num-test (>= 1.0 1/1 1.0) #t) +(num-test (+ 1.0 1/1 1/1) 3.0) +(num-test (- 1.0 1/1 1/1) -1.0) +(num-test (* 1.0 1/1 1/1) 1.0) +(num-test (/ 1.0 1/1 1/1) 1.0) +(num-test (= 1.0 1/1 1/1) #t) +(num-test (< 1.0 1/1 1/1) #f) +(num-test (<= 1.0 1/1 1/1) #t) +(num-test (> 1.0 1/1 1/1) #f) +(num-test (>= 1.0 1/1 1/1) #t) +(num-test (+ 1.0 1/1 1.0+1.0i) 3.0+1.0i) +(num-test (- 1.0 1/1 1.0+1.0i) -1.0-1.0i) +(num-test (* 1.0 1/1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1.0 1/1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1.0 1/1 1.0+1.0i) #f) +(num-test (+ 1.0 1/1 0) 2.0) +(num-test (- 1.0 1/1 0) 0.0) +(num-test (* 1.0 1/1 0) 0.0) +(num-test (+ 1.0 1/1 0.0) 2.0) +(num-test (- 1.0 1/1 0.0) 0.0) +(num-test (* 1.0 1/1 0.0) 0.0) +(num-test (+ 1.0 1/1 1234) 1236.0) +(num-test (- 1.0 1/1 1234) -1234.0) +(num-test (* 1.0 1/1 1234) 1234.0) +(num-test (/ 1.0 1/1 1234) 0.00081037277147) +(num-test (= 1.0 1/1 1234) #f) +(num-test (< 1.0 1/1 1234) #f) +(num-test (<= 1.0 1/1 1234) #t) +(num-test (> 1.0 1/1 1234) #f) +(num-test (>= 1.0 1/1 1234) #f) +(num-test (+ 1.0 1/1 123.4) 125.4) +(num-test (- 1.0 1/1 123.4) -123.4) +(num-test (* 1.0 1/1 123.4) 123.4) +(num-test (/ 1.0 1/1 123.4) 0.00810372771475) +(num-test (= 1.0 1/1 123.4) #f) +(num-test (< 1.0 1/1 123.4) #f) +(num-test (<= 1.0 1/1 123.4) #t) +(num-test (> 1.0 1/1 123.4) #f) +(num-test (>= 1.0 1/1 123.4) #f) +(num-test (+ 1.0 1/1 1234/11) 114.18181818181819) +(num-test (- 1.0 1/1 1234/11) -112.18181818181819) +(num-test (* 1.0 1/1 1234/11) 112.18181818181819) +(num-test (/ 1.0 1/1 1234/11) 0.00891410048622) +(num-test (= 1.0 1/1 1234/11) #f) +(num-test (< 1.0 1/1 1234/11) #f) +(num-test (<= 1.0 1/1 1234/11) #t) +(num-test (> 1.0 1/1 1234/11) #f) +(num-test (>= 1.0 1/1 1234/11) #f) +(num-test (+ 1.0 1/1 1.234+1.234i) 3.234+1.234i) +(num-test (- 1.0 1/1 1.234+1.234i) -1.234-1.234i) +(num-test (* 1.0 1/1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1.0 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1/1 1.234+1.234i) #f) +(num-test (+ 1.0 1/1 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1.0 1/1 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1.0 1/1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0 1/1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0 1/1 -1.0+1.0i) #f) +(num-test (+ 1.0 1/1 0.0+1.0i) 2.0+1.0i) +(num-test (- 1.0 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (* 1.0 1/1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1.0 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1.0 1/1 0.0+1.0i) #f) +(num-test (+ 1.0 1.0+1.0i 1) 3.0+1.0i) +(num-test (- 1.0 1.0+1.0i 1) -1.0-1.0i) +(num-test (* 1.0 1.0+1.0i 1) 1.0+1.0i) +(num-test (/ 1.0 1.0+1.0i 1) 0.5-0.5i) +(num-test (= 1.0 1.0+1.0i 1) #f) +(num-test (+ 1.0 1.0+1.0i 1.0) 3.0+1.0i) +(num-test (- 1.0 1.0+1.0i 1.0) -1.0-1.0i) +(num-test (* 1.0 1.0+1.0i 1.0) 1.0+1.0i) +(num-test (/ 1.0 1.0+1.0i 1.0) 0.5-0.5i) +(num-test (= 1.0 1.0+1.0i 1.0) #f) +(num-test (+ 1.0 1.0+1.0i 1/1) 3.0+1.0i) +(num-test (- 1.0 1.0+1.0i 1/1) -1.0-1.0i) +(num-test (* 1.0 1.0+1.0i 1/1) 1.0+1.0i) +(num-test (/ 1.0 1.0+1.0i 1/1) 0.5-0.5i) +(num-test (= 1.0 1.0+1.0i 1/1) #f) +(num-test (+ 1.0 1.0+1.0i 1.0+1.0i) 3.0+2.0i) +(num-test (- 1.0 1.0+1.0i 1.0+1.0i) -1.0-2.0i) +(num-test (* 1.0 1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1.0 1.0+1.0i 1.0+1.0i) 0.0-0.5i) +(num-test (= 1.0 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.0 1.0+1.0i 0) 2.0+1.0i) +(num-test (- 1.0 1.0+1.0i 0) 0.0-1.0i) +(num-test (* 1.0 1.0+1.0i 0) 0.0) +(num-test (+ 1.0 1.0+1.0i 0.0) 2.0+1.0i) +(num-test (- 1.0 1.0+1.0i 0.0) 0.0-1.0i) +(num-test (* 1.0 1.0+1.0i 0.0) 0.0) +(num-test (+ 1.0 1.0+1.0i 1234) 1236.0+1.0i) +(num-test (- 1.0 1.0+1.0i 1234) -1234.0-1.0i) +(num-test (* 1.0 1.0+1.0i 1234) 1234.0+1234.0i) +(num-test (/ 1.0 1.0+1.0i 1234) 0.00040518638574-0.00040518638574i) +(num-test (= 1.0 1.0+1.0i 1234) #f) +(num-test (+ 1.0 1.0+1.0i 123.4) 125.4+1.0i) +(num-test (- 1.0 1.0+1.0i 123.4) -123.4-1.0i) +(num-test (* 1.0 1.0+1.0i 123.4) 123.4+123.4i) +(num-test (/ 1.0 1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i) +(num-test (= 1.0 1.0+1.0i 123.4) #f) +(num-test (+ 1.0 1.0+1.0i 1234/11) 114.18181818181819+1.0i) +(num-test (- 1.0 1.0+1.0i 1234/11) -112.18181818181819-1.0i) +(num-test (* 1.0 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0 1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i) +(num-test (= 1.0 1.0+1.0i 1234/11) #f) +(num-test (+ 1.0 1.0+1.0i 1.234+1.234i) 3.234+2.234i) +(num-test (- 1.0 1.0+1.0i 1.234+1.234i) -1.234-2.234i) +(num-test (* 1.0 1.0+1.0i 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1.0 1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i) +(num-test (= 1.0 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0 1.0+1.0i -1.0+1.0i) 1.0+2.0i) +(num-test (- 1.0 1.0+1.0i -1.0+1.0i) 1.0-2.0i) +(num-test (* 1.0 1.0+1.0i -1.0+1.0i) -2.0) +(num-test (/ 1.0 1.0+1.0i -1.0+1.0i) -0.5) +(num-test (= 1.0 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0 1.0+1.0i 0.0+1.0i) 2.0+2.0i) +(num-test (- 1.0 1.0+1.0i 0.0+1.0i) 0.0-2.0i) +(num-test (* 1.0 1.0+1.0i 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0 1.0+1.0i 0.0+1.0i) -0.5-0.5i) +(num-test (= 1.0 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.0 0 1) 2.0) +(num-test (- 1.0 0 1) 0.0) +(num-test (* 1.0 0 1) 0.0) +(num-test (+ 1.0 0 1.0) 2.0) +(num-test (- 1.0 0 1.0) 0.0) +(num-test (* 1.0 0 1.0) 0.0) +(num-test (+ 1.0 0 1/1) 2.0) +(num-test (- 1.0 0 1/1) 0.0) +(num-test (* 1.0 0 1/1) 0.0) +(num-test (+ 1.0 0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1.0 0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1.0 0 1.0+1.0i) 0.0) +(num-test (+ 1.0 0 0) 1.0) +(num-test (- 1.0 0 0) 1.0) +(num-test (* 1.0 0 0) 0.0) +(num-test (+ 1.0 0 0.0) 1.0) +(num-test (- 1.0 0 0.0) 1.0) +(num-test (* 1.0 0 0.0) 0.0) +(num-test (+ 1.0 0 1234) 1235.0) +(num-test (- 1.0 0 1234) -1233.0) +(num-test (* 1.0 0 1234) 0.0) +(num-test (+ 1.0 0 123.4) 124.4) +(num-test (- 1.0 0 123.4) -122.4) +(num-test (* 1.0 0 123.4) 0.0) +(num-test (+ 1.0 0 1234/11) 113.18181818181819) +(num-test (- 1.0 0 1234/11) -111.18181818181819) +(num-test (* 1.0 0 1234/11) 0.0) +(num-test (+ 1.0 0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1.0 0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1.0 0 1.234+1.234i) 0.0) +(num-test (+ 1.0 0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1.0 0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1.0 0 -1.0+1.0i) -0.0) +(num-test (+ 1.0 0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1.0 0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1.0 0 0.0+1.0i) 0.0) +(num-test (+ 1.0 0.0 1) 2.0) +(num-test (- 1.0 0.0 1) 0.0) +(num-test (* 1.0 0.0 1) 0.0) +(num-test (+ 1.0 0.0 1.0) 2.0) +(num-test (- 1.0 0.0 1.0) 0.0) +(num-test (* 1.0 0.0 1.0) 0.0) +(num-test (+ 1.0 0.0 1/1) 2.0) +(num-test (- 1.0 0.0 1/1) 0.0) +(num-test (* 1.0 0.0 1/1) 0.0) +(num-test (+ 1.0 0.0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1.0 0.0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1.0 0.0 1.0+1.0i) 0.0) +(num-test (+ 1.0 0.0 0) 1.0) +(num-test (- 1.0 0.0 0) 1.0) +(num-test (* 1.0 0.0 0) 0.0) +(num-test (+ 1.0 0.0 0.0) 1.0) +(num-test (- 1.0 0.0 0.0) 1.0) +(num-test (* 1.0 0.0 0.0) 0.0) +(num-test (+ 1.0 0.0 1234) 1235.0) +(num-test (- 1.0 0.0 1234) -1233.0) +(num-test (* 1.0 0.0 1234) 0.0) +(num-test (+ 1.0 0.0 123.4) 124.4) +(num-test (- 1.0 0.0 123.4) -122.4) +(num-test (* 1.0 0.0 123.4) 0.0) +(num-test (+ 1.0 0.0 1234/11) 113.18181818181819) +(num-test (- 1.0 0.0 1234/11) -111.18181818181819) +(num-test (* 1.0 0.0 1234/11) 0.0) +(num-test (+ 1.0 0.0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1.0 0.0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1.0 0.0 1.234+1.234i) 0.0) +(num-test (+ 1.0 0.0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1.0 0.0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1.0 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1.0 0.0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1.0 0.0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1.0 0.0 0.0+1.0i) 0.0) +(num-test (+ 1.0 1234 1) 1236.0) +(num-test (- 1.0 1234 1) -1234.0) +(num-test (* 1.0 1234 1) 1234.0) +(num-test (/ 1.0 1234 1) 0.00081037277147) +(num-test (= 1.0 1234 1) #f) +(num-test (< 1.0 1234 1) #f) +(num-test (<= 1.0 1234 1) #f) +(num-test (> 1.0 1234 1) #f) +(num-test (>= 1.0 1234 1) #f) +(num-test (+ 1.0 1234 1.0) 1236.0) +(num-test (- 1.0 1234 1.0) -1234.0) +(num-test (* 1.0 1234 1.0) 1234.0) +(num-test (/ 1.0 1234 1.0) 0.00081037277147) +(num-test (= 1.0 1234 1.0) #f) +(num-test (< 1.0 1234 1.0) #f) +(num-test (<= 1.0 1234 1.0) #f) +(num-test (> 1.0 1234 1.0) #f) +(num-test (>= 1.0 1234 1.0) #f) +(num-test (+ 1.0 1234 1/1) 1236.0) +(num-test (- 1.0 1234 1/1) -1234.0) +(num-test (* 1.0 1234 1/1) 1234.0) +(num-test (/ 1.0 1234 1/1) 0.00081037277147) +(num-test (= 1.0 1234 1/1) #f) +(num-test (< 1.0 1234 1/1) #f) +(num-test (<= 1.0 1234 1/1) #f) +(num-test (> 1.0 1234 1/1) #f) +(num-test (>= 1.0 1234 1/1) #f) +(num-test (+ 1.0 1234 1.0+1.0i) 1236.0+1.0i) +(num-test (- 1.0 1234 1.0+1.0i) -1234.0-1.0i) +(num-test (* 1.0 1234 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1.0 1234 1.0+1.0i) 0.00040518638574-0.00040518638574i) +(num-test (= 1.0 1234 1.0+1.0i) #f) +(num-test (+ 1.0 1234 0) 1235.0) +(num-test (- 1.0 1234 0) -1233.0) +(num-test (* 1.0 1234 0) 0.0) +(num-test (+ 1.0 1234 0.0) 1235.0) +(num-test (- 1.0 1234 0.0) -1233.0) +(num-test (* 1.0 1234 0.0) 0.0) +(num-test (+ 1.0 1234 1234) 2469.0) +(num-test (- 1.0 1234 1234) -2467.0) +(num-test (* 1.0 1234 1234) 1522756.0) +(num-test (/ 1.0 1234 1234) 0.00000065670403) +(num-test (= 1.0 1234 1234) #f) +(num-test (< 1.0 1234 1234) #f) +(num-test (<= 1.0 1234 1234) #t) +(num-test (> 1.0 1234 1234) #f) +(num-test (>= 1.0 1234 1234) #f) +(num-test (+ 1.0 1234 123.4) 1358.4) +(num-test (- 1.0 1234 123.4) -1356.4) +(num-test (* 1.0 1234 123.4) 152275.60000000000582) +(num-test (/ 1.0 1234 123.4) 0.00000656704029) +(num-test (= 1.0 1234 123.4) #f) +(num-test (< 1.0 1234 123.4) #f) +(num-test (<= 1.0 1234 123.4) #f) +(num-test (> 1.0 1234 123.4) #f) +(num-test (>= 1.0 1234 123.4) #f) +(num-test (+ 1.0 1234 1234/11) 1347.18181818181824) +(num-test (- 1.0 1234 1234/11) -1345.18181818181824) +(num-test (* 1.0 1234 1234/11) 138432.36363636364695) +(num-test (/ 1.0 1234 1234/11) 0.00000722374432) +(num-test (= 1.0 1234 1234/11) #f) +(num-test (< 1.0 1234 1234/11) #f) +(num-test (<= 1.0 1234 1234/11) #f) +(num-test (> 1.0 1234 1234/11) #f) +(num-test (>= 1.0 1234 1234/11) #f) +(num-test (+ 1.0 1234 1.234+1.234i) 1236.23399999999992+1.234i) +(num-test (- 1.0 1234 1.234+1.234i) -1234.23399999999992-1.234i) +(num-test (* 1.0 1234 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1.0 1234 1.234+1.234i) 0.00032835201437-0.00032835201437i) +(num-test (= 1.0 1234 1.234+1.234i) #f) +(num-test (+ 1.0 1234 -1.0+1.0i) 1234.0+1.0i) +(num-test (- 1.0 1234 -1.0+1.0i) -1232.0-1.0i) +(num-test (* 1.0 1234 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1.0 1234 -1.0+1.0i) -0.00040518638574-0.00040518638574i) +(num-test (= 1.0 1234 -1.0+1.0i) #f) +(num-test (+ 1.0 1234 0.0+1.0i) 1235.0+1.0i) +(num-test (- 1.0 1234 0.0+1.0i) -1233.0-1.0i) +(num-test (* 1.0 1234 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1.0 1234 0.0+1.0i) 0.0-0.00081037277147i) +(num-test (= 1.0 1234 0.0+1.0i) #f) +(num-test (+ 1.0 123.4 1) 125.4) +(num-test (- 1.0 123.4 1) -123.4) +(num-test (* 1.0 123.4 1) 123.4) +(num-test (/ 1.0 123.4 1) 0.00810372771475) +(num-test (= 1.0 123.4 1) #f) +(num-test (< 1.0 123.4 1) #f) +(num-test (<= 1.0 123.4 1) #f) +(num-test (> 1.0 123.4 1) #f) +(num-test (>= 1.0 123.4 1) #f) +(num-test (+ 1.0 123.4 1.0) 125.4) +(num-test (- 1.0 123.4 1.0) -123.4) +(num-test (* 1.0 123.4 1.0) 123.4) +(num-test (/ 1.0 123.4 1.0) 0.00810372771475) +(num-test (= 1.0 123.4 1.0) #f) +(num-test (< 1.0 123.4 1.0) #f) +(num-test (<= 1.0 123.4 1.0) #f) +(num-test (> 1.0 123.4 1.0) #f) +(num-test (>= 1.0 123.4 1.0) #f) +(num-test (+ 1.0 123.4 1/1) 125.4) +(num-test (- 1.0 123.4 1/1) -123.4) +(num-test (* 1.0 123.4 1/1) 123.4) +(num-test (/ 1.0 123.4 1/1) 0.00810372771475) +(num-test (= 1.0 123.4 1/1) #f) +(num-test (< 1.0 123.4 1/1) #f) +(num-test (<= 1.0 123.4 1/1) #f) +(num-test (> 1.0 123.4 1/1) #f) +(num-test (>= 1.0 123.4 1/1) #f) +(num-test (+ 1.0 123.4 1.0+1.0i) 125.4+1.0i) +(num-test (- 1.0 123.4 1.0+1.0i) -123.4-1.0i) +(num-test (* 1.0 123.4 1.0+1.0i) 123.4+123.4i) +(num-test (/ 1.0 123.4 1.0+1.0i) 0.00405186385737-0.00405186385737i) +(num-test (= 1.0 123.4 1.0+1.0i) #f) +(num-test (+ 1.0 123.4 0) 124.4) +(num-test (- 1.0 123.4 0) -122.4) +(num-test (* 1.0 123.4 0) 0.0) +(num-test (+ 1.0 123.4 0.0) 124.4) +(num-test (- 1.0 123.4 0.0) -122.4) +(num-test (* 1.0 123.4 0.0) 0.0) +(num-test (+ 1.0 123.4 1234) 1358.4) +(num-test (- 1.0 123.4 1234) -1356.4) +(num-test (* 1.0 123.4 1234) 152275.60000000000582) +(num-test (/ 1.0 123.4 1234) 0.00000656704029) +(num-test (= 1.0 123.4 1234) #f) +(num-test (< 1.0 123.4 1234) #t) +(num-test (<= 1.0 123.4 1234) #t) +(num-test (> 1.0 123.4 1234) #f) +(num-test (>= 1.0 123.4 1234) #f) +(num-test (+ 1.0 123.4 123.4) 247.8) +(num-test (- 1.0 123.4 123.4) -245.8) +(num-test (* 1.0 123.4 123.4) 15227.56000000000131) +(num-test (/ 1.0 123.4 123.4) 0.00006567040287) +(num-test (= 1.0 123.4 123.4) #f) +(num-test (< 1.0 123.4 123.4) #f) +(num-test (<= 1.0 123.4 123.4) #t) +(num-test (> 1.0 123.4 123.4) #f) +(num-test (>= 1.0 123.4 123.4) #f) +(num-test (+ 1.0 123.4 1234/11) 236.58181818181819) +(num-test (- 1.0 123.4 1234/11) -234.58181818181819) +(num-test (* 1.0 123.4 1234/11) 13843.23636363636433) +(num-test (/ 1.0 123.4 1234/11) 0.00007223744316) +(num-test (= 1.0 123.4 1234/11) #f) +(num-test (< 1.0 123.4 1234/11) #f) +(num-test (<= 1.0 123.4 1234/11) #f) +(num-test (> 1.0 123.4 1234/11) #f) +(num-test (>= 1.0 123.4 1234/11) #f) +(num-test (+ 1.0 123.4 1.234+1.234i) 125.634+1.234i) +(num-test (- 1.0 123.4 1.234+1.234i) -123.634-1.234i) +(num-test (* 1.0 123.4 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 1.0 123.4 1.234+1.234i) 0.00328352014374-0.00328352014374i) +(num-test (= 1.0 123.4 1.234+1.234i) #f) +(num-test (+ 1.0 123.4 -1.0+1.0i) 123.4+1.0i) +(num-test (- 1.0 123.4 -1.0+1.0i) -121.4-1.0i) +(num-test (* 1.0 123.4 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 1.0 123.4 -1.0+1.0i) -0.00405186385737-0.00405186385737i) +(num-test (= 1.0 123.4 -1.0+1.0i) #f) +(num-test (+ 1.0 123.4 0.0+1.0i) 124.4+1.0i) +(num-test (- 1.0 123.4 0.0+1.0i) -122.4-1.0i) +(num-test (* 1.0 123.4 0.0+1.0i) 0.0+123.4i) +(num-test (/ 1.0 123.4 0.0+1.0i) 0.0-0.00810372771475i) +(num-test (= 1.0 123.4 0.0+1.0i) #f) +(num-test (+ 1.0 1234/11 1) 114.18181818181819) +(num-test (- 1.0 1234/11 1) -112.18181818181819) +(num-test (* 1.0 1234/11 1) 112.18181818181819) +(num-test (/ 1.0 1234/11 1) 0.00891410048622) +(num-test (= 1.0 1234/11 1) #f) +(num-test (< 1.0 1234/11 1) #f) +(num-test (<= 1.0 1234/11 1) #f) +(num-test (> 1.0 1234/11 1) #f) +(num-test (>= 1.0 1234/11 1) #f) +(num-test (+ 1.0 1234/11 1.0) 114.18181818181819) +(num-test (- 1.0 1234/11 1.0) -112.18181818181819) +(num-test (* 1.0 1234/11 1.0) 112.18181818181819) +(num-test (/ 1.0 1234/11 1.0) 0.00891410048622) +(num-test (= 1.0 1234/11 1.0) #f) +(num-test (< 1.0 1234/11 1.0) #f) +(num-test (<= 1.0 1234/11 1.0) #f) +(num-test (> 1.0 1234/11 1.0) #f) +(num-test (>= 1.0 1234/11 1.0) #f) +(num-test (+ 1.0 1234/11 1/1) 114.18181818181819) +(num-test (- 1.0 1234/11 1/1) -112.18181818181819) +(num-test (* 1.0 1234/11 1/1) 112.18181818181819) +(num-test (/ 1.0 1234/11 1/1) 0.00891410048622) +(num-test (= 1.0 1234/11 1/1) #f) +(num-test (< 1.0 1234/11 1/1) #f) +(num-test (<= 1.0 1234/11 1/1) #f) +(num-test (> 1.0 1234/11 1/1) #f) +(num-test (>= 1.0 1234/11 1/1) #f) +(num-test (+ 1.0 1234/11 1.0+1.0i) 114.18181818181819+1.0i) +(num-test (- 1.0 1234/11 1.0+1.0i) -112.18181818181819-1.0i) +(num-test (* 1.0 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0 1234/11 1.0+1.0i) 0.00445705024311-0.00445705024311i) +(num-test (= 1.0 1234/11 1.0+1.0i) #f) +(num-test (+ 1.0 1234/11 0) 113.18181818181819) +(num-test (- 1.0 1234/11 0) -111.18181818181819) +(num-test (* 1.0 1234/11 0) 0.0) +(num-test (+ 1.0 1234/11 0.0) 113.18181818181819) +(num-test (- 1.0 1234/11 0.0) -111.18181818181819) +(num-test (* 1.0 1234/11 0.0) 0.0) +(num-test (+ 1.0 1234/11 1234) 1347.18181818181824) +(num-test (- 1.0 1234/11 1234) -1345.18181818181824) +(num-test (* 1.0 1234/11 1234) 138432.36363636364695) +(num-test (/ 1.0 1234/11 1234) 0.00000722374432) +(num-test (= 1.0 1234/11 1234) #f) +(num-test (< 1.0 1234/11 1234) #t) +(num-test (<= 1.0 1234/11 1234) #t) +(num-test (> 1.0 1234/11 1234) #f) +(num-test (>= 1.0 1234/11 1234) #f) +(num-test (+ 1.0 1234/11 123.4) 236.58181818181819) +(num-test (- 1.0 1234/11 123.4) -234.58181818181819) +(num-test (* 1.0 1234/11 123.4) 13843.23636363636433) +(num-test (/ 1.0 1234/11 123.4) 0.00007223744316) +(num-test (= 1.0 1234/11 123.4) #f) +(num-test (< 1.0 1234/11 123.4) #t) +(num-test (<= 1.0 1234/11 123.4) #t) +(num-test (> 1.0 1234/11 123.4) #f) +(num-test (>= 1.0 1234/11 123.4) #f) +(num-test (+ 1.0 1234/11 1234/11) 225.36363636363637) +(num-test (- 1.0 1234/11 1234/11) -223.36363636363637) +(num-test (* 1.0 1234/11 1234/11) 12584.76033057851237) +(num-test (/ 1.0 1234/11 1234/11) 0.00007946118748) +(num-test (= 1.0 1234/11 1234/11) #f) +(num-test (< 1.0 1234/11 1234/11) #f) +(num-test (<= 1.0 1234/11 1234/11) #t) +(num-test (> 1.0 1234/11 1234/11) #f) +(num-test (>= 1.0 1234/11 1234/11) #f) +(num-test (+ 1.0 1234/11 1.234+1.234i) 114.41581818181818+1.234i) +(num-test (- 1.0 1234/11 1.234+1.234i) -112.41581818181818-1.234i) +(num-test (* 1.0 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.0 1234/11 1.234+1.234i) 0.00361187215811-0.00361187215811i) +(num-test (= 1.0 1234/11 1.234+1.234i) #f) +(num-test (+ 1.0 1234/11 -1.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1.0 1234/11 -1.0+1.0i) -110.18181818181819-1.0i) +(num-test (* 1.0 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1.0 1234/11 -1.0+1.0i) -0.00445705024311-0.00445705024311i) +(num-test (= 1.0 1234/11 -1.0+1.0i) #f) +(num-test (+ 1.0 1234/11 0.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1.0 1234/11 0.0+1.0i) -111.18181818181819-1.0i) +(num-test (* 1.0 1234/11 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1.0 1234/11 0.0+1.0i) 0.0-0.00891410048622i) +(num-test (= 1.0 1234/11 0.0+1.0i) #f) +(num-test (+ 1.0 1.234+1.234i 1) 3.234+1.234i) +(num-test (- 1.0 1.234+1.234i 1) -1.234-1.234i) +(num-test (* 1.0 1.234+1.234i 1) 1.234+1.234i) +(num-test (/ 1.0 1.234+1.234i 1) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1.234+1.234i 1) #f) +(num-test (+ 1.0 1.234+1.234i 1.0) 3.234+1.234i) +(num-test (- 1.0 1.234+1.234i 1.0) -1.234-1.234i) +(num-test (* 1.0 1.234+1.234i 1.0) 1.234+1.234i) +(num-test (/ 1.0 1.234+1.234i 1.0) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1.234+1.234i 1.0) #f) +(num-test (+ 1.0 1.234+1.234i 1/1) 3.234+1.234i) +(num-test (- 1.0 1.234+1.234i 1/1) -1.234-1.234i) +(num-test (* 1.0 1.234+1.234i 1/1) 1.234+1.234i) +(num-test (/ 1.0 1.234+1.234i 1/1) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1.234+1.234i 1/1) #f) +(num-test (+ 1.0 1.234+1.234i 1.0+1.0i) 3.234+2.234i) +(num-test (- 1.0 1.234+1.234i 1.0+1.0i) -1.234-2.234i) +(num-test (* 1.0 1.234+1.234i 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1.0 1.234+1.234i 1.0+1.0i) 0.0-0.40518638573744i) +(num-test (= 1.0 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1.0 1.234+1.234i 0) 2.234+1.234i) +(num-test (- 1.0 1.234+1.234i 0) -0.234-1.234i) +(num-test (* 1.0 1.234+1.234i 0) 0.0) +(num-test (+ 1.0 1.234+1.234i 0.0) 2.234+1.234i) +(num-test (- 1.0 1.234+1.234i 0.0) -0.234-1.234i) +(num-test (* 1.0 1.234+1.234i 0.0) 0.0) +(num-test (+ 1.0 1.234+1.234i 1234) 1236.23399999999992+1.234i) +(num-test (- 1.0 1.234+1.234i 1234) -1234.23399999999992-1.234i) +(num-test (* 1.0 1.234+1.234i 1234) 1522.756+1522.756i) +(num-test (/ 1.0 1.234+1.234i 1234) 0.00032835201437-0.00032835201437i) +(num-test (= 1.0 1.234+1.234i 1234) #f) +(num-test (+ 1.0 1.234+1.234i 123.4) 125.634+1.234i) +(num-test (- 1.0 1.234+1.234i 123.4) -123.634-1.234i) +(num-test (* 1.0 1.234+1.234i 123.4) 152.2756+152.2756i) +(num-test (/ 1.0 1.234+1.234i 123.4) 0.00328352014374-0.00328352014374i) +(num-test (= 1.0 1.234+1.234i 123.4) #f) +(num-test (+ 1.0 1.234+1.234i 1234/11) 114.41581818181818+1.234i) +(num-test (- 1.0 1.234+1.234i 1234/11) -112.41581818181818-1.234i) +(num-test (* 1.0 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.0 1.234+1.234i 1234/11) 0.00361187215811-0.00361187215811i) +(num-test (= 1.0 1.234+1.234i 1234/11) #f) +(num-test (+ 1.0 1.234+1.234i 1.234+1.234i) 3.468+2.468i) +(num-test (- 1.0 1.234+1.234i 1.234+1.234i) -1.468-2.468i) +(num-test (* 1.0 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1.0 1.234+1.234i 1.234+1.234i) 0.0-0.32835201437394i) +(num-test (= 1.0 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 1.0 1.234+1.234i -1.0+1.0i) 1.234+2.234i) +(num-test (- 1.0 1.234+1.234i -1.0+1.0i) 0.766-2.234i) +(num-test (* 1.0 1.234+1.234i -1.0+1.0i) -2.468) +(num-test (/ 1.0 1.234+1.234i -1.0+1.0i) -0.40518638573744) +(num-test (= 1.0 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1.0 1.234+1.234i 0.0+1.0i) 2.234+2.234i) +(num-test (- 1.0 1.234+1.234i 0.0+1.0i) -0.234-2.234i) +(num-test (* 1.0 1.234+1.234i 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1.0 1.234+1.234i 0.0+1.0i) -0.40518638573744-0.40518638573744i) +(num-test (= 1.0 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1.0 -1.0+1.0i 1) 1.0+1.0i) +(num-test (- 1.0 -1.0+1.0i 1) 1.0-1.0i) +(num-test (* 1.0 -1.0+1.0i 1) -1.0+1.0i) +(num-test (/ 1.0 -1.0+1.0i 1) -0.5-0.5i) +(num-test (= 1.0 -1.0+1.0i 1) #f) +(num-test (+ 1.0 -1.0+1.0i 1.0) 1.0+1.0i) +(num-test (- 1.0 -1.0+1.0i 1.0) 1.0-1.0i) +(num-test (* 1.0 -1.0+1.0i 1.0) -1.0+1.0i) +(num-test (/ 1.0 -1.0+1.0i 1.0) -0.5-0.5i) +(num-test (= 1.0 -1.0+1.0i 1.0) #f) +(num-test (+ 1.0 -1.0+1.0i 1/1) 1.0+1.0i) +(num-test (- 1.0 -1.0+1.0i 1/1) 1.0-1.0i) +(num-test (* 1.0 -1.0+1.0i 1/1) -1.0+1.0i) +(num-test (/ 1.0 -1.0+1.0i 1/1) -0.5-0.5i) +(num-test (= 1.0 -1.0+1.0i 1/1) #f) +(num-test (+ 1.0 -1.0+1.0i 1.0+1.0i) 1.0+2.0i) +(num-test (- 1.0 -1.0+1.0i 1.0+1.0i) 1.0-2.0i) +(num-test (* 1.0 -1.0+1.0i 1.0+1.0i) -2.0) +(num-test (/ 1.0 -1.0+1.0i 1.0+1.0i) -0.5) +(num-test (= 1.0 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.0 -1.0+1.0i 0) 0.0+1.0i) +(num-test (- 1.0 -1.0+1.0i 0) 2.0-1.0i) +(num-test (* 1.0 -1.0+1.0i 0) -0.0) +(num-test (+ 1.0 -1.0+1.0i 0.0) 0.0+1.0i) +(num-test (- 1.0 -1.0+1.0i 0.0) 2.0-1.0i) +(num-test (* 1.0 -1.0+1.0i 0.0) -0.0) +(num-test (+ 1.0 -1.0+1.0i 1234) 1234.0+1.0i) +(num-test (- 1.0 -1.0+1.0i 1234) -1232.0-1.0i) +(num-test (* 1.0 -1.0+1.0i 1234) -1234.0+1234.0i) +(num-test (/ 1.0 -1.0+1.0i 1234) -0.00040518638574-0.00040518638574i) +(num-test (= 1.0 -1.0+1.0i 1234) #f) +(num-test (+ 1.0 -1.0+1.0i 123.4) 123.4+1.0i) +(num-test (- 1.0 -1.0+1.0i 123.4) -121.4-1.0i) +(num-test (* 1.0 -1.0+1.0i 123.4) -123.4+123.4i) +(num-test (/ 1.0 -1.0+1.0i 123.4) -0.00405186385737-0.00405186385737i) +(num-test (= 1.0 -1.0+1.0i 123.4) #f) +(num-test (+ 1.0 -1.0+1.0i 1234/11) 112.18181818181819+1.0i) +(num-test (- 1.0 -1.0+1.0i 1234/11) -110.18181818181819-1.0i) +(num-test (* 1.0 -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ 1.0 -1.0+1.0i 1234/11) -0.00445705024311-0.00445705024311i) +(num-test (= 1.0 -1.0+1.0i 1234/11) #f) +(num-test (+ 1.0 -1.0+1.0i 1.234+1.234i) 1.234+2.234i) +(num-test (- 1.0 -1.0+1.0i 1.234+1.234i) 0.766-2.234i) +(num-test (* 1.0 -1.0+1.0i 1.234+1.234i) -2.468) +(num-test (/ 1.0 -1.0+1.0i 1.234+1.234i) -0.40518638573744) +(num-test (= 1.0 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0 -1.0+1.0i -1.0+1.0i) -1.0+2.0i) +(num-test (- 1.0 -1.0+1.0i -1.0+1.0i) 3.0-2.0i) +(num-test (* 1.0 -1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (/ 1.0 -1.0+1.0i -1.0+1.0i) -0.0+0.5i) +(num-test (= 1.0 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0 -1.0+1.0i 0.0+1.0i) 0.0+2.0i) +(num-test (- 1.0 -1.0+1.0i 0.0+1.0i) 2.0-2.0i) +(num-test (* 1.0 -1.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (/ 1.0 -1.0+1.0i 0.0+1.0i) -0.5+0.5i) +(num-test (= 1.0 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.0 0.0+1.0i 1) 2.0+1.0i) +(num-test (- 1.0 0.0+1.0i 1) 0.0-1.0i) +(num-test (* 1.0 0.0+1.0i 1) 0.0+1.0i) +(num-test (/ 1.0 0.0+1.0i 1) 0.0-1.0i) +(num-test (= 1.0 0.0+1.0i 1) #f) +(num-test (+ 1.0 0.0+1.0i 1.0) 2.0+1.0i) +(num-test (- 1.0 0.0+1.0i 1.0) 0.0-1.0i) +(num-test (* 1.0 0.0+1.0i 1.0) 0.0+1.0i) +(num-test (/ 1.0 0.0+1.0i 1.0) 0.0-1.0i) +(num-test (= 1.0 0.0+1.0i 1.0) #f) +(num-test (+ 1.0 0.0+1.0i 1/1) 2.0+1.0i) +(num-test (- 1.0 0.0+1.0i 1/1) 0.0-1.0i) +(num-test (* 1.0 0.0+1.0i 1/1) 0.0+1.0i) +(num-test (/ 1.0 0.0+1.0i 1/1) 0.0-1.0i) +(num-test (= 1.0 0.0+1.0i 1/1) #f) +(num-test (+ 1.0 0.0+1.0i 1.0+1.0i) 2.0+2.0i) +(num-test (- 1.0 0.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (* 1.0 0.0+1.0i 1.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0 0.0+1.0i 1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.0 0.0+1.0i 0) 1.0+1.0i) +(num-test (- 1.0 0.0+1.0i 0) 1.0-1.0i) +(num-test (* 1.0 0.0+1.0i 0) 0.0) +(num-test (+ 1.0 0.0+1.0i 0.0) 1.0+1.0i) +(num-test (- 1.0 0.0+1.0i 0.0) 1.0-1.0i) +(num-test (* 1.0 0.0+1.0i 0.0) 0.0) +(num-test (+ 1.0 0.0+1.0i 1234) 1235.0+1.0i) +(num-test (- 1.0 0.0+1.0i 1234) -1233.0-1.0i) +(num-test (* 1.0 0.0+1.0i 1234) 0.0+1234.0i) +(num-test (/ 1.0 0.0+1.0i 1234) 0.0-0.00081037277147i) +(num-test (= 1.0 0.0+1.0i 1234) #f) +(num-test (+ 1.0 0.0+1.0i 123.4) 124.4+1.0i) +(num-test (- 1.0 0.0+1.0i 123.4) -122.4-1.0i) +(num-test (* 1.0 0.0+1.0i 123.4) 0.0+123.4i) +(num-test (/ 1.0 0.0+1.0i 123.4) 0.0-0.00810372771475i) +(num-test (= 1.0 0.0+1.0i 123.4) #f) +(num-test (+ 1.0 0.0+1.0i 1234/11) 113.18181818181819+1.0i) +(num-test (- 1.0 0.0+1.0i 1234/11) -111.18181818181819-1.0i) +(num-test (* 1.0 0.0+1.0i 1234/11) 0.0+112.18181818181819i) +(num-test (/ 1.0 0.0+1.0i 1234/11) 0.0-0.00891410048622i) +(num-test (= 1.0 0.0+1.0i 1234/11) #f) +(num-test (+ 1.0 0.0+1.0i 1.234+1.234i) 2.234+2.234i) +(num-test (- 1.0 0.0+1.0i 1.234+1.234i) -0.234-2.234i) +(num-test (* 1.0 0.0+1.0i 1.234+1.234i) -1.234+1.234i) +(num-test (/ 1.0 0.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i) +(num-test (= 1.0 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0 0.0+1.0i -1.0+1.0i) 0.0+2.0i) +(num-test (- 1.0 0.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (* 1.0 0.0+1.0i -1.0+1.0i) -1.0-1.0i) +(num-test (/ 1.0 0.0+1.0i -1.0+1.0i) -0.5+0.5i) +(num-test (= 1.0 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0 0.0+1.0i 0.0+1.0i) 1.0+2.0i) +(num-test (- 1.0 0.0+1.0i 0.0+1.0i) 1.0-2.0i) +(num-test (* 1.0 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (/ 1.0 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (= 1.0 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1/1 1 1) 3) +(num-test (- 1/1 1 1) -1) +(num-test (* 1/1 1 1) 1) +(num-test (/ 1/1 1 1) 1) +(num-test (= 1/1 1 1) #t) +(num-test (< 1/1 1 1) #f) +(num-test (<= 1/1 1 1) #t) +(num-test (> 1/1 1 1) #f) +(num-test (>= 1/1 1 1) #t) +(num-test (+ 1/1 1 1.0) 3.0) +(num-test (- 1/1 1 1.0) -1.0) +(num-test (* 1/1 1 1.0) 1.0) +(num-test (/ 1/1 1 1.0) 1.0) +(num-test (= 1/1 1 1.0) #t) +(num-test (< 1/1 1 1.0) #f) +(num-test (<= 1/1 1 1.0) #t) +(num-test (> 1/1 1 1.0) #f) +(num-test (>= 1/1 1 1.0) #t) +(num-test (+ 1/1 1 1/1) 3) +(num-test (- 1/1 1 1/1) -1) +(num-test (* 1/1 1 1/1) 1) +(num-test (/ 1/1 1 1/1) 1) +(num-test (= 1/1 1 1/1) #t) +(num-test (< 1/1 1 1/1) #f) +(num-test (<= 1/1 1 1/1) #t) +(num-test (> 1/1 1 1/1) #f) +(num-test (>= 1/1 1 1/1) #t) +(num-test (+ 1/1 1 1.0+1.0i) 3.0+1.0i) +(num-test (- 1/1 1 1.0+1.0i) -1.0-1.0i) +(num-test (* 1/1 1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1/1 1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1/1 1 1.0+1.0i) #f) +(num-test (+ 1/1 1 0) 2) +(num-test (- 1/1 1 0) 0) +(num-test (* 1/1 1 0) 0) +(num-test (+ 1/1 1 0.0) 2.0) +(num-test (- 1/1 1 0.0) 0.0) +(num-test (* 1/1 1 0.0) 0.0) +(num-test (+ 1/1 1 1234) 1236) +(num-test (- 1/1 1 1234) -1234) +(num-test (* 1/1 1 1234) 1234) +(num-test (/ 1/1 1 1234) 1/1234) +(num-test (= 1/1 1 1234) #f) +(num-test (< 1/1 1 1234) #f) +(num-test (<= 1/1 1 1234) #t) +(num-test (> 1/1 1 1234) #f) +(num-test (>= 1/1 1 1234) #f) +(num-test (+ 1/1 1 123.4) 125.4) +(num-test (- 1/1 1 123.4) -123.4) +(num-test (* 1/1 1 123.4) 123.4) +(num-test (/ 1/1 1 123.4) 0.00810372771475) +(num-test (= 1/1 1 123.4) #f) +(num-test (< 1/1 1 123.4) #f) +(num-test (<= 1/1 1 123.4) #t) +(num-test (> 1/1 1 123.4) #f) +(num-test (>= 1/1 1 123.4) #f) +(num-test (+ 1/1 1 1234/11) 1256/11) +(num-test (- 1/1 1 1234/11) -1234/11) +(num-test (* 1/1 1 1234/11) 1234/11) +(num-test (/ 1/1 1 1234/11) 11/1234) +(num-test (= 1/1 1 1234/11) #f) +(num-test (< 1/1 1 1234/11) #f) +(num-test (<= 1/1 1 1234/11) #t) +(num-test (> 1/1 1 1234/11) #f) +(num-test (>= 1/1 1 1234/11) #f) +(num-test (+ 1/1 1 1.234+1.234i) 3.234+1.234i) +(num-test (- 1/1 1 1.234+1.234i) -1.234-1.234i) +(num-test (* 1/1 1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1/1 1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1 1.234+1.234i) #f) +(num-test (+ 1/1 1 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1/1 1 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1/1 1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1/1 1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1/1 1 -1.0+1.0i) #f) +(num-test (+ 1/1 1 0.0+1.0i) 2.0+1.0i) +(num-test (- 1/1 1 0.0+1.0i) 0.0-1.0i) +(num-test (* 1/1 1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1/1 1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1/1 1 0.0+1.0i) #f) +(num-test (+ 1/1 1.0 1) 3.0) +(num-test (- 1/1 1.0 1) -1.0) +(num-test (* 1/1 1.0 1) 1.0) +(num-test (/ 1/1 1.0 1) 1.0) +(num-test (= 1/1 1.0 1) #t) +(num-test (< 1/1 1.0 1) #f) +(num-test (<= 1/1 1.0 1) #t) +(num-test (> 1/1 1.0 1) #f) +(num-test (>= 1/1 1.0 1) #t) +(num-test (+ 1/1 1.0 1.0) 3.0) +(num-test (- 1/1 1.0 1.0) -1.0) +(num-test (* 1/1 1.0 1.0) 1.0) +(num-test (/ 1/1 1.0 1.0) 1.0) +(num-test (= 1/1 1.0 1.0) #t) +(num-test (< 1/1 1.0 1.0) #f) +(num-test (<= 1/1 1.0 1.0) #t) +(num-test (> 1/1 1.0 1.0) #f) +(num-test (>= 1/1 1.0 1.0) #t) +(num-test (+ 1/1 1.0 1/1) 3.0) +(num-test (- 1/1 1.0 1/1) -1.0) +(num-test (* 1/1 1.0 1/1) 1.0) +(num-test (/ 1/1 1.0 1/1) 1.0) +(num-test (= 1/1 1.0 1/1) #t) +(num-test (< 1/1 1.0 1/1) #f) +(num-test (<= 1/1 1.0 1/1) #t) +(num-test (> 1/1 1.0 1/1) #f) +(num-test (>= 1/1 1.0 1/1) #t) +(num-test (+ 1/1 1.0 1.0+1.0i) 3.0+1.0i) +(num-test (- 1/1 1.0 1.0+1.0i) -1.0-1.0i) +(num-test (* 1/1 1.0 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1/1 1.0 1.0+1.0i) 0.5-0.5i) +(num-test (= 1/1 1.0 1.0+1.0i) #f) +(num-test (+ 1/1 1.0 0) 2.0) +(num-test (- 1/1 1.0 0) 0.0) +(num-test (* 1/1 1.0 0) 0.0) +(num-test (+ 1/1 1.0 0.0) 2.0) +(num-test (- 1/1 1.0 0.0) 0.0) +(num-test (* 1/1 1.0 0.0) 0.0) +(num-test (+ 1/1 1.0 1234) 1236.0) +(num-test (- 1/1 1.0 1234) -1234.0) +(num-test (* 1/1 1.0 1234) 1234.0) +(num-test (/ 1/1 1.0 1234) 0.00081037277147) +(num-test (= 1/1 1.0 1234) #f) +(num-test (< 1/1 1.0 1234) #f) +(num-test (<= 1/1 1.0 1234) #t) +(num-test (> 1/1 1.0 1234) #f) +(num-test (>= 1/1 1.0 1234) #f) +(num-test (+ 1/1 1.0 123.4) 125.4) +(num-test (- 1/1 1.0 123.4) -123.4) +(num-test (* 1/1 1.0 123.4) 123.4) +(num-test (/ 1/1 1.0 123.4) 0.00810372771475) +(num-test (= 1/1 1.0 123.4) #f) +(num-test (< 1/1 1.0 123.4) #f) +(num-test (<= 1/1 1.0 123.4) #t) +(num-test (> 1/1 1.0 123.4) #f) +(num-test (>= 1/1 1.0 123.4) #f) +(num-test (+ 1/1 1.0 1234/11) 114.18181818181819) +(num-test (- 1/1 1.0 1234/11) -112.18181818181819) +(num-test (* 1/1 1.0 1234/11) 112.18181818181819) +(num-test (/ 1/1 1.0 1234/11) 0.00891410048622) +(num-test (= 1/1 1.0 1234/11) #f) +(num-test (< 1/1 1.0 1234/11) #f) +(num-test (<= 1/1 1.0 1234/11) #t) +(num-test (> 1/1 1.0 1234/11) #f) +(num-test (>= 1/1 1.0 1234/11) #f) +(num-test (+ 1/1 1.0 1.234+1.234i) 3.234+1.234i) +(num-test (- 1/1 1.0 1.234+1.234i) -1.234-1.234i) +(num-test (* 1/1 1.0 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1/1 1.0 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1.0 1.234+1.234i) #f) +(num-test (+ 1/1 1.0 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1/1 1.0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1/1 1.0 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1/1 1.0 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1/1 1.0 -1.0+1.0i) #f) +(num-test (+ 1/1 1.0 0.0+1.0i) 2.0+1.0i) +(num-test (- 1/1 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (* 1/1 1.0 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1/1 1.0 0.0+1.0i) 0.0-1.0i) +(num-test (= 1/1 1.0 0.0+1.0i) #f) +(num-test (+ 1/1 1/1 1) 3) +(num-test (- 1/1 1/1 1) -1) +(num-test (* 1/1 1/1 1) 1) +(num-test (/ 1/1 1/1 1) 1) +(num-test (= 1/1 1/1 1) #t) +(num-test (< 1/1 1/1 1) #f) +(num-test (<= 1/1 1/1 1) #t) +(num-test (> 1/1 1/1 1) #f) +(num-test (>= 1/1 1/1 1) #t) +(num-test (+ 1/1 1/1 1.0) 3.0) +(num-test (- 1/1 1/1 1.0) -1.0) +(num-test (* 1/1 1/1 1.0) 1.0) +(num-test (/ 1/1 1/1 1.0) 1.0) +(num-test (= 1/1 1/1 1.0) #t) +(num-test (< 1/1 1/1 1.0) #f) +(num-test (<= 1/1 1/1 1.0) #t) +(num-test (> 1/1 1/1 1.0) #f) +(num-test (>= 1/1 1/1 1.0) #t) +(num-test (+ 1/1 1/1 1/1) 3) +(num-test (- 1/1 1/1 1/1) -1) +(num-test (* 1/1 1/1 1/1) 1) +(num-test (/ 1/1 1/1 1/1) 1) +(num-test (= 1/1 1/1 1/1) #t) +(num-test (< 1/1 1/1 1/1) #f) +(num-test (<= 1/1 1/1 1/1) #t) +(num-test (> 1/1 1/1 1/1) #f) +(num-test (>= 1/1 1/1 1/1) #t) +(num-test (+ 1/1 1/1 1.0+1.0i) 3.0+1.0i) +(num-test (- 1/1 1/1 1.0+1.0i) -1.0-1.0i) +(num-test (* 1/1 1/1 1.0+1.0i) 1.0+1.0i) +(num-test (/ 1/1 1/1 1.0+1.0i) 0.5-0.5i) +(num-test (= 1/1 1/1 1.0+1.0i) #f) +(num-test (+ 1/1 1/1 0) 2) +(num-test (- 1/1 1/1 0) 0) +(num-test (* 1/1 1/1 0) 0) +(num-test (+ 1/1 1/1 0.0) 2.0) +(num-test (- 1/1 1/1 0.0) 0.0) +(num-test (* 1/1 1/1 0.0) 0.0) +(num-test (+ 1/1 1/1 1234) 1236) +(num-test (- 1/1 1/1 1234) -1234) +(num-test (* 1/1 1/1 1234) 1234) +(num-test (/ 1/1 1/1 1234) 1/1234) +(num-test (= 1/1 1/1 1234) #f) +(num-test (< 1/1 1/1 1234) #f) +(num-test (<= 1/1 1/1 1234) #t) +(num-test (> 1/1 1/1 1234) #f) +(num-test (>= 1/1 1/1 1234) #f) +(num-test (+ 1/1 1/1 123.4) 125.4) +(num-test (- 1/1 1/1 123.4) -123.4) +(num-test (* 1/1 1/1 123.4) 123.4) +(num-test (/ 1/1 1/1 123.4) 0.00810372771475) +(num-test (= 1/1 1/1 123.4) #f) +(num-test (< 1/1 1/1 123.4) #f) +(num-test (<= 1/1 1/1 123.4) #t) +(num-test (> 1/1 1/1 123.4) #f) +(num-test (>= 1/1 1/1 123.4) #f) +(num-test (+ 1/1 1/1 1234/11) 1256/11) +(num-test (- 1/1 1/1 1234/11) -1234/11) +(num-test (* 1/1 1/1 1234/11) 1234/11) +(num-test (/ 1/1 1/1 1234/11) 11/1234) +(num-test (= 1/1 1/1 1234/11) #f) +(num-test (< 1/1 1/1 1234/11) #f) +(num-test (<= 1/1 1/1 1234/11) #t) +(num-test (> 1/1 1/1 1234/11) #f) +(num-test (>= 1/1 1/1 1234/11) #f) +(num-test (+ 1/1 1/1 1.234+1.234i) 3.234+1.234i) +(num-test (- 1/1 1/1 1.234+1.234i) -1.234-1.234i) +(num-test (* 1/1 1/1 1.234+1.234i) 1.234+1.234i) +(num-test (/ 1/1 1/1 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1/1 1.234+1.234i) #f) +(num-test (+ 1/1 1/1 -1.0+1.0i) 1.0+1.0i) +(num-test (- 1/1 1/1 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1/1 1/1 -1.0+1.0i) -1.0+1.0i) +(num-test (/ 1/1 1/1 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1/1 1/1 -1.0+1.0i) #f) +(num-test (+ 1/1 1/1 0.0+1.0i) 2.0+1.0i) +(num-test (- 1/1 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (* 1/1 1/1 0.0+1.0i) 0.0+1.0i) +(num-test (/ 1/1 1/1 0.0+1.0i) 0.0-1.0i) +(num-test (= 1/1 1/1 0.0+1.0i) #f) +(num-test (+ 1/1 1.0+1.0i 1) 3.0+1.0i) +(num-test (- 1/1 1.0+1.0i 1) -1.0-1.0i) +(num-test (* 1/1 1.0+1.0i 1) 1.0+1.0i) +(num-test (/ 1/1 1.0+1.0i 1) 0.5-0.5i) +(num-test (= 1/1 1.0+1.0i 1) #f) +(num-test (+ 1/1 1.0+1.0i 1.0) 3.0+1.0i) +(num-test (- 1/1 1.0+1.0i 1.0) -1.0-1.0i) +(num-test (* 1/1 1.0+1.0i 1.0) 1.0+1.0i) +(num-test (/ 1/1 1.0+1.0i 1.0) 0.5-0.5i) +(num-test (= 1/1 1.0+1.0i 1.0) #f) +(num-test (+ 1/1 1.0+1.0i 1/1) 3.0+1.0i) +(num-test (- 1/1 1.0+1.0i 1/1) -1.0-1.0i) +(num-test (* 1/1 1.0+1.0i 1/1) 1.0+1.0i) +(num-test (/ 1/1 1.0+1.0i 1/1) 0.5-0.5i) +(num-test (= 1/1 1.0+1.0i 1/1) #f) +(num-test (+ 1/1 1.0+1.0i 1.0+1.0i) 3.0+2.0i) +(num-test (- 1/1 1.0+1.0i 1.0+1.0i) -1.0-2.0i) +(num-test (* 1/1 1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1/1 1.0+1.0i 1.0+1.0i) 0.0-0.5i) +(num-test (= 1/1 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1/1 1.0+1.0i 0) 2.0+1.0i) +(num-test (- 1/1 1.0+1.0i 0) 0.0-1.0i) +(num-test (* 1/1 1.0+1.0i 0) 0.0) +(num-test (+ 1/1 1.0+1.0i 0.0) 2.0+1.0i) +(num-test (- 1/1 1.0+1.0i 0.0) 0.0-1.0i) +(num-test (* 1/1 1.0+1.0i 0.0) 0.0) +(num-test (+ 1/1 1.0+1.0i 1234) 1236.0+1.0i) +(num-test (- 1/1 1.0+1.0i 1234) -1234.0-1.0i) +(num-test (* 1/1 1.0+1.0i 1234) 1234.0+1234.0i) +(num-test (/ 1/1 1.0+1.0i 1234) 0.00040518638574-0.00040518638574i) +(num-test (= 1/1 1.0+1.0i 1234) #f) +(num-test (+ 1/1 1.0+1.0i 123.4) 125.4+1.0i) +(num-test (- 1/1 1.0+1.0i 123.4) -123.4-1.0i) +(num-test (* 1/1 1.0+1.0i 123.4) 123.4+123.4i) +(num-test (/ 1/1 1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i) +(num-test (= 1/1 1.0+1.0i 123.4) #f) +(num-test (+ 1/1 1.0+1.0i 1234/11) 114.18181818181819+1.0i) +(num-test (- 1/1 1.0+1.0i 1234/11) -112.18181818181819-1.0i) +(num-test (* 1/1 1.0+1.0i 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1/1 1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i) +(num-test (= 1/1 1.0+1.0i 1234/11) #f) +(num-test (+ 1/1 1.0+1.0i 1.234+1.234i) 3.234+2.234i) +(num-test (- 1/1 1.0+1.0i 1.234+1.234i) -1.234-2.234i) +(num-test (* 1/1 1.0+1.0i 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1/1 1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i) +(num-test (= 1/1 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1/1 1.0+1.0i -1.0+1.0i) 1.0+2.0i) +(num-test (- 1/1 1.0+1.0i -1.0+1.0i) 1.0-2.0i) +(num-test (* 1/1 1.0+1.0i -1.0+1.0i) -2.0) +(num-test (/ 1/1 1.0+1.0i -1.0+1.0i) -0.5) +(num-test (= 1/1 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1/1 1.0+1.0i 0.0+1.0i) 2.0+2.0i) +(num-test (- 1/1 1.0+1.0i 0.0+1.0i) 0.0-2.0i) +(num-test (* 1/1 1.0+1.0i 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1/1 1.0+1.0i 0.0+1.0i) -0.5-0.5i) +(num-test (= 1/1 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1/1 0 1) 2) +(num-test (- 1/1 0 1) 0) +(num-test (* 1/1 0 1) 0) +(num-test (+ 1/1 0 1.0) 2.0) +(num-test (- 1/1 0 1.0) 0.0) +(num-test (* 1/1 0 1.0) 0.0) +(num-test (+ 1/1 0 1/1) 2) +(num-test (- 1/1 0 1/1) 0) +(num-test (* 1/1 0 1/1) 0) +(num-test (+ 1/1 0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1/1 0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1/1 0 1.0+1.0i) 0.0) +(num-test (+ 1/1 0 0) 1) +(num-test (- 1/1 0 0) 1) +(num-test (* 1/1 0 0) 0) +(num-test (+ 1/1 0 0.0) 1.0) +(num-test (- 1/1 0 0.0) 1.0) +(num-test (* 1/1 0 0.0) 0.0) +(num-test (+ 1/1 0 1234) 1235) +(num-test (- 1/1 0 1234) -1233) +(num-test (* 1/1 0 1234) 0) +(num-test (+ 1/1 0 123.4) 124.4) +(num-test (- 1/1 0 123.4) -122.4) +(num-test (* 1/1 0 123.4) 0.0) +(num-test (+ 1/1 0 1234/11) 1245/11) +(num-test (- 1/1 0 1234/11) -1223/11) +(num-test (* 1/1 0 1234/11) 0) +(num-test (+ 1/1 0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1/1 0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1/1 0 1.234+1.234i) 0.0) +(num-test (+ 1/1 0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1/1 0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1/1 0 -1.0+1.0i) -0.0) +(num-test (+ 1/1 0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1/1 0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1/1 0 0.0+1.0i) 0.0) +(num-test (+ 1/1 0.0 1) 2.0) +(num-test (- 1/1 0.0 1) 0.0) +(num-test (* 1/1 0.0 1) 0.0) +(num-test (+ 1/1 0.0 1.0) 2.0) +(num-test (- 1/1 0.0 1.0) 0.0) +(num-test (* 1/1 0.0 1.0) 0.0) +(num-test (+ 1/1 0.0 1/1) 2.0) +(num-test (- 1/1 0.0 1/1) 0.0) +(num-test (* 1/1 0.0 1/1) 0.0) +(num-test (+ 1/1 0.0 1.0+1.0i) 2.0+1.0i) +(num-test (- 1/1 0.0 1.0+1.0i) 0.0-1.0i) +(num-test (* 1/1 0.0 1.0+1.0i) 0.0) +(num-test (+ 1/1 0.0 0) 1.0) +(num-test (- 1/1 0.0 0) 1.0) +(num-test (* 1/1 0.0 0) 0.0) +(num-test (+ 1/1 0.0 0.0) 1.0) +(num-test (- 1/1 0.0 0.0) 1.0) +(num-test (* 1/1 0.0 0.0) 0.0) +(num-test (+ 1/1 0.0 1234) 1235.0) +(num-test (- 1/1 0.0 1234) -1233.0) +(num-test (* 1/1 0.0 1234) 0.0) +(num-test (+ 1/1 0.0 123.4) 124.4) +(num-test (- 1/1 0.0 123.4) -122.4) +(num-test (* 1/1 0.0 123.4) 0.0) +(num-test (+ 1/1 0.0 1234/11) 113.18181818181819) +(num-test (- 1/1 0.0 1234/11) -111.18181818181819) +(num-test (* 1/1 0.0 1234/11) 0.0) +(num-test (+ 1/1 0.0 1.234+1.234i) 2.234+1.234i) +(num-test (- 1/1 0.0 1.234+1.234i) -0.234-1.234i) +(num-test (* 1/1 0.0 1.234+1.234i) 0.0) +(num-test (+ 1/1 0.0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 1/1 0.0 -1.0+1.0i) 2.0-1.0i) +(num-test (* 1/1 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1/1 0.0 0.0+1.0i) 1.0+1.0i) +(num-test (- 1/1 0.0 0.0+1.0i) 1.0-1.0i) +(num-test (* 1/1 0.0 0.0+1.0i) 0.0) +(num-test (+ 1/1 1234 1) 1236) +(num-test (- 1/1 1234 1) -1234) +(num-test (* 1/1 1234 1) 1234) +(num-test (/ 1/1 1234 1) 1/1234) +(num-test (= 1/1 1234 1) #f) +(num-test (< 1/1 1234 1) #f) +(num-test (<= 1/1 1234 1) #f) +(num-test (> 1/1 1234 1) #f) +(num-test (>= 1/1 1234 1) #f) +(num-test (+ 1/1 1234 1.0) 1236.0) +(num-test (- 1/1 1234 1.0) -1234.0) +(num-test (* 1/1 1234 1.0) 1234.0) +(num-test (/ 1/1 1234 1.0) 0.00081037277147) +(num-test (= 1/1 1234 1.0) #f) +(num-test (< 1/1 1234 1.0) #f) +(num-test (<= 1/1 1234 1.0) #f) +(num-test (> 1/1 1234 1.0) #f) +(num-test (>= 1/1 1234 1.0) #f) +(num-test (+ 1/1 1234 1/1) 1236) +(num-test (- 1/1 1234 1/1) -1234) +(num-test (* 1/1 1234 1/1) 1234) +(num-test (/ 1/1 1234 1/1) 1/1234) +(num-test (= 1/1 1234 1/1) #f) +(num-test (< 1/1 1234 1/1) #f) +(num-test (<= 1/1 1234 1/1) #f) +(num-test (> 1/1 1234 1/1) #f) +(num-test (>= 1/1 1234 1/1) #f) +(num-test (+ 1/1 1234 1.0+1.0i) 1236.0+1.0i) +(num-test (- 1/1 1234 1.0+1.0i) -1234.0-1.0i) +(num-test (* 1/1 1234 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1/1 1234 1.0+1.0i) 0.00040518638574-0.00040518638574i) +(num-test (= 1/1 1234 1.0+1.0i) #f) +(num-test (+ 1/1 1234 0) 1235) +(num-test (- 1/1 1234 0) -1233) +(num-test (* 1/1 1234 0) 0) +(num-test (+ 1/1 1234 0.0) 1235.0) +(num-test (- 1/1 1234 0.0) -1233.0) +(num-test (* 1/1 1234 0.0) 0.0) +(num-test (+ 1/1 1234 1234) 2469) +(num-test (- 1/1 1234 1234) -2467) +(num-test (* 1/1 1234 1234) 1522756) +(num-test (/ 1/1 1234 1234) 1/1522756) +(num-test (= 1/1 1234 1234) #f) +(num-test (< 1/1 1234 1234) #f) +(num-test (<= 1/1 1234 1234) #t) +(num-test (> 1/1 1234 1234) #f) +(num-test (>= 1/1 1234 1234) #f) +(num-test (+ 1/1 1234 123.4) 1358.4) +(num-test (- 1/1 1234 123.4) -1356.4) +(num-test (* 1/1 1234 123.4) 152275.60000000000582) +(num-test (/ 1/1 1234 123.4) 0.00000656704029) +(num-test (= 1/1 1234 123.4) #f) +(num-test (< 1/1 1234 123.4) #f) +(num-test (<= 1/1 1234 123.4) #f) +(num-test (> 1/1 1234 123.4) #f) +(num-test (>= 1/1 1234 123.4) #f) +(num-test (+ 1/1 1234 1234/11) 14819/11) +(num-test (- 1/1 1234 1234/11) -14797/11) +(num-test (* 1/1 1234 1234/11) 1522756/11) +(num-test (/ 1/1 1234 1234/11) 11/1522756) +(num-test (= 1/1 1234 1234/11) #f) +(num-test (< 1/1 1234 1234/11) #f) +(num-test (<= 1/1 1234 1234/11) #f) +(num-test (> 1/1 1234 1234/11) #f) +(num-test (>= 1/1 1234 1234/11) #f) +(num-test (+ 1/1 1234 1.234+1.234i) 1236.23399999999992+1.234i) +(num-test (- 1/1 1234 1.234+1.234i) -1234.23399999999992-1.234i) +(num-test (* 1/1 1234 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1/1 1234 1.234+1.234i) 0.00032835201437-0.00032835201437i) +(num-test (= 1/1 1234 1.234+1.234i) #f) +(num-test (+ 1/1 1234 -1.0+1.0i) 1234.0+1.0i) +(num-test (- 1/1 1234 -1.0+1.0i) -1232.0-1.0i) +(num-test (* 1/1 1234 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1/1 1234 -1.0+1.0i) -0.00040518638574-0.00040518638574i) +(num-test (= 1/1 1234 -1.0+1.0i) #f) +(num-test (+ 1/1 1234 0.0+1.0i) 1235.0+1.0i) +(num-test (- 1/1 1234 0.0+1.0i) -1233.0-1.0i) +(num-test (* 1/1 1234 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1/1 1234 0.0+1.0i) 0.0-0.00081037277147i) +(num-test (= 1/1 1234 0.0+1.0i) #f) +(num-test (+ 1/1 123.4 1) 125.4) +(num-test (- 1/1 123.4 1) -123.4) +(num-test (* 1/1 123.4 1) 123.4) +(num-test (/ 1/1 123.4 1) 0.00810372771475) +(num-test (= 1/1 123.4 1) #f) +(num-test (< 1/1 123.4 1) #f) +(num-test (<= 1/1 123.4 1) #f) +(num-test (> 1/1 123.4 1) #f) +(num-test (>= 1/1 123.4 1) #f) +(num-test (+ 1/1 123.4 1.0) 125.4) +(num-test (- 1/1 123.4 1.0) -123.4) +(num-test (* 1/1 123.4 1.0) 123.4) +(num-test (/ 1/1 123.4 1.0) 0.00810372771475) +(num-test (= 1/1 123.4 1.0) #f) +(num-test (< 1/1 123.4 1.0) #f) +(num-test (<= 1/1 123.4 1.0) #f) +(num-test (> 1/1 123.4 1.0) #f) +(num-test (>= 1/1 123.4 1.0) #f) +(num-test (+ 1/1 123.4 1/1) 125.4) +(num-test (- 1/1 123.4 1/1) -123.4) +(num-test (* 1/1 123.4 1/1) 123.4) +(num-test (/ 1/1 123.4 1/1) 0.00810372771475) +(num-test (= 1/1 123.4 1/1) #f) +(num-test (< 1/1 123.4 1/1) #f) +(num-test (<= 1/1 123.4 1/1) #f) +(num-test (> 1/1 123.4 1/1) #f) +(num-test (>= 1/1 123.4 1/1) #f) +(num-test (+ 1/1 123.4 1.0+1.0i) 125.4+1.0i) +(num-test (- 1/1 123.4 1.0+1.0i) -123.4-1.0i) +(num-test (* 1/1 123.4 1.0+1.0i) 123.4+123.4i) +(num-test (/ 1/1 123.4 1.0+1.0i) 0.00405186385737-0.00405186385737i) +(num-test (= 1/1 123.4 1.0+1.0i) #f) +(num-test (+ 1/1 123.4 0) 124.4) +(num-test (- 1/1 123.4 0) -122.4) +(num-test (* 1/1 123.4 0) 0.0) +(num-test (+ 1/1 123.4 0.0) 124.4) +(num-test (- 1/1 123.4 0.0) -122.4) +(num-test (* 1/1 123.4 0.0) 0.0) +(num-test (+ 1/1 123.4 1234) 1358.4) +(num-test (- 1/1 123.4 1234) -1356.4) +(num-test (* 1/1 123.4 1234) 152275.60000000000582) +(num-test (/ 1/1 123.4 1234) 0.00000656704029) +(num-test (= 1/1 123.4 1234) #f) +(num-test (< 1/1 123.4 1234) #t) +(num-test (<= 1/1 123.4 1234) #t) +(num-test (> 1/1 123.4 1234) #f) +(num-test (>= 1/1 123.4 1234) #f) +(num-test (+ 1/1 123.4 123.4) 247.8) +(num-test (- 1/1 123.4 123.4) -245.8) +(num-test (* 1/1 123.4 123.4) 15227.56000000000131) +(num-test (/ 1/1 123.4 123.4) 0.00006567040287) +(num-test (= 1/1 123.4 123.4) #f) +(num-test (< 1/1 123.4 123.4) #f) +(num-test (<= 1/1 123.4 123.4) #t) +(num-test (> 1/1 123.4 123.4) #f) +(num-test (>= 1/1 123.4 123.4) #f) +(num-test (+ 1/1 123.4 1234/11) 236.58181818181819) +(num-test (- 1/1 123.4 1234/11) -234.58181818181819) +(num-test (* 1/1 123.4 1234/11) 13843.23636363636433) +(num-test (/ 1/1 123.4 1234/11) 0.00007223744316) +(num-test (= 1/1 123.4 1234/11) #f) +(num-test (< 1/1 123.4 1234/11) #f) +(num-test (<= 1/1 123.4 1234/11) #f) +(num-test (> 1/1 123.4 1234/11) #f) +(num-test (>= 1/1 123.4 1234/11) #f) +(num-test (+ 1/1 123.4 1.234+1.234i) 125.634+1.234i) +(num-test (- 1/1 123.4 1.234+1.234i) -123.634-1.234i) +(num-test (* 1/1 123.4 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 1/1 123.4 1.234+1.234i) 0.00328352014374-0.00328352014374i) +(num-test (= 1/1 123.4 1.234+1.234i) #f) +(num-test (+ 1/1 123.4 -1.0+1.0i) 123.4+1.0i) +(num-test (- 1/1 123.4 -1.0+1.0i) -121.4-1.0i) +(num-test (* 1/1 123.4 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 1/1 123.4 -1.0+1.0i) -0.00405186385737-0.00405186385737i) +(num-test (= 1/1 123.4 -1.0+1.0i) #f) +(num-test (+ 1/1 123.4 0.0+1.0i) 124.4+1.0i) +(num-test (- 1/1 123.4 0.0+1.0i) -122.4-1.0i) +(num-test (* 1/1 123.4 0.0+1.0i) 0.0+123.4i) +(num-test (/ 1/1 123.4 0.0+1.0i) 0.0-0.00810372771475i) +(num-test (= 1/1 123.4 0.0+1.0i) #f) +(num-test (+ 1/1 1234/11 1) 1256/11) +(num-test (- 1/1 1234/11 1) -1234/11) +(num-test (* 1/1 1234/11 1) 1234/11) +(num-test (/ 1/1 1234/11 1) 11/1234) +(num-test (= 1/1 1234/11 1) #f) +(num-test (< 1/1 1234/11 1) #f) +(num-test (<= 1/1 1234/11 1) #f) +(num-test (> 1/1 1234/11 1) #f) +(num-test (>= 1/1 1234/11 1) #f) +(num-test (+ 1/1 1234/11 1.0) 114.18181818181819) +(num-test (- 1/1 1234/11 1.0) -112.18181818181819) +(num-test (* 1/1 1234/11 1.0) 112.18181818181819) +(num-test (/ 1/1 1234/11 1.0) 0.00891410048622) +(num-test (= 1/1 1234/11 1.0) #f) +(num-test (< 1/1 1234/11 1.0) #f) +(num-test (<= 1/1 1234/11 1.0) #f) +(num-test (> 1/1 1234/11 1.0) #f) +(num-test (>= 1/1 1234/11 1.0) #f) +(num-test (+ 1/1 1234/11 1/1) 1256/11) +(num-test (- 1/1 1234/11 1/1) -1234/11) +(num-test (* 1/1 1234/11 1/1) 1234/11) +(num-test (/ 1/1 1234/11 1/1) 11/1234) +(num-test (= 1/1 1234/11 1/1) #f) +(num-test (< 1/1 1234/11 1/1) #f) +(num-test (<= 1/1 1234/11 1/1) #f) +(num-test (> 1/1 1234/11 1/1) #f) +(num-test (>= 1/1 1234/11 1/1) #f) +(num-test (+ 1/1 1234/11 1.0+1.0i) 114.18181818181819+1.0i) +(num-test (- 1/1 1234/11 1.0+1.0i) -112.18181818181819-1.0i) +(num-test (* 1/1 1234/11 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1/1 1234/11 1.0+1.0i) 0.00445705024311-0.00445705024311i) +(num-test (= 1/1 1234/11 1.0+1.0i) #f) +(num-test (+ 1/1 1234/11 0) 1245/11) +(num-test (- 1/1 1234/11 0) -1223/11) +(num-test (* 1/1 1234/11 0) 0) +(num-test (+ 1/1 1234/11 0.0) 113.18181818181819) +(num-test (- 1/1 1234/11 0.0) -111.18181818181819) +(num-test (* 1/1 1234/11 0.0) 0.0) +(num-test (+ 1/1 1234/11 1234) 14819/11) +(num-test (- 1/1 1234/11 1234) -14797/11) +(num-test (* 1/1 1234/11 1234) 1522756/11) +(num-test (/ 1/1 1234/11 1234) 11/1522756) +(num-test (= 1/1 1234/11 1234) #f) +(num-test (< 1/1 1234/11 1234) #t) +(num-test (<= 1/1 1234/11 1234) #t) +(num-test (> 1/1 1234/11 1234) #f) +(num-test (>= 1/1 1234/11 1234) #f) +(num-test (+ 1/1 1234/11 123.4) 236.58181818181819) +(num-test (- 1/1 1234/11 123.4) -234.58181818181819) +(num-test (* 1/1 1234/11 123.4) 13843.23636363636433) +(num-test (/ 1/1 1234/11 123.4) 0.00007223744316) +(num-test (= 1/1 1234/11 123.4) #f) +(num-test (< 1/1 1234/11 123.4) #t) +(num-test (<= 1/1 1234/11 123.4) #t) +(num-test (> 1/1 1234/11 123.4) #f) +(num-test (>= 1/1 1234/11 123.4) #f) +(num-test (+ 1/1 1234/11 1234/11) 2479/11) +(num-test (- 1/1 1234/11 1234/11) -2457/11) +(num-test (* 1/1 1234/11 1234/11) 1522756/121) +(num-test (/ 1/1 1234/11 1234/11) 121/1522756) +(num-test (= 1/1 1234/11 1234/11) #f) +(num-test (< 1/1 1234/11 1234/11) #f) +(num-test (<= 1/1 1234/11 1234/11) #t) +(num-test (> 1/1 1234/11 1234/11) #f) +(num-test (>= 1/1 1234/11 1234/11) #f) +(num-test (+ 1/1 1234/11 1.234+1.234i) 114.41581818181818+1.234i) +(num-test (- 1/1 1234/11 1.234+1.234i) -112.41581818181818-1.234i) +(num-test (* 1/1 1234/11 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1/1 1234/11 1.234+1.234i) 0.00361187215811-0.00361187215811i) +(num-test (= 1/1 1234/11 1.234+1.234i) #f) +(num-test (+ 1/1 1234/11 -1.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1/1 1234/11 -1.0+1.0i) -110.18181818181819-1.0i) +(num-test (* 1/1 1234/11 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1/1 1234/11 -1.0+1.0i) -0.00445705024311-0.00445705024311i) +(num-test (= 1/1 1234/11 -1.0+1.0i) #f) +(num-test (+ 1/1 1234/11 0.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1/1 1234/11 0.0+1.0i) -111.18181818181819-1.0i) +(num-test (* 1/1 1234/11 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1/1 1234/11 0.0+1.0i) 0.0-0.00891410048622i) +(num-test (= 1/1 1234/11 0.0+1.0i) #f) +(num-test (+ 1/1 1.234+1.234i 1) 3.234+1.234i) +(num-test (- 1/1 1.234+1.234i 1) -1.234-1.234i) +(num-test (* 1/1 1.234+1.234i 1) 1.234+1.234i) +(num-test (/ 1/1 1.234+1.234i 1) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1.234+1.234i 1) #f) +(num-test (+ 1/1 1.234+1.234i 1.0) 3.234+1.234i) +(num-test (- 1/1 1.234+1.234i 1.0) -1.234-1.234i) +(num-test (* 1/1 1.234+1.234i 1.0) 1.234+1.234i) +(num-test (/ 1/1 1.234+1.234i 1.0) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1.234+1.234i 1.0) #f) +(num-test (+ 1/1 1.234+1.234i 1/1) 3.234+1.234i) +(num-test (- 1/1 1.234+1.234i 1/1) -1.234-1.234i) +(num-test (* 1/1 1.234+1.234i 1/1) 1.234+1.234i) +(num-test (/ 1/1 1.234+1.234i 1/1) 0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1.234+1.234i 1/1) #f) +(num-test (+ 1/1 1.234+1.234i 1.0+1.0i) 3.234+2.234i) +(num-test (- 1/1 1.234+1.234i 1.0+1.0i) -1.234-2.234i) +(num-test (* 1/1 1.234+1.234i 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1/1 1.234+1.234i 1.0+1.0i) 0.0-0.40518638573744i) +(num-test (= 1/1 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1/1 1.234+1.234i 0) 2.234+1.234i) +(num-test (- 1/1 1.234+1.234i 0) -0.234-1.234i) +(num-test (* 1/1 1.234+1.234i 0) 0.0) +(num-test (+ 1/1 1.234+1.234i 0.0) 2.234+1.234i) +(num-test (- 1/1 1.234+1.234i 0.0) -0.234-1.234i) +(num-test (* 1/1 1.234+1.234i 0.0) 0.0) +(num-test (+ 1/1 1.234+1.234i 1234) 1236.23399999999992+1.234i) +(num-test (- 1/1 1.234+1.234i 1234) -1234.23399999999992-1.234i) +(num-test (* 1/1 1.234+1.234i 1234) 1522.756+1522.756i) +(num-test (/ 1/1 1.234+1.234i 1234) 0.00032835201437-0.00032835201437i) +(num-test (= 1/1 1.234+1.234i 1234) #f) +(num-test (+ 1/1 1.234+1.234i 123.4) 125.634+1.234i) +(num-test (- 1/1 1.234+1.234i 123.4) -123.634-1.234i) +(num-test (* 1/1 1.234+1.234i 123.4) 152.2756+152.2756i) +(num-test (/ 1/1 1.234+1.234i 123.4) 0.00328352014374-0.00328352014374i) +(num-test (= 1/1 1.234+1.234i 123.4) #f) +(num-test (+ 1/1 1.234+1.234i 1234/11) 114.41581818181818+1.234i) +(num-test (- 1/1 1.234+1.234i 1234/11) -112.41581818181818-1.234i) +(num-test (* 1/1 1.234+1.234i 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1/1 1.234+1.234i 1234/11) 0.00361187215811-0.00361187215811i) +(num-test (= 1/1 1.234+1.234i 1234/11) #f) +(num-test (+ 1/1 1.234+1.234i 1.234+1.234i) 3.468+2.468i) +(num-test (- 1/1 1.234+1.234i 1.234+1.234i) -1.468-2.468i) +(num-test (* 1/1 1.234+1.234i 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1/1 1.234+1.234i 1.234+1.234i) 0.0-0.32835201437394i) +(num-test (= 1/1 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 1/1 1.234+1.234i -1.0+1.0i) 1.234+2.234i) +(num-test (- 1/1 1.234+1.234i -1.0+1.0i) 0.766-2.234i) +(num-test (* 1/1 1.234+1.234i -1.0+1.0i) -2.468) +(num-test (/ 1/1 1.234+1.234i -1.0+1.0i) -0.40518638573744) +(num-test (= 1/1 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1/1 1.234+1.234i 0.0+1.0i) 2.234+2.234i) +(num-test (- 1/1 1.234+1.234i 0.0+1.0i) -0.234-2.234i) +(num-test (* 1/1 1.234+1.234i 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1/1 1.234+1.234i 0.0+1.0i) -0.40518638573744-0.40518638573744i) +(num-test (= 1/1 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1/1 -1.0+1.0i 1) 1.0+1.0i) +(num-test (- 1/1 -1.0+1.0i 1) 1.0-1.0i) +(num-test (* 1/1 -1.0+1.0i 1) -1.0+1.0i) +(num-test (/ 1/1 -1.0+1.0i 1) -0.5-0.5i) +(num-test (= 1/1 -1.0+1.0i 1) #f) +(num-test (+ 1/1 -1.0+1.0i 1.0) 1.0+1.0i) +(num-test (- 1/1 -1.0+1.0i 1.0) 1.0-1.0i) +(num-test (* 1/1 -1.0+1.0i 1.0) -1.0+1.0i) +(num-test (/ 1/1 -1.0+1.0i 1.0) -0.5-0.5i) +(num-test (= 1/1 -1.0+1.0i 1.0) #f) +(num-test (+ 1/1 -1.0+1.0i 1/1) 1.0+1.0i) +(num-test (- 1/1 -1.0+1.0i 1/1) 1.0-1.0i) +(num-test (* 1/1 -1.0+1.0i 1/1) -1.0+1.0i) +(num-test (/ 1/1 -1.0+1.0i 1/1) -0.5-0.5i) +(num-test (= 1/1 -1.0+1.0i 1/1) #f) +(num-test (+ 1/1 -1.0+1.0i 1.0+1.0i) 1.0+2.0i) +(num-test (- 1/1 -1.0+1.0i 1.0+1.0i) 1.0-2.0i) +(num-test (* 1/1 -1.0+1.0i 1.0+1.0i) -2.0) +(num-test (/ 1/1 -1.0+1.0i 1.0+1.0i) -0.5) +(num-test (= 1/1 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1/1 -1.0+1.0i 0) 0.0+1.0i) +(num-test (- 1/1 -1.0+1.0i 0) 2.0-1.0i) +(num-test (* 1/1 -1.0+1.0i 0) -0.0) +(num-test (+ 1/1 -1.0+1.0i 0.0) 0.0+1.0i) +(num-test (- 1/1 -1.0+1.0i 0.0) 2.0-1.0i) +(num-test (* 1/1 -1.0+1.0i 0.0) -0.0) +(num-test (+ 1/1 -1.0+1.0i 1234) 1234.0+1.0i) +(num-test (- 1/1 -1.0+1.0i 1234) -1232.0-1.0i) +(num-test (* 1/1 -1.0+1.0i 1234) -1234.0+1234.0i) +(num-test (/ 1/1 -1.0+1.0i 1234) -0.00040518638574-0.00040518638574i) +(num-test (= 1/1 -1.0+1.0i 1234) #f) +(num-test (+ 1/1 -1.0+1.0i 123.4) 123.4+1.0i) +(num-test (- 1/1 -1.0+1.0i 123.4) -121.4-1.0i) +(num-test (* 1/1 -1.0+1.0i 123.4) -123.4+123.4i) +(num-test (/ 1/1 -1.0+1.0i 123.4) -0.00405186385737-0.00405186385737i) +(num-test (= 1/1 -1.0+1.0i 123.4) #f) +(num-test (+ 1/1 -1.0+1.0i 1234/11) 112.18181818181819+1.0i) +(num-test (- 1/1 -1.0+1.0i 1234/11) -110.18181818181819-1.0i) +(num-test (* 1/1 -1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ 1/1 -1.0+1.0i 1234/11) -0.00445705024311-0.00445705024311i) +(num-test (= 1/1 -1.0+1.0i 1234/11) #f) +(num-test (+ 1/1 -1.0+1.0i 1.234+1.234i) 1.234+2.234i) +(num-test (- 1/1 -1.0+1.0i 1.234+1.234i) 0.766-2.234i) +(num-test (* 1/1 -1.0+1.0i 1.234+1.234i) -2.468) +(num-test (/ 1/1 -1.0+1.0i 1.234+1.234i) -0.40518638573744) +(num-test (= 1/1 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1/1 -1.0+1.0i -1.0+1.0i) -1.0+2.0i) +(num-test (- 1/1 -1.0+1.0i -1.0+1.0i) 3.0-2.0i) +(num-test (* 1/1 -1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (/ 1/1 -1.0+1.0i -1.0+1.0i) -0.0+0.5i) +(num-test (= 1/1 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1/1 -1.0+1.0i 0.0+1.0i) 0.0+2.0i) +(num-test (- 1/1 -1.0+1.0i 0.0+1.0i) 2.0-2.0i) +(num-test (* 1/1 -1.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (/ 1/1 -1.0+1.0i 0.0+1.0i) -0.5+0.5i) +(num-test (= 1/1 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1/1 0.0+1.0i 1) 2.0+1.0i) +(num-test (- 1/1 0.0+1.0i 1) 0.0-1.0i) +(num-test (* 1/1 0.0+1.0i 1) 0.0+1.0i) +(num-test (/ 1/1 0.0+1.0i 1) 0.0-1.0i) +(num-test (= 1/1 0.0+1.0i 1) #f) +(num-test (+ 1/1 0.0+1.0i 1.0) 2.0+1.0i) +(num-test (- 1/1 0.0+1.0i 1.0) 0.0-1.0i) +(num-test (* 1/1 0.0+1.0i 1.0) 0.0+1.0i) +(num-test (/ 1/1 0.0+1.0i 1.0) 0.0-1.0i) +(num-test (= 1/1 0.0+1.0i 1.0) #f) +(num-test (+ 1/1 0.0+1.0i 1/1) 2.0+1.0i) +(num-test (- 1/1 0.0+1.0i 1/1) 0.0-1.0i) +(num-test (* 1/1 0.0+1.0i 1/1) 0.0+1.0i) +(num-test (/ 1/1 0.0+1.0i 1/1) 0.0-1.0i) +(num-test (= 1/1 0.0+1.0i 1/1) #f) +(num-test (+ 1/1 0.0+1.0i 1.0+1.0i) 2.0+2.0i) +(num-test (- 1/1 0.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (* 1/1 0.0+1.0i 1.0+1.0i) -1.0+1.0i) +(num-test (/ 1/1 0.0+1.0i 1.0+1.0i) -0.5-0.5i) +(num-test (= 1/1 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1/1 0.0+1.0i 0) 1.0+1.0i) +(num-test (- 1/1 0.0+1.0i 0) 1.0-1.0i) +(num-test (* 1/1 0.0+1.0i 0) 0.0) +(num-test (+ 1/1 0.0+1.0i 0.0) 1.0+1.0i) +(num-test (- 1/1 0.0+1.0i 0.0) 1.0-1.0i) +(num-test (* 1/1 0.0+1.0i 0.0) 0.0) +(num-test (+ 1/1 0.0+1.0i 1234) 1235.0+1.0i) +(num-test (- 1/1 0.0+1.0i 1234) -1233.0-1.0i) +(num-test (* 1/1 0.0+1.0i 1234) 0.0+1234.0i) +(num-test (/ 1/1 0.0+1.0i 1234) 0.0-0.00081037277147i) +(num-test (= 1/1 0.0+1.0i 1234) #f) +(num-test (+ 1/1 0.0+1.0i 123.4) 124.4+1.0i) +(num-test (- 1/1 0.0+1.0i 123.4) -122.4-1.0i) +(num-test (* 1/1 0.0+1.0i 123.4) 0.0+123.4i) +(num-test (/ 1/1 0.0+1.0i 123.4) 0.0-0.00810372771475i) +(num-test (= 1/1 0.0+1.0i 123.4) #f) +(num-test (+ 1/1 0.0+1.0i 1234/11) 113.18181818181819+1.0i) +(num-test (- 1/1 0.0+1.0i 1234/11) -111.18181818181819-1.0i) +(num-test (* 1/1 0.0+1.0i 1234/11) 0.0+112.18181818181819i) +(num-test (/ 1/1 0.0+1.0i 1234/11) 0.0-0.00891410048622i) +(num-test (= 1/1 0.0+1.0i 1234/11) #f) +(num-test (+ 1/1 0.0+1.0i 1.234+1.234i) 2.234+2.234i) +(num-test (- 1/1 0.0+1.0i 1.234+1.234i) -0.234-2.234i) +(num-test (* 1/1 0.0+1.0i 1.234+1.234i) -1.234+1.234i) +(num-test (/ 1/1 0.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i) +(num-test (= 1/1 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1/1 0.0+1.0i -1.0+1.0i) 0.0+2.0i) +(num-test (- 1/1 0.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (* 1/1 0.0+1.0i -1.0+1.0i) -1.0-1.0i) +(num-test (/ 1/1 0.0+1.0i -1.0+1.0i) -0.5+0.5i) +(num-test (= 1/1 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1/1 0.0+1.0i 0.0+1.0i) 1.0+2.0i) +(num-test (- 1/1 0.0+1.0i 0.0+1.0i) 1.0-2.0i) +(num-test (* 1/1 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (/ 1/1 0.0+1.0i 0.0+1.0i) -1.0) +(num-test (= 1/1 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1 1) 3.0+1.0i) +(num-test (- 1.0+1.0i 1 1) -1.0+1.0i) +(num-test (* 1.0+1.0i 1 1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1 1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1 1) #f) +(num-test (+ 1.0+1.0i 1 1.0) 3.0+1.0i) +(num-test (- 1.0+1.0i 1 1.0) -1.0+1.0i) +(num-test (* 1.0+1.0i 1 1.0) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1 1.0) 1.0+1.0i) +(num-test (= 1.0+1.0i 1 1.0) #f) +(num-test (+ 1.0+1.0i 1 1/1) 3.0+1.0i) +(num-test (- 1.0+1.0i 1 1/1) -1.0+1.0i) +(num-test (* 1.0+1.0i 1 1/1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1 1/1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1 1/1) #f) +(num-test (+ 1.0+1.0i 1 1.0+1.0i) 3.0+2.0i) +(num-test (- 1.0+1.0i 1 1.0+1.0i) -1.0) +(num-test (* 1.0+1.0i 1 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1 1.0+1.0i) 1.0) +(num-test (= 1.0+1.0i 1 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1 0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1 0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1 0) 0.0) +(num-test (+ 1.0+1.0i 1 0.0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1 0.0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1 0.0) 0.0) +(num-test (+ 1.0+1.0i 1 1234) 1236.0+1.0i) +(num-test (- 1.0+1.0i 1 1234) -1234.0+1.0i) +(num-test (* 1.0+1.0i 1 1234) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1 1234) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1 1234) #f) +(num-test (+ 1.0+1.0i 1 123.4) 125.4+1.0i) +(num-test (- 1.0+1.0i 1 123.4) -123.4+1.0i) +(num-test (* 1.0+1.0i 1 123.4) 123.4+123.4i) +(num-test (/ 1.0+1.0i 1 123.4) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 1 123.4) #f) +(num-test (+ 1.0+1.0i 1 1234/11) 114.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1 1234/11) -112.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1 1234/11) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1 1234/11) #f) +(num-test (+ 1.0+1.0i 1 1.234+1.234i) 3.234+2.234i) +(num-test (- 1.0+1.0i 1 1.234+1.234i) -1.234-0.234i) +(num-test (* 1.0+1.0i 1 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1 1.234+1.234i) 0.81037277147488) +(num-test (= 1.0+1.0i 1 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1 -1.0+1.0i) 1.0+2.0i) +(num-test (- 1.0+1.0i 1 -1.0+1.0i) 1.0) +(num-test (* 1.0+1.0i 1 -1.0+1.0i) -2.0) +(num-test (/ 1.0+1.0i 1 -1.0+1.0i) -0.0-1.0i) +(num-test (= 1.0+1.0i 1 -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1 0.0+1.0i) 2.0+2.0i) +(num-test (- 1.0+1.0i 1 0.0+1.0i) 0.0) +(num-test (* 1.0+1.0i 1 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0+1.0i 1 0.0+1.0i) 1.0-1.0i) +(num-test (= 1.0+1.0i 1 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.0 1) 3.0+1.0i) +(num-test (- 1.0+1.0i 1.0 1) -1.0+1.0i) +(num-test (* 1.0+1.0i 1.0 1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1.0 1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1.0 1) #f) +(num-test (+ 1.0+1.0i 1.0 1.0) 3.0+1.0i) +(num-test (- 1.0+1.0i 1.0 1.0) -1.0+1.0i) +(num-test (* 1.0+1.0i 1.0 1.0) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1.0 1.0) 1.0+1.0i) +(num-test (= 1.0+1.0i 1.0 1.0) #f) +(num-test (+ 1.0+1.0i 1.0 1/1) 3.0+1.0i) +(num-test (- 1.0+1.0i 1.0 1/1) -1.0+1.0i) +(num-test (* 1.0+1.0i 1.0 1/1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1.0 1/1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1.0 1/1) #f) +(num-test (+ 1.0+1.0i 1.0 1.0+1.0i) 3.0+2.0i) +(num-test (- 1.0+1.0i 1.0 1.0+1.0i) -1.0) +(num-test (* 1.0+1.0i 1.0 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1.0 1.0+1.0i) 1.0) +(num-test (= 1.0+1.0i 1.0 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.0 0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1.0 0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1.0 0) 0.0) +(num-test (+ 1.0+1.0i 1.0 0.0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1.0 0.0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1.0 0.0) 0.0) +(num-test (+ 1.0+1.0i 1.0 1234) 1236.0+1.0i) +(num-test (- 1.0+1.0i 1.0 1234) -1234.0+1.0i) +(num-test (* 1.0+1.0i 1.0 1234) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1.0 1234) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1.0 1234) #f) +(num-test (+ 1.0+1.0i 1.0 123.4) 125.4+1.0i) +(num-test (- 1.0+1.0i 1.0 123.4) -123.4+1.0i) +(num-test (* 1.0+1.0i 1.0 123.4) 123.4+123.4i) +(num-test (/ 1.0+1.0i 1.0 123.4) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 1.0 123.4) #f) +(num-test (+ 1.0+1.0i 1.0 1234/11) 114.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1.0 1234/11) -112.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1.0 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1.0 1234/11) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1.0 1234/11) #f) +(num-test (+ 1.0+1.0i 1.0 1.234+1.234i) 3.234+2.234i) +(num-test (- 1.0+1.0i 1.0 1.234+1.234i) -1.234-0.234i) +(num-test (* 1.0+1.0i 1.0 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1.0 1.234+1.234i) 0.81037277147488) +(num-test (= 1.0+1.0i 1.0 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1.0 -1.0+1.0i) 1.0+2.0i) +(num-test (- 1.0+1.0i 1.0 -1.0+1.0i) 1.0) +(num-test (* 1.0+1.0i 1.0 -1.0+1.0i) -2.0) +(num-test (/ 1.0+1.0i 1.0 -1.0+1.0i) -0.0-1.0i) +(num-test (= 1.0+1.0i 1.0 -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.0 0.0+1.0i) 2.0+2.0i) +(num-test (- 1.0+1.0i 1.0 0.0+1.0i) 0.0) +(num-test (* 1.0+1.0i 1.0 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0+1.0i 1.0 0.0+1.0i) 1.0-1.0i) +(num-test (= 1.0+1.0i 1.0 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1/1 1) 3.0+1.0i) +(num-test (- 1.0+1.0i 1/1 1) -1.0+1.0i) +(num-test (* 1.0+1.0i 1/1 1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1/1 1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1/1 1) #f) +(num-test (+ 1.0+1.0i 1/1 1.0) 3.0+1.0i) +(num-test (- 1.0+1.0i 1/1 1.0) -1.0+1.0i) +(num-test (* 1.0+1.0i 1/1 1.0) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1/1 1.0) 1.0+1.0i) +(num-test (= 1.0+1.0i 1/1 1.0) #f) +(num-test (+ 1.0+1.0i 1/1 1/1) 3.0+1.0i) +(num-test (- 1.0+1.0i 1/1 1/1) -1.0+1.0i) +(num-test (* 1.0+1.0i 1/1 1/1) 1.0+1.0i) +(num-test (/ 1.0+1.0i 1/1 1/1) 1.0+1.0i) +(num-test (= 1.0+1.0i 1/1 1/1) #f) +(num-test (+ 1.0+1.0i 1/1 1.0+1.0i) 3.0+2.0i) +(num-test (- 1.0+1.0i 1/1 1.0+1.0i) -1.0) +(num-test (* 1.0+1.0i 1/1 1.0+1.0i) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1/1 1.0+1.0i) 1.0) +(num-test (= 1.0+1.0i 1/1 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1/1 0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1/1 0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1/1 0) 0.0) +(num-test (+ 1.0+1.0i 1/1 0.0) 2.0+1.0i) +(num-test (- 1.0+1.0i 1/1 0.0) 0.0+1.0i) +(num-test (* 1.0+1.0i 1/1 0.0) 0.0) +(num-test (+ 1.0+1.0i 1/1 1234) 1236.0+1.0i) +(num-test (- 1.0+1.0i 1/1 1234) -1234.0+1.0i) +(num-test (* 1.0+1.0i 1/1 1234) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1/1 1234) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1/1 1234) #f) +(num-test (+ 1.0+1.0i 1/1 123.4) 125.4+1.0i) +(num-test (- 1.0+1.0i 1/1 123.4) -123.4+1.0i) +(num-test (* 1.0+1.0i 1/1 123.4) 123.4+123.4i) +(num-test (/ 1.0+1.0i 1/1 123.4) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 1/1 123.4) #f) +(num-test (+ 1.0+1.0i 1/1 1234/11) 114.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1/1 1234/11) -112.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1/1 1234/11) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1/1 1234/11) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1/1 1234/11) #f) +(num-test (+ 1.0+1.0i 1/1 1.234+1.234i) 3.234+2.234i) +(num-test (- 1.0+1.0i 1/1 1.234+1.234i) -1.234-0.234i) +(num-test (* 1.0+1.0i 1/1 1.234+1.234i) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1/1 1.234+1.234i) 0.81037277147488) +(num-test (= 1.0+1.0i 1/1 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1/1 -1.0+1.0i) 1.0+2.0i) +(num-test (- 1.0+1.0i 1/1 -1.0+1.0i) 1.0) +(num-test (* 1.0+1.0i 1/1 -1.0+1.0i) -2.0) +(num-test (/ 1.0+1.0i 1/1 -1.0+1.0i) -0.0-1.0i) +(num-test (= 1.0+1.0i 1/1 -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1/1 0.0+1.0i) 2.0+2.0i) +(num-test (- 1.0+1.0i 1/1 0.0+1.0i) 0.0) +(num-test (* 1.0+1.0i 1/1 0.0+1.0i) -1.0+1.0i) +(num-test (/ 1.0+1.0i 1/1 0.0+1.0i) 1.0-1.0i) +(num-test (= 1.0+1.0i 1/1 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 1) 3.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 1) -1.0) +(num-test (* 1.0+1.0i 1.0+1.0i 1) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1) 1.0) +(num-test (= 1.0+1.0i 1.0+1.0i 1) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 1.0) 3.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 1.0) -1.0) +(num-test (* 1.0+1.0i 1.0+1.0i 1.0) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1.0) 1.0) +(num-test (= 1.0+1.0i 1.0+1.0i 1.0) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 1/1) 3.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 1/1) -1.0) +(num-test (* 1.0+1.0i 1.0+1.0i 1/1) 0.0+2.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1/1) 1.0) +(num-test (= 1.0+1.0i 1.0+1.0i 1/1) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 1.0+1.0i) 3.0+3.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 1.0+1.0i) -1.0-1.0i) +(num-test (* 1.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0+2.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1.0+1.0i) 0.5-0.5i) +(num-test (= 1.0+1.0i 1.0+1.0i 1.0+1.0i) #t) +(num-test (+ 1.0+1.0i 1.0+1.0i 0) 2.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 0) 0.0) +(num-test (* 1.0+1.0i 1.0+1.0i 0) 0.0) +(num-test (+ 1.0+1.0i 1.0+1.0i 0.0) 2.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 0.0) 0.0) +(num-test (* 1.0+1.0i 1.0+1.0i 0.0) 0.0) +(num-test (+ 1.0+1.0i 1.0+1.0i 1234) 1236.0+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 1234) -1234.0) +(num-test (* 1.0+1.0i 1.0+1.0i 1234) 0.0+2468.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1234) 0.00081037277147) +(num-test (= 1.0+1.0i 1.0+1.0i 1234) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 123.4) 125.4+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 123.4) -123.4) +(num-test (* 1.0+1.0i 1.0+1.0i 123.4) 0.0+246.8i) +(num-test (/ 1.0+1.0i 1.0+1.0i 123.4) 0.00810372771475) +(num-test (= 1.0+1.0i 1.0+1.0i 123.4) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 1234/11) 114.18181818181819+2.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 1234/11) -112.18181818181819) +(num-test (* 1.0+1.0i 1.0+1.0i 1234/11) 0.0+224.36363636363637i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1234/11) 0.00891410048622) +(num-test (= 1.0+1.0i 1.0+1.0i 1234/11) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 1.234+1.234i) 3.234+3.234i) +(num-test (- 1.0+1.0i 1.0+1.0i 1.234+1.234i) -1.234-1.234i) +(num-test (* 1.0+1.0i 1.0+1.0i 1.234+1.234i) -2.468+2.468i) +(num-test (/ 1.0+1.0i 1.0+1.0i 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0+1.0i 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i -1.0+1.0i) 1.0+3.0i) +(num-test (- 1.0+1.0i 1.0+1.0i -1.0+1.0i) 1.0-1.0i) +(num-test (* 1.0+1.0i 1.0+1.0i -1.0+1.0i) -2.0-2.0i) +(num-test (/ 1.0+1.0i 1.0+1.0i -1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0+1.0i 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.0+1.0i 0.0+1.0i) 2.0+3.0i) +(num-test (- 1.0+1.0i 1.0+1.0i 0.0+1.0i) 0.0-1.0i) +(num-test (* 1.0+1.0i 1.0+1.0i 0.0+1.0i) -2.0) +(num-test (/ 1.0+1.0i 1.0+1.0i 0.0+1.0i) 0.0-1.0i) +(num-test (= 1.0+1.0i 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 0 1) 2.0+1.0i) +(num-test (- 1.0+1.0i 0 1) 0.0+1.0i) +(num-test (* 1.0+1.0i 0 1) 0.0) +(num-test (+ 1.0+1.0i 0 1.0) 2.0+1.0i) +(num-test (- 1.0+1.0i 0 1.0) 0.0+1.0i) +(num-test (* 1.0+1.0i 0 1.0) 0.0) +(num-test (+ 1.0+1.0i 0 1/1) 2.0+1.0i) +(num-test (- 1.0+1.0i 0 1/1) 0.0+1.0i) +(num-test (* 1.0+1.0i 0 1/1) 0.0) +(num-test (+ 1.0+1.0i 0 1.0+1.0i) 2.0+2.0i) +(num-test (- 1.0+1.0i 0 1.0+1.0i) 0.0) +(num-test (* 1.0+1.0i 0 1.0+1.0i) 0.0) +(num-test (+ 1.0+1.0i 0 0) 1.0+1.0i) +(num-test (- 1.0+1.0i 0 0) 1.0+1.0i) +(num-test (* 1.0+1.0i 0 0) 0.0) +(num-test (+ 1.0+1.0i 0 0.0) 1.0+1.0i) +(num-test (- 1.0+1.0i 0 0.0) 1.0+1.0i) +(num-test (* 1.0+1.0i 0 0.0) 0.0) +(num-test (+ 1.0+1.0i 0 1234) 1235.0+1.0i) +(num-test (- 1.0+1.0i 0 1234) -1233.0+1.0i) +(num-test (* 1.0+1.0i 0 1234) 0.0) +(num-test (+ 1.0+1.0i 0 123.4) 124.4+1.0i) +(num-test (- 1.0+1.0i 0 123.4) -122.4+1.0i) +(num-test (* 1.0+1.0i 0 123.4) 0.0) +(num-test (+ 1.0+1.0i 0 1234/11) 113.18181818181819+1.0i) +(num-test (- 1.0+1.0i 0 1234/11) -111.18181818181819+1.0i) +(num-test (* 1.0+1.0i 0 1234/11) 0.0) +(num-test (+ 1.0+1.0i 0 1.234+1.234i) 2.234+2.234i) +(num-test (- 1.0+1.0i 0 1.234+1.234i) -0.234-0.234i) +(num-test (* 1.0+1.0i 0 1.234+1.234i) 0.0) +(num-test (+ 1.0+1.0i 0 -1.0+1.0i) 0.0+2.0i) +(num-test (- 1.0+1.0i 0 -1.0+1.0i) 2.0) +(num-test (* 1.0+1.0i 0 -1.0+1.0i) -0.0) +(num-test (+ 1.0+1.0i 0 0.0+1.0i) 1.0+2.0i) +(num-test (- 1.0+1.0i 0 0.0+1.0i) 1.0) +(num-test (* 1.0+1.0i 0 0.0+1.0i) 0.0) +(num-test (+ 1.0+1.0i 0.0 1) 2.0+1.0i) +(num-test (- 1.0+1.0i 0.0 1) 0.0+1.0i) +(num-test (* 1.0+1.0i 0.0 1) 0.0) +(num-test (+ 1.0+1.0i 0.0 1.0) 2.0+1.0i) +(num-test (- 1.0+1.0i 0.0 1.0) 0.0+1.0i) +(num-test (* 1.0+1.0i 0.0 1.0) 0.0) +(num-test (+ 1.0+1.0i 0.0 1/1) 2.0+1.0i) +(num-test (- 1.0+1.0i 0.0 1/1) 0.0+1.0i) +(num-test (* 1.0+1.0i 0.0 1/1) 0.0) +(num-test (+ 1.0+1.0i 0.0 1.0+1.0i) 2.0+2.0i) +(num-test (- 1.0+1.0i 0.0 1.0+1.0i) 0.0) +(num-test (* 1.0+1.0i 0.0 1.0+1.0i) 0.0) +(num-test (+ 1.0+1.0i 0.0 0) 1.0+1.0i) +(num-test (- 1.0+1.0i 0.0 0) 1.0+1.0i) +(num-test (* 1.0+1.0i 0.0 0) 0.0) +(num-test (+ 1.0+1.0i 0.0 0.0) 1.0+1.0i) +(num-test (- 1.0+1.0i 0.0 0.0) 1.0+1.0i) +(num-test (* 1.0+1.0i 0.0 0.0) 0.0) +(num-test (+ 1.0+1.0i 0.0 1234) 1235.0+1.0i) +(num-test (- 1.0+1.0i 0.0 1234) -1233.0+1.0i) +(num-test (* 1.0+1.0i 0.0 1234) 0.0) +(num-test (+ 1.0+1.0i 0.0 123.4) 124.4+1.0i) +(num-test (- 1.0+1.0i 0.0 123.4) -122.4+1.0i) +(num-test (* 1.0+1.0i 0.0 123.4) 0.0) +(num-test (+ 1.0+1.0i 0.0 1234/11) 113.18181818181819+1.0i) +(num-test (- 1.0+1.0i 0.0 1234/11) -111.18181818181819+1.0i) +(num-test (* 1.0+1.0i 0.0 1234/11) 0.0) +(num-test (+ 1.0+1.0i 0.0 1.234+1.234i) 2.234+2.234i) +(num-test (- 1.0+1.0i 0.0 1.234+1.234i) -0.234-0.234i) +(num-test (* 1.0+1.0i 0.0 1.234+1.234i) 0.0) +(num-test (+ 1.0+1.0i 0.0 -1.0+1.0i) 0.0+2.0i) +(num-test (- 1.0+1.0i 0.0 -1.0+1.0i) 2.0) +(num-test (* 1.0+1.0i 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1.0+1.0i 0.0 0.0+1.0i) 1.0+2.0i) +(num-test (- 1.0+1.0i 0.0 0.0+1.0i) 1.0) +(num-test (* 1.0+1.0i 0.0 0.0+1.0i) 0.0) +(num-test (+ 1.0+1.0i 1234 1) 1236.0+1.0i) +(num-test (- 1.0+1.0i 1234 1) -1234.0+1.0i) +(num-test (* 1.0+1.0i 1234 1) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1234 1) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1234 1) #f) +(num-test (+ 1.0+1.0i 1234 1.0) 1236.0+1.0i) +(num-test (- 1.0+1.0i 1234 1.0) -1234.0+1.0i) +(num-test (* 1.0+1.0i 1234 1.0) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1234 1.0) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1234 1.0) #f) +(num-test (+ 1.0+1.0i 1234 1/1) 1236.0+1.0i) +(num-test (- 1.0+1.0i 1234 1/1) -1234.0+1.0i) +(num-test (* 1.0+1.0i 1234 1/1) 1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1234 1/1) 0.00081037277147+0.00081037277147i) +(num-test (= 1.0+1.0i 1234 1/1) #f) +(num-test (+ 1.0+1.0i 1234 1.0+1.0i) 1236.0+2.0i) +(num-test (- 1.0+1.0i 1234 1.0+1.0i) -1234.0) +(num-test (* 1.0+1.0i 1234 1.0+1.0i) 0.0+2468.0i) +(num-test (/ 1.0+1.0i 1234 1.0+1.0i) 0.00081037277147) +(num-test (= 1.0+1.0i 1234 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1234 0) 1235.0+1.0i) +(num-test (- 1.0+1.0i 1234 0) -1233.0+1.0i) +(num-test (* 1.0+1.0i 1234 0) 0.0) +(num-test (+ 1.0+1.0i 1234 0.0) 1235.0+1.0i) +(num-test (- 1.0+1.0i 1234 0.0) -1233.0+1.0i) +(num-test (* 1.0+1.0i 1234 0.0) 0.0) +(num-test (+ 1.0+1.0i 1234 1234) 2469.0+1.0i) +(num-test (- 1.0+1.0i 1234 1234) -2467.0+1.0i) +(num-test (* 1.0+1.0i 1234 1234) 1522756.0+1522756.0i) +(num-test (/ 1.0+1.0i 1234 1234) 0.00000065670403+0.00000065670403i) +(num-test (= 1.0+1.0i 1234 1234) #f) +(num-test (+ 1.0+1.0i 1234 123.4) 1358.4+1.0i) +(num-test (- 1.0+1.0i 1234 123.4) -1356.4+1.0i) +(num-test (* 1.0+1.0i 1234 123.4) 152275.60000000000582+152275.60000000000582i) +(num-test (/ 1.0+1.0i 1234 123.4) 0.00000656704029+0.00000656704029i) +(num-test (= 1.0+1.0i 1234 123.4) #f) +(num-test (+ 1.0+1.0i 1234 1234/11) 1347.18181818181824+1.0i) +(num-test (- 1.0+1.0i 1234 1234/11) -1345.18181818181824+1.0i) +(num-test (* 1.0+1.0i 1234 1234/11) 138432.36363636364695+138432.36363636364695i) +(num-test (/ 1.0+1.0i 1234 1234/11) 0.00000722374432+0.00000722374432i) +(num-test (= 1.0+1.0i 1234 1234/11) #f) +(num-test (+ 1.0+1.0i 1234 1.234+1.234i) 1236.23399999999992+2.234i) +(num-test (- 1.0+1.0i 1234 1.234+1.234i) -1234.23399999999992-0.234i) +(num-test (* 1.0+1.0i 1234 1.234+1.234i) 0.0+3045.51200000000017i) +(num-test (/ 1.0+1.0i 1234 1.234+1.234i) 0.00065670402875) +(num-test (= 1.0+1.0i 1234 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1234 -1.0+1.0i) 1234.0+2.0i) +(num-test (- 1.0+1.0i 1234 -1.0+1.0i) -1232.0) +(num-test (* 1.0+1.0i 1234 -1.0+1.0i) -2468.0) +(num-test (/ 1.0+1.0i 1234 -1.0+1.0i) -0.0-0.00081037277147i) +(num-test (= 1.0+1.0i 1234 -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1234 0.0+1.0i) 1235.0+2.0i) +(num-test (- 1.0+1.0i 1234 0.0+1.0i) -1233.0) +(num-test (* 1.0+1.0i 1234 0.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1.0+1.0i 1234 0.0+1.0i) 0.00081037277147-0.00081037277147i) +(num-test (= 1.0+1.0i 1234 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 123.4 1) 125.4+1.0i) +(num-test (- 1.0+1.0i 123.4 1) -123.4+1.0i) +(num-test (* 1.0+1.0i 123.4 1) 123.4+123.4i) +(num-test (/ 1.0+1.0i 123.4 1) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 123.4 1) #f) +(num-test (+ 1.0+1.0i 123.4 1.0) 125.4+1.0i) +(num-test (- 1.0+1.0i 123.4 1.0) -123.4+1.0i) +(num-test (* 1.0+1.0i 123.4 1.0) 123.4+123.4i) +(num-test (/ 1.0+1.0i 123.4 1.0) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 123.4 1.0) #f) +(num-test (+ 1.0+1.0i 123.4 1/1) 125.4+1.0i) +(num-test (- 1.0+1.0i 123.4 1/1) -123.4+1.0i) +(num-test (* 1.0+1.0i 123.4 1/1) 123.4+123.4i) +(num-test (/ 1.0+1.0i 123.4 1/1) 0.00810372771475+0.00810372771475i) +(num-test (= 1.0+1.0i 123.4 1/1) #f) +(num-test (+ 1.0+1.0i 123.4 1.0+1.0i) 125.4+2.0i) +(num-test (- 1.0+1.0i 123.4 1.0+1.0i) -123.4) +(num-test (* 1.0+1.0i 123.4 1.0+1.0i) 0.0+246.8i) +(num-test (/ 1.0+1.0i 123.4 1.0+1.0i) 0.00810372771475) +(num-test (= 1.0+1.0i 123.4 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 123.4 0) 124.4+1.0i) +(num-test (- 1.0+1.0i 123.4 0) -122.4+1.0i) +(num-test (* 1.0+1.0i 123.4 0) 0.0) +(num-test (+ 1.0+1.0i 123.4 0.0) 124.4+1.0i) +(num-test (- 1.0+1.0i 123.4 0.0) -122.4+1.0i) +(num-test (* 1.0+1.0i 123.4 0.0) 0.0) +(num-test (+ 1.0+1.0i 123.4 1234) 1358.4+1.0i) +(num-test (- 1.0+1.0i 123.4 1234) -1356.4+1.0i) +(num-test (* 1.0+1.0i 123.4 1234) 152275.60000000000582+152275.60000000000582i) +(num-test (/ 1.0+1.0i 123.4 1234) 0.00000656704029+0.00000656704029i) +(num-test (= 1.0+1.0i 123.4 1234) #f) +(num-test (+ 1.0+1.0i 123.4 123.4) 247.8+1.0i) +(num-test (- 1.0+1.0i 123.4 123.4) -245.8+1.0i) +(num-test (* 1.0+1.0i 123.4 123.4) 15227.56000000000131+15227.56000000000131i) +(num-test (/ 1.0+1.0i 123.4 123.4) 0.00006567040287+0.00006567040287i) +(num-test (= 1.0+1.0i 123.4 123.4) #f) +(num-test (+ 1.0+1.0i 123.4 1234/11) 236.58181818181819+1.0i) +(num-test (- 1.0+1.0i 123.4 1234/11) -234.58181818181819+1.0i) +(num-test (* 1.0+1.0i 123.4 1234/11) 13843.23636363636433+13843.23636363636433i) +(num-test (/ 1.0+1.0i 123.4 1234/11) 0.00007223744316+0.00007223744316i) +(num-test (= 1.0+1.0i 123.4 1234/11) #f) +(num-test (+ 1.0+1.0i 123.4 1.234+1.234i) 125.634+2.234i) +(num-test (- 1.0+1.0i 123.4 1.234+1.234i) -123.634-0.234i) +(num-test (* 1.0+1.0i 123.4 1.234+1.234i) 0.0+304.55119999999999i) +(num-test (/ 1.0+1.0i 123.4 1.234+1.234i) 0.00656704028748) +(num-test (= 1.0+1.0i 123.4 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 123.4 -1.0+1.0i) 123.4+2.0i) +(num-test (- 1.0+1.0i 123.4 -1.0+1.0i) -121.4) +(num-test (* 1.0+1.0i 123.4 -1.0+1.0i) -246.8) +(num-test (/ 1.0+1.0i 123.4 -1.0+1.0i) -0.0-0.00810372771475i) +(num-test (= 1.0+1.0i 123.4 -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 123.4 0.0+1.0i) 124.4+2.0i) +(num-test (- 1.0+1.0i 123.4 0.0+1.0i) -122.4) +(num-test (* 1.0+1.0i 123.4 0.0+1.0i) -123.4+123.4i) +(num-test (/ 1.0+1.0i 123.4 0.0+1.0i) 0.00810372771475-0.00810372771475i) +(num-test (= 1.0+1.0i 123.4 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1234/11 1) 114.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11 1) -112.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11 1) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1234/11 1) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1234/11 1) #f) +(num-test (+ 1.0+1.0i 1234/11 1.0) 114.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11 1.0) -112.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11 1.0) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1234/11 1.0) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1234/11 1.0) #f) +(num-test (+ 1.0+1.0i 1234/11 1/1) 114.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11 1/1) -112.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11 1/1) 112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1234/11 1/1) 0.00891410048622+0.00891410048622i) +(num-test (= 1.0+1.0i 1234/11 1/1) #f) +(num-test (+ 1.0+1.0i 1234/11 1.0+1.0i) 114.18181818181819+2.0i) +(num-test (- 1.0+1.0i 1234/11 1.0+1.0i) -112.18181818181819) +(num-test (* 1.0+1.0i 1234/11 1.0+1.0i) 0.0+224.36363636363637i) +(num-test (/ 1.0+1.0i 1234/11 1.0+1.0i) 0.00891410048622) +(num-test (= 1.0+1.0i 1234/11 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1234/11 0) 113.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11 0) -111.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11 0) 0.0) +(num-test (+ 1.0+1.0i 1234/11 0.0) 113.18181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11 0.0) -111.18181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11 0.0) 0.0) +(num-test (+ 1.0+1.0i 1234/11 1234) 1347.18181818181824+1.0i) +(num-test (- 1.0+1.0i 1234/11 1234) -1345.18181818181824+1.0i) +(num-test (* 1.0+1.0i 1234/11 1234) 138432.36363636364695+138432.36363636364695i) +(num-test (/ 1.0+1.0i 1234/11 1234) 0.00000722374432+0.00000722374432i) +(num-test (= 1.0+1.0i 1234/11 1234) #f) +(num-test (+ 1.0+1.0i 1234/11 123.4) 236.58181818181819+1.0i) +(num-test (- 1.0+1.0i 1234/11 123.4) -234.58181818181819+1.0i) +(num-test (* 1.0+1.0i 1234/11 123.4) 13843.23636363636433+13843.23636363636433i) +(num-test (/ 1.0+1.0i 1234/11 123.4) 0.00007223744316+0.00007223744316i) +(num-test (= 1.0+1.0i 1234/11 123.4) #f) +(num-test (+ 1.0+1.0i 1234/11 1234/11) 225.36363636363637+1.0i) +(num-test (- 1.0+1.0i 1234/11 1234/11) -223.36363636363637+1.0i) +(num-test (* 1.0+1.0i 1234/11 1234/11) 12584.76033057851419+12584.76033057851419i) +(num-test (/ 1.0+1.0i 1234/11 1234/11) 0.00007946118748+0.00007946118748i) +(num-test (= 1.0+1.0i 1234/11 1234/11) #f) +(num-test (+ 1.0+1.0i 1234/11 1.234+1.234i) 114.41581818181818+2.234i) +(num-test (- 1.0+1.0i 1234/11 1.234+1.234i) -112.41581818181818-0.234i) +(num-test (* 1.0+1.0i 1234/11 1.234+1.234i) 0.0+276.86472727272729i) +(num-test (/ 1.0+1.0i 1234/11 1.234+1.234i) 0.00722374431623) +(num-test (= 1.0+1.0i 1234/11 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1234/11 -1.0+1.0i) 112.18181818181819+2.0i) +(num-test (- 1.0+1.0i 1234/11 -1.0+1.0i) -110.18181818181819) +(num-test (* 1.0+1.0i 1234/11 -1.0+1.0i) -224.36363636363637) +(num-test (/ 1.0+1.0i 1234/11 -1.0+1.0i) -0.0-0.00891410048622i) +(num-test (= 1.0+1.0i 1234/11 -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1234/11 0.0+1.0i) 113.18181818181819+2.0i) +(num-test (- 1.0+1.0i 1234/11 0.0+1.0i) -111.18181818181819) +(num-test (* 1.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 1234/11 0.0+1.0i) 0.00891410048622-0.00891410048622i) +(num-test (= 1.0+1.0i 1234/11 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 1) 3.234+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 1) -1.234-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 1) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1) 0.81037277147488) +(num-test (= 1.0+1.0i 1.234+1.234i 1) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 1.0) 3.234+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 1.0) -1.234-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 1.0) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1.0) 0.81037277147488) +(num-test (= 1.0+1.0i 1.234+1.234i 1.0) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 1/1) 3.234+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 1/1) -1.234-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 1/1) 0.0+2.468i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1/1) 0.81037277147488) +(num-test (= 1.0+1.0i 1.234+1.234i 1/1) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 1.0+1.0i) 3.234+3.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 1.0+1.0i) -1.234-1.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 1.0+1.0i) -2.468+2.468i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1.0+1.0i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.0+1.0i 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 0) 2.234+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 0) -0.234-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 0) 0.0) +(num-test (+ 1.0+1.0i 1.234+1.234i 0.0) 2.234+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 0.0) -0.234-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 0.0) 0.0) +(num-test (+ 1.0+1.0i 1.234+1.234i 1234) 1236.23399999999992+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 1234) -1234.23399999999992-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 1234) 0.0+3045.51200000000017i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1234) 0.00065670402875) +(num-test (= 1.0+1.0i 1.234+1.234i 1234) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 123.4) 125.634+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 123.4) -123.634-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 123.4) 0.0+304.55119999999999i) +(num-test (/ 1.0+1.0i 1.234+1.234i 123.4) 0.00656704028748) +(num-test (= 1.0+1.0i 1.234+1.234i 123.4) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 1234/11) 114.41581818181818+2.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 1234/11) -112.41581818181818-0.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 1234/11) 0.0+276.86472727272729i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1234/11) 0.00722374431623) +(num-test (= 1.0+1.0i 1.234+1.234i 1234/11) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 1.234+1.234i) 3.468+3.468i) +(num-test (- 1.0+1.0i 1.234+1.234i 1.234+1.234i) -1.468-1.468i) +(num-test (* 1.0+1.0i 1.234+1.234i 1.234+1.234i) -3.04551200000000+3.04551200000000i) +(num-test (/ 1.0+1.0i 1.234+1.234i 1.234+1.234i) 0.32835201437394-0.32835201437394i) +(num-test (= 1.0+1.0i 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i -1.0+1.0i) 1.234+3.234i) +(num-test (- 1.0+1.0i 1.234+1.234i -1.0+1.0i) 0.766-1.234i) +(num-test (* 1.0+1.0i 1.234+1.234i -1.0+1.0i) -2.468-2.468i) +(num-test (/ 1.0+1.0i 1.234+1.234i -1.0+1.0i) -0.40518638573744-0.40518638573744i) +(num-test (= 1.0+1.0i 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 1.234+1.234i 0.0+1.0i) 2.234+3.234i) +(num-test (- 1.0+1.0i 1.234+1.234i 0.0+1.0i) -0.234-1.234i) +(num-test (* 1.0+1.0i 1.234+1.234i 0.0+1.0i) -2.468) +(num-test (/ 1.0+1.0i 1.234+1.234i 0.0+1.0i) 0.0-0.81037277147488i) +(num-test (= 1.0+1.0i 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 1) 1.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 1) 1.0) +(num-test (* 1.0+1.0i -1.0+1.0i 1) -2.0) +(num-test (/ 1.0+1.0i -1.0+1.0i 1) -0.0-1.0i) +(num-test (= 1.0+1.0i -1.0+1.0i 1) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 1.0) 1.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 1.0) 1.0) +(num-test (* 1.0+1.0i -1.0+1.0i 1.0) -2.0) +(num-test (/ 1.0+1.0i -1.0+1.0i 1.0) -0.0-1.0i) +(num-test (= 1.0+1.0i -1.0+1.0i 1.0) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 1/1) 1.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 1/1) 1.0) +(num-test (* 1.0+1.0i -1.0+1.0i 1/1) -2.0) +(num-test (/ 1.0+1.0i -1.0+1.0i 1/1) -0.0-1.0i) +(num-test (= 1.0+1.0i -1.0+1.0i 1/1) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 1.0+1.0i) 1.0+3.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 1.0+1.0i) 1.0-1.0i) +(num-test (* 1.0+1.0i -1.0+1.0i 1.0+1.0i) -2.0-2.0i) +(num-test (/ 1.0+1.0i -1.0+1.0i 1.0+1.0i) -0.5-0.5i) +(num-test (= 1.0+1.0i -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 0) 0.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 0) 2.0) +(num-test (* 1.0+1.0i -1.0+1.0i 0) -0.0) +(num-test (+ 1.0+1.0i -1.0+1.0i 0.0) 0.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 0.0) 2.0) +(num-test (* 1.0+1.0i -1.0+1.0i 0.0) -0.0) +(num-test (+ 1.0+1.0i -1.0+1.0i 1234) 1234.0+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 1234) -1232.0) +(num-test (* 1.0+1.0i -1.0+1.0i 1234) -2468.0) +(num-test (/ 1.0+1.0i -1.0+1.0i 1234) -0.0-0.00081037277147i) +(num-test (= 1.0+1.0i -1.0+1.0i 1234) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 123.4) 123.4+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 123.4) -121.4) +(num-test (* 1.0+1.0i -1.0+1.0i 123.4) -246.8) +(num-test (/ 1.0+1.0i -1.0+1.0i 123.4) -0.0-0.00810372771475i) +(num-test (= 1.0+1.0i -1.0+1.0i 123.4) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 1234/11) 112.18181818181819+2.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 1234/11) -110.18181818181819) +(num-test (* 1.0+1.0i -1.0+1.0i 1234/11) -224.36363636363637) +(num-test (/ 1.0+1.0i -1.0+1.0i 1234/11) -0.0-0.00891410048622i) +(num-test (= 1.0+1.0i -1.0+1.0i 1234/11) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 1.234+1.234i) 1.234+3.234i) +(num-test (- 1.0+1.0i -1.0+1.0i 1.234+1.234i) 0.766-1.234i) +(num-test (* 1.0+1.0i -1.0+1.0i 1.234+1.234i) -2.468-2.468i) +(num-test (/ 1.0+1.0i -1.0+1.0i 1.234+1.234i) -0.40518638573744-0.40518638573744i) +(num-test (= 1.0+1.0i -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i -1.0+1.0i) -1.0+3.0i) +(num-test (- 1.0+1.0i -1.0+1.0i -1.0+1.0i) 3.0-1.0i) +(num-test (* 1.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (/ 1.0+1.0i -1.0+1.0i -1.0+1.0i) -0.5+0.5i) +(num-test (= 1.0+1.0i -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i -1.0+1.0i 0.0+1.0i) 0.0+3.0i) +(num-test (- 1.0+1.0i -1.0+1.0i 0.0+1.0i) 2.0-1.0i) +(num-test (* 1.0+1.0i -1.0+1.0i 0.0+1.0i) -0.0-2.0i) +(num-test (/ 1.0+1.0i -1.0+1.0i 0.0+1.0i) -1.0) +(num-test (= 1.0+1.0i -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 1) 2.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 1) 0.0) +(num-test (* 1.0+1.0i 0.0+1.0i 1) -1.0+1.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i 1) 1.0-1.0i) +(num-test (= 1.0+1.0i 0.0+1.0i 1) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 1.0) 2.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 1.0) 0.0) +(num-test (* 1.0+1.0i 0.0+1.0i 1.0) -1.0+1.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i 1.0) 1.0-1.0i) +(num-test (= 1.0+1.0i 0.0+1.0i 1.0) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 1/1) 2.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 1/1) 0.0) +(num-test (* 1.0+1.0i 0.0+1.0i 1/1) -1.0+1.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i 1/1) 1.0-1.0i) +(num-test (= 1.0+1.0i 0.0+1.0i 1/1) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 1.0+1.0i) 2.0+3.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0-1.0i) +(num-test (* 1.0+1.0i 0.0+1.0i 1.0+1.0i) -2.0) +(num-test (/ 1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0-1.0i) +(num-test (= 1.0+1.0i 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 0) 1.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 0) 1.0) +(num-test (* 1.0+1.0i 0.0+1.0i 0) -0.0) +(num-test (+ 1.0+1.0i 0.0+1.0i 0.0) 1.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 0.0) 1.0) +(num-test (* 1.0+1.0i 0.0+1.0i 0.0) -0.0) +(num-test (+ 1.0+1.0i 0.0+1.0i 1234) 1235.0+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 1234) -1233.0) +(num-test (* 1.0+1.0i 0.0+1.0i 1234) -1234.0+1234.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i 1234) 0.00081037277147-0.00081037277147i) +(num-test (= 1.0+1.0i 0.0+1.0i 1234) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 123.4) 124.4+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 123.4) -122.4) +(num-test (* 1.0+1.0i 0.0+1.0i 123.4) -123.4+123.4i) +(num-test (/ 1.0+1.0i 0.0+1.0i 123.4) 0.00810372771475-0.00810372771475i) +(num-test (= 1.0+1.0i 0.0+1.0i 123.4) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 1234/11) 113.18181818181819+2.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 1234/11) -111.18181818181819) +(num-test (* 1.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ 1.0+1.0i 0.0+1.0i 1234/11) 0.00891410048622-0.00891410048622i) +(num-test (= 1.0+1.0i 0.0+1.0i 1234/11) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 1.234+1.234i) 2.234+3.234i) +(num-test (- 1.0+1.0i 0.0+1.0i 1.234+1.234i) -0.234-1.234i) +(num-test (* 1.0+1.0i 0.0+1.0i 1.234+1.234i) -2.468) +(num-test (/ 1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.0-0.81037277147488i) +(num-test (= 1.0+1.0i 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i -1.0+1.0i) 0.0+3.0i) +(num-test (- 1.0+1.0i 0.0+1.0i -1.0+1.0i) 2.0-1.0i) +(num-test (* 1.0+1.0i 0.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i -1.0+1.0i) -1.0) +(num-test (= 1.0+1.0i 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0+3.0i) +(num-test (- 1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0-1.0i) +(num-test (* 1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (/ 1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (= 1.0+1.0i 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0 1 1) 2) +(num-test (- 0 1 1) -2) +(num-test (* 0 1 1) 0) +(num-test (/ 0 1 1) 0) +(num-test (= 0 1 1) #f) +(num-test (< 0 1 1) #f) +(num-test (<= 0 1 1) #t) +(num-test (> 0 1 1) #f) +(num-test (>= 0 1 1) #f) +(num-test (+ 0 1 1.0) 2.0) +(num-test (- 0 1 1.0) -2.0) +(num-test (* 0 1 1.0) 0.0) +(num-test (/ 0 1 1.0) 0.0) +(num-test (= 0 1 1.0) #f) +(num-test (< 0 1 1.0) #f) +(num-test (<= 0 1 1.0) #t) +(num-test (> 0 1 1.0) #f) +(num-test (>= 0 1 1.0) #f) +(num-test (+ 0 1 1/1) 2) +(num-test (- 0 1 1/1) -2) +(num-test (* 0 1 1/1) 0) +(num-test (/ 0 1 1/1) 0) +(num-test (= 0 1 1/1) #f) +(num-test (< 0 1 1/1) #f) +(num-test (<= 0 1 1/1) #t) +(num-test (> 0 1 1/1) #f) +(num-test (>= 0 1 1/1) #f) +(num-test (+ 0 1 1.0+1.0i) 2.0+1.0i) +(num-test (- 0 1 1.0+1.0i) -2.0-1.0i) +(num-test (* 0 1 1.0+1.0i) 0.0) +(num-test (/ 0 1 1.0+1.0i) 0.0) +(num-test (= 0 1 1.0+1.0i) #f) +(num-test (+ 0 1 0) 1) +(num-test (- 0 1 0) -1) +(num-test (* 0 1 0) 0) +(num-test (+ 0 1 0.0) 1.0) +(num-test (- 0 1 0.0) -1.0) +(num-test (* 0 1 0.0) 0.0) +(num-test (+ 0 1 1234) 1235) +(num-test (- 0 1 1234) -1235) +(num-test (* 0 1 1234) 0) +(num-test (/ 0 1 1234) 0) +(num-test (= 0 1 1234) #f) +(num-test (< 0 1 1234) #t) +(num-test (<= 0 1 1234) #t) +(num-test (> 0 1 1234) #f) +(num-test (>= 0 1 1234) #f) +(num-test (+ 0 1 123.4) 124.4) +(num-test (- 0 1 123.4) -124.4) +(num-test (* 0 1 123.4) 0.0) +(num-test (/ 0 1 123.4) 0.0) +(num-test (= 0 1 123.4) #f) +(num-test (< 0 1 123.4) #t) +(num-test (<= 0 1 123.4) #t) +(num-test (> 0 1 123.4) #f) +(num-test (>= 0 1 123.4) #f) +(num-test (+ 0 1 1234/11) 1245/11) +(num-test (- 0 1 1234/11) -1245/11) +(num-test (* 0 1 1234/11) 0) +(num-test (/ 0 1 1234/11) 0) +(num-test (= 0 1 1234/11) #f) +(num-test (< 0 1 1234/11) #t) +(num-test (<= 0 1 1234/11) #t) +(num-test (> 0 1 1234/11) #f) +(num-test (>= 0 1 1234/11) #f) +(num-test (+ 0 1 1.234+1.234i) 2.234+1.234i) +(num-test (- 0 1 1.234+1.234i) -2.234-1.234i) +(num-test (* 0 1 1.234+1.234i) 0.0) +(num-test (/ 0 1 1.234+1.234i) 0.0) +(num-test (= 0 1 1.234+1.234i) #f) +(num-test (+ 0 1 -1.0+1.0i) 0.0+1.0i) +(num-test (- 0 1 -1.0+1.0i) 0.0-1.0i) +(num-test (* 0 1 -1.0+1.0i) -0.0) +(num-test (/ 0 1 -1.0+1.0i) -0.0) +(num-test (= 0 1 -1.0+1.0i) #f) +(num-test (+ 0 1 0.0+1.0i) 1.0+1.0i) +(num-test (- 0 1 0.0+1.0i) -1.0-1.0i) +(num-test (* 0 1 0.0+1.0i) 0.0) +(num-test (/ 0 1 0.0+1.0i) 0.0) +(num-test (= 0 1 0.0+1.0i) #f) +(num-test (+ 0 1.0 1) 2.0) +(num-test (- 0 1.0 1) -2.0) +(num-test (* 0 1.0 1) 0.0) +(num-test (/ 0 1.0 1) 0.0) +(num-test (= 0 1.0 1) #f) +(num-test (< 0 1.0 1) #f) +(num-test (<= 0 1.0 1) #t) +(num-test (> 0 1.0 1) #f) +(num-test (>= 0 1.0 1) #f) +(num-test (+ 0 1.0 1.0) 2.0) +(num-test (- 0 1.0 1.0) -2.0) +(num-test (* 0 1.0 1.0) 0.0) +(num-test (/ 0 1.0 1.0) 0.0) +(num-test (= 0 1.0 1.0) #f) +(num-test (< 0 1.0 1.0) #f) +(num-test (<= 0 1.0 1.0) #t) +(num-test (> 0 1.0 1.0) #f) +(num-test (>= 0 1.0 1.0) #f) +(num-test (+ 0 1.0 1/1) 2.0) +(num-test (- 0 1.0 1/1) -2.0) +(num-test (* 0 1.0 1/1) 0.0) +(num-test (/ 0 1.0 1/1) 0.0) +(num-test (= 0 1.0 1/1) #f) +(num-test (< 0 1.0 1/1) #f) +(num-test (<= 0 1.0 1/1) #t) +(num-test (> 0 1.0 1/1) #f) +(num-test (>= 0 1.0 1/1) #f) +(num-test (+ 0 1.0 1.0+1.0i) 2.0+1.0i) +(num-test (- 0 1.0 1.0+1.0i) -2.0-1.0i) +(num-test (* 0 1.0 1.0+1.0i) 0.0) +(num-test (/ 0 1.0 1.0+1.0i) 0.0) +(num-test (= 0 1.0 1.0+1.0i) #f) +(num-test (+ 0 1.0 0) 1.0) +(num-test (- 0 1.0 0) -1.0) +(num-test (* 0 1.0 0) 0.0) +(num-test (+ 0 1.0 0.0) 1.0) +(num-test (- 0 1.0 0.0) -1.0) +(num-test (* 0 1.0 0.0) 0.0) +(num-test (+ 0 1.0 1234) 1235.0) +(num-test (- 0 1.0 1234) -1235.0) +(num-test (* 0 1.0 1234) 0.0) +(num-test (/ 0 1.0 1234) 0.0) +(num-test (= 0 1.0 1234) #f) +(num-test (< 0 1.0 1234) #t) +(num-test (<= 0 1.0 1234) #t) +(num-test (> 0 1.0 1234) #f) +(num-test (>= 0 1.0 1234) #f) +(num-test (+ 0 1.0 123.4) 124.4) +(num-test (- 0 1.0 123.4) -124.4) +(num-test (* 0 1.0 123.4) 0.0) +(num-test (/ 0 1.0 123.4) 0.0) +(num-test (= 0 1.0 123.4) #f) +(num-test (< 0 1.0 123.4) #t) +(num-test (<= 0 1.0 123.4) #t) +(num-test (> 0 1.0 123.4) #f) +(num-test (>= 0 1.0 123.4) #f) +(num-test (+ 0 1.0 1234/11) 113.18181818181819) +(num-test (- 0 1.0 1234/11) -113.18181818181819) +(num-test (* 0 1.0 1234/11) 0.0) +(num-test (/ 0 1.0 1234/11) 0.0) +(num-test (= 0 1.0 1234/11) #f) +(num-test (< 0 1.0 1234/11) #t) +(num-test (<= 0 1.0 1234/11) #t) +(num-test (> 0 1.0 1234/11) #f) +(num-test (>= 0 1.0 1234/11) #f) +(num-test (+ 0 1.0 1.234+1.234i) 2.234+1.234i) +(num-test (- 0 1.0 1.234+1.234i) -2.234-1.234i) +(num-test (* 0 1.0 1.234+1.234i) 0.0) +(num-test (/ 0 1.0 1.234+1.234i) 0.0) +(num-test (= 0 1.0 1.234+1.234i) #f) +(num-test (+ 0 1.0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 0 1.0 -1.0+1.0i) 0.0-1.0i) +(num-test (* 0 1.0 -1.0+1.0i) -0.0) +(num-test (/ 0 1.0 -1.0+1.0i) -0.0) +(num-test (= 0 1.0 -1.0+1.0i) #f) +(num-test (+ 0 1.0 0.0+1.0i) 1.0+1.0i) +(num-test (- 0 1.0 0.0+1.0i) -1.0-1.0i) +(num-test (* 0 1.0 0.0+1.0i) 0.0) +(num-test (/ 0 1.0 0.0+1.0i) 0.0) +(num-test (= 0 1.0 0.0+1.0i) #f) +(num-test (+ 0 1/1 1) 2) +(num-test (- 0 1/1 1) -2) +(num-test (* 0 1/1 1) 0) +(num-test (/ 0 1/1 1) 0) +(num-test (= 0 1/1 1) #f) +(num-test (< 0 1/1 1) #f) +(num-test (<= 0 1/1 1) #t) +(num-test (> 0 1/1 1) #f) +(num-test (>= 0 1/1 1) #f) +(num-test (+ 0 1/1 1.0) 2.0) +(num-test (- 0 1/1 1.0) -2.0) +(num-test (* 0 1/1 1.0) 0.0) +(num-test (/ 0 1/1 1.0) 0.0) +(num-test (= 0 1/1 1.0) #f) +(num-test (< 0 1/1 1.0) #f) +(num-test (<= 0 1/1 1.0) #t) +(num-test (> 0 1/1 1.0) #f) +(num-test (>= 0 1/1 1.0) #f) +(num-test (+ 0 1/1 1/1) 2) +(num-test (- 0 1/1 1/1) -2) +(num-test (* 0 1/1 1/1) 0) +(num-test (/ 0 1/1 1/1) 0) +(num-test (= 0 1/1 1/1) #f) +(num-test (< 0 1/1 1/1) #f) +(num-test (<= 0 1/1 1/1) #t) +(num-test (> 0 1/1 1/1) #f) +(num-test (>= 0 1/1 1/1) #f) +(num-test (+ 0 1/1 1.0+1.0i) 2.0+1.0i) +(num-test (- 0 1/1 1.0+1.0i) -2.0-1.0i) +(num-test (* 0 1/1 1.0+1.0i) 0.0) +(num-test (/ 0 1/1 1.0+1.0i) 0.0) +(num-test (= 0 1/1 1.0+1.0i) #f) +(num-test (+ 0 1/1 0) 1) +(num-test (- 0 1/1 0) -1) +(num-test (* 0 1/1 0) 0) +(num-test (+ 0 1/1 0.0) 1.0) +(num-test (- 0 1/1 0.0) -1.0) +(num-test (* 0 1/1 0.0) 0.0) +(num-test (+ 0 1/1 1234) 1235) +(num-test (- 0 1/1 1234) -1235) +(num-test (* 0 1/1 1234) 0) +(num-test (/ 0 1/1 1234) 0) +(num-test (= 0 1/1 1234) #f) +(num-test (< 0 1/1 1234) #t) +(num-test (<= 0 1/1 1234) #t) +(num-test (> 0 1/1 1234) #f) +(num-test (>= 0 1/1 1234) #f) +(num-test (+ 0 1/1 123.4) 124.4) +(num-test (- 0 1/1 123.4) -124.4) +(num-test (* 0 1/1 123.4) 0.0) +(num-test (/ 0 1/1 123.4) 0.0) +(num-test (= 0 1/1 123.4) #f) +(num-test (< 0 1/1 123.4) #t) +(num-test (<= 0 1/1 123.4) #t) +(num-test (> 0 1/1 123.4) #f) +(num-test (>= 0 1/1 123.4) #f) +(num-test (+ 0 1/1 1234/11) 1245/11) +(num-test (- 0 1/1 1234/11) -1245/11) +(num-test (* 0 1/1 1234/11) 0) +(num-test (/ 0 1/1 1234/11) 0) +(num-test (= 0 1/1 1234/11) #f) +(num-test (< 0 1/1 1234/11) #t) +(num-test (<= 0 1/1 1234/11) #t) +(num-test (> 0 1/1 1234/11) #f) +(num-test (>= 0 1/1 1234/11) #f) +(num-test (+ 0 1/1 1.234+1.234i) 2.234+1.234i) +(num-test (- 0 1/1 1.234+1.234i) -2.234-1.234i) +(num-test (* 0 1/1 1.234+1.234i) 0.0) +(num-test (/ 0 1/1 1.234+1.234i) 0.0) +(num-test (= 0 1/1 1.234+1.234i) #f) +(num-test (+ 0 1/1 -1.0+1.0i) 0.0+1.0i) +(num-test (- 0 1/1 -1.0+1.0i) 0.0-1.0i) +(num-test (* 0 1/1 -1.0+1.0i) -0.0) +(num-test (/ 0 1/1 -1.0+1.0i) -0.0) +(num-test (= 0 1/1 -1.0+1.0i) #f) +(num-test (+ 0 1/1 0.0+1.0i) 1.0+1.0i) +(num-test (- 0 1/1 0.0+1.0i) -1.0-1.0i) +(num-test (* 0 1/1 0.0+1.0i) 0.0) +(num-test (/ 0 1/1 0.0+1.0i) 0.0) +(num-test (= 0 1/1 0.0+1.0i) #f) +(num-test (+ 0 1.0+1.0i 1) 2.0+1.0i) +(num-test (- 0 1.0+1.0i 1) -2.0-1.0i) +(num-test (* 0 1.0+1.0i 1) 0.0) +(num-test (/ 0 1.0+1.0i 1) 0.0) +(num-test (= 0 1.0+1.0i 1) #f) +(num-test (+ 0 1.0+1.0i 1.0) 2.0+1.0i) +(num-test (- 0 1.0+1.0i 1.0) -2.0-1.0i) +(num-test (* 0 1.0+1.0i 1.0) 0.0) +(num-test (/ 0 1.0+1.0i 1.0) 0.0) +(num-test (= 0 1.0+1.0i 1.0) #f) +(num-test (+ 0 1.0+1.0i 1/1) 2.0+1.0i) +(num-test (- 0 1.0+1.0i 1/1) -2.0-1.0i) +(num-test (* 0 1.0+1.0i 1/1) 0.0) +(num-test (/ 0 1.0+1.0i 1/1) 0.0) +(num-test (= 0 1.0+1.0i 1/1) #f) +(num-test (+ 0 1.0+1.0i 1.0+1.0i) 2.0+2.0i) +(num-test (- 0 1.0+1.0i 1.0+1.0i) -2.0-2.0i) +(num-test (* 0 1.0+1.0i 1.0+1.0i) 0.0) +(num-test (/ 0 1.0+1.0i 1.0+1.0i) 0.0) +(num-test (= 0 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0 1.0+1.0i 0) 1.0+1.0i) +(num-test (- 0 1.0+1.0i 0) -1.0-1.0i) +(num-test (* 0 1.0+1.0i 0) 0.0) +(num-test (+ 0 1.0+1.0i 0.0) 1.0+1.0i) +(num-test (- 0 1.0+1.0i 0.0) -1.0-1.0i) +(num-test (* 0 1.0+1.0i 0.0) 0.0) +(num-test (+ 0 1.0+1.0i 1234) 1235.0+1.0i) +(num-test (- 0 1.0+1.0i 1234) -1235.0-1.0i) +(num-test (* 0 1.0+1.0i 1234) 0.0) +(num-test (/ 0 1.0+1.0i 1234) 0.0) +(num-test (= 0 1.0+1.0i 1234) #f) +(num-test (+ 0 1.0+1.0i 123.4) 124.4+1.0i) +(num-test (- 0 1.0+1.0i 123.4) -124.4-1.0i) +(num-test (* 0 1.0+1.0i 123.4) 0.0) +(num-test (/ 0 1.0+1.0i 123.4) 0.0) +(num-test (= 0 1.0+1.0i 123.4) #f) +(num-test (+ 0 1.0+1.0i 1234/11) 113.18181818181819+1.0i) +(num-test (- 0 1.0+1.0i 1234/11) -113.18181818181819-1.0i) +(num-test (* 0 1.0+1.0i 1234/11) 0.0) +(num-test (/ 0 1.0+1.0i 1234/11) 0.0) +(num-test (= 0 1.0+1.0i 1234/11) #f) +(num-test (+ 0 1.0+1.0i 1.234+1.234i) 2.234+2.234i) +(num-test (- 0 1.0+1.0i 1.234+1.234i) -2.234-2.234i) +(num-test (* 0 1.0+1.0i 1.234+1.234i) 0.0) +(num-test (/ 0 1.0+1.0i 1.234+1.234i) 0.0) +(num-test (= 0 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0 1.0+1.0i -1.0+1.0i) 0.0+2.0i) +(num-test (- 0 1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (* 0 1.0+1.0i -1.0+1.0i) -0.0) +(num-test (/ 0 1.0+1.0i -1.0+1.0i) -0.0) +(num-test (= 0 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0 1.0+1.0i 0.0+1.0i) 1.0+2.0i) +(num-test (- 0 1.0+1.0i 0.0+1.0i) -1.0-2.0i) +(num-test (* 0 1.0+1.0i 0.0+1.0i) 0.0) +(num-test (/ 0 1.0+1.0i 0.0+1.0i) 0.0) +(num-test (= 0 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0 0 1) 1) +(num-test (- 0 0 1) -1) +(num-test (* 0 0 1) 0) +(num-test (+ 0 0 1.0) 1.0) +(num-test (- 0 0 1.0) -1.0) +(num-test (* 0 0 1.0) 0.0) +(num-test (+ 0 0 1/1) 1) +(num-test (- 0 0 1/1) -1) +(num-test (* 0 0 1/1) 0) +(num-test (+ 0 0 1.0+1.0i) 1.0+1.0i) +(num-test (- 0 0 1.0+1.0i) -1.0-1.0i) +(num-test (* 0 0 1.0+1.0i) 0.0) +(num-test (+ 0 0 0) 0) +(num-test (- 0 0 0) 0) +(num-test (* 0 0 0) 0) +(num-test (+ 0 0 0.0) 0.0) +(num-test (- 0 0 0.0) 0.0) +(num-test (* 0 0 0.0) 0.0) +(num-test (+ 0 0 1234) 1234) +(num-test (- 0 0 1234) -1234) +(num-test (* 0 0 1234) 0) +(num-test (+ 0 0 123.4) 123.4) +(num-test (- 0 0 123.4) -123.4) +(num-test (* 0 0 123.4) 0.0) +(num-test (+ 0 0 1234/11) 1234/11) +(num-test (- 0 0 1234/11) -1234/11) +(num-test (* 0 0 1234/11) 0) +(num-test (+ 0 0 1.234+1.234i) 1.234+1.234i) +(num-test (- 0 0 1.234+1.234i) -1.234-1.234i) +(num-test (* 0 0 1.234+1.234i) 0.0) +(num-test (+ 0 0 -1.0+1.0i) -1.0+1.0i) +(num-test (- 0 0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 0 0 -1.0+1.0i) -0.0) +(num-test (+ 0 0 0.0+1.0i) 0.0+1.0i) +(num-test (- 0 0 0.0+1.0i) 0.0-1.0i) +(num-test (* 0 0 0.0+1.0i) 0.0) +(num-test (+ 0 0.0 1) 1.0) +(num-test (- 0 0.0 1) -1.0) +(num-test (* 0 0.0 1) 0.0) +(num-test (+ 0 0.0 1.0) 1.0) +(num-test (- 0 0.0 1.0) -1.0) +(num-test (* 0 0.0 1.0) 0.0) +(num-test (+ 0 0.0 1/1) 1.0) +(num-test (- 0 0.0 1/1) -1.0) +(num-test (* 0 0.0 1/1) 0.0) +(num-test (+ 0 0.0 1.0+1.0i) 1.0+1.0i) +(num-test (- 0 0.0 1.0+1.0i) -1.0-1.0i) +(num-test (* 0 0.0 1.0+1.0i) 0.0) +(num-test (+ 0 0.0 0) 0.0) +(num-test (- 0 0.0 0) 0.0) +(num-test (* 0 0.0 0) 0.0) +(num-test (+ 0 0.0 0.0) 0.0) +(num-test (- 0 0.0 0.0) 0.0) +(num-test (* 0 0.0 0.0) 0.0) +(num-test (+ 0 0.0 1234) 1234.0) +(num-test (- 0 0.0 1234) -1234.0) +(num-test (* 0 0.0 1234) 0.0) +(num-test (+ 0 0.0 123.4) 123.4) +(num-test (- 0 0.0 123.4) -123.4) +(num-test (* 0 0.0 123.4) 0.0) +(num-test (+ 0 0.0 1234/11) 112.18181818181819) +(num-test (- 0 0.0 1234/11) -112.18181818181819) +(num-test (* 0 0.0 1234/11) 0.0) +(num-test (+ 0 0.0 1.234+1.234i) 1.234+1.234i) +(num-test (- 0 0.0 1.234+1.234i) -1.234-1.234i) +(num-test (* 0 0.0 1.234+1.234i) 0.0) +(num-test (+ 0 0.0 -1.0+1.0i) -1.0+1.0i) +(num-test (- 0 0.0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 0 0.0 -1.0+1.0i) -0.0) +(num-test (+ 0 0.0 0.0+1.0i) 0.0+1.0i) +(num-test (- 0 0.0 0.0+1.0i) 0.0-1.0i) +(num-test (* 0 0.0 0.0+1.0i) 0.0) +(num-test (+ 0 1234 1) 1235) +(num-test (- 0 1234 1) -1235) +(num-test (* 0 1234 1) 0) +(num-test (/ 0 1234 1) 0) +(num-test (= 0 1234 1) #f) +(num-test (< 0 1234 1) #f) +(num-test (<= 0 1234 1) #f) +(num-test (> 0 1234 1) #f) +(num-test (>= 0 1234 1) #f) +(num-test (+ 0 1234 1.0) 1235.0) +(num-test (- 0 1234 1.0) -1235.0) +(num-test (* 0 1234 1.0) 0.0) +(num-test (/ 0 1234 1.0) 0.0) +(num-test (= 0 1234 1.0) #f) +(num-test (< 0 1234 1.0) #f) +(num-test (<= 0 1234 1.0) #f) +(num-test (> 0 1234 1.0) #f) +(num-test (>= 0 1234 1.0) #f) +(num-test (+ 0 1234 1/1) 1235) +(num-test (- 0 1234 1/1) -1235) +(num-test (* 0 1234 1/1) 0) +(num-test (/ 0 1234 1/1) 0) +(num-test (= 0 1234 1/1) #f) +(num-test (< 0 1234 1/1) #f) +(num-test (<= 0 1234 1/1) #f) +(num-test (> 0 1234 1/1) #f) +(num-test (>= 0 1234 1/1) #f) +(num-test (+ 0 1234 1.0+1.0i) 1235.0+1.0i) +(num-test (- 0 1234 1.0+1.0i) -1235.0-1.0i) +(num-test (* 0 1234 1.0+1.0i) 0.0) +(num-test (/ 0 1234 1.0+1.0i) 0.0) +(num-test (= 0 1234 1.0+1.0i) #f) +(num-test (+ 0 1234 0) 1234) +(num-test (- 0 1234 0) -1234) +(num-test (* 0 1234 0) 0) +(num-test (+ 0 1234 0.0) 1234.0) +(num-test (- 0 1234 0.0) -1234.0) +(num-test (* 0 1234 0.0) 0.0) +(num-test (+ 0 1234 1234) 2468) +(num-test (- 0 1234 1234) -2468) +(num-test (* 0 1234 1234) 0) +(num-test (/ 0 1234 1234) 0) +(num-test (= 0 1234 1234) #f) +(num-test (< 0 1234 1234) #f) +(num-test (<= 0 1234 1234) #t) +(num-test (> 0 1234 1234) #f) +(num-test (>= 0 1234 1234) #f) +(num-test (+ 0 1234 123.4) 1357.4) +(num-test (- 0 1234 123.4) -1357.4) +(num-test (* 0 1234 123.4) 0.0) +(num-test (/ 0 1234 123.4) 0.0) +(num-test (= 0 1234 123.4) #f) +(num-test (< 0 1234 123.4) #f) +(num-test (<= 0 1234 123.4) #f) +(num-test (> 0 1234 123.4) #f) +(num-test (>= 0 1234 123.4) #f) +(num-test (+ 0 1234 1234/11) 14808/11) +(num-test (- 0 1234 1234/11) -14808/11) +(num-test (* 0 1234 1234/11) 0) +(num-test (/ 0 1234 1234/11) 0) +(num-test (= 0 1234 1234/11) #f) +(num-test (< 0 1234 1234/11) #f) +(num-test (<= 0 1234 1234/11) #f) +(num-test (> 0 1234 1234/11) #f) +(num-test (>= 0 1234 1234/11) #f) +(num-test (+ 0 1234 1.234+1.234i) 1235.23399999999992+1.234i) +(num-test (- 0 1234 1.234+1.234i) -1235.23399999999992-1.234i) +(num-test (* 0 1234 1.234+1.234i) 0.0) +(num-test (/ 0 1234 1.234+1.234i) 0.0) +(num-test (= 0 1234 1.234+1.234i) #f) +(num-test (+ 0 1234 -1.0+1.0i) 1233.0+1.0i) +(num-test (- 0 1234 -1.0+1.0i) -1233.0-1.0i) +(num-test (* 0 1234 -1.0+1.0i) -0.0) +(num-test (/ 0 1234 -1.0+1.0i) -0.0) +(num-test (= 0 1234 -1.0+1.0i) #f) +(num-test (+ 0 1234 0.0+1.0i) 1234.0+1.0i) +(num-test (- 0 1234 0.0+1.0i) -1234.0-1.0i) +(num-test (* 0 1234 0.0+1.0i) 0.0) +(num-test (/ 0 1234 0.0+1.0i) 0.0) +(num-test (= 0 1234 0.0+1.0i) #f) +(num-test (+ 0 123.4 1) 124.4) +(num-test (- 0 123.4 1) -124.4) +(num-test (* 0 123.4 1) 0.0) +(num-test (/ 0 123.4 1) 0.0) +(num-test (= 0 123.4 1) #f) +(num-test (< 0 123.4 1) #f) +(num-test (<= 0 123.4 1) #f) +(num-test (> 0 123.4 1) #f) +(num-test (>= 0 123.4 1) #f) +(num-test (+ 0 123.4 1.0) 124.4) +(num-test (- 0 123.4 1.0) -124.4) +(num-test (* 0 123.4 1.0) 0.0) +(num-test (/ 0 123.4 1.0) 0.0) +(num-test (= 0 123.4 1.0) #f) +(num-test (< 0 123.4 1.0) #f) +(num-test (<= 0 123.4 1.0) #f) +(num-test (> 0 123.4 1.0) #f) +(num-test (>= 0 123.4 1.0) #f) +(num-test (+ 0 123.4 1/1) 124.4) +(num-test (- 0 123.4 1/1) -124.4) +(num-test (* 0 123.4 1/1) 0.0) +(num-test (/ 0 123.4 1/1) 0.0) +(num-test (= 0 123.4 1/1) #f) +(num-test (< 0 123.4 1/1) #f) +(num-test (<= 0 123.4 1/1) #f) +(num-test (> 0 123.4 1/1) #f) +(num-test (>= 0 123.4 1/1) #f) +(num-test (+ 0 123.4 1.0+1.0i) 124.4+1.0i) +(num-test (- 0 123.4 1.0+1.0i) -124.4-1.0i) +(num-test (* 0 123.4 1.0+1.0i) 0.0) +(num-test (/ 0 123.4 1.0+1.0i) 0.0) +(num-test (= 0 123.4 1.0+1.0i) #f) +(num-test (+ 0 123.4 0) 123.4) +(num-test (- 0 123.4 0) -123.4) +(num-test (* 0 123.4 0) 0.0) +(num-test (+ 0 123.4 0.0) 123.4) +(num-test (- 0 123.4 0.0) -123.4) +(num-test (* 0 123.4 0.0) 0.0) +(num-test (+ 0 123.4 1234) 1357.4) +(num-test (- 0 123.4 1234) -1357.4) +(num-test (* 0 123.4 1234) 0.0) +(num-test (/ 0 123.4 1234) 0.0) +(num-test (= 0 123.4 1234) #f) +(num-test (< 0 123.4 1234) #t) +(num-test (<= 0 123.4 1234) #t) +(num-test (> 0 123.4 1234) #f) +(num-test (>= 0 123.4 1234) #f) +(num-test (+ 0 123.4 123.4) 246.8) +(num-test (- 0 123.4 123.4) -246.8) +(num-test (* 0 123.4 123.4) 0.0) +(num-test (/ 0 123.4 123.4) 0.0) +(num-test (= 0 123.4 123.4) #f) +(num-test (< 0 123.4 123.4) #f) +(num-test (<= 0 123.4 123.4) #t) +(num-test (> 0 123.4 123.4) #f) +(num-test (>= 0 123.4 123.4) #f) +(num-test (+ 0 123.4 1234/11) 235.58181818181819) +(num-test (- 0 123.4 1234/11) -235.58181818181819) +(num-test (* 0 123.4 1234/11) 0.0) +(num-test (/ 0 123.4 1234/11) 0.0) +(num-test (= 0 123.4 1234/11) #f) +(num-test (< 0 123.4 1234/11) #f) +(num-test (<= 0 123.4 1234/11) #f) +(num-test (> 0 123.4 1234/11) #f) +(num-test (>= 0 123.4 1234/11) #f) +(num-test (+ 0 123.4 1.234+1.234i) 124.634+1.234i) +(num-test (- 0 123.4 1.234+1.234i) -124.634-1.234i) +(num-test (* 0 123.4 1.234+1.234i) 0.0) +(num-test (/ 0 123.4 1.234+1.234i) 0.0) +(num-test (= 0 123.4 1.234+1.234i) #f) +(num-test (+ 0 123.4 -1.0+1.0i) 122.4+1.0i) +(num-test (- 0 123.4 -1.0+1.0i) -122.4-1.0i) +(num-test (* 0 123.4 -1.0+1.0i) -0.0) +(num-test (/ 0 123.4 -1.0+1.0i) -0.0) +(num-test (= 0 123.4 -1.0+1.0i) #f) +(num-test (+ 0 123.4 0.0+1.0i) 123.4+1.0i) +(num-test (- 0 123.4 0.0+1.0i) -123.4-1.0i) +(num-test (* 0 123.4 0.0+1.0i) 0.0) +(num-test (/ 0 123.4 0.0+1.0i) 0.0) +(num-test (= 0 123.4 0.0+1.0i) #f) +(num-test (+ 0 1234/11 1) 1245/11) +(num-test (- 0 1234/11 1) -1245/11) +(num-test (* 0 1234/11 1) 0) +(num-test (/ 0 1234/11 1) 0) +(num-test (= 0 1234/11 1) #f) +(num-test (< 0 1234/11 1) #f) +(num-test (<= 0 1234/11 1) #f) +(num-test (> 0 1234/11 1) #f) +(num-test (>= 0 1234/11 1) #f) +(num-test (+ 0 1234/11 1.0) 113.18181818181819) +(num-test (- 0 1234/11 1.0) -113.18181818181819) +(num-test (* 0 1234/11 1.0) 0.0) +(num-test (/ 0 1234/11 1.0) 0.0) +(num-test (= 0 1234/11 1.0) #f) +(num-test (< 0 1234/11 1.0) #f) +(num-test (<= 0 1234/11 1.0) #f) +(num-test (> 0 1234/11 1.0) #f) +(num-test (>= 0 1234/11 1.0) #f) +(num-test (+ 0 1234/11 1/1) 1245/11) +(num-test (- 0 1234/11 1/1) -1245/11) +(num-test (* 0 1234/11 1/1) 0) +(num-test (/ 0 1234/11 1/1) 0) +(num-test (= 0 1234/11 1/1) #f) +(num-test (< 0 1234/11 1/1) #f) +(num-test (<= 0 1234/11 1/1) #f) +(num-test (> 0 1234/11 1/1) #f) +(num-test (>= 0 1234/11 1/1) #f) +(num-test (+ 0 1234/11 1.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 0 1234/11 1.0+1.0i) -113.18181818181819-1.0i) +(num-test (* 0 1234/11 1.0+1.0i) 0.0) +(num-test (/ 0 1234/11 1.0+1.0i) 0.0) +(num-test (= 0 1234/11 1.0+1.0i) #f) +(num-test (+ 0 1234/11 0) 1234/11) +(num-test (- 0 1234/11 0) -1234/11) +(num-test (* 0 1234/11 0) 0) +(num-test (+ 0 1234/11 0.0) 112.18181818181819) +(num-test (- 0 1234/11 0.0) -112.18181818181819) +(num-test (* 0 1234/11 0.0) 0.0) +(num-test (+ 0 1234/11 1234) 14808/11) +(num-test (- 0 1234/11 1234) -14808/11) +(num-test (* 0 1234/11 1234) 0) +(num-test (/ 0 1234/11 1234) 0) +(num-test (= 0 1234/11 1234) #f) +(num-test (< 0 1234/11 1234) #t) +(num-test (<= 0 1234/11 1234) #t) +(num-test (> 0 1234/11 1234) #f) +(num-test (>= 0 1234/11 1234) #f) +(num-test (+ 0 1234/11 123.4) 235.58181818181819) +(num-test (- 0 1234/11 123.4) -235.58181818181819) +(num-test (* 0 1234/11 123.4) 0.0) +(num-test (/ 0 1234/11 123.4) 0.0) +(num-test (= 0 1234/11 123.4) #f) +(num-test (< 0 1234/11 123.4) #t) +(num-test (<= 0 1234/11 123.4) #t) +(num-test (> 0 1234/11 123.4) #f) +(num-test (>= 0 1234/11 123.4) #f) +(num-test (+ 0 1234/11 1234/11) 2468/11) +(num-test (- 0 1234/11 1234/11) -2468/11) +(num-test (* 0 1234/11 1234/11) 0) +(num-test (/ 0 1234/11 1234/11) 0) +(num-test (= 0 1234/11 1234/11) #f) +(num-test (< 0 1234/11 1234/11) #f) +(num-test (<= 0 1234/11 1234/11) #t) +(num-test (> 0 1234/11 1234/11) #f) +(num-test (>= 0 1234/11 1234/11) #f) +(num-test (+ 0 1234/11 1.234+1.234i) 113.41581818181818+1.234i) +(num-test (- 0 1234/11 1.234+1.234i) -113.41581818181818-1.234i) +(num-test (* 0 1234/11 1.234+1.234i) 0.0) +(num-test (/ 0 1234/11 1.234+1.234i) 0.0) +(num-test (= 0 1234/11 1.234+1.234i) #f) +(num-test (+ 0 1234/11 -1.0+1.0i) 111.18181818181819+1.0i) +(num-test (- 0 1234/11 -1.0+1.0i) -111.18181818181819-1.0i) +(num-test (* 0 1234/11 -1.0+1.0i) -0.0) +(num-test (/ 0 1234/11 -1.0+1.0i) -0.0) +(num-test (= 0 1234/11 -1.0+1.0i) #f) +(num-test (+ 0 1234/11 0.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 0 1234/11 0.0+1.0i) -112.18181818181819-1.0i) +(num-test (* 0 1234/11 0.0+1.0i) 0.0) +(num-test (/ 0 1234/11 0.0+1.0i) 0.0) +(num-test (= 0 1234/11 0.0+1.0i) #f) +(num-test (+ 0 1.234+1.234i 1) 2.234+1.234i) +(num-test (- 0 1.234+1.234i 1) -2.234-1.234i) +(num-test (* 0 1.234+1.234i 1) 0.0) +(num-test (/ 0 1.234+1.234i 1) 0.0) +(num-test (= 0 1.234+1.234i 1) #f) +(num-test (+ 0 1.234+1.234i 1.0) 2.234+1.234i) +(num-test (- 0 1.234+1.234i 1.0) -2.234-1.234i) +(num-test (* 0 1.234+1.234i 1.0) 0.0) +(num-test (/ 0 1.234+1.234i 1.0) 0.0) +(num-test (= 0 1.234+1.234i 1.0) #f) +(num-test (+ 0 1.234+1.234i 1/1) 2.234+1.234i) +(num-test (- 0 1.234+1.234i 1/1) -2.234-1.234i) +(num-test (* 0 1.234+1.234i 1/1) 0.0) +(num-test (/ 0 1.234+1.234i 1/1) 0.0) +(num-test (= 0 1.234+1.234i 1/1) #f) +(num-test (+ 0 1.234+1.234i 1.0+1.0i) 2.234+2.234i) +(num-test (- 0 1.234+1.234i 1.0+1.0i) -2.234-2.234i) +(num-test (* 0 1.234+1.234i 1.0+1.0i) 0.0) +(num-test (/ 0 1.234+1.234i 1.0+1.0i) 0.0) +(num-test (= 0 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 0 1.234+1.234i 0) 1.234+1.234i) +(num-test (- 0 1.234+1.234i 0) -1.234-1.234i) +(num-test (* 0 1.234+1.234i 0) 0.0) +(num-test (+ 0 1.234+1.234i 0.0) 1.234+1.234i) +(num-test (- 0 1.234+1.234i 0.0) -1.234-1.234i) +(num-test (* 0 1.234+1.234i 0.0) 0.0) +(num-test (+ 0 1.234+1.234i 1234) 1235.23399999999992+1.234i) +(num-test (- 0 1.234+1.234i 1234) -1235.23399999999992-1.234i) +(num-test (* 0 1.234+1.234i 1234) 0.0) +(num-test (/ 0 1.234+1.234i 1234) 0.0) +(num-test (= 0 1.234+1.234i 1234) #f) +(num-test (+ 0 1.234+1.234i 123.4) 124.634+1.234i) +(num-test (- 0 1.234+1.234i 123.4) -124.634-1.234i) +(num-test (* 0 1.234+1.234i 123.4) 0.0) +(num-test (/ 0 1.234+1.234i 123.4) 0.0) +(num-test (= 0 1.234+1.234i 123.4) #f) +(num-test (+ 0 1.234+1.234i 1234/11) 113.41581818181818+1.234i) +(num-test (- 0 1.234+1.234i 1234/11) -113.41581818181818-1.234i) +(num-test (* 0 1.234+1.234i 1234/11) 0.0) +(num-test (/ 0 1.234+1.234i 1234/11) 0.0) +(num-test (= 0 1.234+1.234i 1234/11) #f) +(num-test (+ 0 1.234+1.234i 1.234+1.234i) 2.468+2.468i) +(num-test (- 0 1.234+1.234i 1.234+1.234i) -2.468-2.468i) +(num-test (* 0 1.234+1.234i 1.234+1.234i) 0.0) +(num-test (/ 0 1.234+1.234i 1.234+1.234i) 0.0) +(num-test (= 0 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 0 1.234+1.234i -1.0+1.0i) 0.234+2.234i) +(num-test (- 0 1.234+1.234i -1.0+1.0i) -0.234-2.234i) +(num-test (* 0 1.234+1.234i -1.0+1.0i) -0.0) +(num-test (/ 0 1.234+1.234i -1.0+1.0i) -0.0) +(num-test (= 0 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 0 1.234+1.234i 0.0+1.0i) 1.234+2.234i) +(num-test (- 0 1.234+1.234i 0.0+1.0i) -1.234-2.234i) +(num-test (* 0 1.234+1.234i 0.0+1.0i) 0.0) +(num-test (/ 0 1.234+1.234i 0.0+1.0i) 0.0) +(num-test (= 0 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 0 -1.0+1.0i 1) 0.0+1.0i) +(num-test (- 0 -1.0+1.0i 1) 0.0-1.0i) +(num-test (* 0 -1.0+1.0i 1) -0.0) +(num-test (/ 0 -1.0+1.0i 1) -0.0) +(num-test (= 0 -1.0+1.0i 1) #f) +(num-test (+ 0 -1.0+1.0i 1.0) 0.0+1.0i) +(num-test (- 0 -1.0+1.0i 1.0) 0.0-1.0i) +(num-test (* 0 -1.0+1.0i 1.0) -0.0) +(num-test (/ 0 -1.0+1.0i 1.0) -0.0) +(num-test (= 0 -1.0+1.0i 1.0) #f) +(num-test (+ 0 -1.0+1.0i 1/1) 0.0+1.0i) +(num-test (- 0 -1.0+1.0i 1/1) 0.0-1.0i) +(num-test (* 0 -1.0+1.0i 1/1) -0.0) +(num-test (/ 0 -1.0+1.0i 1/1) -0.0) +(num-test (= 0 -1.0+1.0i 1/1) #f) +(num-test (+ 0 -1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (- 0 -1.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (* 0 -1.0+1.0i 1.0+1.0i) -0.0) +(num-test (/ 0 -1.0+1.0i 1.0+1.0i) -0.0) +(num-test (= 0 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0 -1.0+1.0i 0) -1.0+1.0i) +(num-test (- 0 -1.0+1.0i 0) 1.0-1.0i) +(num-test (* 0 -1.0+1.0i 0) -0.0) +(num-test (+ 0 -1.0+1.0i 0.0) -1.0+1.0i) +(num-test (- 0 -1.0+1.0i 0.0) 1.0-1.0i) +(num-test (* 0 -1.0+1.0i 0.0) -0.0) +(num-test (+ 0 -1.0+1.0i 1234) 1233.0+1.0i) +(num-test (- 0 -1.0+1.0i 1234) -1233.0-1.0i) +(num-test (* 0 -1.0+1.0i 1234) -0.0) +(num-test (/ 0 -1.0+1.0i 1234) -0.0) +(num-test (= 0 -1.0+1.0i 1234) #f) +(num-test (+ 0 -1.0+1.0i 123.4) 122.4+1.0i) +(num-test (- 0 -1.0+1.0i 123.4) -122.4-1.0i) +(num-test (* 0 -1.0+1.0i 123.4) -0.0) +(num-test (/ 0 -1.0+1.0i 123.4) -0.0) +(num-test (= 0 -1.0+1.0i 123.4) #f) +(num-test (+ 0 -1.0+1.0i 1234/11) 111.18181818181819+1.0i) +(num-test (- 0 -1.0+1.0i 1234/11) -111.18181818181819-1.0i) +(num-test (* 0 -1.0+1.0i 1234/11) -0.0) +(num-test (/ 0 -1.0+1.0i 1234/11) -0.0) +(num-test (= 0 -1.0+1.0i 1234/11) #f) +(num-test (+ 0 -1.0+1.0i 1.234+1.234i) 0.234+2.234i) +(num-test (- 0 -1.0+1.0i 1.234+1.234i) -0.234-2.234i) +(num-test (* 0 -1.0+1.0i 1.234+1.234i) -0.0) +(num-test (/ 0 -1.0+1.0i 1.234+1.234i) -0.0) +(num-test (= 0 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0 -1.0+1.0i -1.0+1.0i) -2.0+2.0i) +(num-test (- 0 -1.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (* 0 -1.0+1.0i -1.0+1.0i) 0.0) +(num-test (/ 0 -1.0+1.0i -1.0+1.0i) -0.0) +(num-test (= 0 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0 -1.0+1.0i 0.0+1.0i) -1.0+2.0i) +(num-test (- 0 -1.0+1.0i 0.0+1.0i) 1.0-2.0i) +(num-test (* 0 -1.0+1.0i 0.0+1.0i) -0.0) +(num-test (/ 0 -1.0+1.0i 0.0+1.0i) -0.0) +(num-test (= 0 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0 0.0+1.0i 1) 1.0+1.0i) +(num-test (- 0 0.0+1.0i 1) -1.0-1.0i) +(num-test (* 0 0.0+1.0i 1) 0.0) +(num-test (/ 0 0.0+1.0i 1) 0.0) +(num-test (= 0 0.0+1.0i 1) #f) +(num-test (+ 0 0.0+1.0i 1.0) 1.0+1.0i) +(num-test (- 0 0.0+1.0i 1.0) -1.0-1.0i) +(num-test (* 0 0.0+1.0i 1.0) 0.0) +(num-test (/ 0 0.0+1.0i 1.0) 0.0) +(num-test (= 0 0.0+1.0i 1.0) #f) +(num-test (+ 0 0.0+1.0i 1/1) 1.0+1.0i) +(num-test (- 0 0.0+1.0i 1/1) -1.0-1.0i) +(num-test (* 0 0.0+1.0i 1/1) 0.0) +(num-test (/ 0 0.0+1.0i 1/1) 0.0) +(num-test (= 0 0.0+1.0i 1/1) #f) +(num-test (+ 0 0.0+1.0i 1.0+1.0i) 1.0+2.0i) +(num-test (- 0 0.0+1.0i 1.0+1.0i) -1.0-2.0i) +(num-test (* 0 0.0+1.0i 1.0+1.0i) 0.0) +(num-test (/ 0 0.0+1.0i 1.0+1.0i) 0.0) +(num-test (= 0 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0 0.0+1.0i 0) 0.0+1.0i) +(num-test (- 0 0.0+1.0i 0) 0.0-1.0i) +(num-test (* 0 0.0+1.0i 0) 0.0) +(num-test (+ 0 0.0+1.0i 0.0) 0.0+1.0i) +(num-test (- 0 0.0+1.0i 0.0) 0.0-1.0i) +(num-test (* 0 0.0+1.0i 0.0) 0.0) +(num-test (+ 0 0.0+1.0i 1234) 1234.0+1.0i) +(num-test (- 0 0.0+1.0i 1234) -1234.0-1.0i) +(num-test (* 0 0.0+1.0i 1234) 0.0) +(num-test (/ 0 0.0+1.0i 1234) 0.0) +(num-test (= 0 0.0+1.0i 1234) #f) +(num-test (+ 0 0.0+1.0i 123.4) 123.4+1.0i) +(num-test (- 0 0.0+1.0i 123.4) -123.4-1.0i) +(num-test (* 0 0.0+1.0i 123.4) 0.0) +(num-test (/ 0 0.0+1.0i 123.4) 0.0) +(num-test (= 0 0.0+1.0i 123.4) #f) +(num-test (+ 0 0.0+1.0i 1234/11) 112.18181818181819+1.0i) +(num-test (- 0 0.0+1.0i 1234/11) -112.18181818181819-1.0i) +(num-test (* 0 0.0+1.0i 1234/11) 0.0) +(num-test (/ 0 0.0+1.0i 1234/11) 0.0) +(num-test (= 0 0.0+1.0i 1234/11) #f) +(num-test (+ 0 0.0+1.0i 1.234+1.234i) 1.234+2.234i) +(num-test (- 0 0.0+1.0i 1.234+1.234i) -1.234-2.234i) +(num-test (* 0 0.0+1.0i 1.234+1.234i) 0.0) +(num-test (/ 0 0.0+1.0i 1.234+1.234i) 0.0) +(num-test (= 0 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0 0.0+1.0i -1.0+1.0i) -1.0+2.0i) +(num-test (- 0 0.0+1.0i -1.0+1.0i) 1.0-2.0i) +(num-test (* 0 0.0+1.0i -1.0+1.0i) -0.0) +(num-test (/ 0 0.0+1.0i -1.0+1.0i) -0.0) +(num-test (= 0 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0 0.0+1.0i 0.0+1.0i) 0.0+2.0i) +(num-test (- 0 0.0+1.0i 0.0+1.0i) 0.0-2.0i) +(num-test (* 0 0.0+1.0i 0.0+1.0i) 0.0) +(num-test (/ 0 0.0+1.0i 0.0+1.0i) 0.0) +(num-test (= 0 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0 1 1) 2.0) +(num-test (- 0.0 1 1) -2.0) +(num-test (* 0.0 1 1) 0.0) +(num-test (/ 0.0 1 1) 0.0) +(num-test (= 0.0 1 1) #f) +(num-test (< 0.0 1 1) #f) +(num-test (<= 0.0 1 1) #t) +(num-test (> 0.0 1 1) #f) +(num-test (>= 0.0 1 1) #f) +(num-test (+ 0.0 1 1.0) 2.0) +(num-test (- 0.0 1 1.0) -2.0) +(num-test (* 0.0 1 1.0) 0.0) +(num-test (/ 0.0 1 1.0) 0.0) +(num-test (= 0.0 1 1.0) #f) +(num-test (< 0.0 1 1.0) #f) +(num-test (<= 0.0 1 1.0) #t) +(num-test (> 0.0 1 1.0) #f) +(num-test (>= 0.0 1 1.0) #f) +(num-test (+ 0.0 1 1/1) 2.0) +(num-test (- 0.0 1 1/1) -2.0) +(num-test (* 0.0 1 1/1) 0.0) +(num-test (/ 0.0 1 1/1) 0.0) +(num-test (= 0.0 1 1/1) #f) +(num-test (< 0.0 1 1/1) #f) +(num-test (<= 0.0 1 1/1) #t) +(num-test (> 0.0 1 1/1) #f) +(num-test (>= 0.0 1 1/1) #f) +(num-test (+ 0.0 1 1.0+1.0i) 2.0+1.0i) +(num-test (- 0.0 1 1.0+1.0i) -2.0-1.0i) +(num-test (* 0.0 1 1.0+1.0i) 0.0) +(num-test (/ 0.0 1 1.0+1.0i) 0.0) +(num-test (= 0.0 1 1.0+1.0i) #f) +(num-test (+ 0.0 1 0) 1.0) +(num-test (- 0.0 1 0) -1.0) +(num-test (* 0.0 1 0) 0.0) +(num-test (+ 0.0 1 0.0) 1.0) +(num-test (- 0.0 1 0.0) -1.0) +(num-test (* 0.0 1 0.0) 0.0) +(num-test (+ 0.0 1 1234) 1235.0) +(num-test (- 0.0 1 1234) -1235.0) +(num-test (* 0.0 1 1234) 0.0) +(num-test (/ 0.0 1 1234) 0.0) +(num-test (= 0.0 1 1234) #f) +(num-test (< 0.0 1 1234) #t) +(num-test (<= 0.0 1 1234) #t) +(num-test (> 0.0 1 1234) #f) +(num-test (>= 0.0 1 1234) #f) +(num-test (+ 0.0 1 123.4) 124.4) +(num-test (- 0.0 1 123.4) -124.4) +(num-test (* 0.0 1 123.4) 0.0) +(num-test (/ 0.0 1 123.4) 0.0) +(num-test (= 0.0 1 123.4) #f) +(num-test (< 0.0 1 123.4) #t) +(num-test (<= 0.0 1 123.4) #t) +(num-test (> 0.0 1 123.4) #f) +(num-test (>= 0.0 1 123.4) #f) +(num-test (+ 0.0 1 1234/11) 113.18181818181819) +(num-test (- 0.0 1 1234/11) -113.18181818181819) +(num-test (* 0.0 1 1234/11) 0.0) +(num-test (/ 0.0 1 1234/11) 0.0) +(num-test (= 0.0 1 1234/11) #f) +(num-test (< 0.0 1 1234/11) #t) +(num-test (<= 0.0 1 1234/11) #t) +(num-test (> 0.0 1 1234/11) #f) +(num-test (>= 0.0 1 1234/11) #f) +(num-test (+ 0.0 1 1.234+1.234i) 2.234+1.234i) +(num-test (- 0.0 1 1.234+1.234i) -2.234-1.234i) +(num-test (* 0.0 1 1.234+1.234i) 0.0) +(num-test (/ 0.0 1 1.234+1.234i) 0.0) +(num-test (= 0.0 1 1.234+1.234i) #f) +(num-test (+ 0.0 1 -1.0+1.0i) 0.0+1.0i) +(num-test (- 0.0 1 -1.0+1.0i) 0.0-1.0i) +(num-test (* 0.0 1 -1.0+1.0i) -0.0) +(num-test (/ 0.0 1 -1.0+1.0i) -0.0) +(num-test (= 0.0 1 -1.0+1.0i) #f) +(num-test (+ 0.0 1 0.0+1.0i) 1.0+1.0i) +(num-test (- 0.0 1 0.0+1.0i) -1.0-1.0i) +(num-test (* 0.0 1 0.0+1.0i) 0.0) +(num-test (/ 0.0 1 0.0+1.0i) 0.0) +(num-test (= 0.0 1 0.0+1.0i) #f) +(num-test (+ 0.0 1.0 1) 2.0) +(num-test (- 0.0 1.0 1) -2.0) +(num-test (* 0.0 1.0 1) 0.0) +(num-test (/ 0.0 1.0 1) 0.0) +(num-test (= 0.0 1.0 1) #f) +(num-test (< 0.0 1.0 1) #f) +(num-test (<= 0.0 1.0 1) #t) +(num-test (> 0.0 1.0 1) #f) +(num-test (>= 0.0 1.0 1) #f) +(num-test (+ 0.0 1.0 1.0) 2.0) +(num-test (- 0.0 1.0 1.0) -2.0) +(num-test (* 0.0 1.0 1.0) 0.0) +(num-test (/ 0.0 1.0 1.0) 0.0) +(num-test (= 0.0 1.0 1.0) #f) +(num-test (< 0.0 1.0 1.0) #f) +(num-test (<= 0.0 1.0 1.0) #t) +(num-test (> 0.0 1.0 1.0) #f) +(num-test (>= 0.0 1.0 1.0) #f) +(num-test (+ 0.0 1.0 1/1) 2.0) +(num-test (- 0.0 1.0 1/1) -2.0) +(num-test (* 0.0 1.0 1/1) 0.0) +(num-test (/ 0.0 1.0 1/1) 0.0) +(num-test (= 0.0 1.0 1/1) #f) +(num-test (< 0.0 1.0 1/1) #f) +(num-test (<= 0.0 1.0 1/1) #t) +(num-test (> 0.0 1.0 1/1) #f) +(num-test (>= 0.0 1.0 1/1) #f) +(num-test (+ 0.0 1.0 1.0+1.0i) 2.0+1.0i) +(num-test (- 0.0 1.0 1.0+1.0i) -2.0-1.0i) +(num-test (* 0.0 1.0 1.0+1.0i) 0.0) +(num-test (/ 0.0 1.0 1.0+1.0i) 0.0) +(num-test (= 0.0 1.0 1.0+1.0i) #f) +(num-test (+ 0.0 1.0 0) 1.0) +(num-test (- 0.0 1.0 0) -1.0) +(num-test (* 0.0 1.0 0) 0.0) +(num-test (+ 0.0 1.0 0.0) 1.0) +(num-test (- 0.0 1.0 0.0) -1.0) +(num-test (* 0.0 1.0 0.0) 0.0) +(num-test (+ 0.0 1.0 1234) 1235.0) +(num-test (- 0.0 1.0 1234) -1235.0) +(num-test (* 0.0 1.0 1234) 0.0) +(num-test (/ 0.0 1.0 1234) 0.0) +(num-test (= 0.0 1.0 1234) #f) +(num-test (< 0.0 1.0 1234) #t) +(num-test (<= 0.0 1.0 1234) #t) +(num-test (> 0.0 1.0 1234) #f) +(num-test (>= 0.0 1.0 1234) #f) +(num-test (+ 0.0 1.0 123.4) 124.4) +(num-test (- 0.0 1.0 123.4) -124.4) +(num-test (* 0.0 1.0 123.4) 0.0) +(num-test (/ 0.0 1.0 123.4) 0.0) +(num-test (= 0.0 1.0 123.4) #f) +(num-test (< 0.0 1.0 123.4) #t) +(num-test (<= 0.0 1.0 123.4) #t) +(num-test (> 0.0 1.0 123.4) #f) +(num-test (>= 0.0 1.0 123.4) #f) +(num-test (+ 0.0 1.0 1234/11) 113.18181818181819) +(num-test (- 0.0 1.0 1234/11) -113.18181818181819) +(num-test (* 0.0 1.0 1234/11) 0.0) +(num-test (/ 0.0 1.0 1234/11) 0.0) +(num-test (= 0.0 1.0 1234/11) #f) +(num-test (< 0.0 1.0 1234/11) #t) +(num-test (<= 0.0 1.0 1234/11) #t) +(num-test (> 0.0 1.0 1234/11) #f) +(num-test (>= 0.0 1.0 1234/11) #f) +(num-test (+ 0.0 1.0 1.234+1.234i) 2.234+1.234i) +(num-test (- 0.0 1.0 1.234+1.234i) -2.234-1.234i) +(num-test (* 0.0 1.0 1.234+1.234i) 0.0) +(num-test (/ 0.0 1.0 1.234+1.234i) 0.0) +(num-test (= 0.0 1.0 1.234+1.234i) #f) +(num-test (+ 0.0 1.0 -1.0+1.0i) 0.0+1.0i) +(num-test (- 0.0 1.0 -1.0+1.0i) 0.0-1.0i) +(num-test (* 0.0 1.0 -1.0+1.0i) -0.0) +(num-test (/ 0.0 1.0 -1.0+1.0i) -0.0) +(num-test (= 0.0 1.0 -1.0+1.0i) #f) +(num-test (+ 0.0 1.0 0.0+1.0i) 1.0+1.0i) +(num-test (- 0.0 1.0 0.0+1.0i) -1.0-1.0i) +(num-test (* 0.0 1.0 0.0+1.0i) 0.0) +(num-test (/ 0.0 1.0 0.0+1.0i) 0.0) +(num-test (= 0.0 1.0 0.0+1.0i) #f) +(num-test (+ 0.0 1/1 1) 2.0) +(num-test (- 0.0 1/1 1) -2.0) +(num-test (* 0.0 1/1 1) 0.0) +(num-test (/ 0.0 1/1 1) 0.0) +(num-test (= 0.0 1/1 1) #f) +(num-test (< 0.0 1/1 1) #f) +(num-test (<= 0.0 1/1 1) #t) +(num-test (> 0.0 1/1 1) #f) +(num-test (>= 0.0 1/1 1) #f) +(num-test (+ 0.0 1/1 1.0) 2.0) +(num-test (- 0.0 1/1 1.0) -2.0) +(num-test (* 0.0 1/1 1.0) 0.0) +(num-test (/ 0.0 1/1 1.0) 0.0) +(num-test (= 0.0 1/1 1.0) #f) +(num-test (< 0.0 1/1 1.0) #f) +(num-test (<= 0.0 1/1 1.0) #t) +(num-test (> 0.0 1/1 1.0) #f) +(num-test (>= 0.0 1/1 1.0) #f) +(num-test (+ 0.0 1/1 1/1) 2.0) +(num-test (- 0.0 1/1 1/1) -2.0) +(num-test (* 0.0 1/1 1/1) 0.0) +(num-test (/ 0.0 1/1 1/1) 0.0) +(num-test (= 0.0 1/1 1/1) #f) +(num-test (< 0.0 1/1 1/1) #f) +(num-test (<= 0.0 1/1 1/1) #t) +(num-test (> 0.0 1/1 1/1) #f) +(num-test (>= 0.0 1/1 1/1) #f) +(num-test (+ 0.0 1/1 1.0+1.0i) 2.0+1.0i) +(num-test (- 0.0 1/1 1.0+1.0i) -2.0-1.0i) +(num-test (* 0.0 1/1 1.0+1.0i) 0.0) +(num-test (/ 0.0 1/1 1.0+1.0i) 0.0) +(num-test (= 0.0 1/1 1.0+1.0i) #f) +(num-test (+ 0.0 1/1 0) 1.0) +(num-test (- 0.0 1/1 0) -1.0) +(num-test (* 0.0 1/1 0) 0.0) +(num-test (+ 0.0 1/1 0.0) 1.0) +(num-test (- 0.0 1/1 0.0) -1.0) +(num-test (* 0.0 1/1 0.0) 0.0) +(num-test (+ 0.0 1/1 1234) 1235.0) +(num-test (- 0.0 1/1 1234) -1235.0) +(num-test (* 0.0 1/1 1234) 0.0) +(num-test (/ 0.0 1/1 1234) 0.0) +(num-test (= 0.0 1/1 1234) #f) +(num-test (< 0.0 1/1 1234) #t) +(num-test (<= 0.0 1/1 1234) #t) +(num-test (> 0.0 1/1 1234) #f) +(num-test (>= 0.0 1/1 1234) #f) +(num-test (+ 0.0 1/1 123.4) 124.4) +(num-test (- 0.0 1/1 123.4) -124.4) +(num-test (* 0.0 1/1 123.4) 0.0) +(num-test (/ 0.0 1/1 123.4) 0.0) +(num-test (= 0.0 1/1 123.4) #f) +(num-test (< 0.0 1/1 123.4) #t) +(num-test (<= 0.0 1/1 123.4) #t) +(num-test (> 0.0 1/1 123.4) #f) +(num-test (>= 0.0 1/1 123.4) #f) +(num-test (+ 0.0 1/1 1234/11) 113.18181818181819) +(num-test (- 0.0 1/1 1234/11) -113.18181818181819) +(num-test (* 0.0 1/1 1234/11) 0.0) +(num-test (/ 0.0 1/1 1234/11) 0.0) +(num-test (= 0.0 1/1 1234/11) #f) +(num-test (< 0.0 1/1 1234/11) #t) +(num-test (<= 0.0 1/1 1234/11) #t) +(num-test (> 0.0 1/1 1234/11) #f) +(num-test (>= 0.0 1/1 1234/11) #f) +(num-test (+ 0.0 1/1 1.234+1.234i) 2.234+1.234i) +(num-test (- 0.0 1/1 1.234+1.234i) -2.234-1.234i) +(num-test (* 0.0 1/1 1.234+1.234i) 0.0) +(num-test (/ 0.0 1/1 1.234+1.234i) 0.0) +(num-test (= 0.0 1/1 1.234+1.234i) #f) +(num-test (+ 0.0 1/1 -1.0+1.0i) 0.0+1.0i) +(num-test (- 0.0 1/1 -1.0+1.0i) 0.0-1.0i) +(num-test (* 0.0 1/1 -1.0+1.0i) -0.0) +(num-test (/ 0.0 1/1 -1.0+1.0i) -0.0) +(num-test (= 0.0 1/1 -1.0+1.0i) #f) +(num-test (+ 0.0 1/1 0.0+1.0i) 1.0+1.0i) +(num-test (- 0.0 1/1 0.0+1.0i) -1.0-1.0i) +(num-test (* 0.0 1/1 0.0+1.0i) 0.0) +(num-test (/ 0.0 1/1 0.0+1.0i) 0.0) +(num-test (= 0.0 1/1 0.0+1.0i) #f) +(num-test (+ 0.0 1.0+1.0i 1) 2.0+1.0i) +(num-test (- 0.0 1.0+1.0i 1) -2.0-1.0i) +(num-test (* 0.0 1.0+1.0i 1) 0.0) +(num-test (/ 0.0 1.0+1.0i 1) 0.0) +(num-test (= 0.0 1.0+1.0i 1) #f) +(num-test (+ 0.0 1.0+1.0i 1.0) 2.0+1.0i) +(num-test (- 0.0 1.0+1.0i 1.0) -2.0-1.0i) +(num-test (* 0.0 1.0+1.0i 1.0) 0.0) +(num-test (/ 0.0 1.0+1.0i 1.0) 0.0) +(num-test (= 0.0 1.0+1.0i 1.0) #f) +(num-test (+ 0.0 1.0+1.0i 1/1) 2.0+1.0i) +(num-test (- 0.0 1.0+1.0i 1/1) -2.0-1.0i) +(num-test (* 0.0 1.0+1.0i 1/1) 0.0) +(num-test (/ 0.0 1.0+1.0i 1/1) 0.0) +(num-test (= 0.0 1.0+1.0i 1/1) #f) +(num-test (+ 0.0 1.0+1.0i 1.0+1.0i) 2.0+2.0i) +(num-test (- 0.0 1.0+1.0i 1.0+1.0i) -2.0-2.0i) +(num-test (* 0.0 1.0+1.0i 1.0+1.0i) 0.0) +(num-test (/ 0.0 1.0+1.0i 1.0+1.0i) 0.0) +(num-test (= 0.0 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0 1.0+1.0i 0) 1.0+1.0i) +(num-test (- 0.0 1.0+1.0i 0) -1.0-1.0i) +(num-test (* 0.0 1.0+1.0i 0) 0.0) +(num-test (+ 0.0 1.0+1.0i 0.0) 1.0+1.0i) +(num-test (- 0.0 1.0+1.0i 0.0) -1.0-1.0i) +(num-test (* 0.0 1.0+1.0i 0.0) 0.0) +(num-test (+ 0.0 1.0+1.0i 1234) 1235.0+1.0i) +(num-test (- 0.0 1.0+1.0i 1234) -1235.0-1.0i) +(num-test (* 0.0 1.0+1.0i 1234) 0.0) +(num-test (/ 0.0 1.0+1.0i 1234) 0.0) +(num-test (= 0.0 1.0+1.0i 1234) #f) +(num-test (+ 0.0 1.0+1.0i 123.4) 124.4+1.0i) +(num-test (- 0.0 1.0+1.0i 123.4) -124.4-1.0i) +(num-test (* 0.0 1.0+1.0i 123.4) 0.0) +(num-test (/ 0.0 1.0+1.0i 123.4) 0.0) +(num-test (= 0.0 1.0+1.0i 123.4) #f) +(num-test (+ 0.0 1.0+1.0i 1234/11) 113.18181818181819+1.0i) +(num-test (- 0.0 1.0+1.0i 1234/11) -113.18181818181819-1.0i) +(num-test (* 0.0 1.0+1.0i 1234/11) 0.0) +(num-test (/ 0.0 1.0+1.0i 1234/11) 0.0) +(num-test (= 0.0 1.0+1.0i 1234/11) #f) +(num-test (+ 0.0 1.0+1.0i 1.234+1.234i) 2.234+2.234i) +(num-test (- 0.0 1.0+1.0i 1.234+1.234i) -2.234-2.234i) +(num-test (* 0.0 1.0+1.0i 1.234+1.234i) 0.0) +(num-test (/ 0.0 1.0+1.0i 1.234+1.234i) 0.0) +(num-test (= 0.0 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0 1.0+1.0i -1.0+1.0i) 0.0+2.0i) +(num-test (- 0.0 1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (* 0.0 1.0+1.0i -1.0+1.0i) -0.0) +(num-test (/ 0.0 1.0+1.0i -1.0+1.0i) -0.0) +(num-test (= 0.0 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0 1.0+1.0i 0.0+1.0i) 1.0+2.0i) +(num-test (- 0.0 1.0+1.0i 0.0+1.0i) -1.0-2.0i) +(num-test (* 0.0 1.0+1.0i 0.0+1.0i) 0.0) +(num-test (/ 0.0 1.0+1.0i 0.0+1.0i) 0.0) +(num-test (= 0.0 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0 0 1) 1.0) +(num-test (- 0.0 0 1) -1.0) +(num-test (* 0.0 0 1) 0.0) +(num-test (+ 0.0 0 1.0) 1.0) +(num-test (- 0.0 0 1.0) -1.0) +(num-test (* 0.0 0 1.0) 0.0) +(num-test (+ 0.0 0 1/1) 1.0) +(num-test (- 0.0 0 1/1) -1.0) +(num-test (* 0.0 0 1/1) 0.0) +(num-test (+ 0.0 0 1.0+1.0i) 1.0+1.0i) +(num-test (- 0.0 0 1.0+1.0i) -1.0-1.0i) +(num-test (* 0.0 0 1.0+1.0i) 0.0) +(num-test (+ 0.0 0 0) 0.0) +(num-test (- 0.0 0 0) 0.0) +(num-test (* 0.0 0 0) 0.0) +(num-test (+ 0.0 0 0.0) 0.0) +(num-test (- 0.0 0 0.0) 0.0) +(num-test (* 0.0 0 0.0) 0.0) +(num-test (+ 0.0 0 1234) 1234.0) +(num-test (- 0.0 0 1234) -1234.0) +(num-test (* 0.0 0 1234) 0.0) +(num-test (+ 0.0 0 123.4) 123.4) +(num-test (- 0.0 0 123.4) -123.4) +(num-test (* 0.0 0 123.4) 0.0) +(num-test (+ 0.0 0 1234/11) 112.18181818181819) +(num-test (- 0.0 0 1234/11) -112.18181818181819) +(num-test (* 0.0 0 1234/11) 0.0) +(num-test (+ 0.0 0 1.234+1.234i) 1.234+1.234i) +(num-test (- 0.0 0 1.234+1.234i) -1.234-1.234i) +(num-test (* 0.0 0 1.234+1.234i) 0.0) +(num-test (+ 0.0 0 -1.0+1.0i) -1.0+1.0i) +(num-test (- 0.0 0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 0.0 0 -1.0+1.0i) -0.0) +(num-test (+ 0.0 0 0.0+1.0i) 0.0+1.0i) +(num-test (- 0.0 0 0.0+1.0i) 0.0-1.0i) +(num-test (* 0.0 0 0.0+1.0i) 0.0) +(num-test (+ 0.0 0.0 1) 1.0) +(num-test (- 0.0 0.0 1) -1.0) +(num-test (* 0.0 0.0 1) 0.0) +(num-test (+ 0.0 0.0 1.0) 1.0) +(num-test (- 0.0 0.0 1.0) -1.0) +(num-test (* 0.0 0.0 1.0) 0.0) +(num-test (+ 0.0 0.0 1/1) 1.0) +(num-test (- 0.0 0.0 1/1) -1.0) +(num-test (* 0.0 0.0 1/1) 0.0) +(num-test (+ 0.0 0.0 1.0+1.0i) 1.0+1.0i) +(num-test (- 0.0 0.0 1.0+1.0i) -1.0-1.0i) +(num-test (* 0.0 0.0 1.0+1.0i) 0.0) +(num-test (+ 0.0 0.0 0) 0.0) +(num-test (- 0.0 0.0 0) 0.0) +(num-test (* 0.0 0.0 0) 0.0) +(num-test (+ 0.0 0.0 0.0) 0.0) +(num-test (- 0.0 0.0 0.0) 0.0) +(num-test (* 0.0 0.0 0.0) 0.0) +(num-test (+ 0.0 0.0 1234) 1234.0) +(num-test (- 0.0 0.0 1234) -1234.0) +(num-test (* 0.0 0.0 1234) 0.0) +(num-test (+ 0.0 0.0 123.4) 123.4) +(num-test (- 0.0 0.0 123.4) -123.4) +(num-test (* 0.0 0.0 123.4) 0.0) +(num-test (+ 0.0 0.0 1234/11) 112.18181818181819) +(num-test (- 0.0 0.0 1234/11) -112.18181818181819) +(num-test (* 0.0 0.0 1234/11) 0.0) +(num-test (+ 0.0 0.0 1.234+1.234i) 1.234+1.234i) +(num-test (- 0.0 0.0 1.234+1.234i) -1.234-1.234i) +(num-test (* 0.0 0.0 1.234+1.234i) 0.0) +(num-test (+ 0.0 0.0 -1.0+1.0i) -1.0+1.0i) +(num-test (- 0.0 0.0 -1.0+1.0i) 1.0-1.0i) +(num-test (* 0.0 0.0 -1.0+1.0i) -0.0) +(num-test (+ 0.0 0.0 0.0+1.0i) 0.0+1.0i) +(num-test (- 0.0 0.0 0.0+1.0i) 0.0-1.0i) +(num-test (* 0.0 0.0 0.0+1.0i) 0.0) +(num-test (+ 0.0 1234 1) 1235.0) +(num-test (- 0.0 1234 1) -1235.0) +(num-test (* 0.0 1234 1) 0.0) +(num-test (/ 0.0 1234 1) 0.0) +(num-test (= 0.0 1234 1) #f) +(num-test (< 0.0 1234 1) #f) +(num-test (<= 0.0 1234 1) #f) +(num-test (> 0.0 1234 1) #f) +(num-test (>= 0.0 1234 1) #f) +(num-test (+ 0.0 1234 1.0) 1235.0) +(num-test (- 0.0 1234 1.0) -1235.0) +(num-test (* 0.0 1234 1.0) 0.0) +(num-test (/ 0.0 1234 1.0) 0.0) +(num-test (= 0.0 1234 1.0) #f) +(num-test (< 0.0 1234 1.0) #f) +(num-test (<= 0.0 1234 1.0) #f) +(num-test (> 0.0 1234 1.0) #f) +(num-test (>= 0.0 1234 1.0) #f) +(num-test (+ 0.0 1234 1/1) 1235.0) +(num-test (- 0.0 1234 1/1) -1235.0) +(num-test (* 0.0 1234 1/1) 0.0) +(num-test (/ 0.0 1234 1/1) 0.0) +(num-test (= 0.0 1234 1/1) #f) +(num-test (< 0.0 1234 1/1) #f) +(num-test (<= 0.0 1234 1/1) #f) +(num-test (> 0.0 1234 1/1) #f) +(num-test (>= 0.0 1234 1/1) #f) +(num-test (+ 0.0 1234 1.0+1.0i) 1235.0+1.0i) +(num-test (- 0.0 1234 1.0+1.0i) -1235.0-1.0i) +(num-test (* 0.0 1234 1.0+1.0i) 0.0) +(num-test (/ 0.0 1234 1.0+1.0i) 0.0) +(num-test (= 0.0 1234 1.0+1.0i) #f) +(num-test (+ 0.0 1234 0) 1234.0) +(num-test (- 0.0 1234 0) -1234.0) +(num-test (* 0.0 1234 0) 0.0) +(num-test (+ 0.0 1234 0.0) 1234.0) +(num-test (- 0.0 1234 0.0) -1234.0) +(num-test (* 0.0 1234 0.0) 0.0) +(num-test (+ 0.0 1234 1234) 2468.0) +(num-test (- 0.0 1234 1234) -2468.0) +(num-test (* 0.0 1234 1234) 0.0) +(num-test (/ 0.0 1234 1234) 0.0) +(num-test (= 0.0 1234 1234) #f) +(num-test (< 0.0 1234 1234) #f) +(num-test (<= 0.0 1234 1234) #t) +(num-test (> 0.0 1234 1234) #f) +(num-test (>= 0.0 1234 1234) #f) +(num-test (+ 0.0 1234 123.4) 1357.4) +(num-test (- 0.0 1234 123.4) -1357.4) +(num-test (* 0.0 1234 123.4) 0.0) +(num-test (/ 0.0 1234 123.4) 0.0) +(num-test (= 0.0 1234 123.4) #f) +(num-test (< 0.0 1234 123.4) #f) +(num-test (<= 0.0 1234 123.4) #f) +(num-test (> 0.0 1234 123.4) #f) +(num-test (>= 0.0 1234 123.4) #f) +(num-test (+ 0.0 1234 1234/11) 1346.18181818181824) +(num-test (- 0.0 1234 1234/11) -1346.18181818181824) +(num-test (* 0.0 1234 1234/11) 0.0) +(num-test (/ 0.0 1234 1234/11) 0.0) +(num-test (= 0.0 1234 1234/11) #f) +(num-test (< 0.0 1234 1234/11) #f) +(num-test (<= 0.0 1234 1234/11) #f) +(num-test (> 0.0 1234 1234/11) #f) +(num-test (>= 0.0 1234 1234/11) #f) +(num-test (+ 0.0 1234 1.234+1.234i) 1235.23399999999992+1.234i) +(num-test (- 0.0 1234 1.234+1.234i) -1235.23399999999992-1.234i) +(num-test (* 0.0 1234 1.234+1.234i) 0.0) +(num-test (/ 0.0 1234 1.234+1.234i) 0.0) +(num-test (= 0.0 1234 1.234+1.234i) #f) +(num-test (+ 0.0 1234 -1.0+1.0i) 1233.0+1.0i) +(num-test (- 0.0 1234 -1.0+1.0i) -1233.0-1.0i) +(num-test (* 0.0 1234 -1.0+1.0i) -0.0) +(num-test (/ 0.0 1234 -1.0+1.0i) -0.0) +(num-test (= 0.0 1234 -1.0+1.0i) #f) +(num-test (+ 0.0 1234 0.0+1.0i) 1234.0+1.0i) +(num-test (- 0.0 1234 0.0+1.0i) -1234.0-1.0i) +(num-test (* 0.0 1234 0.0+1.0i) 0.0) +(num-test (/ 0.0 1234 0.0+1.0i) 0.0) +(num-test (= 0.0 1234 0.0+1.0i) #f) +(num-test (+ 0.0 123.4 1) 124.4) +(num-test (- 0.0 123.4 1) -124.4) +(num-test (* 0.0 123.4 1) 0.0) +(num-test (/ 0.0 123.4 1) 0.0) +(num-test (= 0.0 123.4 1) #f) +(num-test (< 0.0 123.4 1) #f) +(num-test (<= 0.0 123.4 1) #f) +(num-test (> 0.0 123.4 1) #f) +(num-test (>= 0.0 123.4 1) #f) +(num-test (+ 0.0 123.4 1.0) 124.4) +(num-test (- 0.0 123.4 1.0) -124.4) +(num-test (* 0.0 123.4 1.0) 0.0) +(num-test (/ 0.0 123.4 1.0) 0.0) +(num-test (= 0.0 123.4 1.0) #f) +(num-test (< 0.0 123.4 1.0) #f) +(num-test (<= 0.0 123.4 1.0) #f) +(num-test (> 0.0 123.4 1.0) #f) +(num-test (>= 0.0 123.4 1.0) #f) +(num-test (+ 0.0 123.4 1/1) 124.4) +(num-test (- 0.0 123.4 1/1) -124.4) +(num-test (* 0.0 123.4 1/1) 0.0) +(num-test (/ 0.0 123.4 1/1) 0.0) +(num-test (= 0.0 123.4 1/1) #f) +(num-test (< 0.0 123.4 1/1) #f) +(num-test (<= 0.0 123.4 1/1) #f) +(num-test (> 0.0 123.4 1/1) #f) +(num-test (>= 0.0 123.4 1/1) #f) +(num-test (+ 0.0 123.4 1.0+1.0i) 124.4+1.0i) +(num-test (- 0.0 123.4 1.0+1.0i) -124.4-1.0i) +(num-test (* 0.0 123.4 1.0+1.0i) 0.0) +(num-test (/ 0.0 123.4 1.0+1.0i) 0.0) +(num-test (= 0.0 123.4 1.0+1.0i) #f) +(num-test (+ 0.0 123.4 0) 123.4) +(num-test (- 0.0 123.4 0) -123.4) +(num-test (* 0.0 123.4 0) 0.0) +(num-test (+ 0.0 123.4 0.0) 123.4) +(num-test (- 0.0 123.4 0.0) -123.4) +(num-test (* 0.0 123.4 0.0) 0.0) +(num-test (+ 0.0 123.4 1234) 1357.4) +(num-test (- 0.0 123.4 1234) -1357.4) +(num-test (* 0.0 123.4 1234) 0.0) +(num-test (/ 0.0 123.4 1234) 0.0) +(num-test (= 0.0 123.4 1234) #f) +(num-test (< 0.0 123.4 1234) #t) +(num-test (<= 0.0 123.4 1234) #t) +(num-test (> 0.0 123.4 1234) #f) +(num-test (>= 0.0 123.4 1234) #f) +(num-test (+ 0.0 123.4 123.4) 246.8) +(num-test (- 0.0 123.4 123.4) -246.8) +(num-test (* 0.0 123.4 123.4) 0.0) +(num-test (/ 0.0 123.4 123.4) 0.0) +(num-test (= 0.0 123.4 123.4) #f) +(num-test (< 0.0 123.4 123.4) #f) +(num-test (<= 0.0 123.4 123.4) #t) +(num-test (> 0.0 123.4 123.4) #f) +(num-test (>= 0.0 123.4 123.4) #f) +(num-test (+ 0.0 123.4 1234/11) 235.58181818181819) +(num-test (- 0.0 123.4 1234/11) -235.58181818181819) +(num-test (* 0.0 123.4 1234/11) 0.0) +(num-test (/ 0.0 123.4 1234/11) 0.0) +(num-test (= 0.0 123.4 1234/11) #f) +(num-test (< 0.0 123.4 1234/11) #f) +(num-test (<= 0.0 123.4 1234/11) #f) +(num-test (> 0.0 123.4 1234/11) #f) +(num-test (>= 0.0 123.4 1234/11) #f) +(num-test (+ 0.0 123.4 1.234+1.234i) 124.634+1.234i) +(num-test (- 0.0 123.4 1.234+1.234i) -124.634-1.234i) +(num-test (* 0.0 123.4 1.234+1.234i) 0.0) +(num-test (/ 0.0 123.4 1.234+1.234i) 0.0) +(num-test (= 0.0 123.4 1.234+1.234i) #f) +(num-test (+ 0.0 123.4 -1.0+1.0i) 122.4+1.0i) +(num-test (- 0.0 123.4 -1.0+1.0i) -122.4-1.0i) +(num-test (* 0.0 123.4 -1.0+1.0i) -0.0) +(num-test (/ 0.0 123.4 -1.0+1.0i) -0.0) +(num-test (= 0.0 123.4 -1.0+1.0i) #f) +(num-test (+ 0.0 123.4 0.0+1.0i) 123.4+1.0i) +(num-test (- 0.0 123.4 0.0+1.0i) -123.4-1.0i) +(num-test (* 0.0 123.4 0.0+1.0i) 0.0) +(num-test (/ 0.0 123.4 0.0+1.0i) 0.0) +(num-test (= 0.0 123.4 0.0+1.0i) #f) +(num-test (+ 0.0 1234/11 1) 113.18181818181819) +(num-test (- 0.0 1234/11 1) -113.18181818181819) +(num-test (* 0.0 1234/11 1) 0.0) +(num-test (/ 0.0 1234/11 1) 0.0) +(num-test (= 0.0 1234/11 1) #f) +(num-test (< 0.0 1234/11 1) #f) +(num-test (<= 0.0 1234/11 1) #f) +(num-test (> 0.0 1234/11 1) #f) +(num-test (>= 0.0 1234/11 1) #f) +(num-test (+ 0.0 1234/11 1.0) 113.18181818181819) +(num-test (- 0.0 1234/11 1.0) -113.18181818181819) +(num-test (* 0.0 1234/11 1.0) 0.0) +(num-test (/ 0.0 1234/11 1.0) 0.0) +(num-test (= 0.0 1234/11 1.0) #f) +(num-test (< 0.0 1234/11 1.0) #f) +(num-test (<= 0.0 1234/11 1.0) #f) +(num-test (> 0.0 1234/11 1.0) #f) +(num-test (>= 0.0 1234/11 1.0) #f) +(num-test (+ 0.0 1234/11 1/1) 113.18181818181819) +(num-test (- 0.0 1234/11 1/1) -113.18181818181819) +(num-test (* 0.0 1234/11 1/1) 0.0) +(num-test (/ 0.0 1234/11 1/1) 0.0) +(num-test (= 0.0 1234/11 1/1) #f) +(num-test (< 0.0 1234/11 1/1) #f) +(num-test (<= 0.0 1234/11 1/1) #f) +(num-test (> 0.0 1234/11 1/1) #f) +(num-test (>= 0.0 1234/11 1/1) #f) +(num-test (+ 0.0 1234/11 1.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 0.0 1234/11 1.0+1.0i) -113.18181818181819-1.0i) +(num-test (* 0.0 1234/11 1.0+1.0i) 0.0) +(num-test (/ 0.0 1234/11 1.0+1.0i) 0.0) +(num-test (= 0.0 1234/11 1.0+1.0i) #f) +(num-test (+ 0.0 1234/11 0) 112.18181818181819) +(num-test (- 0.0 1234/11 0) -112.18181818181819) +(num-test (* 0.0 1234/11 0) 0.0) +(num-test (+ 0.0 1234/11 0.0) 112.18181818181819) +(num-test (- 0.0 1234/11 0.0) -112.18181818181819) +(num-test (* 0.0 1234/11 0.0) 0.0) +(num-test (+ 0.0 1234/11 1234) 1346.18181818181824) +(num-test (- 0.0 1234/11 1234) -1346.18181818181824) +(num-test (* 0.0 1234/11 1234) 0.0) +(num-test (/ 0.0 1234/11 1234) 0.0) +(num-test (= 0.0 1234/11 1234) #f) +(num-test (< 0.0 1234/11 1234) #t) +(num-test (<= 0.0 1234/11 1234) #t) +(num-test (> 0.0 1234/11 1234) #f) +(num-test (>= 0.0 1234/11 1234) #f) +(num-test (+ 0.0 1234/11 123.4) 235.58181818181819) +(num-test (- 0.0 1234/11 123.4) -235.58181818181819) +(num-test (* 0.0 1234/11 123.4) 0.0) +(num-test (/ 0.0 1234/11 123.4) 0.0) +(num-test (= 0.0 1234/11 123.4) #f) +(num-test (< 0.0 1234/11 123.4) #t) +(num-test (<= 0.0 1234/11 123.4) #t) +(num-test (> 0.0 1234/11 123.4) #f) +(num-test (>= 0.0 1234/11 123.4) #f) +(num-test (+ 0.0 1234/11 1234/11) 224.36363636363637) +(num-test (- 0.0 1234/11 1234/11) -224.36363636363637) +(num-test (* 0.0 1234/11 1234/11) 0.0) +(num-test (/ 0.0 1234/11 1234/11) 0.0) +(num-test (= 0.0 1234/11 1234/11) #f) +(num-test (< 0.0 1234/11 1234/11) #f) +(num-test (<= 0.0 1234/11 1234/11) #t) +(num-test (> 0.0 1234/11 1234/11) #f) +(num-test (>= 0.0 1234/11 1234/11) #f) +(num-test (+ 0.0 1234/11 1.234+1.234i) 113.41581818181818+1.234i) +(num-test (- 0.0 1234/11 1.234+1.234i) -113.41581818181818-1.234i) +(num-test (* 0.0 1234/11 1.234+1.234i) 0.0) +(num-test (/ 0.0 1234/11 1.234+1.234i) 0.0) +(num-test (= 0.0 1234/11 1.234+1.234i) #f) +(num-test (+ 0.0 1234/11 -1.0+1.0i) 111.18181818181819+1.0i) +(num-test (- 0.0 1234/11 -1.0+1.0i) -111.18181818181819-1.0i) +(num-test (* 0.0 1234/11 -1.0+1.0i) -0.0) +(num-test (/ 0.0 1234/11 -1.0+1.0i) -0.0) +(num-test (= 0.0 1234/11 -1.0+1.0i) #f) +(num-test (+ 0.0 1234/11 0.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 0.0 1234/11 0.0+1.0i) -112.18181818181819-1.0i) +(num-test (* 0.0 1234/11 0.0+1.0i) 0.0) +(num-test (/ 0.0 1234/11 0.0+1.0i) 0.0) +(num-test (= 0.0 1234/11 0.0+1.0i) #f) +(num-test (+ 0.0 1.234+1.234i 1) 2.234+1.234i) +(num-test (- 0.0 1.234+1.234i 1) -2.234-1.234i) +(num-test (* 0.0 1.234+1.234i 1) 0.0) +(num-test (/ 0.0 1.234+1.234i 1) 0.0) +(num-test (= 0.0 1.234+1.234i 1) #f) +(num-test (+ 0.0 1.234+1.234i 1.0) 2.234+1.234i) +(num-test (- 0.0 1.234+1.234i 1.0) -2.234-1.234i) +(num-test (* 0.0 1.234+1.234i 1.0) 0.0) +(num-test (/ 0.0 1.234+1.234i 1.0) 0.0) +(num-test (= 0.0 1.234+1.234i 1.0) #f) +(num-test (+ 0.0 1.234+1.234i 1/1) 2.234+1.234i) +(num-test (- 0.0 1.234+1.234i 1/1) -2.234-1.234i) +(num-test (* 0.0 1.234+1.234i 1/1) 0.0) +(num-test (/ 0.0 1.234+1.234i 1/1) 0.0) +(num-test (= 0.0 1.234+1.234i 1/1) #f) +(num-test (+ 0.0 1.234+1.234i 1.0+1.0i) 2.234+2.234i) +(num-test (- 0.0 1.234+1.234i 1.0+1.0i) -2.234-2.234i) +(num-test (* 0.0 1.234+1.234i 1.0+1.0i) 0.0) +(num-test (/ 0.0 1.234+1.234i 1.0+1.0i) 0.0) +(num-test (= 0.0 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 0.0 1.234+1.234i 0) 1.234+1.234i) +(num-test (- 0.0 1.234+1.234i 0) -1.234-1.234i) +(num-test (* 0.0 1.234+1.234i 0) 0.0) +(num-test (+ 0.0 1.234+1.234i 0.0) 1.234+1.234i) +(num-test (- 0.0 1.234+1.234i 0.0) -1.234-1.234i) +(num-test (* 0.0 1.234+1.234i 0.0) 0.0) +(num-test (+ 0.0 1.234+1.234i 1234) 1235.23399999999992+1.234i) +(num-test (- 0.0 1.234+1.234i 1234) -1235.23399999999992-1.234i) +(num-test (* 0.0 1.234+1.234i 1234) 0.0) +(num-test (/ 0.0 1.234+1.234i 1234) 0.0) +(num-test (= 0.0 1.234+1.234i 1234) #f) +(num-test (+ 0.0 1.234+1.234i 123.4) 124.634+1.234i) +(num-test (- 0.0 1.234+1.234i 123.4) -124.634-1.234i) +(num-test (* 0.0 1.234+1.234i 123.4) 0.0) +(num-test (/ 0.0 1.234+1.234i 123.4) 0.0) +(num-test (= 0.0 1.234+1.234i 123.4) #f) +(num-test (+ 0.0 1.234+1.234i 1234/11) 113.41581818181818+1.234i) +(num-test (- 0.0 1.234+1.234i 1234/11) -113.41581818181818-1.234i) +(num-test (* 0.0 1.234+1.234i 1234/11) 0.0) +(num-test (/ 0.0 1.234+1.234i 1234/11) 0.0) +(num-test (= 0.0 1.234+1.234i 1234/11) #f) +(num-test (+ 0.0 1.234+1.234i 1.234+1.234i) 2.468+2.468i) +(num-test (- 0.0 1.234+1.234i 1.234+1.234i) -2.468-2.468i) +(num-test (* 0.0 1.234+1.234i 1.234+1.234i) 0.0) +(num-test (/ 0.0 1.234+1.234i 1.234+1.234i) 0.0) +(num-test (= 0.0 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 0.0 1.234+1.234i -1.0+1.0i) 0.234+2.234i) +(num-test (- 0.0 1.234+1.234i -1.0+1.0i) -0.234-2.234i) +(num-test (* 0.0 1.234+1.234i -1.0+1.0i) -0.0) +(num-test (/ 0.0 1.234+1.234i -1.0+1.0i) -0.0) +(num-test (= 0.0 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 0.0 1.234+1.234i 0.0+1.0i) 1.234+2.234i) +(num-test (- 0.0 1.234+1.234i 0.0+1.0i) -1.234-2.234i) +(num-test (* 0.0 1.234+1.234i 0.0+1.0i) 0.0) +(num-test (/ 0.0 1.234+1.234i 0.0+1.0i) 0.0) +(num-test (= 0.0 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 0.0 -1.0+1.0i 1) 0.0+1.0i) +(num-test (- 0.0 -1.0+1.0i 1) 0.0-1.0i) +(num-test (* 0.0 -1.0+1.0i 1) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1) -0.0) +(num-test (= 0.0 -1.0+1.0i 1) #f) +(num-test (+ 0.0 -1.0+1.0i 1.0) 0.0+1.0i) +(num-test (- 0.0 -1.0+1.0i 1.0) 0.0-1.0i) +(num-test (* 0.0 -1.0+1.0i 1.0) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1.0) -0.0) +(num-test (= 0.0 -1.0+1.0i 1.0) #f) +(num-test (+ 0.0 -1.0+1.0i 1/1) 0.0+1.0i) +(num-test (- 0.0 -1.0+1.0i 1/1) 0.0-1.0i) +(num-test (* 0.0 -1.0+1.0i 1/1) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1/1) -0.0) +(num-test (= 0.0 -1.0+1.0i 1/1) #f) +(num-test (+ 0.0 -1.0+1.0i 1.0+1.0i) 0.0+2.0i) +(num-test (- 0.0 -1.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (* 0.0 -1.0+1.0i 1.0+1.0i) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1.0+1.0i) -0.0) +(num-test (= 0.0 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0 -1.0+1.0i 0) -1.0+1.0i) +(num-test (- 0.0 -1.0+1.0i 0) 1.0-1.0i) +(num-test (* 0.0 -1.0+1.0i 0) -0.0) +(num-test (+ 0.0 -1.0+1.0i 0.0) -1.0+1.0i) +(num-test (- 0.0 -1.0+1.0i 0.0) 1.0-1.0i) +(num-test (* 0.0 -1.0+1.0i 0.0) -0.0) +(num-test (+ 0.0 -1.0+1.0i 1234) 1233.0+1.0i) +(num-test (- 0.0 -1.0+1.0i 1234) -1233.0-1.0i) +(num-test (* 0.0 -1.0+1.0i 1234) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1234) -0.0) +(num-test (= 0.0 -1.0+1.0i 1234) #f) +(num-test (+ 0.0 -1.0+1.0i 123.4) 122.4+1.0i) +(num-test (- 0.0 -1.0+1.0i 123.4) -122.4-1.0i) +(num-test (* 0.0 -1.0+1.0i 123.4) -0.0) +(num-test (/ 0.0 -1.0+1.0i 123.4) -0.0) +(num-test (= 0.0 -1.0+1.0i 123.4) #f) +(num-test (+ 0.0 -1.0+1.0i 1234/11) 111.18181818181819+1.0i) +(num-test (- 0.0 -1.0+1.0i 1234/11) -111.18181818181819-1.0i) +(num-test (* 0.0 -1.0+1.0i 1234/11) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1234/11) -0.0) +(num-test (= 0.0 -1.0+1.0i 1234/11) #f) +(num-test (+ 0.0 -1.0+1.0i 1.234+1.234i) 0.234+2.234i) +(num-test (- 0.0 -1.0+1.0i 1.234+1.234i) -0.234-2.234i) +(num-test (* 0.0 -1.0+1.0i 1.234+1.234i) -0.0) +(num-test (/ 0.0 -1.0+1.0i 1.234+1.234i) -0.0) +(num-test (= 0.0 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0 -1.0+1.0i -1.0+1.0i) -2.0+2.0i) +(num-test (- 0.0 -1.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (* 0.0 -1.0+1.0i -1.0+1.0i) 0.0) +(num-test (/ 0.0 -1.0+1.0i -1.0+1.0i) -0.0) +(num-test (= 0.0 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0 -1.0+1.0i 0.0+1.0i) -1.0+2.0i) +(num-test (- 0.0 -1.0+1.0i 0.0+1.0i) 1.0-2.0i) +(num-test (* 0.0 -1.0+1.0i 0.0+1.0i) -0.0) +(num-test (/ 0.0 -1.0+1.0i 0.0+1.0i) -0.0) +(num-test (= 0.0 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0 0.0+1.0i 1) 1.0+1.0i) +(num-test (- 0.0 0.0+1.0i 1) -1.0-1.0i) +(num-test (* 0.0 0.0+1.0i 1) 0.0) +(num-test (/ 0.0 0.0+1.0i 1) 0.0) +(num-test (= 0.0 0.0+1.0i 1) #f) +(num-test (+ 0.0 0.0+1.0i 1.0) 1.0+1.0i) +(num-test (- 0.0 0.0+1.0i 1.0) -1.0-1.0i) +(num-test (* 0.0 0.0+1.0i 1.0) 0.0) +(num-test (/ 0.0 0.0+1.0i 1.0) 0.0) +(num-test (= 0.0 0.0+1.0i 1.0) #f) +(num-test (+ 0.0 0.0+1.0i 1/1) 1.0+1.0i) +(num-test (- 0.0 0.0+1.0i 1/1) -1.0-1.0i) +(num-test (* 0.0 0.0+1.0i 1/1) 0.0) +(num-test (/ 0.0 0.0+1.0i 1/1) 0.0) +(num-test (= 0.0 0.0+1.0i 1/1) #f) +(num-test (+ 0.0 0.0+1.0i 1.0+1.0i) 1.0+2.0i) +(num-test (- 0.0 0.0+1.0i 1.0+1.0i) -1.0-2.0i) +(num-test (* 0.0 0.0+1.0i 1.0+1.0i) 0.0) +(num-test (/ 0.0 0.0+1.0i 1.0+1.0i) 0.0) +(num-test (= 0.0 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0 0.0+1.0i 0) 0.0+1.0i) +(num-test (- 0.0 0.0+1.0i 0) 0.0-1.0i) +(num-test (* 0.0 0.0+1.0i 0) 0.0) +(num-test (+ 0.0 0.0+1.0i 0.0) 0.0+1.0i) +(num-test (- 0.0 0.0+1.0i 0.0) 0.0-1.0i) +(num-test (* 0.0 0.0+1.0i 0.0) 0.0) +(num-test (+ 0.0 0.0+1.0i 1234) 1234.0+1.0i) +(num-test (- 0.0 0.0+1.0i 1234) -1234.0-1.0i) +(num-test (* 0.0 0.0+1.0i 1234) 0.0) +(num-test (/ 0.0 0.0+1.0i 1234) 0.0) +(num-test (= 0.0 0.0+1.0i 1234) #f) +(num-test (+ 0.0 0.0+1.0i 123.4) 123.4+1.0i) +(num-test (- 0.0 0.0+1.0i 123.4) -123.4-1.0i) +(num-test (* 0.0 0.0+1.0i 123.4) 0.0) +(num-test (/ 0.0 0.0+1.0i 123.4) 0.0) +(num-test (= 0.0 0.0+1.0i 123.4) #f) +(num-test (+ 0.0 0.0+1.0i 1234/11) 112.18181818181819+1.0i) +(num-test (- 0.0 0.0+1.0i 1234/11) -112.18181818181819-1.0i) +(num-test (* 0.0 0.0+1.0i 1234/11) 0.0) +(num-test (/ 0.0 0.0+1.0i 1234/11) 0.0) +(num-test (= 0.0 0.0+1.0i 1234/11) #f) +(num-test (+ 0.0 0.0+1.0i 1.234+1.234i) 1.234+2.234i) +(num-test (- 0.0 0.0+1.0i 1.234+1.234i) -1.234-2.234i) +(num-test (* 0.0 0.0+1.0i 1.234+1.234i) 0.0) +(num-test (/ 0.0 0.0+1.0i 1.234+1.234i) 0.0) +(num-test (= 0.0 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0 0.0+1.0i -1.0+1.0i) -1.0+2.0i) +(num-test (- 0.0 0.0+1.0i -1.0+1.0i) 1.0-2.0i) +(num-test (* 0.0 0.0+1.0i -1.0+1.0i) -0.0) +(num-test (/ 0.0 0.0+1.0i -1.0+1.0i) -0.0) +(num-test (= 0.0 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0 0.0+1.0i 0.0+1.0i) 0.0+2.0i) +(num-test (- 0.0 0.0+1.0i 0.0+1.0i) 0.0-2.0i) +(num-test (* 0.0 0.0+1.0i 0.0+1.0i) 0.0) +(num-test (/ 0.0 0.0+1.0i 0.0+1.0i) 0.0) +(num-test (= 0.0 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1234 1 1) 1236) +(num-test (- 1234 1 1) 1232) +(num-test (* 1234 1 1) 1234) +(num-test (/ 1234 1 1) 1234) +(num-test (= 1234 1 1) #f) +(num-test (< 1234 1 1) #f) +(num-test (<= 1234 1 1) #f) +(num-test (> 1234 1 1) #f) +(num-test (>= 1234 1 1) #t) +(num-test (+ 1234 1 1.0) 1236.0) +(num-test (- 1234 1 1.0) 1232.0) +(num-test (* 1234 1 1.0) 1234.0) +(num-test (/ 1234 1 1.0) 1234.0) +(num-test (= 1234 1 1.0) #f) +(num-test (< 1234 1 1.0) #f) +(num-test (<= 1234 1 1.0) #f) +(num-test (> 1234 1 1.0) #f) +(num-test (>= 1234 1 1.0) #t) +(num-test (+ 1234 1 1/1) 1236) +(num-test (- 1234 1 1/1) 1232) +(num-test (* 1234 1 1/1) 1234) +(num-test (/ 1234 1 1/1) 1234) +(num-test (= 1234 1 1/1) #f) +(num-test (< 1234 1 1/1) #f) +(num-test (<= 1234 1 1/1) #f) +(num-test (> 1234 1 1/1) #f) +(num-test (>= 1234 1 1/1) #t) +(num-test (+ 1234 1 1.0+1.0i) 1236.0+1.0i) +(num-test (- 1234 1 1.0+1.0i) 1232.0-1.0i) +(num-test (* 1234 1 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1234 1 1.0+1.0i) 617.0-617.0i) +(num-test (= 1234 1 1.0+1.0i) #f) +(num-test (+ 1234 1 0) 1235) +(num-test (- 1234 1 0) 1233) +(num-test (* 1234 1 0) 0) +(num-test (+ 1234 1 0.0) 1235.0) +(num-test (- 1234 1 0.0) 1233.0) +(num-test (* 1234 1 0.0) 0.0) +(num-test (+ 1234 1 1234) 2469) +(num-test (- 1234 1 1234) -1) +(num-test (* 1234 1 1234) 1522756) +(num-test (/ 1234 1 1234) 1) +(num-test (= 1234 1 1234) #f) +(num-test (< 1234 1 1234) #f) +(num-test (<= 1234 1 1234) #f) +(num-test (> 1234 1 1234) #f) +(num-test (>= 1234 1 1234) #f) +(num-test (+ 1234 1 123.4) 1358.4) +(num-test (- 1234 1 123.4) 1109.59999999999991) +(num-test (* 1234 1 123.4) 152275.60000000000582) +(num-test (/ 1234 1 123.4) 10.0) +(num-test (= 1234 1 123.4) #f) +(num-test (< 1234 1 123.4) #f) +(num-test (<= 1234 1 123.4) #f) +(num-test (> 1234 1 123.4) #f) +(num-test (>= 1234 1 123.4) #f) +(num-test (+ 1234 1 1234/11) 14819/11) +(num-test (- 1234 1 1234/11) 12329/11) +(num-test (* 1234 1 1234/11) 1522756/11) +(num-test (/ 1234 1 1234/11) 11) +(num-test (= 1234 1 1234/11) #f) +(num-test (< 1234 1 1234/11) #f) +(num-test (<= 1234 1 1234/11) #f) +(num-test (> 1234 1 1234/11) #f) +(num-test (>= 1234 1 1234/11) #f) +(num-test (+ 1234 1 1.234+1.234i) 1236.23399999999992+1.234i) +(num-test (- 1234 1 1.234+1.234i) 1231.766-1.234i) +(num-test (* 1234 1 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1234 1 1.234+1.234i) 500.0-500.0i) +(num-test (= 1234 1 1.234+1.234i) #f) +(num-test (+ 1234 1 -1.0+1.0i) 1234.0+1.0i) +(num-test (- 1234 1 -1.0+1.0i) 1234.0-1.0i) +(num-test (* 1234 1 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1234 1 -1.0+1.0i) -617.0-617.0i) +(num-test (= 1234 1 -1.0+1.0i) #f) +(num-test (+ 1234 1 0.0+1.0i) 1235.0+1.0i) +(num-test (- 1234 1 0.0+1.0i) 1233.0-1.0i) +(num-test (* 1234 1 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1234 1 0.0+1.0i) 0.0-1234.0i) +(num-test (= 1234 1 0.0+1.0i) #f) +(num-test (+ 1234 1.0 1) 1236.0) +(num-test (- 1234 1.0 1) 1232.0) +(num-test (* 1234 1.0 1) 1234.0) +(num-test (/ 1234 1.0 1) 1234.0) +(num-test (= 1234 1.0 1) #f) +(num-test (< 1234 1.0 1) #f) +(num-test (<= 1234 1.0 1) #f) +(num-test (> 1234 1.0 1) #f) +(num-test (>= 1234 1.0 1) #t) +(num-test (+ 1234 1.0 1.0) 1236.0) +(num-test (- 1234 1.0 1.0) 1232.0) +(num-test (* 1234 1.0 1.0) 1234.0) +(num-test (/ 1234 1.0 1.0) 1234.0) +(num-test (= 1234 1.0 1.0) #f) +(num-test (< 1234 1.0 1.0) #f) +(num-test (<= 1234 1.0 1.0) #f) +(num-test (> 1234 1.0 1.0) #f) +(num-test (>= 1234 1.0 1.0) #t) +(num-test (+ 1234 1.0 1/1) 1236.0) +(num-test (- 1234 1.0 1/1) 1232.0) +(num-test (* 1234 1.0 1/1) 1234.0) +(num-test (/ 1234 1.0 1/1) 1234.0) +(num-test (= 1234 1.0 1/1) #f) +(num-test (< 1234 1.0 1/1) #f) +(num-test (<= 1234 1.0 1/1) #f) +(num-test (> 1234 1.0 1/1) #f) +(num-test (>= 1234 1.0 1/1) #t) +(num-test (+ 1234 1.0 1.0+1.0i) 1236.0+1.0i) +(num-test (- 1234 1.0 1.0+1.0i) 1232.0-1.0i) +(num-test (* 1234 1.0 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1234 1.0 1.0+1.0i) 617.0-617.0i) +(num-test (= 1234 1.0 1.0+1.0i) #f) +(num-test (+ 1234 1.0 0) 1235.0) +(num-test (- 1234 1.0 0) 1233.0) +(num-test (* 1234 1.0 0) 0.0) +(num-test (+ 1234 1.0 0.0) 1235.0) +(num-test (- 1234 1.0 0.0) 1233.0) +(num-test (* 1234 1.0 0.0) 0.0) +(num-test (+ 1234 1.0 1234) 2469.0) +(num-test (- 1234 1.0 1234) -1.0) +(num-test (* 1234 1.0 1234) 1522756.0) +(num-test (/ 1234 1.0 1234) 1.0) +(num-test (= 1234 1.0 1234) #f) +(num-test (< 1234 1.0 1234) #f) +(num-test (<= 1234 1.0 1234) #f) +(num-test (> 1234 1.0 1234) #f) +(num-test (>= 1234 1.0 1234) #f) +(num-test (+ 1234 1.0 123.4) 1358.4) +(num-test (- 1234 1.0 123.4) 1109.59999999999991) +(num-test (* 1234 1.0 123.4) 152275.60000000000582) +(num-test (/ 1234 1.0 123.4) 10.0) +(num-test (= 1234 1.0 123.4) #f) +(num-test (< 1234 1.0 123.4) #f) +(num-test (<= 1234 1.0 123.4) #f) +(num-test (> 1234 1.0 123.4) #f) +(num-test (>= 1234 1.0 123.4) #f) +(num-test (+ 1234 1.0 1234/11) 1347.18181818181824) +(num-test (- 1234 1.0 1234/11) 1120.81818181818176) +(num-test (* 1234 1.0 1234/11) 138432.36363636364695) +(num-test (/ 1234 1.0 1234/11) 11.0) +(num-test (= 1234 1.0 1234/11) #f) +(num-test (< 1234 1.0 1234/11) #f) +(num-test (<= 1234 1.0 1234/11) #f) +(num-test (> 1234 1.0 1234/11) #f) +(num-test (>= 1234 1.0 1234/11) #f) +(num-test (+ 1234 1.0 1.234+1.234i) 1236.23399999999992+1.234i) +(num-test (- 1234 1.0 1.234+1.234i) 1231.766-1.234i) +(num-test (* 1234 1.0 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1234 1.0 1.234+1.234i) 500.0-500.0i) +(num-test (= 1234 1.0 1.234+1.234i) #f) +(num-test (+ 1234 1.0 -1.0+1.0i) 1234.0+1.0i) +(num-test (- 1234 1.0 -1.0+1.0i) 1234.0-1.0i) +(num-test (* 1234 1.0 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1234 1.0 -1.0+1.0i) -617.0-617.0i) +(num-test (= 1234 1.0 -1.0+1.0i) #f) +(num-test (+ 1234 1.0 0.0+1.0i) 1235.0+1.0i) +(num-test (- 1234 1.0 0.0+1.0i) 1233.0-1.0i) +(num-test (* 1234 1.0 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1234 1.0 0.0+1.0i) 0.0-1234.0i) +(num-test (= 1234 1.0 0.0+1.0i) #f) +(num-test (+ 1234 1/1 1) 1236) +(num-test (- 1234 1/1 1) 1232) +(num-test (* 1234 1/1 1) 1234) +(num-test (/ 1234 1/1 1) 1234) +(num-test (= 1234 1/1 1) #f) +(num-test (< 1234 1/1 1) #f) +(num-test (<= 1234 1/1 1) #f) +(num-test (> 1234 1/1 1) #f) +(num-test (>= 1234 1/1 1) #t) +(num-test (+ 1234 1/1 1.0) 1236.0) +(num-test (- 1234 1/1 1.0) 1232.0) +(num-test (* 1234 1/1 1.0) 1234.0) +(num-test (/ 1234 1/1 1.0) 1234.0) +(num-test (= 1234 1/1 1.0) #f) +(num-test (< 1234 1/1 1.0) #f) +(num-test (<= 1234 1/1 1.0) #f) +(num-test (> 1234 1/1 1.0) #f) +(num-test (>= 1234 1/1 1.0) #t) +(num-test (+ 1234 1/1 1/1) 1236) +(num-test (- 1234 1/1 1/1) 1232) +(num-test (* 1234 1/1 1/1) 1234) +(num-test (/ 1234 1/1 1/1) 1234) +(num-test (= 1234 1/1 1/1) #f) +(num-test (< 1234 1/1 1/1) #f) +(num-test (<= 1234 1/1 1/1) #f) +(num-test (> 1234 1/1 1/1) #f) +(num-test (>= 1234 1/1 1/1) #t) +(num-test (+ 1234 1/1 1.0+1.0i) 1236.0+1.0i) +(num-test (- 1234 1/1 1.0+1.0i) 1232.0-1.0i) +(num-test (* 1234 1/1 1.0+1.0i) 1234.0+1234.0i) +(num-test (/ 1234 1/1 1.0+1.0i) 617.0-617.0i) +(num-test (= 1234 1/1 1.0+1.0i) #f) +(num-test (+ 1234 1/1 0) 1235) +(num-test (- 1234 1/1 0) 1233) +(num-test (* 1234 1/1 0) 0) +(num-test (+ 1234 1/1 0.0) 1235.0) +(num-test (- 1234 1/1 0.0) 1233.0) +(num-test (* 1234 1/1 0.0) 0.0) +(num-test (+ 1234 1/1 1234) 2469) +(num-test (- 1234 1/1 1234) -1) +(num-test (* 1234 1/1 1234) 1522756) +(num-test (/ 1234 1/1 1234) 1) +(num-test (= 1234 1/1 1234) #f) +(num-test (< 1234 1/1 1234) #f) +(num-test (<= 1234 1/1 1234) #f) +(num-test (> 1234 1/1 1234) #f) +(num-test (>= 1234 1/1 1234) #f) +(num-test (+ 1234 1/1 123.4) 1358.4) +(num-test (- 1234 1/1 123.4) 1109.59999999999991) +(num-test (* 1234 1/1 123.4) 152275.60000000000582) +(num-test (/ 1234 1/1 123.4) 10.0) +(num-test (= 1234 1/1 123.4) #f) +(num-test (< 1234 1/1 123.4) #f) +(num-test (<= 1234 1/1 123.4) #f) +(num-test (> 1234 1/1 123.4) #f) +(num-test (>= 1234 1/1 123.4) #f) +(num-test (+ 1234 1/1 1234/11) 14819/11) +(num-test (- 1234 1/1 1234/11) 12329/11) +(num-test (* 1234 1/1 1234/11) 1522756/11) +(num-test (/ 1234 1/1 1234/11) 11) +(num-test (= 1234 1/1 1234/11) #f) +(num-test (< 1234 1/1 1234/11) #f) +(num-test (<= 1234 1/1 1234/11) #f) +(num-test (> 1234 1/1 1234/11) #f) +(num-test (>= 1234 1/1 1234/11) #f) +(num-test (+ 1234 1/1 1.234+1.234i) 1236.23399999999992+1.234i) +(num-test (- 1234 1/1 1.234+1.234i) 1231.766-1.234i) +(num-test (* 1234 1/1 1.234+1.234i) 1522.756+1522.756i) +(num-test (/ 1234 1/1 1.234+1.234i) 500.0-500.0i) +(num-test (= 1234 1/1 1.234+1.234i) #f) +(num-test (+ 1234 1/1 -1.0+1.0i) 1234.0+1.0i) +(num-test (- 1234 1/1 -1.0+1.0i) 1234.0-1.0i) +(num-test (* 1234 1/1 -1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1234 1/1 -1.0+1.0i) -617.0-617.0i) +(num-test (= 1234 1/1 -1.0+1.0i) #f) +(num-test (+ 1234 1/1 0.0+1.0i) 1235.0+1.0i) +(num-test (- 1234 1/1 0.0+1.0i) 1233.0-1.0i) +(num-test (* 1234 1/1 0.0+1.0i) 0.0+1234.0i) +(num-test (/ 1234 1/1 0.0+1.0i) 0.0-1234.0i) +(num-test (= 1234 1/1 0.0+1.0i) #f) +(num-test (+ 1234 1.0+1.0i 1) 1236.0+1.0i) +(num-test (- 1234 1.0+1.0i 1) 1232.0-1.0i) +(num-test (* 1234 1.0+1.0i 1) 1234.0+1234.0i) +(num-test (/ 1234 1.0+1.0i 1) 617.0-617.0i) +(num-test (= 1234 1.0+1.0i 1) #f) +(num-test (+ 1234 1.0+1.0i 1.0) 1236.0+1.0i) +(num-test (- 1234 1.0+1.0i 1.0) 1232.0-1.0i) +(num-test (* 1234 1.0+1.0i 1.0) 1234.0+1234.0i) +(num-test (/ 1234 1.0+1.0i 1.0) 617.0-617.0i) +(num-test (= 1234 1.0+1.0i 1.0) #f) +(num-test (+ 1234 1.0+1.0i 1/1) 1236.0+1.0i) +(num-test (- 1234 1.0+1.0i 1/1) 1232.0-1.0i) +(num-test (* 1234 1.0+1.0i 1/1) 1234.0+1234.0i) +(num-test (/ 1234 1.0+1.0i 1/1) 617.0-617.0i) +(num-test (= 1234 1.0+1.0i 1/1) #f) +(num-test (+ 1234 1.0+1.0i 1.0+1.0i) 1236.0+2.0i) +(num-test (- 1234 1.0+1.0i 1.0+1.0i) 1232.0-2.0i) +(num-test (* 1234 1.0+1.0i 1.0+1.0i) 0.0+2468.0i) +(num-test (/ 1234 1.0+1.0i 1.0+1.0i) 0.0-617.0i) +(num-test (= 1234 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1234 1.0+1.0i 0) 1235.0+1.0i) +(num-test (- 1234 1.0+1.0i 0) 1233.0-1.0i) +(num-test (* 1234 1.0+1.0i 0) 0.0) +(num-test (+ 1234 1.0+1.0i 0.0) 1235.0+1.0i) +(num-test (- 1234 1.0+1.0i 0.0) 1233.0-1.0i) +(num-test (* 1234 1.0+1.0i 0.0) 0.0) +(num-test (+ 1234 1.0+1.0i 1234) 2469.0+1.0i) +(num-test (- 1234 1.0+1.0i 1234) -1.0-1.0i) +(num-test (* 1234 1.0+1.0i 1234) 1522756.0+1522756.0i) +(num-test (/ 1234 1.0+1.0i 1234) 0.5-0.5i) +(num-test (= 1234 1.0+1.0i 1234) #f) +(num-test (+ 1234 1.0+1.0i 123.4) 1358.4+1.0i) +(num-test (- 1234 1.0+1.0i 123.4) 1109.59999999999991-1.0i) +(num-test (* 1234 1.0+1.0i 123.4) 152275.60000000000582+152275.60000000000582i) +(num-test (/ 1234 1.0+1.0i 123.4) 5.0-5.0i) +(num-test (= 1234 1.0+1.0i 123.4) #f) +(num-test (+ 1234 1.0+1.0i 1234/11) 1347.18181818181824+1.0i) +(num-test (- 1234 1.0+1.0i 1234/11) 1120.81818181818176-1.0i) +(num-test (* 1234 1.0+1.0i 1234/11) 138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234 1.0+1.0i 1234/11) 5.50000000000000-5.50000000000000i) +(num-test (= 1234 1.0+1.0i 1234/11) #f) +(num-test (+ 1234 1.0+1.0i 1.234+1.234i) 1236.23399999999992+2.234i) +(num-test (- 1234 1.0+1.0i 1.234+1.234i) 1231.766-2.234i) +(num-test (* 1234 1.0+1.0i 1.234+1.234i) 0.0+3045.51200000000017i) +(num-test (/ 1234 1.0+1.0i 1.234+1.234i) 0.0-500.0i) +(num-test (= 1234 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1234 1.0+1.0i -1.0+1.0i) 1234.0+2.0i) +(num-test (- 1234 1.0+1.0i -1.0+1.0i) 1234.0-2.0i) +(num-test (* 1234 1.0+1.0i -1.0+1.0i) -2468.0) +(num-test (/ 1234 1.0+1.0i -1.0+1.0i) -617.0) +(num-test (= 1234 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1234 1.0+1.0i 0.0+1.0i) 1235.0+2.0i) +(num-test (- 1234 1.0+1.0i 0.0+1.0i) 1233.0-2.0i) +(num-test (* 1234 1.0+1.0i 0.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1234 1.0+1.0i 0.0+1.0i) -617.0-617.0i) +(num-test (= 1234 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1234 0 1) 1235) +(num-test (- 1234 0 1) 1233) +(num-test (* 1234 0 1) 0) +(num-test (+ 1234 0 1.0) 1235.0) +(num-test (- 1234 0 1.0) 1233.0) +(num-test (* 1234 0 1.0) 0.0) +(num-test (+ 1234 0 1/1) 1235) +(num-test (- 1234 0 1/1) 1233) +(num-test (* 1234 0 1/1) 0) +(num-test (+ 1234 0 1.0+1.0i) 1235.0+1.0i) +(num-test (- 1234 0 1.0+1.0i) 1233.0-1.0i) +(num-test (* 1234 0 1.0+1.0i) 0.0) +(num-test (+ 1234 0 0) 1234) +(num-test (- 1234 0 0) 1234) +(num-test (* 1234 0 0) 0) +(num-test (+ 1234 0 0.0) 1234.0) +(num-test (- 1234 0 0.0) 1234.0) +(num-test (* 1234 0 0.0) 0.0) +(num-test (+ 1234 0 1234) 2468) +(num-test (- 1234 0 1234) 0) +(num-test (* 1234 0 1234) 0) +(num-test (+ 1234 0 123.4) 1357.4) +(num-test (- 1234 0 123.4) 1110.59999999999991) +(num-test (* 1234 0 123.4) 0.0) +(num-test (+ 1234 0 1234/11) 14808/11) +(num-test (- 1234 0 1234/11) 12340/11) +(num-test (* 1234 0 1234/11) 0) +(num-test (+ 1234 0 1.234+1.234i) 1235.23399999999992+1.234i) +(num-test (- 1234 0 1.234+1.234i) 1232.766-1.234i) +(num-test (* 1234 0 1.234+1.234i) 0.0) +(num-test (+ 1234 0 -1.0+1.0i) 1233.0+1.0i) +(num-test (- 1234 0 -1.0+1.0i) 1235.0-1.0i) +(num-test (* 1234 0 -1.0+1.0i) -0.0) +(num-test (+ 1234 0 0.0+1.0i) 1234.0+1.0i) +(num-test (- 1234 0 0.0+1.0i) 1234.0-1.0i) +(num-test (* 1234 0 0.0+1.0i) 0.0) +(num-test (+ 1234 0.0 1) 1235.0) +(num-test (- 1234 0.0 1) 1233.0) +(num-test (* 1234 0.0 1) 0.0) +(num-test (+ 1234 0.0 1.0) 1235.0) +(num-test (- 1234 0.0 1.0) 1233.0) +(num-test (* 1234 0.0 1.0) 0.0) +(num-test (+ 1234 0.0 1/1) 1235.0) +(num-test (- 1234 0.0 1/1) 1233.0) +(num-test (* 1234 0.0 1/1) 0.0) +(num-test (+ 1234 0.0 1.0+1.0i) 1235.0+1.0i) +(num-test (- 1234 0.0 1.0+1.0i) 1233.0-1.0i) +(num-test (* 1234 0.0 1.0+1.0i) 0.0) +(num-test (+ 1234 0.0 0) 1234.0) +(num-test (- 1234 0.0 0) 1234.0) +(num-test (* 1234 0.0 0) 0.0) +(num-test (+ 1234 0.0 0.0) 1234.0) +(num-test (- 1234 0.0 0.0) 1234.0) +(num-test (* 1234 0.0 0.0) 0.0) +(num-test (+ 1234 0.0 1234) 2468.0) +(num-test (- 1234 0.0 1234) 0.0) +(num-test (* 1234 0.0 1234) 0.0) +(num-test (+ 1234 0.0 123.4) 1357.4) +(num-test (- 1234 0.0 123.4) 1110.59999999999991) +(num-test (* 1234 0.0 123.4) 0.0) +(num-test (+ 1234 0.0 1234/11) 1346.18181818181824) +(num-test (- 1234 0.0 1234/11) 1121.81818181818176) +(num-test (* 1234 0.0 1234/11) 0.0) +(num-test (+ 1234 0.0 1.234+1.234i) 1235.23399999999992+1.234i) +(num-test (- 1234 0.0 1.234+1.234i) 1232.766-1.234i) +(num-test (* 1234 0.0 1.234+1.234i) 0.0) +(num-test (+ 1234 0.0 -1.0+1.0i) 1233.0+1.0i) +(num-test (- 1234 0.0 -1.0+1.0i) 1235.0-1.0i) +(num-test (* 1234 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1234 0.0 0.0+1.0i) 1234.0+1.0i) +(num-test (- 1234 0.0 0.0+1.0i) 1234.0-1.0i) +(num-test (* 1234 0.0 0.0+1.0i) 0.0) +(num-test (+ 1234 1234 1) 2469) +(num-test (- 1234 1234 1) -1) +(num-test (* 1234 1234 1) 1522756) +(num-test (/ 1234 1234 1) 1) +(num-test (= 1234 1234 1) #f) +(num-test (< 1234 1234 1) #f) +(num-test (<= 1234 1234 1) #f) +(num-test (> 1234 1234 1) #f) +(num-test (>= 1234 1234 1) #t) +(num-test (+ 1234 1234 1.0) 2469.0) +(num-test (- 1234 1234 1.0) -1.0) +(num-test (* 1234 1234 1.0) 1522756.0) +(num-test (/ 1234 1234 1.0) 1.0) +(num-test (= 1234 1234 1.0) #f) +(num-test (< 1234 1234 1.0) #f) +(num-test (<= 1234 1234 1.0) #f) +(num-test (> 1234 1234 1.0) #f) +(num-test (>= 1234 1234 1.0) #t) +(num-test (+ 1234 1234 1/1) 2469) +(num-test (- 1234 1234 1/1) -1) +(num-test (* 1234 1234 1/1) 1522756) +(num-test (/ 1234 1234 1/1) 1) +(num-test (= 1234 1234 1/1) #f) +(num-test (< 1234 1234 1/1) #f) +(num-test (<= 1234 1234 1/1) #f) +(num-test (> 1234 1234 1/1) #f) +(num-test (>= 1234 1234 1/1) #t) +(num-test (+ 1234 1234 1.0+1.0i) 2469.0+1.0i) +(num-test (- 1234 1234 1.0+1.0i) -1.0-1.0i) +(num-test (* 1234 1234 1.0+1.0i) 1522756.0+1522756.0i) +(num-test (/ 1234 1234 1.0+1.0i) 0.5-0.5i) +(num-test (= 1234 1234 1.0+1.0i) #f) +(num-test (+ 1234 1234 0) 2468) +(num-test (- 1234 1234 0) 0) +(num-test (* 1234 1234 0) 0) +(num-test (+ 1234 1234 0.0) 2468.0) +(num-test (- 1234 1234 0.0) 0.0) +(num-test (* 1234 1234 0.0) 0.0) +(num-test (+ 1234 1234 1234) 3702) +(num-test (- 1234 1234 1234) -1234) +(num-test (* 1234 1234 1234) 1879080904) +(num-test (/ 1234 1234 1234) 1/1234) +(num-test (= 1234 1234 1234) #t) +(num-test (< 1234 1234 1234) #f) +(num-test (<= 1234 1234 1234) #t) +(num-test (> 1234 1234 1234) #f) +(num-test (>= 1234 1234 1234) #t) +(num-test (+ 1234 1234 123.4) 2591.4) +(num-test (- 1234 1234 123.4) -123.4) +(num-test (* 1234 1234 123.4) 187908090.40000000596046) +(num-test (/ 1234 1234 123.4) 0.00810372771475) +(num-test (= 1234 1234 123.4) #f) +(num-test (< 1234 1234 123.4) #f) +(num-test (<= 1234 1234 123.4) #f) +(num-test (> 1234 1234 123.4) #f) +(num-test (>= 1234 1234 123.4) #t) +(num-test (+ 1234 1234 1234/11) 28382/11) +(num-test (- 1234 1234 1234/11) -1234/11) +(if (not with-64-bit-ints) + (num-test (* 1234 1234 1234/11) 170825536.727273) + (num-test (* 1234 1234 1234/11) 1879080904/11)) +(num-test (/ 1234 1234 1234/11) 11/1234) +(num-test (= 1234 1234 1234/11) #f) +(num-test (< 1234 1234 1234/11) #f) +(num-test (<= 1234 1234 1234/11) #f) +(num-test (> 1234 1234 1234/11) #f) +(num-test (>= 1234 1234 1234/11) #t) +(num-test (+ 1234 1234 1.234+1.234i) 2469.23399999999992+1.234i) +(num-test (- 1234 1234 1.234+1.234i) -1.234-1.234i) +(num-test (* 1234 1234 1.234+1.234i) 1879080.90399999986403+1879080.90399999986403i) +(num-test (/ 1234 1234 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1234 1234 1.234+1.234i) #f) +(num-test (+ 1234 1234 -1.0+1.0i) 2467.0+1.0i) +(num-test (- 1234 1234 -1.0+1.0i) 1.0-1.0i) +(num-test (* 1234 1234 -1.0+1.0i) -1522756.0+1522756.0i) +(num-test (/ 1234 1234 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1234 1234 -1.0+1.0i) #f) +(num-test (+ 1234 1234 0.0+1.0i) 2468.0+1.0i) +(num-test (- 1234 1234 0.0+1.0i) 0.0-1.0i) +(num-test (* 1234 1234 0.0+1.0i) 0.0+1522756.0i) +(num-test (/ 1234 1234 0.0+1.0i) 0.0-1.0i) +(num-test (= 1234 1234 0.0+1.0i) #f) +(num-test (+ 1234 123.4 1) 1358.4) +(num-test (- 1234 123.4 1) 1109.59999999999991) +(num-test (* 1234 123.4 1) 152275.60000000000582) +(num-test (/ 1234 123.4 1) 10.0) +(num-test (= 1234 123.4 1) #f) +(num-test (< 1234 123.4 1) #f) +(num-test (<= 1234 123.4 1) #f) +(num-test (> 1234 123.4 1) #t) +(num-test (>= 1234 123.4 1) #t) +(num-test (+ 1234 123.4 1.0) 1358.4) +(num-test (- 1234 123.4 1.0) 1109.59999999999991) +(num-test (* 1234 123.4 1.0) 152275.60000000000582) +(num-test (/ 1234 123.4 1.0) 10.0) +(num-test (= 1234 123.4 1.0) #f) +(num-test (< 1234 123.4 1.0) #f) +(num-test (<= 1234 123.4 1.0) #f) +(num-test (> 1234 123.4 1.0) #t) +(num-test (>= 1234 123.4 1.0) #t) +(num-test (+ 1234 123.4 1/1) 1358.4) +(num-test (- 1234 123.4 1/1) 1109.59999999999991) +(num-test (* 1234 123.4 1/1) 152275.60000000000582) +(num-test (/ 1234 123.4 1/1) 10.0) +(num-test (= 1234 123.4 1/1) #f) +(num-test (< 1234 123.4 1/1) #f) +(num-test (<= 1234 123.4 1/1) #f) +(num-test (> 1234 123.4 1/1) #t) +(num-test (>= 1234 123.4 1/1) #t) +(num-test (+ 1234 123.4 1.0+1.0i) 1358.4+1.0i) +(num-test (- 1234 123.4 1.0+1.0i) 1109.59999999999991-1.0i) +(num-test (* 1234 123.4 1.0+1.0i) 152275.60000000000582+152275.60000000000582i) +(num-test (/ 1234 123.4 1.0+1.0i) 5.0-5.0i) +(num-test (= 1234 123.4 1.0+1.0i) #f) +(num-test (+ 1234 123.4 0) 1357.4) +(num-test (- 1234 123.4 0) 1110.59999999999991) +(num-test (* 1234 123.4 0) 0.0) +(num-test (+ 1234 123.4 0.0) 1357.4) +(num-test (- 1234 123.4 0.0) 1110.59999999999991) +(num-test (* 1234 123.4 0.0) 0.0) +(num-test (+ 1234 123.4 1234) 2591.4) +(num-test (- 1234 123.4 1234) -123.4) +(num-test (* 1234 123.4 1234) 187908090.40000000596046) +(num-test (/ 1234 123.4 1234) 0.00810372771475) +(num-test (= 1234 123.4 1234) #f) +(num-test (< 1234 123.4 1234) #f) +(num-test (<= 1234 123.4 1234) #f) +(num-test (> 1234 123.4 1234) #f) +(num-test (>= 1234 123.4 1234) #f) +(num-test (+ 1234 123.4 123.4) 1480.80000000000018) +(num-test (- 1234 123.4 123.4) 987.19999999999993) +(num-test (* 1234 123.4 123.4) 18790809.04000000283122) +(num-test (/ 1234 123.4 123.4) 0.08103727714749) +(num-test (= 1234 123.4 123.4) #f) +(num-test (< 1234 123.4 123.4) #f) +(num-test (<= 1234 123.4 123.4) #f) +(num-test (> 1234 123.4 123.4) #f) +(num-test (>= 1234 123.4 123.4) #t) +(num-test (+ 1234 123.4 1234/11) 1469.58181818181833) +(num-test (- 1234 123.4 1234/11) 998.41818181818178) +(num-test (* 1234 123.4 1234/11) 17082553.67272727191448) +(num-test (/ 1234 123.4 1234/11) 0.08914100486224) +(num-test (= 1234 123.4 1234/11) #f) +(num-test (< 1234 123.4 1234/11) #f) +(num-test (<= 1234 123.4 1234/11) #f) +(num-test (> 1234 123.4 1234/11) #t) +(num-test (>= 1234 123.4 1234/11) #t) +(num-test (+ 1234 123.4 1.234+1.234i) 1358.63400000000001+1.234i) +(num-test (- 1234 123.4 1.234+1.234i) 1109.36599999999999-1.234i) +(num-test (* 1234 123.4 1.234+1.234i) 187908.09040000001551+187908.09040000001551i) +(num-test (/ 1234 123.4 1.234+1.234i) 4.05186385737439-4.05186385737439i) +(num-test (= 1234 123.4 1.234+1.234i) #f) +(num-test (+ 1234 123.4 -1.0+1.0i) 1356.4+1.0i) +(num-test (- 1234 123.4 -1.0+1.0i) 1111.59999999999991-1.0i) +(num-test (* 1234 123.4 -1.0+1.0i) -152275.60000000000582+152275.60000000000582i) +(num-test (/ 1234 123.4 -1.0+1.0i) -5.0-5.0i) +(num-test (= 1234 123.4 -1.0+1.0i) #f) +(num-test (+ 1234 123.4 0.0+1.0i) 1357.4+1.0i) +(num-test (- 1234 123.4 0.0+1.0i) 1110.59999999999991-1.0i) +(num-test (* 1234 123.4 0.0+1.0i) 0.0+152275.60000000000582i) +(num-test (/ 1234 123.4 0.0+1.0i) 0.0-10.0i) +(num-test (= 1234 123.4 0.0+1.0i) #f) +(num-test (+ 1234 1234/11 1) 14819/11) +(num-test (- 1234 1234/11 1) 12329/11) +(num-test (* 1234 1234/11 1) 1522756/11) +(num-test (/ 1234 1234/11 1) 11) +(num-test (= 1234 1234/11 1) #f) +(num-test (< 1234 1234/11 1) #f) +(num-test (<= 1234 1234/11 1) #f) +(num-test (> 1234 1234/11 1) #t) +(num-test (>= 1234 1234/11 1) #t) +(num-test (+ 1234 1234/11 1.0) 1347.18181818181824) +(num-test (- 1234 1234/11 1.0) 1120.81818181818176) +(num-test (* 1234 1234/11 1.0) 138432.36363636364695) +(num-test (/ 1234 1234/11 1.0) 11.0) +(num-test (= 1234 1234/11 1.0) #f) +(num-test (< 1234 1234/11 1.0) #f) +(num-test (<= 1234 1234/11 1.0) #f) +(num-test (> 1234 1234/11 1.0) #t) +(num-test (>= 1234 1234/11 1.0) #t) +(num-test (+ 1234 1234/11 1/1) 14819/11) +(num-test (- 1234 1234/11 1/1) 12329/11) +(num-test (* 1234 1234/11 1/1) 1522756/11) +(num-test (/ 1234 1234/11 1/1) 11) +(num-test (= 1234 1234/11 1/1) #f) +(num-test (< 1234 1234/11 1/1) #f) +(num-test (<= 1234 1234/11 1/1) #f) +(num-test (> 1234 1234/11 1/1) #t) +(num-test (>= 1234 1234/11 1/1) #t) +(num-test (+ 1234 1234/11 1.0+1.0i) 1347.18181818181824+1.0i) +(num-test (- 1234 1234/11 1.0+1.0i) 1120.81818181818176-1.0i) +(num-test (* 1234 1234/11 1.0+1.0i) 138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234 1234/11 1.0+1.0i) 5.50000000000000-5.50000000000000i) +(num-test (= 1234 1234/11 1.0+1.0i) #f) +(num-test (+ 1234 1234/11 0) 14808/11) +(num-test (- 1234 1234/11 0) 12340/11) +(num-test (* 1234 1234/11 0) 0) +(num-test (+ 1234 1234/11 0.0) 1346.18181818181824) +(num-test (- 1234 1234/11 0.0) 1121.81818181818176) +(num-test (* 1234 1234/11 0.0) 0.0) +(num-test (+ 1234 1234/11 1234) 28382/11) +(num-test (- 1234 1234/11 1234) -1234/11) +(if (not with-64-bit-ints) + (num-test (* 1234 1234/11 1234) 170825536.727273) + (num-test (* 1234 1234/11 1234) 1879080904/11)) +(num-test (/ 1234 1234/11 1234) 11/1234) +(num-test (= 1234 1234/11 1234) #f) +(num-test (< 1234 1234/11 1234) #f) +(num-test (<= 1234 1234/11 1234) #f) +(num-test (> 1234 1234/11 1234) #f) +(num-test (>= 1234 1234/11 1234) #f) +(num-test (+ 1234 1234/11 123.4) 1469.58181818181833) +(num-test (- 1234 1234/11 123.4) 998.41818181818178) +(num-test (* 1234 1234/11 123.4) 17082553.67272727563977) +(num-test (/ 1234 1234/11 123.4) 0.08914100486224) +(num-test (= 1234 1234/11 123.4) #f) +(num-test (< 1234 1234/11 123.4) #f) +(num-test (<= 1234 1234/11 123.4) #f) +(num-test (> 1234 1234/11 123.4) #f) +(num-test (>= 1234 1234/11 123.4) #f) +(num-test (+ 1234 1234/11 1234/11) 16042/11) +(num-test (- 1234 1234/11 1234/11) 11106/11) +(if (not with-64-bit-ints) + (num-test (* 1234 1234/11 1234/11) 15529594.2479339) + (num-test (* 1234 1234/11 1234/11) 1879080904/121)) +(num-test (/ 1234 1234/11 1234/11) 121/1234) +(num-test (= 1234 1234/11 1234/11) #f) +(num-test (< 1234 1234/11 1234/11) #f) +(num-test (<= 1234 1234/11 1234/11) #f) +(num-test (> 1234 1234/11 1234/11) #f) +(num-test (>= 1234 1234/11 1234/11) #t) +(num-test (+ 1234 1234/11 1.234+1.234i) 1347.41581818181817+1.234i) +(num-test (- 1234 1234/11 1.234+1.234i) 1120.58418181818183-1.234i) +(num-test (* 1234 1234/11 1.234+1.234i) 170825.53672727273079+170825.53672727273079i) +(num-test (/ 1234 1234/11 1.234+1.234i) 4.45705024311183-4.45705024311183i) +(num-test (= 1234 1234/11 1.234+1.234i) #f) +(num-test (+ 1234 1234/11 -1.0+1.0i) 1345.18181818181824+1.0i) +(num-test (- 1234 1234/11 -1.0+1.0i) 1122.81818181818176-1.0i) +(num-test (* 1234 1234/11 -1.0+1.0i) -138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234 1234/11 -1.0+1.0i) -5.50000000000000-5.50000000000000i) +(num-test (= 1234 1234/11 -1.0+1.0i) #f) +(num-test (+ 1234 1234/11 0.0+1.0i) 1346.18181818181824+1.0i) +(num-test (- 1234 1234/11 0.0+1.0i) 1121.81818181818176-1.0i) +(num-test (* 1234 1234/11 0.0+1.0i) 0.0+138432.36363636364695i) +(num-test (/ 1234 1234/11 0.0+1.0i) 0.0-11.0i) +(num-test (= 1234 1234/11 0.0+1.0i) #f) +(num-test (+ 1234 1.234+1.234i 1) 1236.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i 1) 1231.766-1.234i) +(num-test (* 1234 1.234+1.234i 1) 1522.756+1522.756i) +(num-test (/ 1234 1.234+1.234i 1) 500.0-500.0i) +(num-test (= 1234 1.234+1.234i 1) #f) +(num-test (+ 1234 1.234+1.234i 1.0) 1236.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i 1.0) 1231.766-1.234i) +(num-test (* 1234 1.234+1.234i 1.0) 1522.756+1522.756i) +(num-test (/ 1234 1.234+1.234i 1.0) 500.0-500.0i) +(num-test (= 1234 1.234+1.234i 1.0) #f) +(num-test (+ 1234 1.234+1.234i 1/1) 1236.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i 1/1) 1231.766-1.234i) +(num-test (* 1234 1.234+1.234i 1/1) 1522.756+1522.756i) +(num-test (/ 1234 1.234+1.234i 1/1) 500.0-500.0i) +(num-test (= 1234 1.234+1.234i 1/1) #f) +(num-test (+ 1234 1.234+1.234i 1.0+1.0i) 1236.23399999999992+2.234i) +(num-test (- 1234 1.234+1.234i 1.0+1.0i) 1231.766-2.234i) +(num-test (* 1234 1.234+1.234i 1.0+1.0i) 0.0+3045.51200000000017i) +(num-test (/ 1234 1.234+1.234i 1.0+1.0i) 0.0-500.0i) +(num-test (= 1234 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1234 1.234+1.234i 0) 1235.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i 0) 1232.766-1.234i) +(num-test (* 1234 1.234+1.234i 0) 0.0) +(num-test (+ 1234 1.234+1.234i 0.0) 1235.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i 0.0) 1232.766-1.234i) +(num-test (* 1234 1.234+1.234i 0.0) 0.0) +(num-test (+ 1234 1.234+1.234i 1234) 2469.23399999999992+1.234i) +(num-test (- 1234 1.234+1.234i 1234) -1.23399999999992-1.234i) +(num-test (* 1234 1.234+1.234i 1234) 1879080.90400000009686+1879080.90400000009686i) +(num-test (/ 1234 1.234+1.234i 1234) 0.40518638573744-0.40518638573744i) +(num-test (= 1234 1.234+1.234i 1234) #f) +(num-test (+ 1234 1.234+1.234i 123.4) 1358.63400000000001+1.234i) +(num-test (- 1234 1.234+1.234i 123.4) 1109.36599999999999-1.234i) +(num-test (* 1234 1.234+1.234i 123.4) 187908.09040000001551+187908.09040000001551i) +(num-test (/ 1234 1.234+1.234i 123.4) 4.05186385737439-4.05186385737439i) +(num-test (= 1234 1.234+1.234i 123.4) #f) +(num-test (+ 1234 1.234+1.234i 1234/11) 1347.41581818181817+1.234i) +(num-test (- 1234 1.234+1.234i 1234/11) 1120.58418181818183-1.234i) +(num-test (* 1234 1.234+1.234i 1234/11) 170825.53672727273079+170825.53672727273079i) +(num-test (/ 1234 1.234+1.234i 1234/11) 4.45705024311183-4.45705024311183i) +(num-test (= 1234 1.234+1.234i 1234/11) #f) +(num-test (+ 1234 1.234+1.234i 1.234+1.234i) 1236.46799999999985+2.468i) +(num-test (- 1234 1.234+1.234i 1.234+1.234i) 1231.53200000000015-2.468i) +(num-test (* 1234 1.234+1.234i 1.234+1.234i) 0.0+3758.16180800000029i) +(num-test (/ 1234 1.234+1.234i 1.234+1.234i) 0.0-405.18638573743925i) +(num-test (= 1234 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 1234 1.234+1.234i -1.0+1.0i) 1234.23399999999992+2.234i) +(num-test (- 1234 1.234+1.234i -1.0+1.0i) 1233.766-2.234i) +(num-test (* 1234 1.234+1.234i -1.0+1.0i) -3045.51200000000017) +(num-test (/ 1234 1.234+1.234i -1.0+1.0i) -500.0) +(num-test (= 1234 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1234 1.234+1.234i 0.0+1.0i) 1235.23399999999992+2.234i) +(num-test (- 1234 1.234+1.234i 0.0+1.0i) 1232.766-2.234i) +(num-test (* 1234 1.234+1.234i 0.0+1.0i) -1522.756+1522.756i) +(num-test (/ 1234 1.234+1.234i 0.0+1.0i) -500.0-500.0i) +(num-test (= 1234 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1234 -1.0+1.0i 1) 1234.0+1.0i) +(num-test (- 1234 -1.0+1.0i 1) 1234.0-1.0i) +(num-test (* 1234 -1.0+1.0i 1) -1234.0+1234.0i) +(num-test (/ 1234 -1.0+1.0i 1) -617.0-617.0i) +(num-test (= 1234 -1.0+1.0i 1) #f) +(num-test (+ 1234 -1.0+1.0i 1.0) 1234.0+1.0i) +(num-test (- 1234 -1.0+1.0i 1.0) 1234.0-1.0i) +(num-test (* 1234 -1.0+1.0i 1.0) -1234.0+1234.0i) +(num-test (/ 1234 -1.0+1.0i 1.0) -617.0-617.0i) +(num-test (= 1234 -1.0+1.0i 1.0) #f) +(num-test (+ 1234 -1.0+1.0i 1/1) 1234.0+1.0i) +(num-test (- 1234 -1.0+1.0i 1/1) 1234.0-1.0i) +(num-test (* 1234 -1.0+1.0i 1/1) -1234.0+1234.0i) +(num-test (/ 1234 -1.0+1.0i 1/1) -617.0-617.0i) +(num-test (= 1234 -1.0+1.0i 1/1) #f) +(num-test (+ 1234 -1.0+1.0i 1.0+1.0i) 1234.0+2.0i) +(num-test (- 1234 -1.0+1.0i 1.0+1.0i) 1234.0-2.0i) +(num-test (* 1234 -1.0+1.0i 1.0+1.0i) -2468.0) +(num-test (/ 1234 -1.0+1.0i 1.0+1.0i) -617.0) +(num-test (= 1234 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1234 -1.0+1.0i 0) 1233.0+1.0i) +(num-test (- 1234 -1.0+1.0i 0) 1235.0-1.0i) +(num-test (* 1234 -1.0+1.0i 0) -0.0) +(num-test (+ 1234 -1.0+1.0i 0.0) 1233.0+1.0i) +(num-test (- 1234 -1.0+1.0i 0.0) 1235.0-1.0i) +(num-test (* 1234 -1.0+1.0i 0.0) -0.0) +(num-test (+ 1234 -1.0+1.0i 1234) 2467.0+1.0i) +(num-test (- 1234 -1.0+1.0i 1234) 1.0-1.0i) +(num-test (* 1234 -1.0+1.0i 1234) -1522756.0+1522756.0i) +(num-test (/ 1234 -1.0+1.0i 1234) -0.5-0.5i) +(num-test (= 1234 -1.0+1.0i 1234) #f) +(num-test (+ 1234 -1.0+1.0i 123.4) 1356.4+1.0i) +(num-test (- 1234 -1.0+1.0i 123.4) 1111.59999999999991-1.0i) +(num-test (* 1234 -1.0+1.0i 123.4) -152275.60000000000582+152275.60000000000582i) +(num-test (/ 1234 -1.0+1.0i 123.4) -5.0-5.0i) +(num-test (= 1234 -1.0+1.0i 123.4) #f) +(num-test (+ 1234 -1.0+1.0i 1234/11) 1345.18181818181824+1.0i) +(num-test (- 1234 -1.0+1.0i 1234/11) 1122.81818181818176-1.0i) +(num-test (* 1234 -1.0+1.0i 1234/11) -138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234 -1.0+1.0i 1234/11) -5.50000000000000-5.50000000000000i) +(num-test (= 1234 -1.0+1.0i 1234/11) #f) +(num-test (+ 1234 -1.0+1.0i 1.234+1.234i) 1234.23399999999992+2.234i) +(num-test (- 1234 -1.0+1.0i 1.234+1.234i) 1233.766-2.234i) +(num-test (* 1234 -1.0+1.0i 1.234+1.234i) -3045.51200000000017) +(num-test (/ 1234 -1.0+1.0i 1.234+1.234i) -500.0) +(num-test (= 1234 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1234 -1.0+1.0i -1.0+1.0i) 1232.0+2.0i) +(num-test (- 1234 -1.0+1.0i -1.0+1.0i) 1236.0-2.0i) +(num-test (* 1234 -1.0+1.0i -1.0+1.0i) 0.0-2468.0i) +(num-test (/ 1234 -1.0+1.0i -1.0+1.0i) -0.0+617.0i) +(num-test (= 1234 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1234 -1.0+1.0i 0.0+1.0i) 1233.0+2.0i) +(num-test (- 1234 -1.0+1.0i 0.0+1.0i) 1235.0-2.0i) +(num-test (* 1234 -1.0+1.0i 0.0+1.0i) -1234.0-1234.0i) +(num-test (/ 1234 -1.0+1.0i 0.0+1.0i) -617.0+617.0i) +(num-test (= 1234 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1234 0.0+1.0i 1) 1235.0+1.0i) +(num-test (- 1234 0.0+1.0i 1) 1233.0-1.0i) +(num-test (* 1234 0.0+1.0i 1) 0.0+1234.0i) +(num-test (/ 1234 0.0+1.0i 1) 0.0-1234.0i) +(num-test (= 1234 0.0+1.0i 1) #f) +(num-test (+ 1234 0.0+1.0i 1.0) 1235.0+1.0i) +(num-test (- 1234 0.0+1.0i 1.0) 1233.0-1.0i) +(num-test (* 1234 0.0+1.0i 1.0) 0.0+1234.0i) +(num-test (/ 1234 0.0+1.0i 1.0) 0.0-1234.0i) +(num-test (= 1234 0.0+1.0i 1.0) #f) +(num-test (+ 1234 0.0+1.0i 1/1) 1235.0+1.0i) +(num-test (- 1234 0.0+1.0i 1/1) 1233.0-1.0i) +(num-test (* 1234 0.0+1.0i 1/1) 0.0+1234.0i) +(num-test (/ 1234 0.0+1.0i 1/1) 0.0-1234.0i) +(num-test (= 1234 0.0+1.0i 1/1) #f) +(num-test (+ 1234 0.0+1.0i 1.0+1.0i) 1235.0+2.0i) +(num-test (- 1234 0.0+1.0i 1.0+1.0i) 1233.0-2.0i) +(num-test (* 1234 0.0+1.0i 1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 1234 0.0+1.0i 1.0+1.0i) -617.0-617.0i) +(num-test (= 1234 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1234 0.0+1.0i 0) 1234.0+1.0i) +(num-test (- 1234 0.0+1.0i 0) 1234.0-1.0i) +(num-test (* 1234 0.0+1.0i 0) 0.0) +(num-test (+ 1234 0.0+1.0i 0.0) 1234.0+1.0i) +(num-test (- 1234 0.0+1.0i 0.0) 1234.0-1.0i) +(num-test (* 1234 0.0+1.0i 0.0) 0.0) +(num-test (+ 1234 0.0+1.0i 1234) 2468.0+1.0i) +(num-test (- 1234 0.0+1.0i 1234) 0.0-1.0i) +(num-test (* 1234 0.0+1.0i 1234) 0.0+1522756.0i) +(num-test (/ 1234 0.0+1.0i 1234) 0.0-1.0i) +(num-test (= 1234 0.0+1.0i 1234) #f) +(num-test (+ 1234 0.0+1.0i 123.4) 1357.4+1.0i) +(num-test (- 1234 0.0+1.0i 123.4) 1110.59999999999991-1.0i) +(num-test (* 1234 0.0+1.0i 123.4) 0.0+152275.60000000000582i) +(num-test (/ 1234 0.0+1.0i 123.4) 0.0-10.0i) +(num-test (= 1234 0.0+1.0i 123.4) #f) +(num-test (+ 1234 0.0+1.0i 1234/11) 1346.18181818181824+1.0i) +(num-test (- 1234 0.0+1.0i 1234/11) 1121.81818181818176-1.0i) +(num-test (* 1234 0.0+1.0i 1234/11) 0.0+138432.36363636364695i) +(num-test (/ 1234 0.0+1.0i 1234/11) 0.0-11.0i) +(num-test (= 1234 0.0+1.0i 1234/11) #f) +(num-test (+ 1234 0.0+1.0i 1.234+1.234i) 1235.23399999999992+2.234i) +(num-test (- 1234 0.0+1.0i 1.234+1.234i) 1232.766-2.234i) +(num-test (* 1234 0.0+1.0i 1.234+1.234i) -1522.756+1522.756i) +(num-test (/ 1234 0.0+1.0i 1.234+1.234i) -500.0-500.0i) +(num-test (= 1234 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1234 0.0+1.0i -1.0+1.0i) 1233.0+2.0i) +(num-test (- 1234 0.0+1.0i -1.0+1.0i) 1235.0-2.0i) +(num-test (* 1234 0.0+1.0i -1.0+1.0i) -1234.0-1234.0i) +(num-test (/ 1234 0.0+1.0i -1.0+1.0i) -617.0+617.0i) +(num-test (= 1234 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1234 0.0+1.0i 0.0+1.0i) 1234.0+2.0i) +(num-test (- 1234 0.0+1.0i 0.0+1.0i) 1234.0-2.0i) +(num-test (* 1234 0.0+1.0i 0.0+1.0i) -1234.0) +(num-test (/ 1234 0.0+1.0i 0.0+1.0i) -1234.0) +(num-test (= 1234 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 123.4 1 1) 125.4) +(num-test (- 123.4 1 1) 121.4) +(num-test (* 123.4 1 1) 123.4) +(num-test (/ 123.4 1 1) 123.4) +(num-test (= 123.4 1 1) #f) +(num-test (< 123.4 1 1) #f) +(num-test (<= 123.4 1 1) #f) +(num-test (> 123.4 1 1) #f) +(num-test (>= 123.4 1 1) #t) +(num-test (+ 123.4 1 1.0) 125.4) +(num-test (- 123.4 1 1.0) 121.4) +(num-test (* 123.4 1 1.0) 123.4) +(num-test (/ 123.4 1 1.0) 123.4) +(num-test (= 123.4 1 1.0) #f) +(num-test (< 123.4 1 1.0) #f) +(num-test (<= 123.4 1 1.0) #f) +(num-test (> 123.4 1 1.0) #f) +(num-test (>= 123.4 1 1.0) #t) +(num-test (+ 123.4 1 1/1) 125.4) +(num-test (- 123.4 1 1/1) 121.4) +(num-test (* 123.4 1 1/1) 123.4) +(num-test (/ 123.4 1 1/1) 123.4) +(num-test (= 123.4 1 1/1) #f) +(num-test (< 123.4 1 1/1) #f) +(num-test (<= 123.4 1 1/1) #f) +(num-test (> 123.4 1 1/1) #f) +(num-test (>= 123.4 1 1/1) #t) +(num-test (+ 123.4 1 1.0+1.0i) 125.4+1.0i) +(num-test (- 123.4 1 1.0+1.0i) 121.4-1.0i) +(num-test (* 123.4 1 1.0+1.0i) 123.4+123.4i) +(num-test (/ 123.4 1 1.0+1.0i) 61.7-61.7i) +(num-test (= 123.4 1 1.0+1.0i) #f) +(num-test (+ 123.4 1 0) 124.4) +(num-test (- 123.4 1 0) 122.4) +(num-test (* 123.4 1 0) 0.0) +(num-test (+ 123.4 1 0.0) 124.4) +(num-test (- 123.4 1 0.0) 122.4) +(num-test (* 123.4 1 0.0) 0.0) +(num-test (+ 123.4 1 1234) 1358.4) +(num-test (- 123.4 1 1234) -1111.59999999999991) +(num-test (* 123.4 1 1234) 152275.60000000000582) +(num-test (/ 123.4 1 1234) 0.1) +(num-test (= 123.4 1 1234) #f) +(num-test (< 123.4 1 1234) #f) +(num-test (<= 123.4 1 1234) #f) +(num-test (> 123.4 1 1234) #f) +(num-test (>= 123.4 1 1234) #f) +(num-test (+ 123.4 1 123.4) 247.8) +(num-test (- 123.4 1 123.4) -1.0) +(num-test (* 123.4 1 123.4) 15227.56000000000131) +(num-test (/ 123.4 1 123.4) 1.0) +(num-test (= 123.4 1 123.4) #f) +(num-test (< 123.4 1 123.4) #f) +(num-test (<= 123.4 1 123.4) #f) +(num-test (> 123.4 1 123.4) #f) +(num-test (>= 123.4 1 123.4) #f) +(num-test (+ 123.4 1 1234/11) 236.58181818181819) +(num-test (- 123.4 1 1234/11) 10.21818181818182) +(num-test (* 123.4 1 1234/11) 13843.23636363636433) +(num-test (/ 123.4 1 1234/11) 1.10000000000000) +(num-test (= 123.4 1 1234/11) #f) +(num-test (< 123.4 1 1234/11) #f) +(num-test (<= 123.4 1 1234/11) #f) +(num-test (> 123.4 1 1234/11) #f) +(num-test (>= 123.4 1 1234/11) #f) +(num-test (+ 123.4 1 1.234+1.234i) 125.634+1.234i) +(num-test (- 123.4 1 1.234+1.234i) 121.16600000000001-1.234i) +(num-test (* 123.4 1 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 123.4 1 1.234+1.234i) 50.0-50.0i) +(num-test (= 123.4 1 1.234+1.234i) #f) +(num-test (+ 123.4 1 -1.0+1.0i) 123.4+1.0i) +(num-test (- 123.4 1 -1.0+1.0i) 123.4-1.0i) +(num-test (* 123.4 1 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 123.4 1 -1.0+1.0i) -61.7-61.7i) +(num-test (= 123.4 1 -1.0+1.0i) #f) +(num-test (+ 123.4 1 0.0+1.0i) 124.4+1.0i) +(num-test (- 123.4 1 0.0+1.0i) 122.4-1.0i) +(num-test (* 123.4 1 0.0+1.0i) 0.0+123.4i) +(num-test (/ 123.4 1 0.0+1.0i) 0.0-123.4i) +(num-test (= 123.4 1 0.0+1.0i) #f) +(num-test (+ 123.4 1.0 1) 125.4) +(num-test (- 123.4 1.0 1) 121.4) +(num-test (* 123.4 1.0 1) 123.4) +(num-test (/ 123.4 1.0 1) 123.4) +(num-test (= 123.4 1.0 1) #f) +(num-test (< 123.4 1.0 1) #f) +(num-test (<= 123.4 1.0 1) #f) +(num-test (> 123.4 1.0 1) #f) +(num-test (>= 123.4 1.0 1) #t) +(num-test (+ 123.4 1.0 1.0) 125.4) +(num-test (- 123.4 1.0 1.0) 121.4) +(num-test (* 123.4 1.0 1.0) 123.4) +(num-test (/ 123.4 1.0 1.0) 123.4) +(num-test (= 123.4 1.0 1.0) #f) +(num-test (< 123.4 1.0 1.0) #f) +(num-test (<= 123.4 1.0 1.0) #f) +(num-test (> 123.4 1.0 1.0) #f) +(num-test (>= 123.4 1.0 1.0) #t) +(num-test (+ 123.4 1.0 1/1) 125.4) +(num-test (- 123.4 1.0 1/1) 121.4) +(num-test (* 123.4 1.0 1/1) 123.4) +(num-test (/ 123.4 1.0 1/1) 123.4) +(num-test (= 123.4 1.0 1/1) #f) +(num-test (< 123.4 1.0 1/1) #f) +(num-test (<= 123.4 1.0 1/1) #f) +(num-test (> 123.4 1.0 1/1) #f) +(num-test (>= 123.4 1.0 1/1) #t) +(num-test (+ 123.4 1.0 1.0+1.0i) 125.4+1.0i) +(num-test (- 123.4 1.0 1.0+1.0i) 121.4-1.0i) +(num-test (* 123.4 1.0 1.0+1.0i) 123.4+123.4i) +(num-test (/ 123.4 1.0 1.0+1.0i) 61.7-61.7i) +(num-test (= 123.4 1.0 1.0+1.0i) #f) +(num-test (+ 123.4 1.0 0) 124.4) +(num-test (- 123.4 1.0 0) 122.4) +(num-test (* 123.4 1.0 0) 0.0) +(num-test (+ 123.4 1.0 0.0) 124.4) +(num-test (- 123.4 1.0 0.0) 122.4) +(num-test (* 123.4 1.0 0.0) 0.0) +(num-test (+ 123.4 1.0 1234) 1358.4) +(num-test (- 123.4 1.0 1234) -1111.59999999999991) +(num-test (* 123.4 1.0 1234) 152275.60000000000582) +(num-test (/ 123.4 1.0 1234) 0.1) +(num-test (= 123.4 1.0 1234) #f) +(num-test (< 123.4 1.0 1234) #f) +(num-test (<= 123.4 1.0 1234) #f) +(num-test (> 123.4 1.0 1234) #f) +(num-test (>= 123.4 1.0 1234) #f) +(num-test (+ 123.4 1.0 123.4) 247.8) +(num-test (- 123.4 1.0 123.4) -1.0) +(num-test (* 123.4 1.0 123.4) 15227.56000000000131) +(num-test (/ 123.4 1.0 123.4) 1.0) +(num-test (= 123.4 1.0 123.4) #f) +(num-test (< 123.4 1.0 123.4) #f) +(num-test (<= 123.4 1.0 123.4) #f) +(num-test (> 123.4 1.0 123.4) #f) +(num-test (>= 123.4 1.0 123.4) #f) +(num-test (+ 123.4 1.0 1234/11) 236.58181818181819) +(num-test (- 123.4 1.0 1234/11) 10.21818181818182) +(num-test (* 123.4 1.0 1234/11) 13843.23636363636433) +(num-test (/ 123.4 1.0 1234/11) 1.10000000000000) +(num-test (= 123.4 1.0 1234/11) #f) +(num-test (< 123.4 1.0 1234/11) #f) +(num-test (<= 123.4 1.0 1234/11) #f) +(num-test (> 123.4 1.0 1234/11) #f) +(num-test (>= 123.4 1.0 1234/11) #f) +(num-test (+ 123.4 1.0 1.234+1.234i) 125.634+1.234i) +(num-test (- 123.4 1.0 1.234+1.234i) 121.16600000000001-1.234i) +(num-test (* 123.4 1.0 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 123.4 1.0 1.234+1.234i) 50.0-50.0i) +(num-test (= 123.4 1.0 1.234+1.234i) #f) +(num-test (+ 123.4 1.0 -1.0+1.0i) 123.4+1.0i) +(num-test (- 123.4 1.0 -1.0+1.0i) 123.4-1.0i) +(num-test (* 123.4 1.0 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 123.4 1.0 -1.0+1.0i) -61.7-61.7i) +(num-test (= 123.4 1.0 -1.0+1.0i) #f) +(num-test (+ 123.4 1.0 0.0+1.0i) 124.4+1.0i) +(num-test (- 123.4 1.0 0.0+1.0i) 122.4-1.0i) +(num-test (* 123.4 1.0 0.0+1.0i) 0.0+123.4i) +(num-test (/ 123.4 1.0 0.0+1.0i) 0.0-123.4i) +(num-test (= 123.4 1.0 0.0+1.0i) #f) +(num-test (+ 123.4 1/1 1) 125.4) +(num-test (- 123.4 1/1 1) 121.4) +(num-test (* 123.4 1/1 1) 123.4) +(num-test (/ 123.4 1/1 1) 123.4) +(num-test (= 123.4 1/1 1) #f) +(num-test (< 123.4 1/1 1) #f) +(num-test (<= 123.4 1/1 1) #f) +(num-test (> 123.4 1/1 1) #f) +(num-test (>= 123.4 1/1 1) #t) +(num-test (+ 123.4 1/1 1.0) 125.4) +(num-test (- 123.4 1/1 1.0) 121.4) +(num-test (* 123.4 1/1 1.0) 123.4) +(num-test (/ 123.4 1/1 1.0) 123.4) +(num-test (= 123.4 1/1 1.0) #f) +(num-test (< 123.4 1/1 1.0) #f) +(num-test (<= 123.4 1/1 1.0) #f) +(num-test (> 123.4 1/1 1.0) #f) +(num-test (>= 123.4 1/1 1.0) #t) +(num-test (+ 123.4 1/1 1/1) 125.4) +(num-test (- 123.4 1/1 1/1) 121.4) +(num-test (* 123.4 1/1 1/1) 123.4) +(num-test (/ 123.4 1/1 1/1) 123.4) +(num-test (= 123.4 1/1 1/1) #f) +(num-test (< 123.4 1/1 1/1) #f) +(num-test (<= 123.4 1/1 1/1) #f) +(num-test (> 123.4 1/1 1/1) #f) +(num-test (>= 123.4 1/1 1/1) #t) +(num-test (+ 123.4 1/1 1.0+1.0i) 125.4+1.0i) +(num-test (- 123.4 1/1 1.0+1.0i) 121.4-1.0i) +(num-test (* 123.4 1/1 1.0+1.0i) 123.4+123.4i) +(num-test (/ 123.4 1/1 1.0+1.0i) 61.7-61.7i) +(num-test (= 123.4 1/1 1.0+1.0i) #f) +(num-test (+ 123.4 1/1 0) 124.4) +(num-test (- 123.4 1/1 0) 122.4) +(num-test (* 123.4 1/1 0) 0.0) +(num-test (+ 123.4 1/1 0.0) 124.4) +(num-test (- 123.4 1/1 0.0) 122.4) +(num-test (* 123.4 1/1 0.0) 0.0) +(num-test (+ 123.4 1/1 1234) 1358.4) +(num-test (- 123.4 1/1 1234) -1111.59999999999991) +(num-test (* 123.4 1/1 1234) 152275.60000000000582) +(num-test (/ 123.4 1/1 1234) 0.1) +(num-test (= 123.4 1/1 1234) #f) +(num-test (< 123.4 1/1 1234) #f) +(num-test (<= 123.4 1/1 1234) #f) +(num-test (> 123.4 1/1 1234) #f) +(num-test (>= 123.4 1/1 1234) #f) +(num-test (+ 123.4 1/1 123.4) 247.8) +(num-test (- 123.4 1/1 123.4) -1.0) +(num-test (* 123.4 1/1 123.4) 15227.56000000000131) +(num-test (/ 123.4 1/1 123.4) 1.0) +(num-test (= 123.4 1/1 123.4) #f) +(num-test (< 123.4 1/1 123.4) #f) +(num-test (<= 123.4 1/1 123.4) #f) +(num-test (> 123.4 1/1 123.4) #f) +(num-test (>= 123.4 1/1 123.4) #f) +(num-test (+ 123.4 1/1 1234/11) 236.58181818181819) +(num-test (- 123.4 1/1 1234/11) 10.21818181818182) +(num-test (* 123.4 1/1 1234/11) 13843.23636363636433) +(num-test (/ 123.4 1/1 1234/11) 1.10000000000000) +(num-test (= 123.4 1/1 1234/11) #f) +(num-test (< 123.4 1/1 1234/11) #f) +(num-test (<= 123.4 1/1 1234/11) #f) +(num-test (> 123.4 1/1 1234/11) #f) +(num-test (>= 123.4 1/1 1234/11) #f) +(num-test (+ 123.4 1/1 1.234+1.234i) 125.634+1.234i) +(num-test (- 123.4 1/1 1.234+1.234i) 121.16600000000001-1.234i) +(num-test (* 123.4 1/1 1.234+1.234i) 152.2756+152.2756i) +(num-test (/ 123.4 1/1 1.234+1.234i) 50.0-50.0i) +(num-test (= 123.4 1/1 1.234+1.234i) #f) +(num-test (+ 123.4 1/1 -1.0+1.0i) 123.4+1.0i) +(num-test (- 123.4 1/1 -1.0+1.0i) 123.4-1.0i) +(num-test (* 123.4 1/1 -1.0+1.0i) -123.4+123.4i) +(num-test (/ 123.4 1/1 -1.0+1.0i) -61.7-61.7i) +(num-test (= 123.4 1/1 -1.0+1.0i) #f) +(num-test (+ 123.4 1/1 0.0+1.0i) 124.4+1.0i) +(num-test (- 123.4 1/1 0.0+1.0i) 122.4-1.0i) +(num-test (* 123.4 1/1 0.0+1.0i) 0.0+123.4i) +(num-test (/ 123.4 1/1 0.0+1.0i) 0.0-123.4i) +(num-test (= 123.4 1/1 0.0+1.0i) #f) +(num-test (+ 123.4 1.0+1.0i 1) 125.4+1.0i) +(num-test (- 123.4 1.0+1.0i 1) 121.4-1.0i) +(num-test (* 123.4 1.0+1.0i 1) 123.4+123.4i) +(num-test (/ 123.4 1.0+1.0i 1) 61.7-61.7i) +(num-test (= 123.4 1.0+1.0i 1) #f) +(num-test (+ 123.4 1.0+1.0i 1.0) 125.4+1.0i) +(num-test (- 123.4 1.0+1.0i 1.0) 121.4-1.0i) +(num-test (* 123.4 1.0+1.0i 1.0) 123.4+123.4i) +(num-test (/ 123.4 1.0+1.0i 1.0) 61.7-61.7i) +(num-test (= 123.4 1.0+1.0i 1.0) #f) +(num-test (+ 123.4 1.0+1.0i 1/1) 125.4+1.0i) +(num-test (- 123.4 1.0+1.0i 1/1) 121.4-1.0i) +(num-test (* 123.4 1.0+1.0i 1/1) 123.4+123.4i) +(num-test (/ 123.4 1.0+1.0i 1/1) 61.7-61.7i) +(num-test (= 123.4 1.0+1.0i 1/1) #f) +(num-test (+ 123.4 1.0+1.0i 1.0+1.0i) 125.4+2.0i) +(num-test (- 123.4 1.0+1.0i 1.0+1.0i) 121.4-2.0i) +(num-test (* 123.4 1.0+1.0i 1.0+1.0i) 0.0+246.8i) +(num-test (/ 123.4 1.0+1.0i 1.0+1.0i) 0.0-61.7i) +(num-test (= 123.4 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 123.4 1.0+1.0i 0) 124.4+1.0i) +(num-test (- 123.4 1.0+1.0i 0) 122.4-1.0i) +(num-test (* 123.4 1.0+1.0i 0) 0.0) +(num-test (+ 123.4 1.0+1.0i 0.0) 124.4+1.0i) +(num-test (- 123.4 1.0+1.0i 0.0) 122.4-1.0i) +(num-test (* 123.4 1.0+1.0i 0.0) 0.0) +(num-test (+ 123.4 1.0+1.0i 1234) 1358.4+1.0i) +(num-test (- 123.4 1.0+1.0i 1234) -1111.59999999999991-1.0i) +(num-test (* 123.4 1.0+1.0i 1234) 152275.60000000000582+152275.60000000000582i) +(num-test (/ 123.4 1.0+1.0i 1234) 0.05000000000000-0.05000000000000i) +(num-test (= 123.4 1.0+1.0i 1234) #f) +(num-test (+ 123.4 1.0+1.0i 123.4) 247.8+1.0i) +(num-test (- 123.4 1.0+1.0i 123.4) -1.0-1.0i) +(num-test (* 123.4 1.0+1.0i 123.4) 15227.56000000000131+15227.56000000000131i) +(num-test (/ 123.4 1.0+1.0i 123.4) 0.5-0.5i) +(num-test (= 123.4 1.0+1.0i 123.4) #f) +(num-test (+ 123.4 1.0+1.0i 1234/11) 236.58181818181819+1.0i) +(num-test (- 123.4 1.0+1.0i 1234/11) 10.21818181818182-1.0i) +(num-test (* 123.4 1.0+1.0i 1234/11) 13843.23636363636433+13843.23636363636433i) +(num-test (/ 123.4 1.0+1.0i 1234/11) 0.55000000000000-0.55000000000000i) +(num-test (= 123.4 1.0+1.0i 1234/11) #f) +(num-test (+ 123.4 1.0+1.0i 1.234+1.234i) 125.634+2.234i) +(num-test (- 123.4 1.0+1.0i 1.234+1.234i) 121.16600000000001-2.234i) +(num-test (* 123.4 1.0+1.0i 1.234+1.234i) 0.0+304.55119999999999i) +(num-test (/ 123.4 1.0+1.0i 1.234+1.234i) 0.0-50.0i) +(num-test (= 123.4 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 123.4 1.0+1.0i -1.0+1.0i) 123.4+2.0i) +(num-test (- 123.4 1.0+1.0i -1.0+1.0i) 123.4-2.0i) +(num-test (* 123.4 1.0+1.0i -1.0+1.0i) -246.8) +(num-test (/ 123.4 1.0+1.0i -1.0+1.0i) -61.7) +(num-test (= 123.4 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 123.4 1.0+1.0i 0.0+1.0i) 124.4+2.0i) +(num-test (- 123.4 1.0+1.0i 0.0+1.0i) 122.4-2.0i) +(num-test (* 123.4 1.0+1.0i 0.0+1.0i) -123.4+123.4i) +(num-test (/ 123.4 1.0+1.0i 0.0+1.0i) -61.7-61.7i) +(num-test (= 123.4 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 123.4 0 1) 124.4) +(num-test (- 123.4 0 1) 122.4) +(num-test (* 123.4 0 1) 0.0) +(num-test (+ 123.4 0 1.0) 124.4) +(num-test (- 123.4 0 1.0) 122.4) +(num-test (* 123.4 0 1.0) 0.0) +(num-test (+ 123.4 0 1/1) 124.4) +(num-test (- 123.4 0 1/1) 122.4) +(num-test (* 123.4 0 1/1) 0.0) +(num-test (+ 123.4 0 1.0+1.0i) 124.4+1.0i) +(num-test (- 123.4 0 1.0+1.0i) 122.4-1.0i) +(num-test (* 123.4 0 1.0+1.0i) 0.0) +(num-test (+ 123.4 0 0) 123.4) +(num-test (- 123.4 0 0) 123.4) +(num-test (* 123.4 0 0) 0.0) +(num-test (+ 123.4 0 0.0) 123.4) +(num-test (- 123.4 0 0.0) 123.4) +(num-test (* 123.4 0 0.0) 0.0) +(num-test (+ 123.4 0 1234) 1357.4) +(num-test (- 123.4 0 1234) -1110.59999999999991) +(num-test (* 123.4 0 1234) 0.0) +(num-test (+ 123.4 0 123.4) 246.8) +(num-test (- 123.4 0 123.4) 0.0) +(num-test (* 123.4 0 123.4) 0.0) +(num-test (+ 123.4 0 1234/11) 235.58181818181819) +(num-test (- 123.4 0 1234/11) 11.21818181818182) +(num-test (* 123.4 0 1234/11) 0.0) +(num-test (+ 123.4 0 1.234+1.234i) 124.634+1.234i) +(num-test (- 123.4 0 1.234+1.234i) 122.16600000000001-1.234i) +(num-test (* 123.4 0 1.234+1.234i) 0.0) +(num-test (+ 123.4 0 -1.0+1.0i) 122.4+1.0i) +(num-test (- 123.4 0 -1.0+1.0i) 124.4-1.0i) +(num-test (* 123.4 0 -1.0+1.0i) -0.0) +(num-test (+ 123.4 0 0.0+1.0i) 123.4+1.0i) +(num-test (- 123.4 0 0.0+1.0i) 123.4-1.0i) +(num-test (* 123.4 0 0.0+1.0i) 0.0) +(num-test (+ 123.4 0.0 1) 124.4) +(num-test (- 123.4 0.0 1) 122.4) +(num-test (* 123.4 0.0 1) 0.0) +(num-test (+ 123.4 0.0 1.0) 124.4) +(num-test (- 123.4 0.0 1.0) 122.4) +(num-test (* 123.4 0.0 1.0) 0.0) +(num-test (+ 123.4 0.0 1/1) 124.4) +(num-test (- 123.4 0.0 1/1) 122.4) +(num-test (* 123.4 0.0 1/1) 0.0) +(num-test (+ 123.4 0.0 1.0+1.0i) 124.4+1.0i) +(num-test (- 123.4 0.0 1.0+1.0i) 122.4-1.0i) +(num-test (* 123.4 0.0 1.0+1.0i) 0.0) +(num-test (+ 123.4 0.0 0) 123.4) +(num-test (- 123.4 0.0 0) 123.4) +(num-test (* 123.4 0.0 0) 0.0) +(num-test (+ 123.4 0.0 0.0) 123.4) +(num-test (- 123.4 0.0 0.0) 123.4) +(num-test (* 123.4 0.0 0.0) 0.0) +(num-test (+ 123.4 0.0 1234) 1357.4) +(num-test (- 123.4 0.0 1234) -1110.59999999999991) +(num-test (* 123.4 0.0 1234) 0.0) +(num-test (+ 123.4 0.0 123.4) 246.8) +(num-test (- 123.4 0.0 123.4) 0.0) +(num-test (* 123.4 0.0 123.4) 0.0) +(num-test (+ 123.4 0.0 1234/11) 235.58181818181819) +(num-test (- 123.4 0.0 1234/11) 11.21818181818182) +(num-test (* 123.4 0.0 1234/11) 0.0) +(num-test (+ 123.4 0.0 1.234+1.234i) 124.634+1.234i) +(num-test (- 123.4 0.0 1.234+1.234i) 122.16600000000001-1.234i) +(num-test (* 123.4 0.0 1.234+1.234i) 0.0) +(num-test (+ 123.4 0.0 -1.0+1.0i) 122.4+1.0i) +(num-test (- 123.4 0.0 -1.0+1.0i) 124.4-1.0i) +(num-test (* 123.4 0.0 -1.0+1.0i) -0.0) +(num-test (+ 123.4 0.0 0.0+1.0i) 123.4+1.0i) +(num-test (- 123.4 0.0 0.0+1.0i) 123.4-1.0i) +(num-test (* 123.4 0.0 0.0+1.0i) 0.0) +(num-test (+ 123.4 1234 1) 1358.4) +(num-test (- 123.4 1234 1) -1111.59999999999991) +(num-test (* 123.4 1234 1) 152275.60000000000582) +(num-test (/ 123.4 1234 1) 0.1) +(num-test (= 123.4 1234 1) #f) +(num-test (< 123.4 1234 1) #f) +(num-test (<= 123.4 1234 1) #f) +(num-test (> 123.4 1234 1) #f) +(num-test (>= 123.4 1234 1) #f) +(num-test (+ 123.4 1234 1.0) 1358.4) +(num-test (- 123.4 1234 1.0) -1111.59999999999991) +(num-test (* 123.4 1234 1.0) 152275.60000000000582) +(num-test (/ 123.4 1234 1.0) 0.1) +(num-test (= 123.4 1234 1.0) #f) +(num-test (< 123.4 1234 1.0) #f) +(num-test (<= 123.4 1234 1.0) #f) +(num-test (> 123.4 1234 1.0) #f) +(num-test (>= 123.4 1234 1.0) #f) +(num-test (+ 123.4 1234 1/1) 1358.4) +(num-test (- 123.4 1234 1/1) -1111.59999999999991) +(num-test (* 123.4 1234 1/1) 152275.60000000000582) +(num-test (/ 123.4 1234 1/1) 0.1) +(num-test (= 123.4 1234 1/1) #f) +(num-test (< 123.4 1234 1/1) #f) +(num-test (<= 123.4 1234 1/1) #f) +(num-test (> 123.4 1234 1/1) #f) +(num-test (>= 123.4 1234 1/1) #f) +(num-test (+ 123.4 1234 1.0+1.0i) 1358.4+1.0i) +(num-test (- 123.4 1234 1.0+1.0i) -1111.59999999999991-1.0i) +(num-test (* 123.4 1234 1.0+1.0i) 152275.60000000000582+152275.60000000000582i) +(num-test (/ 123.4 1234 1.0+1.0i) 0.05000000000000-0.05000000000000i) +(num-test (= 123.4 1234 1.0+1.0i) #f) +(num-test (+ 123.4 1234 0) 1357.4) +(num-test (- 123.4 1234 0) -1110.59999999999991) +(num-test (* 123.4 1234 0) 0.0) +(num-test (+ 123.4 1234 0.0) 1357.4) +(num-test (- 123.4 1234 0.0) -1110.59999999999991) +(num-test (* 123.4 1234 0.0) 0.0) +(num-test (+ 123.4 1234 1234) 2591.4) +(num-test (- 123.4 1234 1234) -2344.59999999999991) +(num-test (* 123.4 1234 1234) 187908090.40000000596046) +(num-test (/ 123.4 1234 1234) 0.00008103727715) +(num-test (= 123.4 1234 1234) #f) +(num-test (< 123.4 1234 1234) #f) +(num-test (<= 123.4 1234 1234) #t) +(num-test (> 123.4 1234 1234) #f) +(num-test (>= 123.4 1234 1234) #f) +(num-test (+ 123.4 1234 123.4) 1480.80000000000018) +(num-test (- 123.4 1234 123.4) -1234.0) +(num-test (* 123.4 1234 123.4) 18790809.04000000283122) +(num-test (/ 123.4 1234 123.4) 0.00081037277147) +(num-test (= 123.4 1234 123.4) #f) +(num-test (< 123.4 1234 123.4) #f) +(num-test (<= 123.4 1234 123.4) #f) +(num-test (> 123.4 1234 123.4) #f) +(num-test (>= 123.4 1234 123.4) #f) +(num-test (+ 123.4 1234 1234/11) 1469.58181818181833) +(num-test (- 123.4 1234 1234/11) -1222.78181818181815) +(num-test (* 123.4 1234 1234/11) 17082553.67272727191448) +(num-test (/ 123.4 1234 1234/11) 0.00089141004862) +(num-test (= 123.4 1234 1234/11) #f) +(num-test (< 123.4 1234 1234/11) #f) +(num-test (<= 123.4 1234 1234/11) #f) +(num-test (> 123.4 1234 1234/11) #f) +(num-test (>= 123.4 1234 1234/11) #f) +(num-test (+ 123.4 1234 1.234+1.234i) 1358.63400000000001+1.234i) +(num-test (- 123.4 1234 1.234+1.234i) -1111.83399999999983-1.234i) +(num-test (* 123.4 1234 1.234+1.234i) 187908.09040000001551+187908.09040000001551i) +(num-test (/ 123.4 1234 1.234+1.234i) 0.04051863857374-0.04051863857374i) +(num-test (= 123.4 1234 1.234+1.234i) #f) +(num-test (+ 123.4 1234 -1.0+1.0i) 1356.4+1.0i) +(num-test (- 123.4 1234 -1.0+1.0i) -1109.59999999999991-1.0i) +(num-test (* 123.4 1234 -1.0+1.0i) -152275.60000000000582+152275.60000000000582i) +(num-test (/ 123.4 1234 -1.0+1.0i) -0.05000000000000-0.05000000000000i) +(num-test (= 123.4 1234 -1.0+1.0i) #f) +(num-test (+ 123.4 1234 0.0+1.0i) 1357.4+1.0i) +(num-test (- 123.4 1234 0.0+1.0i) -1110.59999999999991-1.0i) +(num-test (* 123.4 1234 0.0+1.0i) 0.0+152275.60000000000582i) +(num-test (/ 123.4 1234 0.0+1.0i) 0.0-0.1i) +(num-test (= 123.4 1234 0.0+1.0i) #f) +(num-test (+ 123.4 123.4 1) 247.8) +(num-test (- 123.4 123.4 1) -1.0) +(num-test (* 123.4 123.4 1) 15227.56000000000131) +(num-test (/ 123.4 123.4 1) 1.0) +(num-test (= 123.4 123.4 1) #f) +(num-test (< 123.4 123.4 1) #f) +(num-test (<= 123.4 123.4 1) #f) +(num-test (> 123.4 123.4 1) #f) +(num-test (>= 123.4 123.4 1) #t) +(num-test (+ 123.4 123.4 1.0) 247.8) +(num-test (- 123.4 123.4 1.0) -1.0) +(num-test (* 123.4 123.4 1.0) 15227.56000000000131) +(num-test (/ 123.4 123.4 1.0) 1.0) +(num-test (= 123.4 123.4 1.0) #f) +(num-test (< 123.4 123.4 1.0) #f) +(num-test (<= 123.4 123.4 1.0) #f) +(num-test (> 123.4 123.4 1.0) #f) +(num-test (>= 123.4 123.4 1.0) #t) +(num-test (+ 123.4 123.4 1/1) 247.8) +(num-test (- 123.4 123.4 1/1) -1.0) +(num-test (* 123.4 123.4 1/1) 15227.56000000000131) +(num-test (/ 123.4 123.4 1/1) 1.0) +(num-test (= 123.4 123.4 1/1) #f) +(num-test (< 123.4 123.4 1/1) #f) +(num-test (<= 123.4 123.4 1/1) #f) +(num-test (> 123.4 123.4 1/1) #f) +(num-test (>= 123.4 123.4 1/1) #t) +(num-test (+ 123.4 123.4 1.0+1.0i) 247.8+1.0i) +(num-test (- 123.4 123.4 1.0+1.0i) -1.0-1.0i) +(num-test (* 123.4 123.4 1.0+1.0i) 15227.56000000000131+15227.56000000000131i) +(num-test (/ 123.4 123.4 1.0+1.0i) 0.5-0.5i) +(num-test (= 123.4 123.4 1.0+1.0i) #f) +(num-test (+ 123.4 123.4 0) 246.8) +(num-test (- 123.4 123.4 0) 0.0) +(num-test (* 123.4 123.4 0) 0.0) +(num-test (+ 123.4 123.4 0.0) 246.8) +(num-test (- 123.4 123.4 0.0) 0.0) +(num-test (* 123.4 123.4 0.0) 0.0) +(num-test (+ 123.4 123.4 1234) 1480.79999999999995) +(num-test (- 123.4 123.4 1234) -1234.0) +(num-test (* 123.4 123.4 1234) 18790809.04000000283122) +(num-test (/ 123.4 123.4 1234) 0.00081037277147) +(num-test (= 123.4 123.4 1234) #f) +(num-test (< 123.4 123.4 1234) #f) +(num-test (<= 123.4 123.4 1234) #t) +(num-test (> 123.4 123.4 1234) #f) +(num-test (>= 123.4 123.4 1234) #f) +(num-test (+ 123.4 123.4 123.4) 370.20000000000005) +(num-test (- 123.4 123.4 123.4) -123.4) +(num-test (* 123.4 123.4 123.4) 1879080.90400000032969) +(num-test (/ 123.4 123.4 123.4) 0.00810372771475) +(num-test (= 123.4 123.4 123.4) #t) +(num-test (< 123.4 123.4 123.4) #f) +(num-test (<= 123.4 123.4 123.4) #t) +(num-test (> 123.4 123.4 123.4) #f) +(num-test (>= 123.4 123.4 123.4) #t) +(num-test (+ 123.4 123.4 1234/11) 358.98181818181820) +(num-test (- 123.4 123.4 1234/11) -112.18181818181819) +(num-test (* 123.4 123.4 1234/11) 1708255.36727272742428) +(num-test (/ 123.4 123.4 1234/11) 0.00891410048622) +(num-test (= 123.4 123.4 1234/11) #f) +(num-test (< 123.4 123.4 1234/11) #f) +(num-test (<= 123.4 123.4 1234/11) #f) +(num-test (> 123.4 123.4 1234/11) #f) +(num-test (>= 123.4 123.4 1234/11) #t) +(num-test (+ 123.4 123.4 1.234+1.234i) 248.03400000000002+1.234i) +(num-test (- 123.4 123.4 1.234+1.234i) -1.234-1.234i) +(num-test (* 123.4 123.4 1.234+1.234i) 18790.80904000000010+18790.80904000000010i) +(num-test (/ 123.4 123.4 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 123.4 123.4 1.234+1.234i) #f) +(num-test (+ 123.4 123.4 -1.0+1.0i) 245.8+1.0i) +(num-test (- 123.4 123.4 -1.0+1.0i) 1.0-1.0i) +(num-test (* 123.4 123.4 -1.0+1.0i) -15227.56000000000131+15227.56000000000131i) +(num-test (/ 123.4 123.4 -1.0+1.0i) -0.5-0.5i) +(num-test (= 123.4 123.4 -1.0+1.0i) #f) +(num-test (+ 123.4 123.4 0.0+1.0i) 246.8+1.0i) +(num-test (- 123.4 123.4 0.0+1.0i) 0.0-1.0i) +(num-test (* 123.4 123.4 0.0+1.0i) 0.0+15227.56000000000131i) +(num-test (/ 123.4 123.4 0.0+1.0i) 0.0-1.0i) +(num-test (= 123.4 123.4 0.0+1.0i) #f) +(num-test (+ 123.4 1234/11 1) 236.58181818181819) +(num-test (- 123.4 1234/11 1) 10.21818181818182) +(num-test (* 123.4 1234/11 1) 13843.23636363636433) +(num-test (/ 123.4 1234/11 1) 1.10000000000000) +(num-test (= 123.4 1234/11 1) #f) +(num-test (< 123.4 1234/11 1) #f) +(num-test (<= 123.4 1234/11 1) #f) +(num-test (> 123.4 1234/11 1) #t) +(num-test (>= 123.4 1234/11 1) #t) +(num-test (+ 123.4 1234/11 1.0) 236.58181818181819) +(num-test (- 123.4 1234/11 1.0) 10.21818181818182) +(num-test (* 123.4 1234/11 1.0) 13843.23636363636433) +(num-test (/ 123.4 1234/11 1.0) 1.10000000000000) +(num-test (= 123.4 1234/11 1.0) #f) +(num-test (< 123.4 1234/11 1.0) #f) +(num-test (<= 123.4 1234/11 1.0) #f) +(num-test (> 123.4 1234/11 1.0) #t) +(num-test (>= 123.4 1234/11 1.0) #t) +(num-test (+ 123.4 1234/11 1/1) 236.58181818181819) +(num-test (- 123.4 1234/11 1/1) 10.21818181818182) +(num-test (* 123.4 1234/11 1/1) 13843.23636363636433) +(num-test (/ 123.4 1234/11 1/1) 1.10000000000000) +(num-test (= 123.4 1234/11 1/1) #f) +(num-test (< 123.4 1234/11 1/1) #f) +(num-test (<= 123.4 1234/11 1/1) #f) +(num-test (> 123.4 1234/11 1/1) #t) +(num-test (>= 123.4 1234/11 1/1) #t) +(num-test (+ 123.4 1234/11 1.0+1.0i) 236.58181818181819+1.0i) +(num-test (- 123.4 1234/11 1.0+1.0i) 10.21818181818182-1.0i) +(num-test (* 123.4 1234/11 1.0+1.0i) 13843.23636363636433+13843.23636363636433i) +(num-test (/ 123.4 1234/11 1.0+1.0i) 0.55000000000000-0.55000000000000i) +(num-test (= 123.4 1234/11 1.0+1.0i) #f) +(num-test (+ 123.4 1234/11 0) 235.58181818181819) +(num-test (- 123.4 1234/11 0) 11.21818181818182) +(num-test (* 123.4 1234/11 0) 0.0) +(num-test (+ 123.4 1234/11 0.0) 235.58181818181819) +(num-test (- 123.4 1234/11 0.0) 11.21818181818182) +(num-test (* 123.4 1234/11 0.0) 0.0) +(num-test (+ 123.4 1234/11 1234) 1469.58181818181811) +(num-test (- 123.4 1234/11 1234) -1222.78181818181815) +(num-test (* 123.4 1234/11 1234) 17082553.67272727191448) +(num-test (/ 123.4 1234/11 1234) 0.00089141004862) +(num-test (= 123.4 1234/11 1234) #f) +(num-test (< 123.4 1234/11 1234) #f) +(num-test (<= 123.4 1234/11 1234) #f) +(num-test (> 123.4 1234/11 1234) #f) +(num-test (>= 123.4 1234/11 1234) #f) +(num-test (+ 123.4 1234/11 123.4) 358.98181818181820) +(num-test (- 123.4 1234/11 123.4) -112.18181818181819) +(num-test (* 123.4 1234/11 123.4) 1708255.36727272742428) +(num-test (/ 123.4 1234/11 123.4) 0.00891410048622) +(num-test (= 123.4 1234/11 123.4) #f) +(num-test (< 123.4 1234/11 123.4) #f) +(num-test (<= 123.4 1234/11 123.4) #f) +(num-test (> 123.4 1234/11 123.4) #f) +(num-test (>= 123.4 1234/11 123.4) #f) +(num-test (+ 123.4 1234/11 1234/11) 347.76363636363635) +(num-test (- 123.4 1234/11 1234/11) -100.96363636363635) +(num-test (* 123.4 1234/11 1234/11) 1552959.42479338846169) +(num-test (/ 123.4 1234/11 1234/11) 0.00980551053485) +(num-test (= 123.4 1234/11 1234/11) #f) +(num-test (< 123.4 1234/11 1234/11) #f) +(num-test (<= 123.4 1234/11 1234/11) #f) +(num-test (> 123.4 1234/11 1234/11) #f) +(num-test (>= 123.4 1234/11 1234/11) #t) +(num-test (+ 123.4 1234/11 1.234+1.234i) 236.81581818181820+1.234i) +(num-test (- 123.4 1234/11 1.234+1.234i) 9.98418181818182-1.234i) +(num-test (* 123.4 1234/11 1.234+1.234i) 17082.55367272727381+17082.55367272727381i) +(num-test (/ 123.4 1234/11 1.234+1.234i) 0.44570502431118-0.44570502431118i) +(num-test (= 123.4 1234/11 1.234+1.234i) #f) +(num-test (+ 123.4 1234/11 -1.0+1.0i) 234.58181818181819+1.0i) +(num-test (- 123.4 1234/11 -1.0+1.0i) 12.21818181818182-1.0i) +(num-test (* 123.4 1234/11 -1.0+1.0i) -13843.23636363636433+13843.23636363636433i) +(num-test (/ 123.4 1234/11 -1.0+1.0i) -0.55000000000000-0.55000000000000i) +(num-test (= 123.4 1234/11 -1.0+1.0i) #f) +(num-test (+ 123.4 1234/11 0.0+1.0i) 235.58181818181819+1.0i) +(num-test (- 123.4 1234/11 0.0+1.0i) 11.21818181818182-1.0i) +(num-test (* 123.4 1234/11 0.0+1.0i) 0.0+13843.23636363636433i) +(num-test (/ 123.4 1234/11 0.0+1.0i) 0.0-1.10000000000000i) +(num-test (= 123.4 1234/11 0.0+1.0i) #f) +(num-test (+ 123.4 1.234+1.234i 1) 125.634+1.234i) +(num-test (- 123.4 1.234+1.234i 1) 121.16600000000001-1.234i) +(num-test (* 123.4 1.234+1.234i 1) 152.2756+152.2756i) +(num-test (/ 123.4 1.234+1.234i 1) 50.0-50.0i) +(num-test (= 123.4 1.234+1.234i 1) #f) +(num-test (+ 123.4 1.234+1.234i 1.0) 125.634+1.234i) +(num-test (- 123.4 1.234+1.234i 1.0) 121.16600000000001-1.234i) +(num-test (* 123.4 1.234+1.234i 1.0) 152.2756+152.2756i) +(num-test (/ 123.4 1.234+1.234i 1.0) 50.0-50.0i) +(num-test (= 123.4 1.234+1.234i 1.0) #f) +(num-test (+ 123.4 1.234+1.234i 1/1) 125.634+1.234i) +(num-test (- 123.4 1.234+1.234i 1/1) 121.16600000000001-1.234i) +(num-test (* 123.4 1.234+1.234i 1/1) 152.2756+152.2756i) +(num-test (/ 123.4 1.234+1.234i 1/1) 50.0-50.0i) +(num-test (= 123.4 1.234+1.234i 1/1) #f) +(num-test (+ 123.4 1.234+1.234i 1.0+1.0i) 125.634+2.234i) +(num-test (- 123.4 1.234+1.234i 1.0+1.0i) 121.16600000000001-2.234i) +(num-test (* 123.4 1.234+1.234i 1.0+1.0i) 0.0+304.55119999999999i) +(num-test (/ 123.4 1.234+1.234i 1.0+1.0i) 0.0-50.0i) +(num-test (= 123.4 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 123.4 1.234+1.234i 0) 124.634+1.234i) +(num-test (- 123.4 1.234+1.234i 0) 122.16600000000001-1.234i) +(num-test (* 123.4 1.234+1.234i 0) 0.0) +(num-test (+ 123.4 1.234+1.234i 0.0) 124.634+1.234i) +(num-test (- 123.4 1.234+1.234i 0.0) 122.16600000000001-1.234i) +(num-test (* 123.4 1.234+1.234i 0.0) 0.0) +(num-test (+ 123.4 1.234+1.234i 1234) 1358.63400000000001+1.234i) +(num-test (- 123.4 1.234+1.234i 1234) -1111.83400000000006-1.234i) +(num-test (* 123.4 1.234+1.234i 1234) 187908.09039999998640+187908.09039999998640i) +(num-test (/ 123.4 1.234+1.234i 1234) 0.04051863857374-0.04051863857374i) +(num-test (= 123.4 1.234+1.234i 1234) #f) +(num-test (+ 123.4 1.234+1.234i 123.4) 248.03399999999999+1.234i) +(num-test (- 123.4 1.234+1.234i 123.4) -1.23399999999999-1.234i) +(num-test (* 123.4 1.234+1.234i 123.4) 18790.80904000000010+18790.80904000000010i) +(num-test (/ 123.4 1.234+1.234i 123.4) 0.40518638573744-0.40518638573744i) +(num-test (= 123.4 1.234+1.234i 123.4) #f) +(num-test (+ 123.4 1.234+1.234i 1234/11) 236.81581818181817+1.234i) +(num-test (- 123.4 1.234+1.234i 1234/11) 9.98418181818183-1.234i) +(num-test (* 123.4 1.234+1.234i 1234/11) 17082.55367272727381+17082.55367272727381i) +(num-test (/ 123.4 1.234+1.234i 1234/11) 0.44570502431118-0.44570502431118i) +(num-test (= 123.4 1.234+1.234i 1234/11) #f) +(num-test (+ 123.4 1.234+1.234i 1.234+1.234i) 125.86799999999999+2.468i) +(num-test (- 123.4 1.234+1.234i 1.234+1.234i) 120.93200000000002-2.468i) +(num-test (* 123.4 1.234+1.234i 1.234+1.234i) 0.0+375.81618079999998i) +(num-test (/ 123.4 1.234+1.234i 1.234+1.234i) 0.0-40.51863857374392i) +(num-test (= 123.4 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 123.4 1.234+1.234i -1.0+1.0i) 123.634+2.234i) +(num-test (- 123.4 1.234+1.234i -1.0+1.0i) 123.16600000000001-2.234i) +(num-test (* 123.4 1.234+1.234i -1.0+1.0i) -304.55119999999999) +(num-test (/ 123.4 1.234+1.234i -1.0+1.0i) -50.0) +(num-test (= 123.4 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 123.4 1.234+1.234i 0.0+1.0i) 124.634+2.234i) +(num-test (- 123.4 1.234+1.234i 0.0+1.0i) 122.16600000000001-2.234i) +(num-test (* 123.4 1.234+1.234i 0.0+1.0i) -152.2756+152.2756i) +(num-test (/ 123.4 1.234+1.234i 0.0+1.0i) -50.0-50.0i) +(num-test (= 123.4 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 123.4 -1.0+1.0i 1) 123.4+1.0i) +(num-test (- 123.4 -1.0+1.0i 1) 123.4-1.0i) +(num-test (* 123.4 -1.0+1.0i 1) -123.4+123.4i) +(num-test (/ 123.4 -1.0+1.0i 1) -61.7-61.7i) +(num-test (= 123.4 -1.0+1.0i 1) #f) +(num-test (+ 123.4 -1.0+1.0i 1.0) 123.4+1.0i) +(num-test (- 123.4 -1.0+1.0i 1.0) 123.4-1.0i) +(num-test (* 123.4 -1.0+1.0i 1.0) -123.4+123.4i) +(num-test (/ 123.4 -1.0+1.0i 1.0) -61.7-61.7i) +(num-test (= 123.4 -1.0+1.0i 1.0) #f) +(num-test (+ 123.4 -1.0+1.0i 1/1) 123.4+1.0i) +(num-test (- 123.4 -1.0+1.0i 1/1) 123.4-1.0i) +(num-test (* 123.4 -1.0+1.0i 1/1) -123.4+123.4i) +(num-test (/ 123.4 -1.0+1.0i 1/1) -61.7-61.7i) +(num-test (= 123.4 -1.0+1.0i 1/1) #f) +(num-test (+ 123.4 -1.0+1.0i 1.0+1.0i) 123.4+2.0i) +(num-test (- 123.4 -1.0+1.0i 1.0+1.0i) 123.4-2.0i) +(num-test (* 123.4 -1.0+1.0i 1.0+1.0i) -246.8) +(num-test (/ 123.4 -1.0+1.0i 1.0+1.0i) -61.7) +(num-test (= 123.4 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 123.4 -1.0+1.0i 0) 122.4+1.0i) +(num-test (- 123.4 -1.0+1.0i 0) 124.4-1.0i) +(num-test (* 123.4 -1.0+1.0i 0) -0.0) +(num-test (+ 123.4 -1.0+1.0i 0.0) 122.4+1.0i) +(num-test (- 123.4 -1.0+1.0i 0.0) 124.4-1.0i) +(num-test (* 123.4 -1.0+1.0i 0.0) -0.0) +(num-test (+ 123.4 -1.0+1.0i 1234) 1356.4+1.0i) +(num-test (- 123.4 -1.0+1.0i 1234) -1109.59999999999991-1.0i) +(num-test (* 123.4 -1.0+1.0i 1234) -152275.60000000000582+152275.60000000000582i) +(num-test (/ 123.4 -1.0+1.0i 1234) -0.05000000000000-0.05000000000000i) +(num-test (= 123.4 -1.0+1.0i 1234) #f) +(num-test (+ 123.4 -1.0+1.0i 123.4) 245.8+1.0i) +(num-test (- 123.4 -1.0+1.0i 123.4) 1.0-1.0i) +(num-test (* 123.4 -1.0+1.0i 123.4) -15227.56000000000131+15227.56000000000131i) +(num-test (/ 123.4 -1.0+1.0i 123.4) -0.5-0.5i) +(num-test (= 123.4 -1.0+1.0i 123.4) #f) +(num-test (+ 123.4 -1.0+1.0i 1234/11) 234.58181818181819+1.0i) +(num-test (- 123.4 -1.0+1.0i 1234/11) 12.21818181818182-1.0i) +(num-test (* 123.4 -1.0+1.0i 1234/11) -13843.23636363636433+13843.23636363636433i) +(num-test (/ 123.4 -1.0+1.0i 1234/11) -0.55000000000000-0.55000000000000i) +(num-test (= 123.4 -1.0+1.0i 1234/11) #f) +(num-test (+ 123.4 -1.0+1.0i 1.234+1.234i) 123.634+2.234i) +(num-test (- 123.4 -1.0+1.0i 1.234+1.234i) 123.16600000000001-2.234i) +(num-test (* 123.4 -1.0+1.0i 1.234+1.234i) -304.55119999999999) +(num-test (/ 123.4 -1.0+1.0i 1.234+1.234i) -50.0) +(num-test (= 123.4 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 123.4 -1.0+1.0i -1.0+1.0i) 121.4+2.0i) +(num-test (- 123.4 -1.0+1.0i -1.0+1.0i) 125.4-2.0i) +(num-test (* 123.4 -1.0+1.0i -1.0+1.0i) 0.0-246.8i) +(num-test (/ 123.4 -1.0+1.0i -1.0+1.0i) -0.0+61.7i) +(num-test (= 123.4 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 123.4 -1.0+1.0i 0.0+1.0i) 122.4+2.0i) +(num-test (- 123.4 -1.0+1.0i 0.0+1.0i) 124.4-2.0i) +(num-test (* 123.4 -1.0+1.0i 0.0+1.0i) -123.4-123.4i) +(num-test (/ 123.4 -1.0+1.0i 0.0+1.0i) -61.7+61.7i) +(num-test (= 123.4 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 123.4 0.0+1.0i 1) 124.4+1.0i) +(num-test (- 123.4 0.0+1.0i 1) 122.4-1.0i) +(num-test (* 123.4 0.0+1.0i 1) 0.0+123.4i) +(num-test (/ 123.4 0.0+1.0i 1) 0.0-123.4i) +(num-test (= 123.4 0.0+1.0i 1) #f) +(num-test (+ 123.4 0.0+1.0i 1.0) 124.4+1.0i) +(num-test (- 123.4 0.0+1.0i 1.0) 122.4-1.0i) +(num-test (* 123.4 0.0+1.0i 1.0) 0.0+123.4i) +(num-test (/ 123.4 0.0+1.0i 1.0) 0.0-123.4i) +(num-test (= 123.4 0.0+1.0i 1.0) #f) +(num-test (+ 123.4 0.0+1.0i 1/1) 124.4+1.0i) +(num-test (- 123.4 0.0+1.0i 1/1) 122.4-1.0i) +(num-test (* 123.4 0.0+1.0i 1/1) 0.0+123.4i) +(num-test (/ 123.4 0.0+1.0i 1/1) 0.0-123.4i) +(num-test (= 123.4 0.0+1.0i 1/1) #f) +(num-test (+ 123.4 0.0+1.0i 1.0+1.0i) 124.4+2.0i) +(num-test (- 123.4 0.0+1.0i 1.0+1.0i) 122.4-2.0i) +(num-test (* 123.4 0.0+1.0i 1.0+1.0i) -123.4+123.4i) +(num-test (/ 123.4 0.0+1.0i 1.0+1.0i) -61.7-61.7i) +(num-test (= 123.4 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 123.4 0.0+1.0i 0) 123.4+1.0i) +(num-test (- 123.4 0.0+1.0i 0) 123.4-1.0i) +(num-test (* 123.4 0.0+1.0i 0) 0.0) +(num-test (+ 123.4 0.0+1.0i 0.0) 123.4+1.0i) +(num-test (- 123.4 0.0+1.0i 0.0) 123.4-1.0i) +(num-test (* 123.4 0.0+1.0i 0.0) 0.0) +(num-test (+ 123.4 0.0+1.0i 1234) 1357.4+1.0i) +(num-test (- 123.4 0.0+1.0i 1234) -1110.59999999999991-1.0i) +(num-test (* 123.4 0.0+1.0i 1234) 0.0+152275.60000000000582i) +(num-test (/ 123.4 0.0+1.0i 1234) 0.0-0.1i) +(num-test (= 123.4 0.0+1.0i 1234) #f) +(num-test (+ 123.4 0.0+1.0i 123.4) 246.8+1.0i) +(num-test (- 123.4 0.0+1.0i 123.4) 0.0-1.0i) +(num-test (* 123.4 0.0+1.0i 123.4) 0.0+15227.56000000000131i) +(num-test (/ 123.4 0.0+1.0i 123.4) 0.0-1.0i) +(num-test (= 123.4 0.0+1.0i 123.4) #f) +(num-test (+ 123.4 0.0+1.0i 1234/11) 235.58181818181819+1.0i) +(num-test (- 123.4 0.0+1.0i 1234/11) 11.21818181818182-1.0i) +(num-test (* 123.4 0.0+1.0i 1234/11) 0.0+13843.23636363636433i) +(num-test (/ 123.4 0.0+1.0i 1234/11) 0.0-1.10000000000000i) +(num-test (= 123.4 0.0+1.0i 1234/11) #f) +(num-test (+ 123.4 0.0+1.0i 1.234+1.234i) 124.634+2.234i) +(num-test (- 123.4 0.0+1.0i 1.234+1.234i) 122.16600000000001-2.234i) +(num-test (* 123.4 0.0+1.0i 1.234+1.234i) -152.2756+152.2756i) +(num-test (/ 123.4 0.0+1.0i 1.234+1.234i) -50.0-50.0i) +(num-test (= 123.4 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 123.4 0.0+1.0i -1.0+1.0i) 122.4+2.0i) +(num-test (- 123.4 0.0+1.0i -1.0+1.0i) 124.4-2.0i) +(num-test (* 123.4 0.0+1.0i -1.0+1.0i) -123.4-123.4i) +(num-test (/ 123.4 0.0+1.0i -1.0+1.0i) -61.7+61.7i) +(num-test (= 123.4 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 123.4 0.0+1.0i 0.0+1.0i) 123.4+2.0i) +(num-test (- 123.4 0.0+1.0i 0.0+1.0i) 123.4-2.0i) +(num-test (* 123.4 0.0+1.0i 0.0+1.0i) -123.4) +(num-test (/ 123.4 0.0+1.0i 0.0+1.0i) -123.4) +(num-test (= 123.4 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1234/11 1 1) 1256/11) +(num-test (- 1234/11 1 1) 1212/11) +(num-test (* 1234/11 1 1) 1234/11) +(num-test (/ 1234/11 1 1) 1234/11) +(num-test (= 1234/11 1 1) #f) +(num-test (< 1234/11 1 1) #f) +(num-test (<= 1234/11 1 1) #f) +(num-test (> 1234/11 1 1) #f) +(num-test (>= 1234/11 1 1) #t) +(num-test (+ 1234/11 1 1.0) 114.18181818181819) +(num-test (- 1234/11 1 1.0) 110.18181818181819) +(num-test (* 1234/11 1 1.0) 112.18181818181819) +(num-test (/ 1234/11 1 1.0) 112.18181818181819) +(num-test (= 1234/11 1 1.0) #f) +(num-test (< 1234/11 1 1.0) #f) +(num-test (<= 1234/11 1 1.0) #f) +(num-test (> 1234/11 1 1.0) #f) +(num-test (>= 1234/11 1 1.0) #t) +(num-test (+ 1234/11 1 1/1) 1256/11) +(num-test (- 1234/11 1 1/1) 1212/11) +(num-test (* 1234/11 1 1/1) 1234/11) +(num-test (/ 1234/11 1 1/1) 1234/11) +(num-test (= 1234/11 1 1/1) #f) +(num-test (< 1234/11 1 1/1) #f) +(num-test (<= 1234/11 1 1/1) #f) +(num-test (> 1234/11 1 1/1) #f) +(num-test (>= 1234/11 1 1/1) #t) +(num-test (+ 1234/11 1 1.0+1.0i) 114.18181818181819+1.0i) +(num-test (- 1234/11 1 1.0+1.0i) 110.18181818181819-1.0i) +(num-test (* 1234/11 1 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1 1.0+1.0i) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1 1.0+1.0i) #f) +(num-test (+ 1234/11 1 0) 1245/11) +(num-test (- 1234/11 1 0) 1223/11) +(num-test (* 1234/11 1 0) 0) +(num-test (+ 1234/11 1 0.0) 113.18181818181819) +(num-test (- 1234/11 1 0.0) 111.18181818181819) +(num-test (* 1234/11 1 0.0) 0.0) +(num-test (+ 1234/11 1 1234) 14819/11) +(num-test (- 1234/11 1 1234) -12351/11) +(num-test (* 1234/11 1 1234) 1522756/11) +(num-test (/ 1234/11 1 1234) 1/11) +(num-test (= 1234/11 1 1234) #f) +(num-test (< 1234/11 1 1234) #f) +(num-test (<= 1234/11 1 1234) #f) +(num-test (> 1234/11 1 1234) #f) +(num-test (>= 1234/11 1 1234) #f) +(num-test (+ 1234/11 1 123.4) 236.58181818181819) +(num-test (- 1234/11 1 123.4) -12.21818181818182) +(num-test (* 1234/11 1 123.4) 13843.23636363636433) +(num-test (/ 1234/11 1 123.4) 0.90909090909091) +(num-test (= 1234/11 1 123.4) #f) +(num-test (< 1234/11 1 123.4) #f) +(num-test (<= 1234/11 1 123.4) #f) +(num-test (> 1234/11 1 123.4) #f) +(num-test (>= 1234/11 1 123.4) #f) +(num-test (+ 1234/11 1 1234/11) 2479/11) +(num-test (- 1234/11 1 1234/11) -1) +(num-test (* 1234/11 1 1234/11) 1522756/121) +(num-test (/ 1234/11 1 1234/11) 1) +(num-test (= 1234/11 1 1234/11) #f) +(num-test (< 1234/11 1 1234/11) #f) +(num-test (<= 1234/11 1 1234/11) #f) +(num-test (> 1234/11 1 1234/11) #f) +(num-test (>= 1234/11 1 1234/11) #f) +(num-test (+ 1234/11 1 1.234+1.234i) 114.41581818181818+1.234i) +(num-test (- 1234/11 1 1.234+1.234i) 109.94781818181819-1.234i) +(num-test (* 1234/11 1 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1 1.234+1.234i) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1 1.234+1.234i) #f) +(num-test (+ 1234/11 1 -1.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1234/11 1 -1.0+1.0i) 112.18181818181819-1.0i) +(num-test (* 1234/11 1 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1 -1.0+1.0i) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1 -1.0+1.0i) #f) +(num-test (+ 1234/11 1 0.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1234/11 1 0.0+1.0i) 111.18181818181819-1.0i) +(num-test (* 1234/11 1 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1234/11 1 0.0+1.0i) 0.0-112.18181818181819i) +(num-test (= 1234/11 1 0.0+1.0i) #f) +(num-test (+ 1234/11 1.0 1) 114.18181818181819) +(num-test (- 1234/11 1.0 1) 110.18181818181819) +(num-test (* 1234/11 1.0 1) 112.18181818181819) +(num-test (/ 1234/11 1.0 1) 112.18181818181819) +(num-test (= 1234/11 1.0 1) #f) +(num-test (< 1234/11 1.0 1) #f) +(num-test (<= 1234/11 1.0 1) #f) +(num-test (> 1234/11 1.0 1) #f) +(num-test (>= 1234/11 1.0 1) #t) +(num-test (+ 1234/11 1.0 1.0) 114.18181818181819) +(num-test (- 1234/11 1.0 1.0) 110.18181818181819) +(num-test (* 1234/11 1.0 1.0) 112.18181818181819) +(num-test (/ 1234/11 1.0 1.0) 112.18181818181819) +(num-test (= 1234/11 1.0 1.0) #f) +(num-test (< 1234/11 1.0 1.0) #f) +(num-test (<= 1234/11 1.0 1.0) #f) +(num-test (> 1234/11 1.0 1.0) #f) +(num-test (>= 1234/11 1.0 1.0) #t) +(num-test (+ 1234/11 1.0 1/1) 114.18181818181819) +(num-test (- 1234/11 1.0 1/1) 110.18181818181819) +(num-test (* 1234/11 1.0 1/1) 112.18181818181819) +(num-test (/ 1234/11 1.0 1/1) 112.18181818181819) +(num-test (= 1234/11 1.0 1/1) #f) +(num-test (< 1234/11 1.0 1/1) #f) +(num-test (<= 1234/11 1.0 1/1) #f) +(num-test (> 1234/11 1.0 1/1) #f) +(num-test (>= 1234/11 1.0 1/1) #t) +(num-test (+ 1234/11 1.0 1.0+1.0i) 114.18181818181819+1.0i) +(num-test (- 1234/11 1.0 1.0+1.0i) 110.18181818181819-1.0i) +(num-test (* 1234/11 1.0 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0 1.0+1.0i) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0 1.0+1.0i) #f) +(num-test (+ 1234/11 1.0 0) 113.18181818181819) +(num-test (- 1234/11 1.0 0) 111.18181818181819) +(num-test (* 1234/11 1.0 0) 0.0) +(num-test (+ 1234/11 1.0 0.0) 113.18181818181819) +(num-test (- 1234/11 1.0 0.0) 111.18181818181819) +(num-test (* 1234/11 1.0 0.0) 0.0) +(num-test (+ 1234/11 1.0 1234) 1347.18181818181824) +(num-test (- 1234/11 1.0 1234) -1122.81818181818176) +(num-test (* 1234/11 1.0 1234) 138432.36363636364695) +(num-test (/ 1234/11 1.0 1234) 0.09090909090909) +(num-test (= 1234/11 1.0 1234) #f) +(num-test (< 1234/11 1.0 1234) #f) +(num-test (<= 1234/11 1.0 1234) #f) +(num-test (> 1234/11 1.0 1234) #f) +(num-test (>= 1234/11 1.0 1234) #f) +(num-test (+ 1234/11 1.0 123.4) 236.58181818181819) +(num-test (- 1234/11 1.0 123.4) -12.21818181818182) +(num-test (* 1234/11 1.0 123.4) 13843.23636363636433) +(num-test (/ 1234/11 1.0 123.4) 0.90909090909091) +(num-test (= 1234/11 1.0 123.4) #f) +(num-test (< 1234/11 1.0 123.4) #f) +(num-test (<= 1234/11 1.0 123.4) #f) +(num-test (> 1234/11 1.0 123.4) #f) +(num-test (>= 1234/11 1.0 123.4) #f) +(num-test (+ 1234/11 1.0 1234/11) 225.36363636363637) +(num-test (- 1234/11 1.0 1234/11) -1.0) +(num-test (* 1234/11 1.0 1234/11) 12584.76033057851237) +(num-test (/ 1234/11 1.0 1234/11) 1.0) +(num-test (= 1234/11 1.0 1234/11) #f) +(num-test (< 1234/11 1.0 1234/11) #f) +(num-test (<= 1234/11 1.0 1234/11) #f) +(num-test (> 1234/11 1.0 1234/11) #f) +(num-test (>= 1234/11 1.0 1234/11) #f) +(num-test (+ 1234/11 1.0 1.234+1.234i) 114.41581818181818+1.234i) +(num-test (- 1234/11 1.0 1.234+1.234i) 109.94781818181819-1.234i) +(num-test (* 1234/11 1.0 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1.0 1.234+1.234i) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1.0 1.234+1.234i) #f) +(num-test (+ 1234/11 1.0 -1.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1234/11 1.0 -1.0+1.0i) 112.18181818181819-1.0i) +(num-test (* 1234/11 1.0 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0 -1.0+1.0i) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0 -1.0+1.0i) #f) +(num-test (+ 1234/11 1.0 0.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1234/11 1.0 0.0+1.0i) 111.18181818181819-1.0i) +(num-test (* 1234/11 1.0 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1234/11 1.0 0.0+1.0i) 0.0-112.18181818181819i) +(num-test (= 1234/11 1.0 0.0+1.0i) #f) +(num-test (+ 1234/11 1/1 1) 1256/11) +(num-test (- 1234/11 1/1 1) 1212/11) +(num-test (* 1234/11 1/1 1) 1234/11) +(num-test (/ 1234/11 1/1 1) 1234/11) +(num-test (= 1234/11 1/1 1) #f) +(num-test (< 1234/11 1/1 1) #f) +(num-test (<= 1234/11 1/1 1) #f) +(num-test (> 1234/11 1/1 1) #f) +(num-test (>= 1234/11 1/1 1) #t) +(num-test (+ 1234/11 1/1 1.0) 114.18181818181819) +(num-test (- 1234/11 1/1 1.0) 110.18181818181819) +(num-test (* 1234/11 1/1 1.0) 112.18181818181819) +(num-test (/ 1234/11 1/1 1.0) 112.18181818181819) +(num-test (= 1234/11 1/1 1.0) #f) +(num-test (< 1234/11 1/1 1.0) #f) +(num-test (<= 1234/11 1/1 1.0) #f) +(num-test (> 1234/11 1/1 1.0) #f) +(num-test (>= 1234/11 1/1 1.0) #t) +(num-test (+ 1234/11 1/1 1/1) 1256/11) +(num-test (- 1234/11 1/1 1/1) 1212/11) +(num-test (* 1234/11 1/1 1/1) 1234/11) +(num-test (/ 1234/11 1/1 1/1) 1234/11) +(num-test (= 1234/11 1/1 1/1) #f) +(num-test (< 1234/11 1/1 1/1) #f) +(num-test (<= 1234/11 1/1 1/1) #f) +(num-test (> 1234/11 1/1 1/1) #f) +(num-test (>= 1234/11 1/1 1/1) #t) +(num-test (+ 1234/11 1/1 1.0+1.0i) 114.18181818181819+1.0i) +(num-test (- 1234/11 1/1 1.0+1.0i) 110.18181818181819-1.0i) +(num-test (* 1234/11 1/1 1.0+1.0i) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1/1 1.0+1.0i) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1/1 1.0+1.0i) #f) +(num-test (+ 1234/11 1/1 0) 1245/11) +(num-test (- 1234/11 1/1 0) 1223/11) +(num-test (* 1234/11 1/1 0) 0) +(num-test (+ 1234/11 1/1 0.0) 113.18181818181819) +(num-test (- 1234/11 1/1 0.0) 111.18181818181819) +(num-test (* 1234/11 1/1 0.0) 0.0) +(num-test (+ 1234/11 1/1 1234) 14819/11) +(num-test (- 1234/11 1/1 1234) -12351/11) +(num-test (* 1234/11 1/1 1234) 1522756/11) +(num-test (/ 1234/11 1/1 1234) 1/11) +(num-test (= 1234/11 1/1 1234) #f) +(num-test (< 1234/11 1/1 1234) #f) +(num-test (<= 1234/11 1/1 1234) #f) +(num-test (> 1234/11 1/1 1234) #f) +(num-test (>= 1234/11 1/1 1234) #f) +(num-test (+ 1234/11 1/1 123.4) 236.58181818181819) +(num-test (- 1234/11 1/1 123.4) -12.21818181818182) +(num-test (* 1234/11 1/1 123.4) 13843.23636363636433) +(num-test (/ 1234/11 1/1 123.4) 0.90909090909091) +(num-test (= 1234/11 1/1 123.4) #f) +(num-test (< 1234/11 1/1 123.4) #f) +(num-test (<= 1234/11 1/1 123.4) #f) +(num-test (> 1234/11 1/1 123.4) #f) +(num-test (>= 1234/11 1/1 123.4) #f) +(num-test (+ 1234/11 1/1 1234/11) 2479/11) +(num-test (- 1234/11 1/1 1234/11) -1) +(num-test (* 1234/11 1/1 1234/11) 1522756/121) +(num-test (/ 1234/11 1/1 1234/11) 1) +(num-test (= 1234/11 1/1 1234/11) #f) +(num-test (< 1234/11 1/1 1234/11) #f) +(num-test (<= 1234/11 1/1 1234/11) #f) +(num-test (> 1234/11 1/1 1234/11) #f) +(num-test (>= 1234/11 1/1 1234/11) #f) +(num-test (+ 1234/11 1/1 1.234+1.234i) 114.41581818181818+1.234i) +(num-test (- 1234/11 1/1 1.234+1.234i) 109.94781818181819-1.234i) +(num-test (* 1234/11 1/1 1.234+1.234i) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1/1 1.234+1.234i) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1/1 1.234+1.234i) #f) +(num-test (+ 1234/11 1/1 -1.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1234/11 1/1 -1.0+1.0i) 112.18181818181819-1.0i) +(num-test (* 1234/11 1/1 -1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1/1 -1.0+1.0i) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1/1 -1.0+1.0i) #f) +(num-test (+ 1234/11 1/1 0.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1234/11 1/1 0.0+1.0i) 111.18181818181819-1.0i) +(num-test (* 1234/11 1/1 0.0+1.0i) 0.0+112.18181818181819i) +(num-test (/ 1234/11 1/1 0.0+1.0i) 0.0-112.18181818181819i) +(num-test (= 1234/11 1/1 0.0+1.0i) #f) +(num-test (+ 1234/11 1.0+1.0i 1) 114.18181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i 1) 110.18181818181819-1.0i) +(num-test (* 1234/11 1.0+1.0i 1) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0+1.0i 1) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0+1.0i 1) #f) +(num-test (+ 1234/11 1.0+1.0i 1.0) 114.18181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i 1.0) 110.18181818181819-1.0i) +(num-test (* 1234/11 1.0+1.0i 1.0) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0+1.0i 1.0) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0+1.0i 1.0) #f) +(num-test (+ 1234/11 1.0+1.0i 1/1) 114.18181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i 1/1) 110.18181818181819-1.0i) +(num-test (* 1234/11 1.0+1.0i 1/1) 112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0+1.0i 1/1) 56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0+1.0i 1/1) #f) +(num-test (+ 1234/11 1.0+1.0i 1.0+1.0i) 114.18181818181819+2.0i) +(num-test (- 1234/11 1.0+1.0i 1.0+1.0i) 110.18181818181819-2.0i) +(num-test (* 1234/11 1.0+1.0i 1.0+1.0i) 0.0+224.36363636363637i) +(num-test (/ 1234/11 1.0+1.0i 1.0+1.0i) 0.0-56.09090909090909i) +(num-test (= 1234/11 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1234/11 1.0+1.0i 0) 113.18181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i 0) 111.18181818181819-1.0i) +(num-test (* 1234/11 1.0+1.0i 0) 0.0) +(num-test (+ 1234/11 1.0+1.0i 0.0) 113.18181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i 0.0) 111.18181818181819-1.0i) +(num-test (* 1234/11 1.0+1.0i 0.0) 0.0) +(num-test (+ 1234/11 1.0+1.0i 1234) 1347.18181818181824+1.0i) +(num-test (- 1234/11 1.0+1.0i 1234) -1122.81818181818176-1.0i) +(num-test (* 1234/11 1.0+1.0i 1234) 138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234/11 1.0+1.0i 1234) 0.04545454545455-0.04545454545455i) +(num-test (= 1234/11 1.0+1.0i 1234) #f) +(num-test (+ 1234/11 1.0+1.0i 123.4) 236.58181818181819+1.0i) +(num-test (- 1234/11 1.0+1.0i 123.4) -12.21818181818182-1.0i) +(num-test (* 1234/11 1.0+1.0i 123.4) 13843.23636363636433+13843.23636363636433i) +(num-test (/ 1234/11 1.0+1.0i 123.4) 0.45454545454545-0.45454545454545i) +(num-test (= 1234/11 1.0+1.0i 123.4) #f) +(num-test (+ 1234/11 1.0+1.0i 1234/11) 225.36363636363637+1.0i) +(num-test (- 1234/11 1.0+1.0i 1234/11) -1.0-1.0i) +(num-test (* 1234/11 1.0+1.0i 1234/11) 12584.76033057851419+12584.76033057851419i) +(num-test (/ 1234/11 1.0+1.0i 1234/11) 0.5-0.5i) +(num-test (= 1234/11 1.0+1.0i 1234/11) #f) +(num-test (+ 1234/11 1.0+1.0i 1.234+1.234i) 114.41581818181818+2.234i) +(num-test (- 1234/11 1.0+1.0i 1.234+1.234i) 109.94781818181819-2.234i) +(num-test (* 1234/11 1.0+1.0i 1.234+1.234i) 0.0+276.86472727272729i) +(num-test (/ 1234/11 1.0+1.0i 1.234+1.234i) 0.0-45.45454545454546i) +(num-test (= 1234/11 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1234/11 1.0+1.0i -1.0+1.0i) 112.18181818181819+2.0i) +(num-test (- 1234/11 1.0+1.0i -1.0+1.0i) 112.18181818181819-2.0i) +(num-test (* 1234/11 1.0+1.0i -1.0+1.0i) -224.36363636363637) +(num-test (/ 1234/11 1.0+1.0i -1.0+1.0i) -56.09090909090909) +(num-test (= 1234/11 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1234/11 1.0+1.0i 0.0+1.0i) 113.18181818181819+2.0i) +(num-test (- 1234/11 1.0+1.0i 0.0+1.0i) 111.18181818181819-2.0i) +(num-test (* 1234/11 1.0+1.0i 0.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 1.0+1.0i 0.0+1.0i) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1234/11 0 1) 1245/11) +(num-test (- 1234/11 0 1) 1223/11) +(num-test (* 1234/11 0 1) 0) +(num-test (+ 1234/11 0 1.0) 113.18181818181819) +(num-test (- 1234/11 0 1.0) 111.18181818181819) +(num-test (* 1234/11 0 1.0) 0.0) +(num-test (+ 1234/11 0 1/1) 1245/11) +(num-test (- 1234/11 0 1/1) 1223/11) +(num-test (* 1234/11 0 1/1) 0) +(num-test (+ 1234/11 0 1.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1234/11 0 1.0+1.0i) 111.18181818181819-1.0i) +(num-test (* 1234/11 0 1.0+1.0i) 0.0) +(num-test (+ 1234/11 0 0) 1234/11) +(num-test (- 1234/11 0 0) 1234/11) +(num-test (* 1234/11 0 0) 0) +(num-test (+ 1234/11 0 0.0) 112.18181818181819) +(num-test (- 1234/11 0 0.0) 112.18181818181819) +(num-test (* 1234/11 0 0.0) 0.0) +(num-test (+ 1234/11 0 1234) 14808/11) +(num-test (- 1234/11 0 1234) -12340/11) +(num-test (* 1234/11 0 1234) 0) +(num-test (+ 1234/11 0 123.4) 235.58181818181819) +(num-test (- 1234/11 0 123.4) -11.21818181818182) +(num-test (* 1234/11 0 123.4) 0.0) +(num-test (+ 1234/11 0 1234/11) 2468/11) +(num-test (- 1234/11 0 1234/11) 0) +(num-test (* 1234/11 0 1234/11) 0) +(num-test (+ 1234/11 0 1.234+1.234i) 113.41581818181818+1.234i) +(num-test (- 1234/11 0 1.234+1.234i) 110.94781818181819-1.234i) +(num-test (* 1234/11 0 1.234+1.234i) 0.0) +(num-test (+ 1234/11 0 -1.0+1.0i) 111.18181818181819+1.0i) +(num-test (- 1234/11 0 -1.0+1.0i) 113.18181818181819-1.0i) +(num-test (* 1234/11 0 -1.0+1.0i) -0.0) +(num-test (+ 1234/11 0 0.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1234/11 0 0.0+1.0i) 112.18181818181819-1.0i) +(num-test (* 1234/11 0 0.0+1.0i) 0.0) +(num-test (+ 1234/11 0.0 1) 113.18181818181819) +(num-test (- 1234/11 0.0 1) 111.18181818181819) +(num-test (* 1234/11 0.0 1) 0.0) +(num-test (+ 1234/11 0.0 1.0) 113.18181818181819) +(num-test (- 1234/11 0.0 1.0) 111.18181818181819) +(num-test (* 1234/11 0.0 1.0) 0.0) +(num-test (+ 1234/11 0.0 1/1) 113.18181818181819) +(num-test (- 1234/11 0.0 1/1) 111.18181818181819) +(num-test (* 1234/11 0.0 1/1) 0.0) +(num-test (+ 1234/11 0.0 1.0+1.0i) 113.18181818181819+1.0i) +(num-test (- 1234/11 0.0 1.0+1.0i) 111.18181818181819-1.0i) +(num-test (* 1234/11 0.0 1.0+1.0i) 0.0) +(num-test (+ 1234/11 0.0 0) 112.18181818181819) +(num-test (- 1234/11 0.0 0) 112.18181818181819) +(num-test (* 1234/11 0.0 0) 0.0) +(num-test (+ 1234/11 0.0 0.0) 112.18181818181819) +(num-test (- 1234/11 0.0 0.0) 112.18181818181819) +(num-test (* 1234/11 0.0 0.0) 0.0) +(num-test (+ 1234/11 0.0 1234) 1346.18181818181824) +(num-test (- 1234/11 0.0 1234) -1121.81818181818176) +(num-test (* 1234/11 0.0 1234) 0.0) +(num-test (+ 1234/11 0.0 123.4) 235.58181818181819) +(num-test (- 1234/11 0.0 123.4) -11.21818181818182) +(num-test (* 1234/11 0.0 123.4) 0.0) +(num-test (+ 1234/11 0.0 1234/11) 224.36363636363637) +(num-test (- 1234/11 0.0 1234/11) 0.00000000000001) +(num-test (* 1234/11 0.0 1234/11) 0.0) +(num-test (+ 1234/11 0.0 1.234+1.234i) 113.41581818181818+1.234i) +(num-test (- 1234/11 0.0 1.234+1.234i) 110.94781818181819-1.234i) +(num-test (* 1234/11 0.0 1.234+1.234i) 0.0) +(num-test (+ 1234/11 0.0 -1.0+1.0i) 111.18181818181819+1.0i) +(num-test (- 1234/11 0.0 -1.0+1.0i) 113.18181818181819-1.0i) +(num-test (* 1234/11 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1234/11 0.0 0.0+1.0i) 112.18181818181819+1.0i) +(num-test (- 1234/11 0.0 0.0+1.0i) 112.18181818181819-1.0i) +(num-test (* 1234/11 0.0 0.0+1.0i) 0.0) +(num-test (+ 1234/11 1234 1) 14819/11) +(num-test (- 1234/11 1234 1) -12351/11) +(num-test (* 1234/11 1234 1) 1522756/11) +(num-test (/ 1234/11 1234 1) 1/11) +(num-test (= 1234/11 1234 1) #f) +(num-test (< 1234/11 1234 1) #f) +(num-test (<= 1234/11 1234 1) #f) +(num-test (> 1234/11 1234 1) #f) +(num-test (>= 1234/11 1234 1) #f) +(num-test (+ 1234/11 1234 1.0) 1347.18181818181824) +(num-test (- 1234/11 1234 1.0) -1122.81818181818176) +(num-test (* 1234/11 1234 1.0) 138432.36363636364695) +(num-test (/ 1234/11 1234 1.0) 0.09090909090909) +(num-test (= 1234/11 1234 1.0) #f) +(num-test (< 1234/11 1234 1.0) #f) +(num-test (<= 1234/11 1234 1.0) #f) +(num-test (> 1234/11 1234 1.0) #f) +(num-test (>= 1234/11 1234 1.0) #f) +(num-test (+ 1234/11 1234 1/1) 14819/11) +(num-test (- 1234/11 1234 1/1) -12351/11) +(num-test (* 1234/11 1234 1/1) 1522756/11) +(num-test (/ 1234/11 1234 1/1) 1/11) +(num-test (= 1234/11 1234 1/1) #f) +(num-test (< 1234/11 1234 1/1) #f) +(num-test (<= 1234/11 1234 1/1) #f) +(num-test (> 1234/11 1234 1/1) #f) +(num-test (>= 1234/11 1234 1/1) #f) +(num-test (+ 1234/11 1234 1.0+1.0i) 1347.18181818181824+1.0i) +(num-test (- 1234/11 1234 1.0+1.0i) -1122.81818181818176-1.0i) +(num-test (* 1234/11 1234 1.0+1.0i) 138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234/11 1234 1.0+1.0i) 0.04545454545455-0.04545454545455i) +(num-test (= 1234/11 1234 1.0+1.0i) #f) +(num-test (+ 1234/11 1234 0) 14808/11) +(num-test (- 1234/11 1234 0) -12340/11) +(num-test (* 1234/11 1234 0) 0) +(num-test (+ 1234/11 1234 0.0) 1346.18181818181824) +(num-test (- 1234/11 1234 0.0) -1121.81818181818176) +(num-test (* 1234/11 1234 0.0) 0.0) +(num-test (+ 1234/11 1234 1234) 28382/11) +(num-test (- 1234/11 1234 1234) -25914/11) +(if (not with-64-bit-ints) + (num-test (* 1234/11 1234 1234) 170825536.727273) + (num-test (* 1234/11 1234 1234) 1879080904/11)) +(num-test (/ 1234/11 1234 1234) 1/13574) +(num-test (= 1234/11 1234 1234) #f) +(num-test (< 1234/11 1234 1234) #f) +(num-test (<= 1234/11 1234 1234) #t) +(num-test (> 1234/11 1234 1234) #f) +(num-test (>= 1234/11 1234 1234) #f) +(num-test (+ 1234/11 1234 123.4) 1469.58181818181833) +(num-test (- 1234/11 1234 123.4) -1245.21818181818185) +(num-test (* 1234/11 1234 123.4) 17082553.67272727563977) +(num-test (/ 1234/11 1234 123.4) 0.00073670251952) +(num-test (= 1234/11 1234 123.4) #f) +(num-test (< 1234/11 1234 123.4) #f) +(num-test (<= 1234/11 1234 123.4) #f) +(num-test (> 1234/11 1234 123.4) #f) +(num-test (>= 1234/11 1234 123.4) #f) +(num-test (+ 1234/11 1234 1234/11) 16042/11) +(num-test (- 1234/11 1234 1234/11) -1234) +(if (not with-64-bit-ints) + (num-test (* 1234/11 1234 1234/11) 15529594.2479339) + (num-test (* 1234/11 1234 1234/11) 1879080904/121)) +(num-test (/ 1234/11 1234 1234/11) 1/1234) +(num-test (= 1234/11 1234 1234/11) #f) +(num-test (< 1234/11 1234 1234/11) #f) +(num-test (<= 1234/11 1234 1234/11) #f) +(num-test (> 1234/11 1234 1234/11) #f) +(num-test (>= 1234/11 1234 1234/11) #f) +(num-test (+ 1234/11 1234 1.234+1.234i) 1347.41581818181817+1.234i) +(num-test (- 1234/11 1234 1.234+1.234i) -1123.05218181818168-1.234i) +(num-test (* 1234/11 1234 1.234+1.234i) 170825.53672727273079+170825.53672727273079i) +(num-test (/ 1234/11 1234 1.234+1.234i) 0.03683512597613-0.03683512597613i) +(num-test (= 1234/11 1234 1.234+1.234i) #f) +(num-test (+ 1234/11 1234 -1.0+1.0i) 1345.18181818181824+1.0i) +(num-test (- 1234/11 1234 -1.0+1.0i) -1120.81818181818176-1.0i) +(num-test (* 1234/11 1234 -1.0+1.0i) -138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234/11 1234 -1.0+1.0i) -0.04545454545455-0.04545454545455i) +(num-test (= 1234/11 1234 -1.0+1.0i) #f) +(num-test (+ 1234/11 1234 0.0+1.0i) 1346.18181818181824+1.0i) +(num-test (- 1234/11 1234 0.0+1.0i) -1121.81818181818176-1.0i) +(num-test (* 1234/11 1234 0.0+1.0i) 0.0+138432.36363636364695i) +(num-test (/ 1234/11 1234 0.0+1.0i) 0.0-0.09090909090909i) +(num-test (= 1234/11 1234 0.0+1.0i) #f) +(num-test (+ 1234/11 123.4 1) 236.58181818181819) +(num-test (- 1234/11 123.4 1) -12.21818181818182) +(num-test (* 1234/11 123.4 1) 13843.23636363636433) +(num-test (/ 1234/11 123.4 1) 0.90909090909091) +(num-test (= 1234/11 123.4 1) #f) +(num-test (< 1234/11 123.4 1) #f) +(num-test (<= 1234/11 123.4 1) #f) +(num-test (> 1234/11 123.4 1) #f) +(num-test (>= 1234/11 123.4 1) #f) +(num-test (+ 1234/11 123.4 1.0) 236.58181818181819) +(num-test (- 1234/11 123.4 1.0) -12.21818181818182) +(num-test (* 1234/11 123.4 1.0) 13843.23636363636433) +(num-test (/ 1234/11 123.4 1.0) 0.90909090909091) +(num-test (= 1234/11 123.4 1.0) #f) +(num-test (< 1234/11 123.4 1.0) #f) +(num-test (<= 1234/11 123.4 1.0) #f) +(num-test (> 1234/11 123.4 1.0) #f) +(num-test (>= 1234/11 123.4 1.0) #f) +(num-test (+ 1234/11 123.4 1/1) 236.58181818181819) +(num-test (- 1234/11 123.4 1/1) -12.21818181818182) +(num-test (* 1234/11 123.4 1/1) 13843.23636363636433) +(num-test (/ 1234/11 123.4 1/1) 0.90909090909091) +(num-test (= 1234/11 123.4 1/1) #f) +(num-test (< 1234/11 123.4 1/1) #f) +(num-test (<= 1234/11 123.4 1/1) #f) +(num-test (> 1234/11 123.4 1/1) #f) +(num-test (>= 1234/11 123.4 1/1) #f) +(num-test (+ 1234/11 123.4 1.0+1.0i) 236.58181818181819+1.0i) +(num-test (- 1234/11 123.4 1.0+1.0i) -12.21818181818182-1.0i) +(num-test (* 1234/11 123.4 1.0+1.0i) 13843.23636363636433+13843.23636363636433i) +(num-test (/ 1234/11 123.4 1.0+1.0i) 0.45454545454545-0.45454545454545i) +(num-test (= 1234/11 123.4 1.0+1.0i) #f) +(num-test (+ 1234/11 123.4 0) 235.58181818181819) +(num-test (- 1234/11 123.4 0) -11.21818181818182) +(num-test (* 1234/11 123.4 0) 0.0) +(num-test (+ 1234/11 123.4 0.0) 235.58181818181819) +(num-test (- 1234/11 123.4 0.0) -11.21818181818182) +(num-test (* 1234/11 123.4 0.0) 0.0) +(num-test (+ 1234/11 123.4 1234) 1469.58181818181811) +(num-test (- 1234/11 123.4 1234) -1245.21818181818185) +(num-test (* 1234/11 123.4 1234) 17082553.67272727191448) +(num-test (/ 1234/11 123.4 1234) 0.00073670251952) +(num-test (= 1234/11 123.4 1234) #f) +(num-test (< 1234/11 123.4 1234) #t) +(num-test (<= 1234/11 123.4 1234) #t) +(num-test (> 1234/11 123.4 1234) #f) +(num-test (>= 1234/11 123.4 1234) #f) +(num-test (+ 1234/11 123.4 123.4) 358.98181818181820) +(num-test (- 1234/11 123.4 123.4) -134.61818181818182) +(num-test (* 1234/11 123.4 123.4) 1708255.36727272742428) +(num-test (/ 1234/11 123.4 123.4) 0.00736702519523) +(num-test (= 1234/11 123.4 123.4) #f) +(num-test (< 1234/11 123.4 123.4) #f) +(num-test (<= 1234/11 123.4 123.4) #t) +(num-test (> 1234/11 123.4 123.4) #f) +(num-test (>= 1234/11 123.4 123.4) #f) +(num-test (+ 1234/11 123.4 1234/11) 347.76363636363635) +(num-test (- 1234/11 123.4 1234/11) -123.4) +(num-test (* 1234/11 123.4 1234/11) 1552959.42479338846169) +(num-test (/ 1234/11 123.4 1234/11) 0.00810372771475) +(num-test (= 1234/11 123.4 1234/11) #f) +(num-test (< 1234/11 123.4 1234/11) #f) +(num-test (<= 1234/11 123.4 1234/11) #f) +(num-test (> 1234/11 123.4 1234/11) #f) +(num-test (>= 1234/11 123.4 1234/11) #f) +(num-test (+ 1234/11 123.4 1.234+1.234i) 236.81581818181820+1.234i) +(num-test (- 1234/11 123.4 1.234+1.234i) -12.45218181818182-1.234i) +(num-test (* 1234/11 123.4 1.234+1.234i) 17082.55367272727381+17082.55367272727381i) +(num-test (/ 1234/11 123.4 1.234+1.234i) 0.36835125976131-0.36835125976131i) +(num-test (= 1234/11 123.4 1.234+1.234i) #f) +(num-test (+ 1234/11 123.4 -1.0+1.0i) 234.58181818181819+1.0i) +(num-test (- 1234/11 123.4 -1.0+1.0i) -10.21818181818182-1.0i) +(num-test (* 1234/11 123.4 -1.0+1.0i) -13843.23636363636433+13843.23636363636433i) +(num-test (/ 1234/11 123.4 -1.0+1.0i) -0.45454545454545-0.45454545454545i) +(num-test (= 1234/11 123.4 -1.0+1.0i) #f) +(num-test (+ 1234/11 123.4 0.0+1.0i) 235.58181818181819+1.0i) +(num-test (- 1234/11 123.4 0.0+1.0i) -11.21818181818182-1.0i) +(num-test (* 1234/11 123.4 0.0+1.0i) 0.0+13843.23636363636433i) +(num-test (/ 1234/11 123.4 0.0+1.0i) 0.0-0.90909090909091i) +(num-test (= 1234/11 123.4 0.0+1.0i) #f) +(num-test (+ 1234/11 1234/11 1) 2479/11) +(num-test (- 1234/11 1234/11 1) -1) +(num-test (* 1234/11 1234/11 1) 1522756/121) +(num-test (/ 1234/11 1234/11 1) 1) +(num-test (= 1234/11 1234/11 1) #f) +(num-test (< 1234/11 1234/11 1) #f) +(num-test (<= 1234/11 1234/11 1) #f) +(num-test (> 1234/11 1234/11 1) #f) +(num-test (>= 1234/11 1234/11 1) #t) +(num-test (+ 1234/11 1234/11 1.0) 225.36363636363637) +(num-test (- 1234/11 1234/11 1.0) -1.0) +(num-test (* 1234/11 1234/11 1.0) 12584.76033057851237) +(num-test (/ 1234/11 1234/11 1.0) 1.0) +(num-test (= 1234/11 1234/11 1.0) #f) +(num-test (< 1234/11 1234/11 1.0) #f) +(num-test (<= 1234/11 1234/11 1.0) #f) +(num-test (> 1234/11 1234/11 1.0) #f) +(num-test (>= 1234/11 1234/11 1.0) #t) +(num-test (+ 1234/11 1234/11 1/1) 2479/11) +(num-test (- 1234/11 1234/11 1/1) -1) +(num-test (* 1234/11 1234/11 1/1) 1522756/121) +(num-test (/ 1234/11 1234/11 1/1) 1) +(num-test (= 1234/11 1234/11 1/1) #f) +(num-test (< 1234/11 1234/11 1/1) #f) +(num-test (<= 1234/11 1234/11 1/1) #f) +(num-test (> 1234/11 1234/11 1/1) #f) +(num-test (>= 1234/11 1234/11 1/1) #t) +(num-test (+ 1234/11 1234/11 1.0+1.0i) 225.36363636363637+1.0i) +(num-test (- 1234/11 1234/11 1.0+1.0i) -1.0-1.0i) +(num-test (* 1234/11 1234/11 1.0+1.0i) 12584.76033057851419+12584.76033057851419i) +(num-test (/ 1234/11 1234/11 1.0+1.0i) 0.5-0.5i) +(num-test (= 1234/11 1234/11 1.0+1.0i) #f) +(num-test (+ 1234/11 1234/11 0) 2468/11) +(num-test (- 1234/11 1234/11 0) 0) +(num-test (* 1234/11 1234/11 0) 0) +(num-test (+ 1234/11 1234/11 0.0) 224.36363636363637) +(num-test (- 1234/11 1234/11 0.0) 0.0) +(num-test (* 1234/11 1234/11 0.0) 0.0) +(num-test (+ 1234/11 1234/11 1234) 16042/11) +(num-test (- 1234/11 1234/11 1234) -1234) +(if (not with-64-bit-ints) + (num-test (* 1234/11 1234/11 1234) 15529594.2479339) + (num-test (* 1234/11 1234/11 1234) 1879080904/121)) +(num-test (/ 1234/11 1234/11 1234) 1/1234) +(num-test (= 1234/11 1234/11 1234) #f) +(num-test (< 1234/11 1234/11 1234) #f) +(num-test (<= 1234/11 1234/11 1234) #t) +(num-test (> 1234/11 1234/11 1234) #f) +(num-test (>= 1234/11 1234/11 1234) #f) +(num-test (+ 1234/11 1234/11 123.4) 347.76363636363635) +(num-test (- 1234/11 1234/11 123.4) -123.4) +(num-test (* 1234/11 1234/11 123.4) 1552959.42479338846169) +(num-test (/ 1234/11 1234/11 123.4) 0.00810372771475) +(num-test (= 1234/11 1234/11 123.4) #f) +(num-test (< 1234/11 1234/11 123.4) #f) +(num-test (<= 1234/11 1234/11 123.4) #t) +(num-test (> 1234/11 1234/11 123.4) #f) +(num-test (>= 1234/11 1234/11 123.4) #f) +(num-test (+ 1234/11 1234/11 1234/11) 3702/11) +(num-test (- 1234/11 1234/11 1234/11) -1234/11) +(if (not with-64-bit-ints) + (num-test (* 1234/11 1234/11 1234/11) 1411781.29526672) + (num-test (* 1234/11 1234/11 1234/11) 1879080904/1331)) +(num-test (/ 1234/11 1234/11 1234/11) 11/1234) +(num-test (= 1234/11 1234/11 1234/11) #t) +(num-test (< 1234/11 1234/11 1234/11) #f) +(num-test (<= 1234/11 1234/11 1234/11) #t) +(num-test (> 1234/11 1234/11 1234/11) #f) +(num-test (>= 1234/11 1234/11 1234/11) #t) +(num-test (+ 1234/11 1234/11 1.234+1.234i) 225.59763636363638+1.234i) +(num-test (- 1234/11 1234/11 1.234+1.234i) -1.23399999999999-1.234i) +(num-test (* 1234/11 1234/11 1.234+1.234i) 15529.59424793388644+15529.59424793388644i) +(num-test (/ 1234/11 1234/11 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1234/11 1234/11 1.234+1.234i) #f) +(num-test (+ 1234/11 1234/11 -1.0+1.0i) 223.36363636363637+1.0i) +(num-test (- 1234/11 1234/11 -1.0+1.0i) 1.00000000000001-1.0i) +(num-test (* 1234/11 1234/11 -1.0+1.0i) -12584.76033057851419+12584.76033057851419i) +(num-test (/ 1234/11 1234/11 -1.0+1.0i) -0.5-0.5i) +(num-test (= 1234/11 1234/11 -1.0+1.0i) #f) +(num-test (+ 1234/11 1234/11 0.0+1.0i) 224.36363636363637+1.0i) +(num-test (- 1234/11 1234/11 0.0+1.0i) 0.0-1.0i) +(num-test (* 1234/11 1234/11 0.0+1.0i) 0.0+12584.76033057851419i) +(num-test (/ 1234/11 1234/11 0.0+1.0i) 0.0-1.0i) +(num-test (= 1234/11 1234/11 0.0+1.0i) #f) +(num-test (+ 1234/11 1.234+1.234i 1) 114.41581818181818+1.234i) +(num-test (- 1234/11 1.234+1.234i 1) 109.94781818181819-1.234i) +(num-test (* 1234/11 1.234+1.234i 1) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1.234+1.234i 1) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1.234+1.234i 1) #f) +(num-test (+ 1234/11 1.234+1.234i 1.0) 114.41581818181818+1.234i) +(num-test (- 1234/11 1.234+1.234i 1.0) 109.94781818181819-1.234i) +(num-test (* 1234/11 1.234+1.234i 1.0) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1.234+1.234i 1.0) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1.234+1.234i 1.0) #f) +(num-test (+ 1234/11 1.234+1.234i 1/1) 114.41581818181818+1.234i) +(num-test (- 1234/11 1.234+1.234i 1/1) 109.94781818181819-1.234i) +(num-test (* 1234/11 1.234+1.234i 1/1) 138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1.234+1.234i 1/1) 45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1.234+1.234i 1/1) #f) +(num-test (+ 1234/11 1.234+1.234i 1.0+1.0i) 114.41581818181818+2.234i) +(num-test (- 1234/11 1.234+1.234i 1.0+1.0i) 109.94781818181819-2.234i) +(num-test (* 1234/11 1.234+1.234i 1.0+1.0i) 0.0+276.86472727272729i) +(num-test (/ 1234/11 1.234+1.234i 1.0+1.0i) 0.0-45.45454545454546i) +(num-test (= 1234/11 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1234/11 1.234+1.234i 0) 113.41581818181818+1.234i) +(num-test (- 1234/11 1.234+1.234i 0) 110.94781818181819-1.234i) +(num-test (* 1234/11 1.234+1.234i 0) 0.0) +(num-test (+ 1234/11 1.234+1.234i 0.0) 113.41581818181818+1.234i) +(num-test (- 1234/11 1.234+1.234i 0.0) 110.94781818181819-1.234i) +(num-test (* 1234/11 1.234+1.234i 0.0) 0.0) +(num-test (+ 1234/11 1.234+1.234i 1234) 1347.41581818181817+1.234i) +(num-test (- 1234/11 1.234+1.234i 1234) -1123.05218181818191-1.234i) +(num-test (* 1234/11 1.234+1.234i 1234) 170825.53672727273079+170825.53672727273079i) +(num-test (/ 1234/11 1.234+1.234i 1234) 0.03683512597613-0.03683512597613i) +(num-test (= 1234/11 1.234+1.234i 1234) #f) +(num-test (+ 1234/11 1.234+1.234i 123.4) 236.81581818181820+1.234i) +(num-test (- 1234/11 1.234+1.234i 123.4) -12.45218181818181-1.234i) +(num-test (* 1234/11 1.234+1.234i 123.4) 17082.55367272727381+17082.55367272727381i) +(num-test (/ 1234/11 1.234+1.234i 123.4) 0.36835125976131-0.36835125976131i) +(num-test (= 1234/11 1.234+1.234i 123.4) #f) +(num-test (+ 1234/11 1.234+1.234i 1234/11) 225.59763636363635+1.234i) +(num-test (- 1234/11 1.234+1.234i 1234/11) -1.23399999999999-1.234i) +(num-test (* 1234/11 1.234+1.234i 1234/11) 15529.59424793388644+15529.59424793388644i) +(num-test (/ 1234/11 1.234+1.234i 1234/11) 0.40518638573744-0.40518638573744i) +(num-test (= 1234/11 1.234+1.234i 1234/11) #f) +(num-test (+ 1234/11 1.234+1.234i 1.234+1.234i) 114.64981818181818+2.468i) +(num-test (- 1234/11 1.234+1.234i 1.234+1.234i) 109.71381818181820-2.468i) +(num-test (* 1234/11 1.234+1.234i 1.234+1.234i) 0.0+341.65107345454550i) +(num-test (/ 1234/11 1.234+1.234i 1.234+1.234i) 0.0-36.83512597613085i) +(num-test (= 1234/11 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 1234/11 1.234+1.234i -1.0+1.0i) 112.41581818181818+2.234i) +(num-test (- 1234/11 1.234+1.234i -1.0+1.0i) 111.94781818181819-2.234i) +(num-test (* 1234/11 1.234+1.234i -1.0+1.0i) -276.86472727272729) +(num-test (/ 1234/11 1.234+1.234i -1.0+1.0i) -45.45454545454546) +(num-test (= 1234/11 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1234/11 1.234+1.234i 0.0+1.0i) 113.41581818181818+2.234i) +(num-test (- 1234/11 1.234+1.234i 0.0+1.0i) 110.94781818181819-2.234i) +(num-test (* 1234/11 1.234+1.234i 0.0+1.0i) -138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 1.234+1.234i 0.0+1.0i) -45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1234/11 -1.0+1.0i 1) 112.18181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i 1) 112.18181818181819-1.0i) +(num-test (* 1234/11 -1.0+1.0i 1) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 -1.0+1.0i 1) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 -1.0+1.0i 1) #f) +(num-test (+ 1234/11 -1.0+1.0i 1.0) 112.18181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i 1.0) 112.18181818181819-1.0i) +(num-test (* 1234/11 -1.0+1.0i 1.0) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 -1.0+1.0i 1.0) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 -1.0+1.0i 1.0) #f) +(num-test (+ 1234/11 -1.0+1.0i 1/1) 112.18181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i 1/1) 112.18181818181819-1.0i) +(num-test (* 1234/11 -1.0+1.0i 1/1) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 -1.0+1.0i 1/1) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 -1.0+1.0i 1/1) #f) +(num-test (+ 1234/11 -1.0+1.0i 1.0+1.0i) 112.18181818181819+2.0i) +(num-test (- 1234/11 -1.0+1.0i 1.0+1.0i) 112.18181818181819-2.0i) +(num-test (* 1234/11 -1.0+1.0i 1.0+1.0i) -224.36363636363637) +(num-test (/ 1234/11 -1.0+1.0i 1.0+1.0i) -56.09090909090909) +(num-test (= 1234/11 -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1234/11 -1.0+1.0i 0) 111.18181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i 0) 113.18181818181819-1.0i) +(num-test (* 1234/11 -1.0+1.0i 0) -0.0) +(num-test (+ 1234/11 -1.0+1.0i 0.0) 111.18181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i 0.0) 113.18181818181819-1.0i) +(num-test (* 1234/11 -1.0+1.0i 0.0) -0.0) +(num-test (+ 1234/11 -1.0+1.0i 1234) 1345.18181818181824+1.0i) +(num-test (- 1234/11 -1.0+1.0i 1234) -1120.81818181818176-1.0i) +(num-test (* 1234/11 -1.0+1.0i 1234) -138432.36363636364695+138432.36363636364695i) +(num-test (/ 1234/11 -1.0+1.0i 1234) -0.04545454545455-0.04545454545455i) +(num-test (= 1234/11 -1.0+1.0i 1234) #f) +(num-test (+ 1234/11 -1.0+1.0i 123.4) 234.58181818181819+1.0i) +(num-test (- 1234/11 -1.0+1.0i 123.4) -10.21818181818182-1.0i) +(num-test (* 1234/11 -1.0+1.0i 123.4) -13843.23636363636433+13843.23636363636433i) +(num-test (/ 1234/11 -1.0+1.0i 123.4) -0.45454545454545-0.45454545454545i) +(num-test (= 1234/11 -1.0+1.0i 123.4) #f) +(num-test (+ 1234/11 -1.0+1.0i 1234/11) 223.36363636363637+1.0i) +(num-test (- 1234/11 -1.0+1.0i 1234/11) 1.00000000000001-1.0i) +(num-test (* 1234/11 -1.0+1.0i 1234/11) -12584.76033057851419+12584.76033057851419i) +(num-test (/ 1234/11 -1.0+1.0i 1234/11) -0.5-0.5i) +(num-test (= 1234/11 -1.0+1.0i 1234/11) #f) +(num-test (+ 1234/11 -1.0+1.0i 1.234+1.234i) 112.41581818181818+2.234i) +(num-test (- 1234/11 -1.0+1.0i 1.234+1.234i) 111.94781818181819-2.234i) +(num-test (* 1234/11 -1.0+1.0i 1.234+1.234i) -276.86472727272729) +(num-test (/ 1234/11 -1.0+1.0i 1.234+1.234i) -45.45454545454546) +(num-test (= 1234/11 -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1234/11 -1.0+1.0i -1.0+1.0i) 110.18181818181819+2.0i) +(num-test (- 1234/11 -1.0+1.0i -1.0+1.0i) 114.18181818181819-2.0i) +(num-test (* 1234/11 -1.0+1.0i -1.0+1.0i) 0.0-224.36363636363637i) +(num-test (/ 1234/11 -1.0+1.0i -1.0+1.0i) -0.0+56.09090909090909i) +(num-test (= 1234/11 -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1234/11 -1.0+1.0i 0.0+1.0i) 111.18181818181819+2.0i) +(num-test (- 1234/11 -1.0+1.0i 0.0+1.0i) 113.18181818181819-2.0i) +(num-test (* 1234/11 -1.0+1.0i 0.0+1.0i) -112.18181818181819-112.18181818181819i) +(num-test (/ 1234/11 -1.0+1.0i 0.0+1.0i) -56.09090909090909+56.09090909090909i) +(num-test (= 1234/11 -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1234/11 0.0+1.0i 1) 113.18181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i 1) 111.18181818181819-1.0i) +(num-test (* 1234/11 0.0+1.0i 1) 0.0+112.18181818181819i) +(num-test (/ 1234/11 0.0+1.0i 1) 0.0-112.18181818181819i) +(num-test (= 1234/11 0.0+1.0i 1) #f) +(num-test (+ 1234/11 0.0+1.0i 1.0) 113.18181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i 1.0) 111.18181818181819-1.0i) +(num-test (* 1234/11 0.0+1.0i 1.0) 0.0+112.18181818181819i) +(num-test (/ 1234/11 0.0+1.0i 1.0) 0.0-112.18181818181819i) +(num-test (= 1234/11 0.0+1.0i 1.0) #f) +(num-test (+ 1234/11 0.0+1.0i 1/1) 113.18181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i 1/1) 111.18181818181819-1.0i) +(num-test (* 1234/11 0.0+1.0i 1/1) 0.0+112.18181818181819i) +(num-test (/ 1234/11 0.0+1.0i 1/1) 0.0-112.18181818181819i) +(num-test (= 1234/11 0.0+1.0i 1/1) #f) +(num-test (+ 1234/11 0.0+1.0i 1.0+1.0i) 113.18181818181819+2.0i) +(num-test (- 1234/11 0.0+1.0i 1.0+1.0i) 111.18181818181819-2.0i) +(num-test (* 1234/11 0.0+1.0i 1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 1234/11 0.0+1.0i 1.0+1.0i) -56.09090909090909-56.09090909090909i) +(num-test (= 1234/11 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1234/11 0.0+1.0i 0) 112.18181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i 0) 112.18181818181819-1.0i) +(num-test (* 1234/11 0.0+1.0i 0) 0.0) +(num-test (+ 1234/11 0.0+1.0i 0.0) 112.18181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i 0.0) 112.18181818181819-1.0i) +(num-test (* 1234/11 0.0+1.0i 0.0) 0.0) +(num-test (+ 1234/11 0.0+1.0i 1234) 1346.18181818181824+1.0i) +(num-test (- 1234/11 0.0+1.0i 1234) -1121.81818181818176-1.0i) +(num-test (* 1234/11 0.0+1.0i 1234) 0.0+138432.36363636364695i) +(num-test (/ 1234/11 0.0+1.0i 1234) 0.0-0.09090909090909i) +(num-test (= 1234/11 0.0+1.0i 1234) #f) +(num-test (+ 1234/11 0.0+1.0i 123.4) 235.58181818181819+1.0i) +(num-test (- 1234/11 0.0+1.0i 123.4) -11.21818181818182-1.0i) +(num-test (* 1234/11 0.0+1.0i 123.4) 0.0+13843.23636363636433i) +(num-test (/ 1234/11 0.0+1.0i 123.4) 0.0-0.90909090909091i) +(num-test (= 1234/11 0.0+1.0i 123.4) #f) +(num-test (+ 1234/11 0.0+1.0i 1234/11) 224.36363636363637+1.0i) +(num-test (- 1234/11 0.0+1.0i 1234/11) 0.00000000000001-1.0i) +(num-test (* 1234/11 0.0+1.0i 1234/11) 0.0+12584.76033057851419i) +(num-test (/ 1234/11 0.0+1.0i 1234/11) 0.0-1.0i) +(num-test (= 1234/11 0.0+1.0i 1234/11) #f) +(num-test (+ 1234/11 0.0+1.0i 1.234+1.234i) 113.41581818181818+2.234i) +(num-test (- 1234/11 0.0+1.0i 1.234+1.234i) 110.94781818181819-2.234i) +(num-test (* 1234/11 0.0+1.0i 1.234+1.234i) -138.43236363636365+138.43236363636365i) +(num-test (/ 1234/11 0.0+1.0i 1.234+1.234i) -45.45454545454546-45.45454545454546i) +(num-test (= 1234/11 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1234/11 0.0+1.0i -1.0+1.0i) 111.18181818181819+2.0i) +(num-test (- 1234/11 0.0+1.0i -1.0+1.0i) 113.18181818181819-2.0i) +(num-test (* 1234/11 0.0+1.0i -1.0+1.0i) -112.18181818181819-112.18181818181819i) +(num-test (/ 1234/11 0.0+1.0i -1.0+1.0i) -56.09090909090909+56.09090909090909i) +(num-test (= 1234/11 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1234/11 0.0+1.0i 0.0+1.0i) 112.18181818181819+2.0i) +(num-test (- 1234/11 0.0+1.0i 0.0+1.0i) 112.18181818181819-2.0i) +(num-test (* 1234/11 0.0+1.0i 0.0+1.0i) -112.18181818181819) +(num-test (/ 1234/11 0.0+1.0i 0.0+1.0i) -112.18181818181819) +(num-test (= 1234/11 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1 1) 3.234+1.234i) +(num-test (- 1.234+1.234i 1 1) -0.766+1.234i) +(num-test (* 1.234+1.234i 1 1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1 1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1 1) #f) +(num-test (+ 1.234+1.234i 1 1.0) 3.234+1.234i) +(num-test (- 1.234+1.234i 1 1.0) -0.766+1.234i) +(num-test (* 1.234+1.234i 1 1.0) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1 1.0) 1.234+1.234i) +(num-test (= 1.234+1.234i 1 1.0) #f) +(num-test (+ 1.234+1.234i 1 1/1) 3.234+1.234i) +(num-test (- 1.234+1.234i 1 1/1) -0.766+1.234i) +(num-test (* 1.234+1.234i 1 1/1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1 1/1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1 1/1) #f) +(num-test (+ 1.234+1.234i 1 1.0+1.0i) 3.234+2.234i) +(num-test (- 1.234+1.234i 1 1.0+1.0i) -0.766+0.234i) +(num-test (* 1.234+1.234i 1 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1 1.0+1.0i) 1.234) +(num-test (= 1.234+1.234i 1 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1 0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1 0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1 0) 0.0) +(num-test (+ 1.234+1.234i 1 0.0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1 0.0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1 0.0) 0.0) +(num-test (+ 1.234+1.234i 1 1234) 1236.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1 1234) -1233.766+1.234i) +(num-test (* 1.234+1.234i 1 1234) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1 1234) 0.001+0.001i) +(num-test (= 1.234+1.234i 1 1234) #f) +(num-test (+ 1.234+1.234i 1 123.4) 125.634+1.234i) +(num-test (- 1.234+1.234i 1 123.4) -123.16600000000001+1.234i) +(num-test (* 1.234+1.234i 1 123.4) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 1 123.4) 0.01+0.01i) +(num-test (= 1.234+1.234i 1 123.4) #f) +(num-test (+ 1.234+1.234i 1 1234/11) 114.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1 1234/11) -111.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1 1234/11) 0.011+0.011i) +(num-test (= 1.234+1.234i 1 1234/11) #f) +(num-test (+ 1.234+1.234i 1 1.234+1.234i) 3.468+2.468i) +(num-test (- 1.234+1.234i 1 1.234+1.234i) -1.0) +(num-test (* 1.234+1.234i 1 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1 1.234+1.234i) 1.0) +(num-test (= 1.234+1.234i 1 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 1 -1.0+1.0i) 1.234+2.234i) +(num-test (- 1.234+1.234i 1 -1.0+1.0i) 1.234+0.234i) +(num-test (* 1.234+1.234i 1 -1.0+1.0i) -2.468) +(num-test (/ 1.234+1.234i 1 -1.0+1.0i) -0.0-1.234i) +(num-test (= 1.234+1.234i 1 -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1 0.0+1.0i) 2.234+2.234i) +(num-test (- 1.234+1.234i 1 0.0+1.0i) 0.234+0.234i) +(num-test (* 1.234+1.234i 1 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1.234+1.234i 1 0.0+1.0i) 1.234-1.234i) +(num-test (= 1.234+1.234i 1 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.0 1) 3.234+1.234i) +(num-test (- 1.234+1.234i 1.0 1) -0.766+1.234i) +(num-test (* 1.234+1.234i 1.0 1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1.0 1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1.0 1) #f) +(num-test (+ 1.234+1.234i 1.0 1.0) 3.234+1.234i) +(num-test (- 1.234+1.234i 1.0 1.0) -0.766+1.234i) +(num-test (* 1.234+1.234i 1.0 1.0) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1.0 1.0) 1.234+1.234i) +(num-test (= 1.234+1.234i 1.0 1.0) #f) +(num-test (+ 1.234+1.234i 1.0 1/1) 3.234+1.234i) +(num-test (- 1.234+1.234i 1.0 1/1) -0.766+1.234i) +(num-test (* 1.234+1.234i 1.0 1/1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1.0 1/1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1.0 1/1) #f) +(num-test (+ 1.234+1.234i 1.0 1.0+1.0i) 3.234+2.234i) +(num-test (- 1.234+1.234i 1.0 1.0+1.0i) -0.766+0.234i) +(num-test (* 1.234+1.234i 1.0 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1.0 1.0+1.0i) 1.234) +(num-test (= 1.234+1.234i 1.0 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.0 0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1.0 0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1.0 0) 0.0) +(num-test (+ 1.234+1.234i 1.0 0.0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1.0 0.0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1.0 0.0) 0.0) +(num-test (+ 1.234+1.234i 1.0 1234) 1236.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1.0 1234) -1233.766+1.234i) +(num-test (* 1.234+1.234i 1.0 1234) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1.0 1234) 0.001+0.001i) +(num-test (= 1.234+1.234i 1.0 1234) #f) +(num-test (+ 1.234+1.234i 1.0 123.4) 125.634+1.234i) +(num-test (- 1.234+1.234i 1.0 123.4) -123.16600000000001+1.234i) +(num-test (* 1.234+1.234i 1.0 123.4) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 1.0 123.4) 0.01+0.01i) +(num-test (= 1.234+1.234i 1.0 123.4) #f) +(num-test (+ 1.234+1.234i 1.0 1234/11) 114.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1.0 1234/11) -111.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1.0 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1.0 1234/11) 0.011+0.011i) +(num-test (= 1.234+1.234i 1.0 1234/11) #f) +(num-test (+ 1.234+1.234i 1.0 1.234+1.234i) 3.468+2.468i) +(num-test (- 1.234+1.234i 1.0 1.234+1.234i) -1.0) +(num-test (* 1.234+1.234i 1.0 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.0 1.234+1.234i) 1.0) +(num-test (= 1.234+1.234i 1.0 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 1.0 -1.0+1.0i) 1.234+2.234i) +(num-test (- 1.234+1.234i 1.0 -1.0+1.0i) 1.234+0.234i) +(num-test (* 1.234+1.234i 1.0 -1.0+1.0i) -2.468) +(num-test (/ 1.234+1.234i 1.0 -1.0+1.0i) -0.0-1.234i) +(num-test (= 1.234+1.234i 1.0 -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.0 0.0+1.0i) 2.234+2.234i) +(num-test (- 1.234+1.234i 1.0 0.0+1.0i) 0.234+0.234i) +(num-test (* 1.234+1.234i 1.0 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1.234+1.234i 1.0 0.0+1.0i) 1.234-1.234i) +(num-test (= 1.234+1.234i 1.0 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1/1 1) 3.234+1.234i) +(num-test (- 1.234+1.234i 1/1 1) -0.766+1.234i) +(num-test (* 1.234+1.234i 1/1 1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1/1 1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1/1 1) #f) +(num-test (+ 1.234+1.234i 1/1 1.0) 3.234+1.234i) +(num-test (- 1.234+1.234i 1/1 1.0) -0.766+1.234i) +(num-test (* 1.234+1.234i 1/1 1.0) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1/1 1.0) 1.234+1.234i) +(num-test (= 1.234+1.234i 1/1 1.0) #f) +(num-test (+ 1.234+1.234i 1/1 1/1) 3.234+1.234i) +(num-test (- 1.234+1.234i 1/1 1/1) -0.766+1.234i) +(num-test (* 1.234+1.234i 1/1 1/1) 1.234+1.234i) +(num-test (/ 1.234+1.234i 1/1 1/1) 1.234+1.234i) +(num-test (= 1.234+1.234i 1/1 1/1) #f) +(num-test (+ 1.234+1.234i 1/1 1.0+1.0i) 3.234+2.234i) +(num-test (- 1.234+1.234i 1/1 1.0+1.0i) -0.766+0.234i) +(num-test (* 1.234+1.234i 1/1 1.0+1.0i) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1/1 1.0+1.0i) 1.234) +(num-test (= 1.234+1.234i 1/1 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1/1 0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1/1 0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1/1 0) 0.0) +(num-test (+ 1.234+1.234i 1/1 0.0) 2.234+1.234i) +(num-test (- 1.234+1.234i 1/1 0.0) 0.234+1.234i) +(num-test (* 1.234+1.234i 1/1 0.0) 0.0) +(num-test (+ 1.234+1.234i 1/1 1234) 1236.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1/1 1234) -1233.766+1.234i) +(num-test (* 1.234+1.234i 1/1 1234) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1/1 1234) 0.001+0.001i) +(num-test (= 1.234+1.234i 1/1 1234) #f) +(num-test (+ 1.234+1.234i 1/1 123.4) 125.634+1.234i) +(num-test (- 1.234+1.234i 1/1 123.4) -123.16600000000001+1.234i) +(num-test (* 1.234+1.234i 1/1 123.4) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 1/1 123.4) 0.01+0.01i) +(num-test (= 1.234+1.234i 1/1 123.4) #f) +(num-test (+ 1.234+1.234i 1/1 1234/11) 114.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1/1 1234/11) -111.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1/1 1234/11) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1/1 1234/11) 0.011+0.011i) +(num-test (= 1.234+1.234i 1/1 1234/11) #f) +(num-test (+ 1.234+1.234i 1/1 1.234+1.234i) 3.468+2.468i) +(num-test (- 1.234+1.234i 1/1 1.234+1.234i) -1.0) +(num-test (* 1.234+1.234i 1/1 1.234+1.234i) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1/1 1.234+1.234i) 1.0) +(num-test (= 1.234+1.234i 1/1 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 1/1 -1.0+1.0i) 1.234+2.234i) +(num-test (- 1.234+1.234i 1/1 -1.0+1.0i) 1.234+0.234i) +(num-test (* 1.234+1.234i 1/1 -1.0+1.0i) -2.468) +(num-test (/ 1.234+1.234i 1/1 -1.0+1.0i) -0.0-1.234i) +(num-test (= 1.234+1.234i 1/1 -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1/1 0.0+1.0i) 2.234+2.234i) +(num-test (- 1.234+1.234i 1/1 0.0+1.0i) 0.234+0.234i) +(num-test (* 1.234+1.234i 1/1 0.0+1.0i) -1.234+1.234i) +(num-test (/ 1.234+1.234i 1/1 0.0+1.0i) 1.234-1.234i) +(num-test (= 1.234+1.234i 1/1 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 1) 3.234+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 1) -0.766+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 1) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1) 1.234) +(num-test (= 1.234+1.234i 1.0+1.0i 1) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 1.0) 3.234+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 1.0) -0.766+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 1.0) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1.0) 1.234) +(num-test (= 1.234+1.234i 1.0+1.0i 1.0) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 1/1) 3.234+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 1/1) -0.766+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 1/1) 0.0+2.468i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1/1) 1.234) +(num-test (= 1.234+1.234i 1.0+1.0i 1/1) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 1.0+1.0i) 3.234+3.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 1.0+1.0i) -0.766-0.766i) +(num-test (* 1.234+1.234i 1.0+1.0i 1.0+1.0i) -2.468+2.468i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1.0+1.0i) 0.617-0.617i) +(num-test (= 1.234+1.234i 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 0) 2.234+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 0) 0.234+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 0) 0.0) +(num-test (+ 1.234+1.234i 1.0+1.0i 0.0) 2.234+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 0.0) 0.234+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 0.0) 0.0) +(num-test (+ 1.234+1.234i 1.0+1.0i 1234) 1236.23399999999992+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 1234) -1233.766+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 1234) 0.0+3045.51200000000017i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1234) 0.001) +(num-test (= 1.234+1.234i 1.0+1.0i 1234) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 123.4) 125.634+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 123.4) -123.16600000000001+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 123.4) 0.0+304.55119999999999i) +(num-test (/ 1.234+1.234i 1.0+1.0i 123.4) 0.01) +(num-test (= 1.234+1.234i 1.0+1.0i 123.4) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 1234/11) 114.41581818181818+2.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 1234/11) -111.94781818181818+0.234i) +(num-test (* 1.234+1.234i 1.0+1.0i 1234/11) 0.0+276.86472727272729i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1234/11) 0.011) +(num-test (= 1.234+1.234i 1.0+1.0i 1234/11) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 1.234+1.234i) 3.468+3.468i) +(num-test (- 1.234+1.234i 1.0+1.0i 1.234+1.234i) -1.0-1.0i) +(num-test (* 1.234+1.234i 1.0+1.0i 1.234+1.234i) -3.04551200000000+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.0+1.0i 1.234+1.234i) 0.5-0.5i) +(num-test (= 1.234+1.234i 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i -1.0+1.0i) 1.234+3.234i) +(num-test (- 1.234+1.234i 1.0+1.0i -1.0+1.0i) 1.234-0.766i) +(num-test (* 1.234+1.234i 1.0+1.0i -1.0+1.0i) -2.468-2.468i) +(num-test (/ 1.234+1.234i 1.0+1.0i -1.0+1.0i) -0.617-0.617i) +(num-test (= 1.234+1.234i 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.0+1.0i 0.0+1.0i) 2.234+3.234i) +(num-test (- 1.234+1.234i 1.0+1.0i 0.0+1.0i) 0.234-0.766i) +(num-test (* 1.234+1.234i 1.0+1.0i 0.0+1.0i) -2.468) +(num-test (/ 1.234+1.234i 1.0+1.0i 0.0+1.0i) 0.0-1.234i) +(num-test (= 1.234+1.234i 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 0 1) 2.234+1.234i) +(num-test (- 1.234+1.234i 0 1) 0.234+1.234i) +(num-test (* 1.234+1.234i 0 1) 0.0) +(num-test (+ 1.234+1.234i 0 1.0) 2.234+1.234i) +(num-test (- 1.234+1.234i 0 1.0) 0.234+1.234i) +(num-test (* 1.234+1.234i 0 1.0) 0.0) +(num-test (+ 1.234+1.234i 0 1/1) 2.234+1.234i) +(num-test (- 1.234+1.234i 0 1/1) 0.234+1.234i) +(num-test (* 1.234+1.234i 0 1/1) 0.0) +(num-test (+ 1.234+1.234i 0 1.0+1.0i) 2.234+2.234i) +(num-test (- 1.234+1.234i 0 1.0+1.0i) 0.234+0.234i) +(num-test (* 1.234+1.234i 0 1.0+1.0i) 0.0) +(num-test (+ 1.234+1.234i 0 0) 1.234+1.234i) +(num-test (- 1.234+1.234i 0 0) 1.234+1.234i) +(num-test (* 1.234+1.234i 0 0) 0.0) +(num-test (+ 1.234+1.234i 0 0.0) 1.234+1.234i) +(num-test (- 1.234+1.234i 0 0.0) 1.234+1.234i) +(num-test (* 1.234+1.234i 0 0.0) 0.0) +(num-test (+ 1.234+1.234i 0 1234) 1235.23399999999992+1.234i) +(num-test (- 1.234+1.234i 0 1234) -1232.766+1.234i) +(num-test (* 1.234+1.234i 0 1234) 0.0) +(num-test (+ 1.234+1.234i 0 123.4) 124.634+1.234i) +(num-test (- 1.234+1.234i 0 123.4) -122.16600000000001+1.234i) +(num-test (* 1.234+1.234i 0 123.4) 0.0) +(num-test (+ 1.234+1.234i 0 1234/11) 113.41581818181818+1.234i) +(num-test (- 1.234+1.234i 0 1234/11) -110.94781818181818+1.234i) +(num-test (* 1.234+1.234i 0 1234/11) 0.0) +(num-test (+ 1.234+1.234i 0 1.234+1.234i) 2.468+2.468i) +(num-test (- 1.234+1.234i 0 1.234+1.234i) 0.0) +(num-test (* 1.234+1.234i 0 1.234+1.234i) 0.0) +(num-test (+ 1.234+1.234i 0 -1.0+1.0i) 0.234+2.234i) +(num-test (- 1.234+1.234i 0 -1.0+1.0i) 2.234+0.234i) +(num-test (* 1.234+1.234i 0 -1.0+1.0i) -0.0) +(num-test (+ 1.234+1.234i 0 0.0+1.0i) 1.234+2.234i) +(num-test (- 1.234+1.234i 0 0.0+1.0i) 1.234+0.234i) +(num-test (* 1.234+1.234i 0 0.0+1.0i) 0.0) +(num-test (+ 1.234+1.234i 0.0 1) 2.234+1.234i) +(num-test (- 1.234+1.234i 0.0 1) 0.234+1.234i) +(num-test (* 1.234+1.234i 0.0 1) 0.0) +(num-test (+ 1.234+1.234i 0.0 1.0) 2.234+1.234i) +(num-test (- 1.234+1.234i 0.0 1.0) 0.234+1.234i) +(num-test (* 1.234+1.234i 0.0 1.0) 0.0) +(num-test (+ 1.234+1.234i 0.0 1/1) 2.234+1.234i) +(num-test (- 1.234+1.234i 0.0 1/1) 0.234+1.234i) +(num-test (* 1.234+1.234i 0.0 1/1) 0.0) +(num-test (+ 1.234+1.234i 0.0 1.0+1.0i) 2.234+2.234i) +(num-test (- 1.234+1.234i 0.0 1.0+1.0i) 0.234+0.234i) +(num-test (* 1.234+1.234i 0.0 1.0+1.0i) 0.0) +(num-test (+ 1.234+1.234i 0.0 0) 1.234+1.234i) +(num-test (- 1.234+1.234i 0.0 0) 1.234+1.234i) +(num-test (* 1.234+1.234i 0.0 0) 0.0) +(num-test (+ 1.234+1.234i 0.0 0.0) 1.234+1.234i) +(num-test (- 1.234+1.234i 0.0 0.0) 1.234+1.234i) +(num-test (* 1.234+1.234i 0.0 0.0) 0.0) +(num-test (+ 1.234+1.234i 0.0 1234) 1235.23399999999992+1.234i) +(num-test (- 1.234+1.234i 0.0 1234) -1232.766+1.234i) +(num-test (* 1.234+1.234i 0.0 1234) 0.0) +(num-test (+ 1.234+1.234i 0.0 123.4) 124.634+1.234i) +(num-test (- 1.234+1.234i 0.0 123.4) -122.166+1.234i) +(num-test (* 1.234+1.234i 0.0 123.4) 0.0) +(num-test (+ 1.234+1.234i 0.0 1234/11) 113.41581818181818+1.234i) +(num-test (- 1.234+1.234i 0.0 1234/11) -110.94781818181818+1.234i) +(num-test (* 1.234+1.234i 0.0 1234/11) 0.0) +(num-test (+ 1.234+1.234i 0.0 1.234+1.234i) 2.468+2.468i) +(num-test (- 1.234+1.234i 0.0 1.234+1.234i) 0.0) +(num-test (* 1.234+1.234i 0.0 1.234+1.234i) 0.0) +(num-test (+ 1.234+1.234i 0.0 -1.0+1.0i) 0.234+2.234i) +(num-test (- 1.234+1.234i 0.0 -1.0+1.0i) 2.234+0.234i) +(num-test (* 1.234+1.234i 0.0 -1.0+1.0i) -0.0) +(num-test (+ 1.234+1.234i 0.0 0.0+1.0i) 1.234+2.234i) +(num-test (- 1.234+1.234i 0.0 0.0+1.0i) 1.234+0.234i) +(num-test (* 1.234+1.234i 0.0 0.0+1.0i) 0.0) +(num-test (+ 1.234+1.234i 1234 1) 1236.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234 1) -1233.766+1.234i) +(num-test (* 1.234+1.234i 1234 1) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1234 1) 0.001+0.001i) +(num-test (= 1.234+1.234i 1234 1) #f) +(num-test (+ 1.234+1.234i 1234 1.0) 1236.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234 1.0) -1233.766+1.234i) +(num-test (* 1.234+1.234i 1234 1.0) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1234 1.0) 0.001+0.001i) +(num-test (= 1.234+1.234i 1234 1.0) #f) +(num-test (+ 1.234+1.234i 1234 1/1) 1236.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234 1/1) -1233.766+1.234i) +(num-test (* 1.234+1.234i 1234 1/1) 1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1234 1/1) 0.001+0.001i) +(num-test (= 1.234+1.234i 1234 1/1) #f) +(num-test (+ 1.234+1.234i 1234 1.0+1.0i) 1236.23399999999992+2.234i) +(num-test (- 1.234+1.234i 1234 1.0+1.0i) -1233.766+0.234i) +(num-test (* 1.234+1.234i 1234 1.0+1.0i) 0.0+3045.51200000000017i) +(num-test (/ 1.234+1.234i 1234 1.0+1.0i) 0.001) +(num-test (= 1.234+1.234i 1234 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1234 0) 1235.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234 0) -1232.766+1.234i) +(num-test (* 1.234+1.234i 1234 0) 0.0) +(num-test (+ 1.234+1.234i 1234 0.0) 1235.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234 0.0) -1232.766+1.234i) +(num-test (* 1.234+1.234i 1234 0.0) 0.0) +(num-test (+ 1.234+1.234i 1234 1234) 2469.23399999999992+1.234i) +(num-test (- 1.234+1.234i 1234 1234) -2466.766+1.234i) +(num-test (* 1.234+1.234i 1234 1234) 1879080.90400000009686+1879080.90400000009686i) +(num-test (/ 1.234+1.234i 1234 1234) 0.00000081037277+0.00000081037277i) +(num-test (= 1.234+1.234i 1234 1234) #f) +(num-test (+ 1.234+1.234i 1234 123.4) 1358.63400000000001+1.234i) +(num-test (- 1.234+1.234i 1234 123.4) -1356.16600000000017+1.234i) +(num-test (* 1.234+1.234i 1234 123.4) 187908.09040000001551+187908.09040000001551i) +(num-test (/ 1.234+1.234i 1234 123.4) 0.00000810372771+0.00000810372771i) +(num-test (= 1.234+1.234i 1234 123.4) #f) +(num-test (+ 1.234+1.234i 1234 1234/11) 1347.41581818181817+1.234i) +(num-test (- 1.234+1.234i 1234 1234/11) -1344.94781818181832+1.234i) +(num-test (* 1.234+1.234i 1234 1234/11) 170825.53672727273079+170825.53672727273079i) +(num-test (/ 1.234+1.234i 1234 1234/11) 0.00000891410049+0.00000891410049i) +(num-test (= 1.234+1.234i 1234 1234/11) #f) +(num-test (+ 1.234+1.234i 1234 1.234+1.234i) 1236.46799999999985+2.468i) +(num-test (- 1.234+1.234i 1234 1.234+1.234i) -1234.0) +(num-test (* 1.234+1.234i 1234 1.234+1.234i) 0.0+3758.16180800000029i) +(num-test (/ 1.234+1.234i 1234 1.234+1.234i) 0.00081037277147) +(num-test (= 1.234+1.234i 1234 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 1234 -1.0+1.0i) 1234.23399999999992+2.234i) +(num-test (- 1.234+1.234i 1234 -1.0+1.0i) -1231.766+0.234i) +(num-test (* 1.234+1.234i 1234 -1.0+1.0i) -3045.51200000000017) +(num-test (/ 1.234+1.234i 1234 -1.0+1.0i) -0.0-0.001i) +(num-test (= 1.234+1.234i 1234 -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1234 0.0+1.0i) 1235.23399999999992+2.234i) +(num-test (- 1.234+1.234i 1234 0.0+1.0i) -1232.766+0.234i) +(num-test (* 1.234+1.234i 1234 0.0+1.0i) -1522.756+1522.756i) +(num-test (/ 1.234+1.234i 1234 0.0+1.0i) 0.001-0.001i) +(num-test (= 1.234+1.234i 1234 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 123.4 1) 125.634+1.234i) +(num-test (- 1.234+1.234i 123.4 1) -123.16600000000001+1.234i) +(num-test (* 1.234+1.234i 123.4 1) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 123.4 1) 0.01+0.01i) +(num-test (= 1.234+1.234i 123.4 1) #f) +(num-test (+ 1.234+1.234i 123.4 1.0) 125.634+1.234i) +(num-test (- 1.234+1.234i 123.4 1.0) -123.16600000000001+1.234i) +(num-test (* 1.234+1.234i 123.4 1.0) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 123.4 1.0) 0.01+0.01i) +(num-test (= 1.234+1.234i 123.4 1.0) #f) +(num-test (+ 1.234+1.234i 123.4 1/1) 125.634+1.234i) +(num-test (- 1.234+1.234i 123.4 1/1) -123.16600000000001+1.234i) +(num-test (* 1.234+1.234i 123.4 1/1) 152.2756+152.2756i) +(num-test (/ 1.234+1.234i 123.4 1/1) 0.01+0.01i) +(num-test (= 1.234+1.234i 123.4 1/1) #f) +(num-test (+ 1.234+1.234i 123.4 1.0+1.0i) 125.634+2.234i) +(num-test (- 1.234+1.234i 123.4 1.0+1.0i) -123.16600000000001+0.234i) +(num-test (* 1.234+1.234i 123.4 1.0+1.0i) 0.0+304.55119999999999i) +(num-test (/ 1.234+1.234i 123.4 1.0+1.0i) 0.01) +(num-test (= 1.234+1.234i 123.4 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 123.4 0) 124.634+1.234i) +(num-test (- 1.234+1.234i 123.4 0) -122.16600000000001+1.234i) +(num-test (* 1.234+1.234i 123.4 0) 0.0) +(num-test (+ 1.234+1.234i 123.4 0.0) 124.634+1.234i) +(num-test (- 1.234+1.234i 123.4 0.0) -122.16600000000001+1.234i) +(num-test (* 1.234+1.234i 123.4 0.0) 0.0) +(num-test (+ 1.234+1.234i 123.4 1234) 1358.63400000000001+1.234i) +(num-test (- 1.234+1.234i 123.4 1234) -1356.16599999999994+1.234i) +(num-test (* 1.234+1.234i 123.4 1234) 187908.09039999998640+187908.09039999998640i) +(num-test (/ 1.234+1.234i 123.4 1234) 0.00000810372771+0.00000810372771i) +(num-test (= 1.234+1.234i 123.4 1234) #f) +(num-test (+ 1.234+1.234i 123.4 123.4) 248.03399999999999+1.234i) +(num-test (- 1.234+1.234i 123.4 123.4) -245.56600000000003+1.234i) +(num-test (* 1.234+1.234i 123.4 123.4) 18790.80904000000010+18790.80904000000010i) +(num-test (/ 1.234+1.234i 123.4 123.4) 0.00008103727715+0.00008103727715i) +(num-test (= 1.234+1.234i 123.4 123.4) #f) +(num-test (+ 1.234+1.234i 123.4 1234/11) 236.81581818181817+1.234i) +(num-test (- 1.234+1.234i 123.4 1234/11) -234.34781818181818+1.234i) +(num-test (* 1.234+1.234i 123.4 1234/11) 17082.55367272727381+17082.55367272727381i) +(num-test (/ 1.234+1.234i 123.4 1234/11) 0.00008914100486+0.00008914100486i) +(num-test (= 1.234+1.234i 123.4 1234/11) #f) +(num-test (+ 1.234+1.234i 123.4 1.234+1.234i) 125.86799999999999+2.468i) +(num-test (- 1.234+1.234i 123.4 1.234+1.234i) -123.4) +(num-test (* 1.234+1.234i 123.4 1.234+1.234i) 0.0+375.81618079999998i) +(num-test (/ 1.234+1.234i 123.4 1.234+1.234i) 0.00810372771475) +(num-test (= 1.234+1.234i 123.4 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 123.4 -1.0+1.0i) 123.634+2.234i) +(num-test (- 1.234+1.234i 123.4 -1.0+1.0i) -121.16600000000001+0.234i) +(num-test (* 1.234+1.234i 123.4 -1.0+1.0i) -304.55119999999999) +(num-test (/ 1.234+1.234i 123.4 -1.0+1.0i) -0.0-0.01i) +(num-test (= 1.234+1.234i 123.4 -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 123.4 0.0+1.0i) 124.634+2.234i) +(num-test (- 1.234+1.234i 123.4 0.0+1.0i) -122.16600000000001+0.234i) +(num-test (* 1.234+1.234i 123.4 0.0+1.0i) -152.2756+152.2756i) +(num-test (/ 1.234+1.234i 123.4 0.0+1.0i) 0.01-0.01i) +(num-test (= 1.234+1.234i 123.4 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1234/11 1) 114.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1234/11 1) -111.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11 1) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1234/11 1) 0.011+0.011i) +(num-test (= 1.234+1.234i 1234/11 1) #f) +(num-test (+ 1.234+1.234i 1234/11 1.0) 114.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1234/11 1.0) -111.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11 1.0) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1234/11 1.0) 0.011+0.011i) +(num-test (= 1.234+1.234i 1234/11 1.0) #f) +(num-test (+ 1.234+1.234i 1234/11 1/1) 114.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1234/11 1/1) -111.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11 1/1) 138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1234/11 1/1) 0.011+0.011i) +(num-test (= 1.234+1.234i 1234/11 1/1) #f) +(num-test (+ 1.234+1.234i 1234/11 1.0+1.0i) 114.41581818181818+2.234i) +(num-test (- 1.234+1.234i 1234/11 1.0+1.0i) -111.94781818181818+0.234i) +(num-test (* 1.234+1.234i 1234/11 1.0+1.0i) 0.0+276.86472727272729i) +(num-test (/ 1.234+1.234i 1234/11 1.0+1.0i) 0.011) +(num-test (= 1.234+1.234i 1234/11 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1234/11 0) 113.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1234/11 0) -110.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11 0) 0.0) +(num-test (+ 1.234+1.234i 1234/11 0.0) 113.41581818181818+1.234i) +(num-test (- 1.234+1.234i 1234/11 0.0) -110.94781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11 0.0) 0.0) +(num-test (+ 1.234+1.234i 1234/11 1234) 1347.41581818181817+1.234i) +(num-test (- 1.234+1.234i 1234/11 1234) -1344.94781818181809+1.234i) +(num-test (* 1.234+1.234i 1234/11 1234) 170825.53672727273079+170825.53672727273079i) +(num-test (/ 1.234+1.234i 1234/11 1234) 0.00000891410049+0.00000891410049i) +(num-test (= 1.234+1.234i 1234/11 1234) #f) +(num-test (+ 1.234+1.234i 1234/11 123.4) 236.81581818181820+1.234i) +(num-test (- 1.234+1.234i 1234/11 123.4) -234.34781818181818+1.234i) +(num-test (* 1.234+1.234i 1234/11 123.4) 17082.55367272727381+17082.55367272727381i) +(num-test (/ 1.234+1.234i 1234/11 123.4) 0.00008914100486+0.00008914100486i) +(num-test (= 1.234+1.234i 1234/11 123.4) #f) +(num-test (+ 1.234+1.234i 1234/11 1234/11) 225.59763636363635+1.234i) +(num-test (- 1.234+1.234i 1234/11 1234/11) -223.12963636363637+1.234i) +(num-test (* 1.234+1.234i 1234/11 1234/11) 15529.59424793388644+15529.59424793388644i) +(num-test (/ 1.234+1.234i 1234/11 1234/11) 0.00009805510535+0.00009805510535i) +(num-test (= 1.234+1.234i 1234/11 1234/11) #f) +(num-test (+ 1.234+1.234i 1234/11 1.234+1.234i) 114.64981818181818+2.468i) +(num-test (- 1.234+1.234i 1234/11 1.234+1.234i) -112.18181818181817) +(num-test (* 1.234+1.234i 1234/11 1.234+1.234i) 0.0+341.65107345454550i) +(num-test (/ 1.234+1.234i 1234/11 1.234+1.234i) 0.00891410048622) +(num-test (= 1.234+1.234i 1234/11 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 1234/11 -1.0+1.0i) 112.41581818181818+2.234i) +(num-test (- 1.234+1.234i 1234/11 -1.0+1.0i) -109.94781818181818+0.234i) +(num-test (* 1.234+1.234i 1234/11 -1.0+1.0i) -276.86472727272729) +(num-test (/ 1.234+1.234i 1234/11 -1.0+1.0i) -0.0-0.011i) +(num-test (= 1.234+1.234i 1234/11 -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1234/11 0.0+1.0i) 113.41581818181818+2.234i) +(num-test (- 1.234+1.234i 1234/11 0.0+1.0i) -110.94781818181818+0.234i) +(num-test (* 1.234+1.234i 1234/11 0.0+1.0i) -138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 1234/11 0.0+1.0i) 0.011-0.011i) +(num-test (= 1.234+1.234i 1234/11 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 1) 3.468+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 1) -1.0) +(num-test (* 1.234+1.234i 1.234+1.234i 1) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1) 1.0) +(num-test (= 1.234+1.234i 1.234+1.234i 1) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 1.0) 3.468+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 1.0) -1.0) +(num-test (* 1.234+1.234i 1.234+1.234i 1.0) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1.0) 1.0) +(num-test (= 1.234+1.234i 1.234+1.234i 1.0) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 1/1) 3.468+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 1/1) -1.0) +(num-test (* 1.234+1.234i 1.234+1.234i 1/1) 0.0+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1/1) 1.0) +(num-test (= 1.234+1.234i 1.234+1.234i 1/1) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 1.0+1.0i) 3.468+3.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 1.0+1.0i) -1.0-1.0i) +(num-test (* 1.234+1.234i 1.234+1.234i 1.0+1.0i) -3.04551200000000+3.04551200000000i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1.0+1.0i) 0.5-0.5i) +(num-test (= 1.234+1.234i 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 0) 2.468+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 0) 0.0) +(num-test (* 1.234+1.234i 1.234+1.234i 0) 0.0) +(num-test (+ 1.234+1.234i 1.234+1.234i 0.0) 2.468+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 0.0) 0.0) +(num-test (* 1.234+1.234i 1.234+1.234i 0.0) 0.0) +(num-test (+ 1.234+1.234i 1.234+1.234i 1234) 1236.46800000000007+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 1234) -1234.0) +(num-test (* 1.234+1.234i 1.234+1.234i 1234) 0.0+3758.16180799999984i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1234) 0.00081037277147) +(num-test (= 1.234+1.234i 1.234+1.234i 1234) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 123.4) 125.86800000000001+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 123.4) -123.4) +(num-test (* 1.234+1.234i 1.234+1.234i 123.4) 0.0+375.81618080000004i) +(num-test (/ 1.234+1.234i 1.234+1.234i 123.4) 0.00810372771475) +(num-test (= 1.234+1.234i 1.234+1.234i 123.4) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 1234/11) 114.64981818181818+2.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 1234/11) -112.18181818181819) +(num-test (* 1.234+1.234i 1.234+1.234i 1234/11) 0.0+341.65107345454550i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1234/11) 0.00891410048622) +(num-test (= 1.234+1.234i 1.234+1.234i 1234/11) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 1.234+1.234i) 3.70200000000000+3.70200000000000i) +(num-test (- 1.234+1.234i 1.234+1.234i 1.234+1.234i) -1.234-1.234i) +(num-test (* 1.234+1.234i 1.234+1.234i 1.234+1.234i) -3.75816180800000+3.75816180800000i) +(num-test (/ 1.234+1.234i 1.234+1.234i 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 1.234+1.234i 1.234+1.234i 1.234+1.234i) #t) +(num-test (+ 1.234+1.234i 1.234+1.234i -1.0+1.0i) 1.468+3.468i) +(num-test (- 1.234+1.234i 1.234+1.234i -1.0+1.0i) 1.0-1.0i) +(num-test (* 1.234+1.234i 1.234+1.234i -1.0+1.0i) -3.04551200000000-3.04551200000000i) +(num-test (/ 1.234+1.234i 1.234+1.234i -1.0+1.0i) -0.5-0.5i) +(num-test (= 1.234+1.234i 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 1.234+1.234i 0.0+1.0i) 2.468+3.468i) +(num-test (- 1.234+1.234i 1.234+1.234i 0.0+1.0i) 0.0-1.0i) +(num-test (* 1.234+1.234i 1.234+1.234i 0.0+1.0i) -3.04551200000000) +(num-test (/ 1.234+1.234i 1.234+1.234i 0.0+1.0i) 0.0-1.0i) +(num-test (= 1.234+1.234i 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 1) 1.234+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 1) 1.234+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 1) -2.468) +(num-test (/ 1.234+1.234i -1.0+1.0i 1) -0.0-1.234i) +(num-test (= 1.234+1.234i -1.0+1.0i 1) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 1.0) 1.234+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 1.0) 1.234+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 1.0) -2.468) +(num-test (/ 1.234+1.234i -1.0+1.0i 1.0) -0.0-1.234i) +(num-test (= 1.234+1.234i -1.0+1.0i 1.0) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 1/1) 1.234+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 1/1) 1.234+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 1/1) -2.468) +(num-test (/ 1.234+1.234i -1.0+1.0i 1/1) -0.0-1.234i) +(num-test (= 1.234+1.234i -1.0+1.0i 1/1) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 1.0+1.0i) 1.234+3.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 1.0+1.0i) 1.234-0.766i) +(num-test (* 1.234+1.234i -1.0+1.0i 1.0+1.0i) -2.468-2.468i) +(num-test (/ 1.234+1.234i -1.0+1.0i 1.0+1.0i) -0.617-0.617i) +(num-test (= 1.234+1.234i -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 0) 0.234+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 0) 2.234+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 0) -0.0) +(num-test (+ 1.234+1.234i -1.0+1.0i 0.0) 0.234+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 0.0) 2.234+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 0.0) -0.0) +(num-test (+ 1.234+1.234i -1.0+1.0i 1234) 1234.23399999999992+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 1234) -1231.766+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 1234) -3045.51200000000017) +(num-test (/ 1.234+1.234i -1.0+1.0i 1234) -0.0-0.001i) +(num-test (= 1.234+1.234i -1.0+1.0i 1234) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 123.4) 123.634+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 123.4) -121.16600000000001+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 123.4) -304.55119999999999) +(num-test (/ 1.234+1.234i -1.0+1.0i 123.4) -0.0-0.01i) +(num-test (= 1.234+1.234i -1.0+1.0i 123.4) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 1234/11) 112.41581818181818+2.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 1234/11) -109.94781818181818+0.234i) +(num-test (* 1.234+1.234i -1.0+1.0i 1234/11) -276.86472727272729) +(num-test (/ 1.234+1.234i -1.0+1.0i 1234/11) -0.0-0.011i) +(num-test (= 1.234+1.234i -1.0+1.0i 1234/11) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 1.234+1.234i) 1.468+3.468i) +(num-test (- 1.234+1.234i -1.0+1.0i 1.234+1.234i) 1.0-1.0i) +(num-test (* 1.234+1.234i -1.0+1.0i 1.234+1.234i) -3.04551200000000-3.04551200000000i) +(num-test (/ 1.234+1.234i -1.0+1.0i 1.234+1.234i) -0.5-0.5i) +(num-test (= 1.234+1.234i -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i -1.0+1.0i) -0.766+3.234i) +(num-test (- 1.234+1.234i -1.0+1.0i -1.0+1.0i) 3.234-0.766i) +(num-test (* 1.234+1.234i -1.0+1.0i -1.0+1.0i) 2.468-2.468i) +(num-test (/ 1.234+1.234i -1.0+1.0i -1.0+1.0i) -0.617+0.617i) +(num-test (= 1.234+1.234i -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i -1.0+1.0i 0.0+1.0i) 0.234+3.234i) +(num-test (- 1.234+1.234i -1.0+1.0i 0.0+1.0i) 2.234-0.766i) +(num-test (* 1.234+1.234i -1.0+1.0i 0.0+1.0i) -0.0-2.468i) +(num-test (/ 1.234+1.234i -1.0+1.0i 0.0+1.0i) -1.234) +(num-test (= 1.234+1.234i -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 1) 2.234+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 1) 0.234+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 1) -1.234+1.234i) +(num-test (/ 1.234+1.234i 0.0+1.0i 1) 1.234-1.234i) +(num-test (= 1.234+1.234i 0.0+1.0i 1) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 1.0) 2.234+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 1.0) 0.234+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 1.0) -1.234+1.234i) +(num-test (/ 1.234+1.234i 0.0+1.0i 1.0) 1.234-1.234i) +(num-test (= 1.234+1.234i 0.0+1.0i 1.0) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 1/1) 2.234+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 1/1) 0.234+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 1/1) -1.234+1.234i) +(num-test (/ 1.234+1.234i 0.0+1.0i 1/1) 1.234-1.234i) +(num-test (= 1.234+1.234i 0.0+1.0i 1/1) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 1.0+1.0i) 2.234+3.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 1.0+1.0i) 0.234-0.766i) +(num-test (* 1.234+1.234i 0.0+1.0i 1.0+1.0i) -2.468) +(num-test (/ 1.234+1.234i 0.0+1.0i 1.0+1.0i) 0.0-1.234i) +(num-test (= 1.234+1.234i 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 0) 1.234+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 0) 1.234+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 0) -0.0) +(num-test (+ 1.234+1.234i 0.0+1.0i 0.0) 1.234+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 0.0) 1.234+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 0.0) -0.0) +(num-test (+ 1.234+1.234i 0.0+1.0i 1234) 1235.23399999999992+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 1234) -1232.766+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 1234) -1522.756+1522.756i) +(num-test (/ 1.234+1.234i 0.0+1.0i 1234) 0.001-0.001i) +(num-test (= 1.234+1.234i 0.0+1.0i 1234) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 123.4) 124.634+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 123.4) -122.16600000000001+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 123.4) -152.2756+152.2756i) +(num-test (/ 1.234+1.234i 0.0+1.0i 123.4) 0.01-0.01i) +(num-test (= 1.234+1.234i 0.0+1.0i 123.4) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 1234/11) 113.41581818181818+2.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 1234/11) -110.94781818181818+0.234i) +(num-test (* 1.234+1.234i 0.0+1.0i 1234/11) -138.43236363636365+138.43236363636365i) +(num-test (/ 1.234+1.234i 0.0+1.0i 1234/11) 0.011-0.011i) +(num-test (= 1.234+1.234i 0.0+1.0i 1234/11) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 1.234+1.234i) 2.468+3.468i) +(num-test (- 1.234+1.234i 0.0+1.0i 1.234+1.234i) 0.0-1.0i) +(num-test (* 1.234+1.234i 0.0+1.0i 1.234+1.234i) -3.04551200000000) +(num-test (/ 1.234+1.234i 0.0+1.0i 1.234+1.234i) 0.0-1.0i) +(num-test (= 1.234+1.234i 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i -1.0+1.0i) 0.234+3.234i) +(num-test (- 1.234+1.234i 0.0+1.0i -1.0+1.0i) 2.234-0.766i) +(num-test (* 1.234+1.234i 0.0+1.0i -1.0+1.0i) 0.0-2.468i) +(num-test (/ 1.234+1.234i 0.0+1.0i -1.0+1.0i) -1.234) +(num-test (= 1.234+1.234i 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 1.234+1.234i 0.0+1.0i 0.0+1.0i) 1.234+3.234i) +(num-test (- 1.234+1.234i 0.0+1.0i 0.0+1.0i) 1.234-0.766i) +(num-test (* 1.234+1.234i 0.0+1.0i 0.0+1.0i) -1.234-1.234i) +(num-test (/ 1.234+1.234i 0.0+1.0i 0.0+1.0i) -1.234-1.234i) +(num-test (= 1.234+1.234i 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1 1) 1.0+1.0i) +(num-test (- -1.0+1.0i 1 1) -3.0+1.0i) +(num-test (* -1.0+1.0i 1 1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1 1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1 1) #f) +(num-test (+ -1.0+1.0i 1 1.0) 1.0+1.0i) +(num-test (- -1.0+1.0i 1 1.0) -3.0+1.0i) +(num-test (* -1.0+1.0i 1 1.0) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1 1.0) -1.0+1.0i) +(num-test (= -1.0+1.0i 1 1.0) #f) +(num-test (+ -1.0+1.0i 1 1/1) 1.0+1.0i) +(num-test (- -1.0+1.0i 1 1/1) -3.0+1.0i) +(num-test (* -1.0+1.0i 1 1/1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1 1/1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1 1/1) #f) +(num-test (+ -1.0+1.0i 1 1.0+1.0i) 1.0+2.0i) +(num-test (- -1.0+1.0i 1 1.0+1.0i) -3.0) +(num-test (* -1.0+1.0i 1 1.0+1.0i) -2.0) +(num-test (/ -1.0+1.0i 1 1.0+1.0i) 0.0+1.0i) +(num-test (= -1.0+1.0i 1 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1 0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1 0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1 0) -0.0) +(num-test (+ -1.0+1.0i 1 0.0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1 0.0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1 0.0) -0.0) +(num-test (+ -1.0+1.0i 1 1234) 1234.0+1.0i) +(num-test (- -1.0+1.0i 1 1234) -1236.0+1.0i) +(num-test (* -1.0+1.0i 1 1234) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1 1234) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1 1234) #f) +(num-test (+ -1.0+1.0i 1 123.4) 123.4+1.0i) +(num-test (- -1.0+1.0i 1 123.4) -125.4+1.0i) +(num-test (* -1.0+1.0i 1 123.4) -123.4+123.4i) +(num-test (/ -1.0+1.0i 1 123.4) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 1 123.4) #f) +(num-test (+ -1.0+1.0i 1 1234/11) 112.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1 1234/11) -114.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1 1234/11) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1 1234/11) #f) +(num-test (+ -1.0+1.0i 1 1.234+1.234i) 1.234+2.234i) +(num-test (- -1.0+1.0i 1 1.234+1.234i) -3.234-0.234i) +(num-test (* -1.0+1.0i 1 1.234+1.234i) -2.468) +(num-test (/ -1.0+1.0i 1 1.234+1.234i) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1 -1.0+1.0i) -1.0+2.0i) +(num-test (- -1.0+1.0i 1 -1.0+1.0i) -1.0) +(num-test (* -1.0+1.0i 1 -1.0+1.0i) 0.0-2.0i) +(num-test (/ -1.0+1.0i 1 -1.0+1.0i) 1.0) +(num-test (= -1.0+1.0i 1 -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1 0.0+1.0i) 0.0+2.0i) +(num-test (- -1.0+1.0i 1 0.0+1.0i) -2.0) +(num-test (* -1.0+1.0i 1 0.0+1.0i) -1.0-1.0i) +(num-test (/ -1.0+1.0i 1 0.0+1.0i) 1.0+1.0i) +(num-test (= -1.0+1.0i 1 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.0 1) 1.0+1.0i) +(num-test (- -1.0+1.0i 1.0 1) -3.0+1.0i) +(num-test (* -1.0+1.0i 1.0 1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1.0 1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1.0 1) #f) +(num-test (+ -1.0+1.0i 1.0 1.0) 1.0+1.0i) +(num-test (- -1.0+1.0i 1.0 1.0) -3.0+1.0i) +(num-test (* -1.0+1.0i 1.0 1.0) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1.0 1.0) -1.0+1.0i) +(num-test (= -1.0+1.0i 1.0 1.0) #f) +(num-test (+ -1.0+1.0i 1.0 1/1) 1.0+1.0i) +(num-test (- -1.0+1.0i 1.0 1/1) -3.0+1.0i) +(num-test (* -1.0+1.0i 1.0 1/1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1.0 1/1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1.0 1/1) #f) +(num-test (+ -1.0+1.0i 1.0 1.0+1.0i) 1.0+2.0i) +(num-test (- -1.0+1.0i 1.0 1.0+1.0i) -3.0) +(num-test (* -1.0+1.0i 1.0 1.0+1.0i) -2.0) +(num-test (/ -1.0+1.0i 1.0 1.0+1.0i) 0.0+1.0i) +(num-test (= -1.0+1.0i 1.0 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.0 0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1.0 0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1.0 0) -0.0) +(num-test (+ -1.0+1.0i 1.0 0.0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1.0 0.0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1.0 0.0) -0.0) +(num-test (+ -1.0+1.0i 1.0 1234) 1234.0+1.0i) +(num-test (- -1.0+1.0i 1.0 1234) -1236.0+1.0i) +(num-test (* -1.0+1.0i 1.0 1234) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1.0 1234) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1.0 1234) #f) +(num-test (+ -1.0+1.0i 1.0 123.4) 123.4+1.0i) +(num-test (- -1.0+1.0i 1.0 123.4) -125.4+1.0i) +(num-test (* -1.0+1.0i 1.0 123.4) -123.4+123.4i) +(num-test (/ -1.0+1.0i 1.0 123.4) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 1.0 123.4) #f) +(num-test (+ -1.0+1.0i 1.0 1234/11) 112.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1.0 1234/11) -114.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1.0 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1.0 1234/11) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1.0 1234/11) #f) +(num-test (+ -1.0+1.0i 1.0 1.234+1.234i) 1.234+2.234i) +(num-test (- -1.0+1.0i 1.0 1.234+1.234i) -3.234-0.234i) +(num-test (* -1.0+1.0i 1.0 1.234+1.234i) -2.468) +(num-test (/ -1.0+1.0i 1.0 1.234+1.234i) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1.0 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1.0 -1.0+1.0i) -1.0+2.0i) +(num-test (- -1.0+1.0i 1.0 -1.0+1.0i) -1.0) +(num-test (* -1.0+1.0i 1.0 -1.0+1.0i) 0.0-2.0i) +(num-test (/ -1.0+1.0i 1.0 -1.0+1.0i) 1.0) +(num-test (= -1.0+1.0i 1.0 -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.0 0.0+1.0i) 0.0+2.0i) +(num-test (- -1.0+1.0i 1.0 0.0+1.0i) -2.0) +(num-test (* -1.0+1.0i 1.0 0.0+1.0i) -1.0-1.0i) +(num-test (/ -1.0+1.0i 1.0 0.0+1.0i) 1.0+1.0i) +(num-test (= -1.0+1.0i 1.0 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1/1 1) 1.0+1.0i) +(num-test (- -1.0+1.0i 1/1 1) -3.0+1.0i) +(num-test (* -1.0+1.0i 1/1 1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1/1 1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1/1 1) #f) +(num-test (+ -1.0+1.0i 1/1 1.0) 1.0+1.0i) +(num-test (- -1.0+1.0i 1/1 1.0) -3.0+1.0i) +(num-test (* -1.0+1.0i 1/1 1.0) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1/1 1.0) -1.0+1.0i) +(num-test (= -1.0+1.0i 1/1 1.0) #f) +(num-test (+ -1.0+1.0i 1/1 1/1) 1.0+1.0i) +(num-test (- -1.0+1.0i 1/1 1/1) -3.0+1.0i) +(num-test (* -1.0+1.0i 1/1 1/1) -1.0+1.0i) +(num-test (/ -1.0+1.0i 1/1 1/1) -1.0+1.0i) +(num-test (= -1.0+1.0i 1/1 1/1) #f) +(num-test (+ -1.0+1.0i 1/1 1.0+1.0i) 1.0+2.0i) +(num-test (- -1.0+1.0i 1/1 1.0+1.0i) -3.0) +(num-test (* -1.0+1.0i 1/1 1.0+1.0i) -2.0) +(num-test (/ -1.0+1.0i 1/1 1.0+1.0i) 0.0+1.0i) +(num-test (= -1.0+1.0i 1/1 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1/1 0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1/1 0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1/1 0) -0.0) +(num-test (+ -1.0+1.0i 1/1 0.0) 0.0+1.0i) +(num-test (- -1.0+1.0i 1/1 0.0) -2.0+1.0i) +(num-test (* -1.0+1.0i 1/1 0.0) -0.0) +(num-test (+ -1.0+1.0i 1/1 1234) 1234.0+1.0i) +(num-test (- -1.0+1.0i 1/1 1234) -1236.0+1.0i) +(num-test (* -1.0+1.0i 1/1 1234) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1/1 1234) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1/1 1234) #f) +(num-test (+ -1.0+1.0i 1/1 123.4) 123.4+1.0i) +(num-test (- -1.0+1.0i 1/1 123.4) -125.4+1.0i) +(num-test (* -1.0+1.0i 1/1 123.4) -123.4+123.4i) +(num-test (/ -1.0+1.0i 1/1 123.4) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 1/1 123.4) #f) +(num-test (+ -1.0+1.0i 1/1 1234/11) 112.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1/1 1234/11) -114.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1/1 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1/1 1234/11) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1/1 1234/11) #f) +(num-test (+ -1.0+1.0i 1/1 1.234+1.234i) 1.234+2.234i) +(num-test (- -1.0+1.0i 1/1 1.234+1.234i) -3.234-0.234i) +(num-test (* -1.0+1.0i 1/1 1.234+1.234i) -2.468) +(num-test (/ -1.0+1.0i 1/1 1.234+1.234i) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1/1 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1/1 -1.0+1.0i) -1.0+2.0i) +(num-test (- -1.0+1.0i 1/1 -1.0+1.0i) -1.0) +(num-test (* -1.0+1.0i 1/1 -1.0+1.0i) 0.0-2.0i) +(num-test (/ -1.0+1.0i 1/1 -1.0+1.0i) 1.0) +(num-test (= -1.0+1.0i 1/1 -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1/1 0.0+1.0i) 0.0+2.0i) +(num-test (- -1.0+1.0i 1/1 0.0+1.0i) -2.0) +(num-test (* -1.0+1.0i 1/1 0.0+1.0i) -1.0-1.0i) +(num-test (/ -1.0+1.0i 1/1 0.0+1.0i) 1.0+1.0i) +(num-test (= -1.0+1.0i 1/1 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 1) 1.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 1) -3.0) +(num-test (* -1.0+1.0i 1.0+1.0i 1) -2.0) +(num-test (/ -1.0+1.0i 1.0+1.0i 1) 0.0+1.0i) +(num-test (= -1.0+1.0i 1.0+1.0i 1) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 1.0) 1.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 1.0) -3.0) +(num-test (* -1.0+1.0i 1.0+1.0i 1.0) -2.0) +(num-test (/ -1.0+1.0i 1.0+1.0i 1.0) 0.0+1.0i) +(num-test (= -1.0+1.0i 1.0+1.0i 1.0) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 1/1) 1.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 1/1) -3.0) +(num-test (* -1.0+1.0i 1.0+1.0i 1/1) -2.0) +(num-test (/ -1.0+1.0i 1.0+1.0i 1/1) 0.0+1.0i) +(num-test (= -1.0+1.0i 1.0+1.0i 1/1) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 1.0+1.0i) 1.0+3.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 1.0+1.0i) -3.0-1.0i) +(num-test (* -1.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0-2.0i) +(num-test (/ -1.0+1.0i 1.0+1.0i 1.0+1.0i) 0.5+0.5i) +(num-test (= -1.0+1.0i 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 0) 0.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 0) -2.0) +(num-test (* -1.0+1.0i 1.0+1.0i 0) -0.0) +(num-test (+ -1.0+1.0i 1.0+1.0i 0.0) 0.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 0.0) -2.0) +(num-test (* -1.0+1.0i 1.0+1.0i 0.0) -0.0) +(num-test (+ -1.0+1.0i 1.0+1.0i 1234) 1234.0+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 1234) -1236.0) +(num-test (* -1.0+1.0i 1.0+1.0i 1234) -2468.0) +(num-test (/ -1.0+1.0i 1.0+1.0i 1234) 0.0+0.00081037277147i) +(num-test (= -1.0+1.0i 1.0+1.0i 1234) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 123.4) 123.4+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 123.4) -125.4) +(num-test (* -1.0+1.0i 1.0+1.0i 123.4) -246.8) +(num-test (/ -1.0+1.0i 1.0+1.0i 123.4) 0.0+0.00810372771475i) +(num-test (= -1.0+1.0i 1.0+1.0i 123.4) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 1234/11) 112.18181818181819+2.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 1234/11) -114.18181818181819) +(num-test (* -1.0+1.0i 1.0+1.0i 1234/11) -224.36363636363637) +(num-test (/ -1.0+1.0i 1.0+1.0i 1234/11) 0.0+0.00891410048622i) +(num-test (= -1.0+1.0i 1.0+1.0i 1234/11) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 1.234+1.234i) 1.234+3.234i) +(num-test (- -1.0+1.0i 1.0+1.0i 1.234+1.234i) -3.234-1.234i) +(num-test (* -1.0+1.0i 1.0+1.0i 1.234+1.234i) -2.468-2.468i) +(num-test (/ -1.0+1.0i 1.0+1.0i 1.234+1.234i) 0.40518638573744+0.40518638573744i) +(num-test (= -1.0+1.0i 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i -1.0+1.0i) -1.0+3.0i) +(num-test (- -1.0+1.0i 1.0+1.0i -1.0+1.0i) -1.0-1.0i) +(num-test (* -1.0+1.0i 1.0+1.0i -1.0+1.0i) 2.0-2.0i) +(num-test (/ -1.0+1.0i 1.0+1.0i -1.0+1.0i) 0.5-0.5i) +(num-test (= -1.0+1.0i 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.0+1.0i 0.0+1.0i) 0.0+3.0i) +(num-test (- -1.0+1.0i 1.0+1.0i 0.0+1.0i) -2.0-1.0i) +(num-test (* -1.0+1.0i 1.0+1.0i 0.0+1.0i) -0.0-2.0i) +(num-test (/ -1.0+1.0i 1.0+1.0i 0.0+1.0i) 1.0) +(num-test (= -1.0+1.0i 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 0 1) 0.0+1.0i) +(num-test (- -1.0+1.0i 0 1) -2.0+1.0i) +(num-test (* -1.0+1.0i 0 1) -0.0) +(num-test (+ -1.0+1.0i 0 1.0) 0.0+1.0i) +(num-test (- -1.0+1.0i 0 1.0) -2.0+1.0i) +(num-test (* -1.0+1.0i 0 1.0) -0.0) +(num-test (+ -1.0+1.0i 0 1/1) 0.0+1.0i) +(num-test (- -1.0+1.0i 0 1/1) -2.0+1.0i) +(num-test (* -1.0+1.0i 0 1/1) -0.0) +(num-test (+ -1.0+1.0i 0 1.0+1.0i) 0.0+2.0i) +(num-test (- -1.0+1.0i 0 1.0+1.0i) -2.0) +(num-test (* -1.0+1.0i 0 1.0+1.0i) -0.0) +(num-test (+ -1.0+1.0i 0 0) -1.0+1.0i) +(num-test (- -1.0+1.0i 0 0) -1.0+1.0i) +(num-test (* -1.0+1.0i 0 0) -0.0) +(num-test (+ -1.0+1.0i 0 0.0) -1.0+1.0i) +(num-test (- -1.0+1.0i 0 0.0) -1.0+1.0i) +(num-test (* -1.0+1.0i 0 0.0) -0.0) +(num-test (+ -1.0+1.0i 0 1234) 1233.0+1.0i) +(num-test (- -1.0+1.0i 0 1234) -1235.0+1.0i) +(num-test (* -1.0+1.0i 0 1234) -0.0) +(num-test (+ -1.0+1.0i 0 123.4) 122.4+1.0i) +(num-test (- -1.0+1.0i 0 123.4) -124.4+1.0i) +(num-test (* -1.0+1.0i 0 123.4) -0.0) +(num-test (+ -1.0+1.0i 0 1234/11) 111.18181818181819+1.0i) +(num-test (- -1.0+1.0i 0 1234/11) -113.18181818181819+1.0i) +(num-test (* -1.0+1.0i 0 1234/11) -0.0) +(num-test (+ -1.0+1.0i 0 1.234+1.234i) 0.234+2.234i) +(num-test (- -1.0+1.0i 0 1.234+1.234i) -2.234-0.234i) +(num-test (* -1.0+1.0i 0 1.234+1.234i) -0.0) +(num-test (+ -1.0+1.0i 0 -1.0+1.0i) -2.0+2.0i) +(num-test (- -1.0+1.0i 0 -1.0+1.0i) 0.0) +(num-test (* -1.0+1.0i 0 -1.0+1.0i) 0.0) +(num-test (+ -1.0+1.0i 0 0.0+1.0i) -1.0+2.0i) +(num-test (- -1.0+1.0i 0 0.0+1.0i) -1.0) +(num-test (* -1.0+1.0i 0 0.0+1.0i) -0.0) +(num-test (+ -1.0+1.0i 0.0 1) 0.0+1.0i) +(num-test (- -1.0+1.0i 0.0 1) -2.0+1.0i) +(num-test (* -1.0+1.0i 0.0 1) -0.0) +(num-test (+ -1.0+1.0i 0.0 1.0) 0.0+1.0i) +(num-test (- -1.0+1.0i 0.0 1.0) -2.0+1.0i) +(num-test (* -1.0+1.0i 0.0 1.0) -0.0) +(num-test (+ -1.0+1.0i 0.0 1/1) 0.0+1.0i) +(num-test (- -1.0+1.0i 0.0 1/1) -2.0+1.0i) +(num-test (* -1.0+1.0i 0.0 1/1) -0.0) +(num-test (+ -1.0+1.0i 0.0 1.0+1.0i) 0.0+2.0i) +(num-test (- -1.0+1.0i 0.0 1.0+1.0i) -2.0) +(num-test (* -1.0+1.0i 0.0 1.0+1.0i) -0.0) +(num-test (+ -1.0+1.0i 0.0 0) -1.0+1.0i) +(num-test (- -1.0+1.0i 0.0 0) -1.0+1.0i) +(num-test (* -1.0+1.0i 0.0 0) -0.0) +(num-test (+ -1.0+1.0i 0.0 0.0) -1.0+1.0i) +(num-test (- -1.0+1.0i 0.0 0.0) -1.0+1.0i) +(num-test (* -1.0+1.0i 0.0 0.0) -0.0) +(num-test (+ -1.0+1.0i 0.0 1234) 1233.0+1.0i) +(num-test (- -1.0+1.0i 0.0 1234) -1235.0+1.0i) +(num-test (* -1.0+1.0i 0.0 1234) -0.0) +(num-test (+ -1.0+1.0i 0.0 123.4) 122.4+1.0i) +(num-test (- -1.0+1.0i 0.0 123.4) -124.4+1.0i) +(num-test (* -1.0+1.0i 0.0 123.4) -0.0) +(num-test (+ -1.0+1.0i 0.0 1234/11) 111.18181818181819+1.0i) +(num-test (- -1.0+1.0i 0.0 1234/11) -113.18181818181819+1.0i) +(num-test (* -1.0+1.0i 0.0 1234/11) -0.0) +(num-test (+ -1.0+1.0i 0.0 1.234+1.234i) 0.234+2.234i) +(num-test (- -1.0+1.0i 0.0 1.234+1.234i) -2.234-0.234i) +(num-test (* -1.0+1.0i 0.0 1.234+1.234i) -0.0) +(num-test (+ -1.0+1.0i 0.0 -1.0+1.0i) -2.0+2.0i) +(num-test (- -1.0+1.0i 0.0 -1.0+1.0i) 0.0) +(num-test (* -1.0+1.0i 0.0 -1.0+1.0i) 0.0) +(num-test (+ -1.0+1.0i 0.0 0.0+1.0i) -1.0+2.0i) +(num-test (- -1.0+1.0i 0.0 0.0+1.0i) -1.0) +(num-test (* -1.0+1.0i 0.0 0.0+1.0i) -0.0) +(num-test (+ -1.0+1.0i 1234 1) 1234.0+1.0i) +(num-test (- -1.0+1.0i 1234 1) -1236.0+1.0i) +(num-test (* -1.0+1.0i 1234 1) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1234 1) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1234 1) #f) +(num-test (+ -1.0+1.0i 1234 1.0) 1234.0+1.0i) +(num-test (- -1.0+1.0i 1234 1.0) -1236.0+1.0i) +(num-test (* -1.0+1.0i 1234 1.0) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1234 1.0) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1234 1.0) #f) +(num-test (+ -1.0+1.0i 1234 1/1) 1234.0+1.0i) +(num-test (- -1.0+1.0i 1234 1/1) -1236.0+1.0i) +(num-test (* -1.0+1.0i 1234 1/1) -1234.0+1234.0i) +(num-test (/ -1.0+1.0i 1234 1/1) -0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1234 1/1) #f) +(num-test (+ -1.0+1.0i 1234 1.0+1.0i) 1234.0+2.0i) +(num-test (- -1.0+1.0i 1234 1.0+1.0i) -1236.0) +(num-test (* -1.0+1.0i 1234 1.0+1.0i) -2468.0) +(num-test (/ -1.0+1.0i 1234 1.0+1.0i) 0.0+0.00081037277147i) +(num-test (= -1.0+1.0i 1234 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1234 0) 1233.0+1.0i) +(num-test (- -1.0+1.0i 1234 0) -1235.0+1.0i) +(num-test (* -1.0+1.0i 1234 0) -0.0) +(num-test (+ -1.0+1.0i 1234 0.0) 1233.0+1.0i) +(num-test (- -1.0+1.0i 1234 0.0) -1235.0+1.0i) +(num-test (* -1.0+1.0i 1234 0.0) -0.0) +(num-test (+ -1.0+1.0i 1234 1234) 2467.0+1.0i) +(num-test (- -1.0+1.0i 1234 1234) -2469.0+1.0i) +(num-test (* -1.0+1.0i 1234 1234) -1522756.0+1522756.0i) +(num-test (/ -1.0+1.0i 1234 1234) -0.00000065670403+0.00000065670403i) +(num-test (= -1.0+1.0i 1234 1234) #f) +(num-test (+ -1.0+1.0i 1234 123.4) 1356.4+1.0i) +(num-test (- -1.0+1.0i 1234 123.4) -1358.4+1.0i) +(num-test (* -1.0+1.0i 1234 123.4) -152275.60000000000582+152275.60000000000582i) +(num-test (/ -1.0+1.0i 1234 123.4) -0.00000656704029+0.00000656704029i) +(num-test (= -1.0+1.0i 1234 123.4) #f) +(num-test (+ -1.0+1.0i 1234 1234/11) 1345.18181818181824+1.0i) +(num-test (- -1.0+1.0i 1234 1234/11) -1347.18181818181824+1.0i) +(num-test (* -1.0+1.0i 1234 1234/11) -138432.36363636364695+138432.36363636364695i) +(num-test (/ -1.0+1.0i 1234 1234/11) -0.00000722374432+0.00000722374432i) +(num-test (= -1.0+1.0i 1234 1234/11) #f) +(num-test (+ -1.0+1.0i 1234 1.234+1.234i) 1234.23399999999992+2.234i) +(num-test (- -1.0+1.0i 1234 1.234+1.234i) -1236.23399999999992-0.234i) +(num-test (* -1.0+1.0i 1234 1.234+1.234i) -3045.51200000000017) +(num-test (/ -1.0+1.0i 1234 1.234+1.234i) 0.0+0.00065670402875i) +(num-test (= -1.0+1.0i 1234 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1234 -1.0+1.0i) 1232.0+2.0i) +(num-test (- -1.0+1.0i 1234 -1.0+1.0i) -1234.0) +(num-test (* -1.0+1.0i 1234 -1.0+1.0i) 0.0-2468.0i) +(num-test (/ -1.0+1.0i 1234 -1.0+1.0i) 0.00081037277147) +(num-test (= -1.0+1.0i 1234 -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1234 0.0+1.0i) 1233.0+2.0i) +(num-test (- -1.0+1.0i 1234 0.0+1.0i) -1235.0) +(num-test (* -1.0+1.0i 1234 0.0+1.0i) -1234.0-1234.0i) +(num-test (/ -1.0+1.0i 1234 0.0+1.0i) 0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 1234 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 123.4 1) 123.4+1.0i) +(num-test (- -1.0+1.0i 123.4 1) -125.4+1.0i) +(num-test (* -1.0+1.0i 123.4 1) -123.4+123.4i) +(num-test (/ -1.0+1.0i 123.4 1) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 123.4 1) #f) +(num-test (+ -1.0+1.0i 123.4 1.0) 123.4+1.0i) +(num-test (- -1.0+1.0i 123.4 1.0) -125.4+1.0i) +(num-test (* -1.0+1.0i 123.4 1.0) -123.4+123.4i) +(num-test (/ -1.0+1.0i 123.4 1.0) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 123.4 1.0) #f) +(num-test (+ -1.0+1.0i 123.4 1/1) 123.4+1.0i) +(num-test (- -1.0+1.0i 123.4 1/1) -125.4+1.0i) +(num-test (* -1.0+1.0i 123.4 1/1) -123.4+123.4i) +(num-test (/ -1.0+1.0i 123.4 1/1) -0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 123.4 1/1) #f) +(num-test (+ -1.0+1.0i 123.4 1.0+1.0i) 123.4+2.0i) +(num-test (- -1.0+1.0i 123.4 1.0+1.0i) -125.4) +(num-test (* -1.0+1.0i 123.4 1.0+1.0i) -246.8) +(num-test (/ -1.0+1.0i 123.4 1.0+1.0i) 0.0+0.00810372771475i) +(num-test (= -1.0+1.0i 123.4 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 123.4 0) 122.4+1.0i) +(num-test (- -1.0+1.0i 123.4 0) -124.4+1.0i) +(num-test (* -1.0+1.0i 123.4 0) -0.0) +(num-test (+ -1.0+1.0i 123.4 0.0) 122.4+1.0i) +(num-test (- -1.0+1.0i 123.4 0.0) -124.4+1.0i) +(num-test (* -1.0+1.0i 123.4 0.0) -0.0) +(num-test (+ -1.0+1.0i 123.4 1234) 1356.4+1.0i) +(num-test (- -1.0+1.0i 123.4 1234) -1358.4+1.0i) +(num-test (* -1.0+1.0i 123.4 1234) -152275.60000000000582+152275.60000000000582i) +(num-test (/ -1.0+1.0i 123.4 1234) -0.00000656704029+0.00000656704029i) +(num-test (= -1.0+1.0i 123.4 1234) #f) +(num-test (+ -1.0+1.0i 123.4 123.4) 245.8+1.0i) +(num-test (- -1.0+1.0i 123.4 123.4) -247.8+1.0i) +(num-test (* -1.0+1.0i 123.4 123.4) -15227.56000000000131+15227.56000000000131i) +(num-test (/ -1.0+1.0i 123.4 123.4) -0.00006567040287+0.00006567040287i) +(num-test (= -1.0+1.0i 123.4 123.4) #f) +(num-test (+ -1.0+1.0i 123.4 1234/11) 234.58181818181819+1.0i) +(num-test (- -1.0+1.0i 123.4 1234/11) -236.58181818181819+1.0i) +(num-test (* -1.0+1.0i 123.4 1234/11) -13843.23636363636433+13843.23636363636433i) +(num-test (/ -1.0+1.0i 123.4 1234/11) -0.00007223744316+0.00007223744316i) +(num-test (= -1.0+1.0i 123.4 1234/11) #f) +(num-test (+ -1.0+1.0i 123.4 1.234+1.234i) 123.634+2.234i) +(num-test (- -1.0+1.0i 123.4 1.234+1.234i) -125.634-0.234i) +(num-test (* -1.0+1.0i 123.4 1.234+1.234i) -304.55119999999999) +(num-test (/ -1.0+1.0i 123.4 1.234+1.234i) 0.0+0.00656704028748i) +(num-test (= -1.0+1.0i 123.4 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 123.4 -1.0+1.0i) 121.4+2.0i) +(num-test (- -1.0+1.0i 123.4 -1.0+1.0i) -123.4) +(num-test (* -1.0+1.0i 123.4 -1.0+1.0i) 0.0-246.8i) +(num-test (/ -1.0+1.0i 123.4 -1.0+1.0i) 0.00810372771475) +(num-test (= -1.0+1.0i 123.4 -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 123.4 0.0+1.0i) 122.4+2.0i) +(num-test (- -1.0+1.0i 123.4 0.0+1.0i) -124.4) +(num-test (* -1.0+1.0i 123.4 0.0+1.0i) -123.4-123.4i) +(num-test (/ -1.0+1.0i 123.4 0.0+1.0i) 0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 123.4 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1234/11 1) 112.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11 1) -114.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11 1) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1234/11 1) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1234/11 1) #f) +(num-test (+ -1.0+1.0i 1234/11 1.0) 112.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11 1.0) -114.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11 1.0) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1234/11 1.0) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1234/11 1.0) #f) +(num-test (+ -1.0+1.0i 1234/11 1/1) 112.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11 1/1) -114.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11 1/1) -112.18181818181819+112.18181818181819i) +(num-test (/ -1.0+1.0i 1234/11 1/1) -0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1234/11 1/1) #f) +(num-test (+ -1.0+1.0i 1234/11 1.0+1.0i) 112.18181818181819+2.0i) +(num-test (- -1.0+1.0i 1234/11 1.0+1.0i) -114.18181818181819) +(num-test (* -1.0+1.0i 1234/11 1.0+1.0i) -224.36363636363637) +(num-test (/ -1.0+1.0i 1234/11 1.0+1.0i) 0.0+0.00891410048622i) +(num-test (= -1.0+1.0i 1234/11 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1234/11 0) 111.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11 0) -113.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11 0) -0.0) +(num-test (+ -1.0+1.0i 1234/11 0.0) 111.18181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11 0.0) -113.18181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11 0.0) -0.0) +(num-test (+ -1.0+1.0i 1234/11 1234) 1345.18181818181824+1.0i) +(num-test (- -1.0+1.0i 1234/11 1234) -1347.18181818181824+1.0i) +(num-test (* -1.0+1.0i 1234/11 1234) -138432.36363636364695+138432.36363636364695i) +(num-test (/ -1.0+1.0i 1234/11 1234) -0.00000722374432+0.00000722374432i) +(num-test (= -1.0+1.0i 1234/11 1234) #f) +(num-test (+ -1.0+1.0i 1234/11 123.4) 234.58181818181819+1.0i) +(num-test (- -1.0+1.0i 1234/11 123.4) -236.58181818181819+1.0i) +(num-test (* -1.0+1.0i 1234/11 123.4) -13843.23636363636433+13843.23636363636433i) +(num-test (/ -1.0+1.0i 1234/11 123.4) -0.00007223744316+0.00007223744316i) +(num-test (= -1.0+1.0i 1234/11 123.4) #f) +(num-test (+ -1.0+1.0i 1234/11 1234/11) 223.36363636363637+1.0i) +(num-test (- -1.0+1.0i 1234/11 1234/11) -225.36363636363637+1.0i) +(num-test (* -1.0+1.0i 1234/11 1234/11) -12584.76033057851419+12584.76033057851419i) +(num-test (/ -1.0+1.0i 1234/11 1234/11) -0.00007946118748+0.00007946118748i) +(num-test (= -1.0+1.0i 1234/11 1234/11) #f) +(num-test (+ -1.0+1.0i 1234/11 1.234+1.234i) 112.41581818181818+2.234i) +(num-test (- -1.0+1.0i 1234/11 1.234+1.234i) -114.41581818181818-0.234i) +(num-test (* -1.0+1.0i 1234/11 1.234+1.234i) -276.86472727272729) +(num-test (/ -1.0+1.0i 1234/11 1.234+1.234i) 0.0+0.00722374431623i) +(num-test (= -1.0+1.0i 1234/11 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1234/11 -1.0+1.0i) 110.18181818181819+2.0i) +(num-test (- -1.0+1.0i 1234/11 -1.0+1.0i) -112.18181818181819) +(num-test (* -1.0+1.0i 1234/11 -1.0+1.0i) 0.0-224.36363636363637i) +(num-test (/ -1.0+1.0i 1234/11 -1.0+1.0i) 0.00891410048622) +(num-test (= -1.0+1.0i 1234/11 -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1234/11 0.0+1.0i) 111.18181818181819+2.0i) +(num-test (- -1.0+1.0i 1234/11 0.0+1.0i) -113.18181818181819) +(num-test (* -1.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819-112.18181818181819i) +(num-test (/ -1.0+1.0i 1234/11 0.0+1.0i) 0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 1234/11 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 1) 1.234+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 1) -3.234-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 1) -2.468) +(num-test (/ -1.0+1.0i 1.234+1.234i 1) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1.234+1.234i 1) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 1.0) 1.234+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 1.0) -3.234-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 1.0) -2.468) +(num-test (/ -1.0+1.0i 1.234+1.234i 1.0) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1.234+1.234i 1.0) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 1/1) 1.234+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 1/1) -3.234-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 1/1) -2.468) +(num-test (/ -1.0+1.0i 1.234+1.234i 1/1) 0.0+0.81037277147488i) +(num-test (= -1.0+1.0i 1.234+1.234i 1/1) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 1.0+1.0i) 1.234+3.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 1.0+1.0i) -3.234-1.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 1.0+1.0i) -2.468-2.468i) +(num-test (/ -1.0+1.0i 1.234+1.234i 1.0+1.0i) 0.40518638573744+0.40518638573744i) +(num-test (= -1.0+1.0i 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 0) 0.234+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 0) -2.234-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 0) -0.0) +(num-test (+ -1.0+1.0i 1.234+1.234i 0.0) 0.234+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 0.0) -2.234-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 0.0) -0.0) +(num-test (+ -1.0+1.0i 1.234+1.234i 1234) 1234.23399999999992+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 1234) -1236.23399999999992-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 1234) -3045.51200000000017) +(num-test (/ -1.0+1.0i 1.234+1.234i 1234) 0.0+0.00065670402875i) +(num-test (= -1.0+1.0i 1.234+1.234i 1234) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 123.4) 123.634+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 123.4) -125.634-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 123.4) -304.55119999999999) +(num-test (/ -1.0+1.0i 1.234+1.234i 123.4) 0.0+0.00656704028748i) +(num-test (= -1.0+1.0i 1.234+1.234i 123.4) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 1234/11) 112.41581818181818+2.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 1234/11) -114.41581818181818-0.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 1234/11) -276.86472727272729) +(num-test (/ -1.0+1.0i 1.234+1.234i 1234/11) 0.0+0.00722374431623i) +(num-test (= -1.0+1.0i 1.234+1.234i 1234/11) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 1.234+1.234i) 1.468+3.468i) +(num-test (- -1.0+1.0i 1.234+1.234i 1.234+1.234i) -3.468-1.468i) +(num-test (* -1.0+1.0i 1.234+1.234i 1.234+1.234i) -3.04551200000000-3.04551200000000i) +(num-test (/ -1.0+1.0i 1.234+1.234i 1.234+1.234i) 0.32835201437394+0.32835201437394i) +(num-test (= -1.0+1.0i 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i -1.0+1.0i) -0.766+3.234i) +(num-test (- -1.0+1.0i 1.234+1.234i -1.0+1.0i) -1.234-1.234i) +(num-test (* -1.0+1.0i 1.234+1.234i -1.0+1.0i) 2.468-2.468i) +(num-test (/ -1.0+1.0i 1.234+1.234i -1.0+1.0i) 0.40518638573744-0.40518638573744i) +(num-test (= -1.0+1.0i 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 1.234+1.234i 0.0+1.0i) 0.234+3.234i) +(num-test (- -1.0+1.0i 1.234+1.234i 0.0+1.0i) -2.234-1.234i) +(num-test (* -1.0+1.0i 1.234+1.234i 0.0+1.0i) -0.0-2.468i) +(num-test (/ -1.0+1.0i 1.234+1.234i 0.0+1.0i) 0.81037277147488) +(num-test (= -1.0+1.0i 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 1) -1.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 1) -1.0) +(num-test (* -1.0+1.0i -1.0+1.0i 1) 0.0-2.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1) 1.0) +(num-test (= -1.0+1.0i -1.0+1.0i 1) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 1.0) -1.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 1.0) -1.0) +(num-test (* -1.0+1.0i -1.0+1.0i 1.0) 0.0-2.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1.0) 1.0) +(num-test (= -1.0+1.0i -1.0+1.0i 1.0) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 1/1) -1.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 1/1) -1.0) +(num-test (* -1.0+1.0i -1.0+1.0i 1/1) 0.0-2.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1/1) 1.0) +(num-test (= -1.0+1.0i -1.0+1.0i 1/1) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 1.0+1.0i) -1.0+3.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 1.0+1.0i) -1.0-1.0i) +(num-test (* -1.0+1.0i -1.0+1.0i 1.0+1.0i) 2.0-2.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1.0+1.0i) 0.5-0.5i) +(num-test (= -1.0+1.0i -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 0) -2.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 0) 0.0) +(num-test (* -1.0+1.0i -1.0+1.0i 0) 0.0) +(num-test (+ -1.0+1.0i -1.0+1.0i 0.0) -2.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 0.0) 0.0) +(num-test (* -1.0+1.0i -1.0+1.0i 0.0) 0.0) +(num-test (+ -1.0+1.0i -1.0+1.0i 1234) 1232.0+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 1234) -1234.0) +(num-test (* -1.0+1.0i -1.0+1.0i 1234) 0.0-2468.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1234) 0.00081037277147) +(num-test (= -1.0+1.0i -1.0+1.0i 1234) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 123.4) 121.4+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 123.4) -123.4) +(num-test (* -1.0+1.0i -1.0+1.0i 123.4) 0.0-246.8i) +(num-test (/ -1.0+1.0i -1.0+1.0i 123.4) 0.00810372771475) +(num-test (= -1.0+1.0i -1.0+1.0i 123.4) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 1234/11) 110.18181818181819+2.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 1234/11) -112.18181818181819) +(num-test (* -1.0+1.0i -1.0+1.0i 1234/11) 0.0-224.36363636363637i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1234/11) 0.00891410048622) +(num-test (= -1.0+1.0i -1.0+1.0i 1234/11) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i 1.234+1.234i) -0.766+3.234i) +(num-test (- -1.0+1.0i -1.0+1.0i 1.234+1.234i) -1.234-1.234i) +(num-test (* -1.0+1.0i -1.0+1.0i 1.234+1.234i) 2.468-2.468i) +(num-test (/ -1.0+1.0i -1.0+1.0i 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= -1.0+1.0i -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i -1.0+1.0i -1.0+1.0i) -3.0+3.0i) +(num-test (- -1.0+1.0i -1.0+1.0i -1.0+1.0i) 1.0-1.0i) +(num-test (* -1.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0+2.0i) +(num-test (/ -1.0+1.0i -1.0+1.0i -1.0+1.0i) -0.5-0.5i) +(num-test (= -1.0+1.0i -1.0+1.0i -1.0+1.0i) #t) +(num-test (+ -1.0+1.0i -1.0+1.0i 0.0+1.0i) -2.0+3.0i) +(num-test (- -1.0+1.0i -1.0+1.0i 0.0+1.0i) 0.0-1.0i) +(num-test (* -1.0+1.0i -1.0+1.0i 0.0+1.0i) 2.0) +(num-test (/ -1.0+1.0i -1.0+1.0i 0.0+1.0i) 0.0-1.0i) +(num-test (= -1.0+1.0i -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 1) 0.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 1) -2.0) +(num-test (* -1.0+1.0i 0.0+1.0i 1) -1.0-1.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1) 1.0+1.0i) +(num-test (= -1.0+1.0i 0.0+1.0i 1) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 1.0) 0.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 1.0) -2.0) +(num-test (* -1.0+1.0i 0.0+1.0i 1.0) -1.0-1.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1.0) 1.0+1.0i) +(num-test (= -1.0+1.0i 0.0+1.0i 1.0) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 1/1) 0.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 1/1) -2.0) +(num-test (* -1.0+1.0i 0.0+1.0i 1/1) -1.0-1.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1/1) 1.0+1.0i) +(num-test (= -1.0+1.0i 0.0+1.0i 1/1) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0+3.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 1.0+1.0i) -2.0-1.0i) +(num-test (* -1.0+1.0i 0.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1.0+1.0i) 1.0) +(num-test (= -1.0+1.0i 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 0) -1.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 0) -1.0) +(num-test (* -1.0+1.0i 0.0+1.0i 0) 0.0) +(num-test (+ -1.0+1.0i 0.0+1.0i 0.0) -1.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 0.0) -1.0) +(num-test (* -1.0+1.0i 0.0+1.0i 0.0) 0.0) +(num-test (+ -1.0+1.0i 0.0+1.0i 1234) 1233.0+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 1234) -1235.0) +(num-test (* -1.0+1.0i 0.0+1.0i 1234) -1234.0-1234.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1234) 0.00081037277147+0.00081037277147i) +(num-test (= -1.0+1.0i 0.0+1.0i 1234) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 123.4) 122.4+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 123.4) -124.4) +(num-test (* -1.0+1.0i 0.0+1.0i 123.4) -123.4-123.4i) +(num-test (/ -1.0+1.0i 0.0+1.0i 123.4) 0.00810372771475+0.00810372771475i) +(num-test (= -1.0+1.0i 0.0+1.0i 123.4) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 1234/11) 111.18181818181819+2.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 1234/11) -113.18181818181819) +(num-test (* -1.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819-112.18181818181819i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1234/11) 0.00891410048622+0.00891410048622i) +(num-test (= -1.0+1.0i 0.0+1.0i 1234/11) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.234+3.234i) +(num-test (- -1.0+1.0i 0.0+1.0i 1.234+1.234i) -2.234-1.234i) +(num-test (* -1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.0-2.468i) +(num-test (/ -1.0+1.0i 0.0+1.0i 1.234+1.234i) 0.81037277147488) +(num-test (= -1.0+1.0i 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i -1.0+1.0i) -2.0+3.0i) +(num-test (- -1.0+1.0i 0.0+1.0i -1.0+1.0i) 0.0-1.0i) +(num-test (* -1.0+1.0i 0.0+1.0i -1.0+1.0i) 2.0) +(num-test (/ -1.0+1.0i 0.0+1.0i -1.0+1.0i) -0.0-1.0i) +(num-test (= -1.0+1.0i 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ -1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0+3.0i) +(num-test (- -1.0+1.0i 0.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (* -1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0-1.0i) +(num-test (/ -1.0+1.0i 0.0+1.0i 0.0+1.0i) 1.0-1.0i) +(num-test (= -1.0+1.0i 0.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1 1) 2.0+1.0i) +(num-test (- 0.0+1.0i 1 1) -2.0+1.0i) +(num-test (* 0.0+1.0i 1 1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1 1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1 1) #f) +(num-test (+ 0.0+1.0i 1 1.0) 2.0+1.0i) +(num-test (- 0.0+1.0i 1 1.0) -2.0+1.0i) +(num-test (* 0.0+1.0i 1 1.0) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1 1.0) 0.0+1.0i) +(num-test (= 0.0+1.0i 1 1.0) #f) +(num-test (+ 0.0+1.0i 1 1/1) 2.0+1.0i) +(num-test (- 0.0+1.0i 1 1/1) -2.0+1.0i) +(num-test (* 0.0+1.0i 1 1/1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1 1/1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1 1/1) #f) +(num-test (+ 0.0+1.0i 1 1.0+1.0i) 2.0+2.0i) +(num-test (- 0.0+1.0i 1 1.0+1.0i) -2.0) +(num-test (* 0.0+1.0i 1 1.0+1.0i) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1 1.0+1.0i) 0.5+0.5i) +(num-test (= 0.0+1.0i 1 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1 0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1 0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1 0) 0.0) +(num-test (+ 0.0+1.0i 1 0.0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1 0.0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1 0.0) 0.0) +(num-test (+ 0.0+1.0i 1 1234) 1235.0+1.0i) +(num-test (- 0.0+1.0i 1 1234) -1235.0+1.0i) +(num-test (* 0.0+1.0i 1 1234) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1 1234) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1 1234) #f) +(num-test (+ 0.0+1.0i 1 123.4) 124.4+1.0i) +(num-test (- 0.0+1.0i 1 123.4) -124.4+1.0i) +(num-test (* 0.0+1.0i 1 123.4) 0.0+123.4i) +(num-test (/ 0.0+1.0i 1 123.4) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 1 123.4) #f) +(num-test (+ 0.0+1.0i 1 1234/11) 113.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1 1234/11) -113.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1 1234/11) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1 1234/11) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1 1234/11) #f) +(num-test (+ 0.0+1.0i 1 1.234+1.234i) 2.234+2.234i) +(num-test (- 0.0+1.0i 1 1.234+1.234i) -2.234-0.234i) +(num-test (* 0.0+1.0i 1 1.234+1.234i) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1 1.234+1.234i) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1 -1.0+1.0i) 0.0+2.0i) +(num-test (- 0.0+1.0i 1 -1.0+1.0i) 0.0) +(num-test (* 0.0+1.0i 1 -1.0+1.0i) -1.0-1.0i) +(num-test (/ 0.0+1.0i 1 -1.0+1.0i) 0.5-0.5i) +(num-test (= 0.0+1.0i 1 -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1 0.0+1.0i) 1.0+2.0i) +(num-test (- 0.0+1.0i 1 0.0+1.0i) -1.0) +(num-test (* 0.0+1.0i 1 0.0+1.0i) -1.0) +(num-test (/ 0.0+1.0i 1 0.0+1.0i) 1.0) +(num-test (= 0.0+1.0i 1 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.0 1) 2.0+1.0i) +(num-test (- 0.0+1.0i 1.0 1) -2.0+1.0i) +(num-test (* 0.0+1.0i 1.0 1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1.0 1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1.0 1) #f) +(num-test (+ 0.0+1.0i 1.0 1.0) 2.0+1.0i) +(num-test (- 0.0+1.0i 1.0 1.0) -2.0+1.0i) +(num-test (* 0.0+1.0i 1.0 1.0) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1.0 1.0) 0.0+1.0i) +(num-test (= 0.0+1.0i 1.0 1.0) #f) +(num-test (+ 0.0+1.0i 1.0 1/1) 2.0+1.0i) +(num-test (- 0.0+1.0i 1.0 1/1) -2.0+1.0i) +(num-test (* 0.0+1.0i 1.0 1/1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1.0 1/1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1.0 1/1) #f) +(num-test (+ 0.0+1.0i 1.0 1.0+1.0i) 2.0+2.0i) +(num-test (- 0.0+1.0i 1.0 1.0+1.0i) -2.0) +(num-test (* 0.0+1.0i 1.0 1.0+1.0i) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1.0 1.0+1.0i) 0.5+0.5i) +(num-test (= 0.0+1.0i 1.0 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.0 0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1.0 0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1.0 0) 0.0) +(num-test (+ 0.0+1.0i 1.0 0.0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1.0 0.0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1.0 0.0) 0.0) +(num-test (+ 0.0+1.0i 1.0 1234) 1235.0+1.0i) +(num-test (- 0.0+1.0i 1.0 1234) -1235.0+1.0i) +(num-test (* 0.0+1.0i 1.0 1234) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1.0 1234) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1.0 1234) #f) +(num-test (+ 0.0+1.0i 1.0 123.4) 124.4+1.0i) +(num-test (- 0.0+1.0i 1.0 123.4) -124.4+1.0i) +(num-test (* 0.0+1.0i 1.0 123.4) 0.0+123.4i) +(num-test (/ 0.0+1.0i 1.0 123.4) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 1.0 123.4) #f) +(num-test (+ 0.0+1.0i 1.0 1234/11) 113.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1.0 1234/11) -113.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1.0 1234/11) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1.0 1234/11) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1.0 1234/11) #f) +(num-test (+ 0.0+1.0i 1.0 1.234+1.234i) 2.234+2.234i) +(num-test (- 0.0+1.0i 1.0 1.234+1.234i) -2.234-0.234i) +(num-test (* 0.0+1.0i 1.0 1.234+1.234i) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1.0 1.234+1.234i) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1.0 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1.0 -1.0+1.0i) 0.0+2.0i) +(num-test (- 0.0+1.0i 1.0 -1.0+1.0i) 0.0) +(num-test (* 0.0+1.0i 1.0 -1.0+1.0i) -1.0-1.0i) +(num-test (/ 0.0+1.0i 1.0 -1.0+1.0i) 0.5-0.5i) +(num-test (= 0.0+1.0i 1.0 -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.0 0.0+1.0i) 1.0+2.0i) +(num-test (- 0.0+1.0i 1.0 0.0+1.0i) -1.0) +(num-test (* 0.0+1.0i 1.0 0.0+1.0i) -1.0) +(num-test (/ 0.0+1.0i 1.0 0.0+1.0i) 1.0) +(num-test (= 0.0+1.0i 1.0 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1/1 1) 2.0+1.0i) +(num-test (- 0.0+1.0i 1/1 1) -2.0+1.0i) +(num-test (* 0.0+1.0i 1/1 1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1/1 1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1/1 1) #f) +(num-test (+ 0.0+1.0i 1/1 1.0) 2.0+1.0i) +(num-test (- 0.0+1.0i 1/1 1.0) -2.0+1.0i) +(num-test (* 0.0+1.0i 1/1 1.0) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1/1 1.0) 0.0+1.0i) +(num-test (= 0.0+1.0i 1/1 1.0) #f) +(num-test (+ 0.0+1.0i 1/1 1/1) 2.0+1.0i) +(num-test (- 0.0+1.0i 1/1 1/1) -2.0+1.0i) +(num-test (* 0.0+1.0i 1/1 1/1) 0.0+1.0i) +(num-test (/ 0.0+1.0i 1/1 1/1) 0.0+1.0i) +(num-test (= 0.0+1.0i 1/1 1/1) #f) +(num-test (+ 0.0+1.0i 1/1 1.0+1.0i) 2.0+2.0i) +(num-test (- 0.0+1.0i 1/1 1.0+1.0i) -2.0) +(num-test (* 0.0+1.0i 1/1 1.0+1.0i) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1/1 1.0+1.0i) 0.5+0.5i) +(num-test (= 0.0+1.0i 1/1 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1/1 0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1/1 0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1/1 0) 0.0) +(num-test (+ 0.0+1.0i 1/1 0.0) 1.0+1.0i) +(num-test (- 0.0+1.0i 1/1 0.0) -1.0+1.0i) +(num-test (* 0.0+1.0i 1/1 0.0) 0.0) +(num-test (+ 0.0+1.0i 1/1 1234) 1235.0+1.0i) +(num-test (- 0.0+1.0i 1/1 1234) -1235.0+1.0i) +(num-test (* 0.0+1.0i 1/1 1234) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1/1 1234) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1/1 1234) #f) +(num-test (+ 0.0+1.0i 1/1 123.4) 124.4+1.0i) +(num-test (- 0.0+1.0i 1/1 123.4) -124.4+1.0i) +(num-test (* 0.0+1.0i 1/1 123.4) 0.0+123.4i) +(num-test (/ 0.0+1.0i 1/1 123.4) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 1/1 123.4) #f) +(num-test (+ 0.0+1.0i 1/1 1234/11) 113.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1/1 1234/11) -113.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1/1 1234/11) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1/1 1234/11) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1/1 1234/11) #f) +(num-test (+ 0.0+1.0i 1/1 1.234+1.234i) 2.234+2.234i) +(num-test (- 0.0+1.0i 1/1 1.234+1.234i) -2.234-0.234i) +(num-test (* 0.0+1.0i 1/1 1.234+1.234i) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1/1 1.234+1.234i) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1/1 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1/1 -1.0+1.0i) 0.0+2.0i) +(num-test (- 0.0+1.0i 1/1 -1.0+1.0i) 0.0) +(num-test (* 0.0+1.0i 1/1 -1.0+1.0i) -1.0-1.0i) +(num-test (/ 0.0+1.0i 1/1 -1.0+1.0i) 0.5-0.5i) +(num-test (= 0.0+1.0i 1/1 -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1/1 0.0+1.0i) 1.0+2.0i) +(num-test (- 0.0+1.0i 1/1 0.0+1.0i) -1.0) +(num-test (* 0.0+1.0i 1/1 0.0+1.0i) -1.0) +(num-test (/ 0.0+1.0i 1/1 0.0+1.0i) 1.0) +(num-test (= 0.0+1.0i 1/1 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 1) 2.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 1) -2.0) +(num-test (* 0.0+1.0i 1.0+1.0i 1) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i 1) 0.5+0.5i) +(num-test (= 0.0+1.0i 1.0+1.0i 1) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 1.0) 2.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 1.0) -2.0) +(num-test (* 0.0+1.0i 1.0+1.0i 1.0) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i 1.0) 0.5+0.5i) +(num-test (= 0.0+1.0i 1.0+1.0i 1.0) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 1/1) 2.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 1/1) -2.0) +(num-test (* 0.0+1.0i 1.0+1.0i 1/1) -1.0+1.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i 1/1) 0.5+0.5i) +(num-test (= 0.0+1.0i 1.0+1.0i 1/1) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 1.0+1.0i) 2.0+3.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0-1.0i) +(num-test (* 0.0+1.0i 1.0+1.0i 1.0+1.0i) -2.0) +(num-test (/ 0.0+1.0i 1.0+1.0i 1.0+1.0i) 0.5) +(num-test (= 0.0+1.0i 1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 0) 1.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 0) -1.0) +(num-test (* 0.0+1.0i 1.0+1.0i 0) -0.0) +(num-test (+ 0.0+1.0i 1.0+1.0i 0.0) 1.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 0.0) -1.0) +(num-test (* 0.0+1.0i 1.0+1.0i 0.0) -0.0) +(num-test (+ 0.0+1.0i 1.0+1.0i 1234) 1235.0+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 1234) -1235.0) +(num-test (* 0.0+1.0i 1.0+1.0i 1234) -1234.0+1234.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i 1234) 0.00040518638574+0.00040518638574i) +(num-test (= 0.0+1.0i 1.0+1.0i 1234) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 123.4) 124.4+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 123.4) -124.4) +(num-test (* 0.0+1.0i 1.0+1.0i 123.4) -123.4+123.4i) +(num-test (/ 0.0+1.0i 1.0+1.0i 123.4) 0.00405186385737+0.00405186385737i) +(num-test (= 0.0+1.0i 1.0+1.0i 123.4) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 1234/11) 113.18181818181819+2.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 1234/11) -113.18181818181819) +(num-test (* 0.0+1.0i 1.0+1.0i 1234/11) -112.18181818181819+112.18181818181819i) +(num-test (/ 0.0+1.0i 1.0+1.0i 1234/11) 0.00445705024311+0.00445705024311i) +(num-test (= 0.0+1.0i 1.0+1.0i 1234/11) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 1.234+1.234i) 2.234+3.234i) +(num-test (- 0.0+1.0i 1.0+1.0i 1.234+1.234i) -2.234-1.234i) +(num-test (* 0.0+1.0i 1.0+1.0i 1.234+1.234i) -2.468) +(num-test (/ 0.0+1.0i 1.0+1.0i 1.234+1.234i) 0.40518638573744) +(num-test (= 0.0+1.0i 1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i -1.0+1.0i) 0.0+3.0i) +(num-test (- 0.0+1.0i 1.0+1.0i -1.0+1.0i) 0.0-1.0i) +(num-test (* 0.0+1.0i 1.0+1.0i -1.0+1.0i) 0.0-2.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i -1.0+1.0i) -0.0-0.5i) +(num-test (= 0.0+1.0i 1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.0+1.0i 0.0+1.0i) 1.0+3.0i) +(num-test (- 0.0+1.0i 1.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (* 0.0+1.0i 1.0+1.0i 0.0+1.0i) -1.0-1.0i) +(num-test (/ 0.0+1.0i 1.0+1.0i 0.0+1.0i) 0.5-0.5i) +(num-test (= 0.0+1.0i 1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 0 1) 1.0+1.0i) +(num-test (- 0.0+1.0i 0 1) -1.0+1.0i) +(num-test (* 0.0+1.0i 0 1) 0.0) +(num-test (+ 0.0+1.0i 0 1.0) 1.0+1.0i) +(num-test (- 0.0+1.0i 0 1.0) -1.0+1.0i) +(num-test (* 0.0+1.0i 0 1.0) 0.0) +(num-test (+ 0.0+1.0i 0 1/1) 1.0+1.0i) +(num-test (- 0.0+1.0i 0 1/1) -1.0+1.0i) +(num-test (* 0.0+1.0i 0 1/1) 0.0) +(num-test (+ 0.0+1.0i 0 1.0+1.0i) 1.0+2.0i) +(num-test (- 0.0+1.0i 0 1.0+1.0i) -1.0) +(num-test (* 0.0+1.0i 0 1.0+1.0i) 0.0) +(num-test (+ 0.0+1.0i 0 0) 0.0+1.0i) +(num-test (- 0.0+1.0i 0 0) 0.0+1.0i) +(num-test (* 0.0+1.0i 0 0) 0.0) +(num-test (+ 0.0+1.0i 0 0.0) 0.0+1.0i) +(num-test (- 0.0+1.0i 0 0.0) 0.0+1.0i) +(num-test (* 0.0+1.0i 0 0.0) 0.0) +(num-test (+ 0.0+1.0i 0 1234) 1234.0+1.0i) +(num-test (- 0.0+1.0i 0 1234) -1234.0+1.0i) +(num-test (* 0.0+1.0i 0 1234) 0.0) +(num-test (+ 0.0+1.0i 0 123.4) 123.4+1.0i) +(num-test (- 0.0+1.0i 0 123.4) -123.4+1.0i) +(num-test (* 0.0+1.0i 0 123.4) 0.0) +(num-test (+ 0.0+1.0i 0 1234/11) 112.18181818181819+1.0i) +(num-test (- 0.0+1.0i 0 1234/11) -112.18181818181819+1.0i) +(num-test (* 0.0+1.0i 0 1234/11) 0.0) +(num-test (+ 0.0+1.0i 0 1.234+1.234i) 1.234+2.234i) +(num-test (- 0.0+1.0i 0 1.234+1.234i) -1.234-0.234i) +(num-test (* 0.0+1.0i 0 1.234+1.234i) 0.0) +(num-test (+ 0.0+1.0i 0 -1.0+1.0i) -1.0+2.0i) +(num-test (- 0.0+1.0i 0 -1.0+1.0i) 1.0) +(num-test (* 0.0+1.0i 0 -1.0+1.0i) -0.0) +(num-test (+ 0.0+1.0i 0 0.0+1.0i) 0.0+2.0i) +(num-test (- 0.0+1.0i 0 0.0+1.0i) 0.0) +(num-test (* 0.0+1.0i 0 0.0+1.0i) 0.0) +(num-test (+ 0.0+1.0i 0.0 1) 1.0+1.0i) +(num-test (- 0.0+1.0i 0.0 1) -1.0+1.0i) +(num-test (* 0.0+1.0i 0.0 1) 0.0) +(num-test (+ 0.0+1.0i 0.0 1.0) 1.0+1.0i) +(num-test (- 0.0+1.0i 0.0 1.0) -1.0+1.0i) +(num-test (* 0.0+1.0i 0.0 1.0) 0.0) +(num-test (+ 0.0+1.0i 0.0 1/1) 1.0+1.0i) +(num-test (- 0.0+1.0i 0.0 1/1) -1.0+1.0i) +(num-test (* 0.0+1.0i 0.0 1/1) 0.0) +(num-test (+ 0.0+1.0i 0.0 1.0+1.0i) 1.0+2.0i) +(num-test (- 0.0+1.0i 0.0 1.0+1.0i) -1.0) +(num-test (* 0.0+1.0i 0.0 1.0+1.0i) 0.0) +(num-test (+ 0.0+1.0i 0.0 0) 0.0+1.0i) +(num-test (- 0.0+1.0i 0.0 0) 0.0+1.0i) +(num-test (* 0.0+1.0i 0.0 0) 0.0) +(num-test (+ 0.0+1.0i 0.0 0.0) 0.0+1.0i) +(num-test (- 0.0+1.0i 0.0 0.0) 0.0+1.0i) +(num-test (* 0.0+1.0i 0.0 0.0) 0.0) +(num-test (+ 0.0+1.0i 0.0 1234) 1234.0+1.0i) +(num-test (- 0.0+1.0i 0.0 1234) -1234.0+1.0i) +(num-test (* 0.0+1.0i 0.0 1234) 0.0) +(num-test (+ 0.0+1.0i 0.0 123.4) 123.4+1.0i) +(num-test (- 0.0+1.0i 0.0 123.4) -123.4+1.0i) +(num-test (* 0.0+1.0i 0.0 123.4) 0.0) +(num-test (+ 0.0+1.0i 0.0 1234/11) 112.18181818181819+1.0i) +(num-test (- 0.0+1.0i 0.0 1234/11) -112.18181818181819+1.0i) +(num-test (* 0.0+1.0i 0.0 1234/11) 0.0) +(num-test (+ 0.0+1.0i 0.0 1.234+1.234i) 1.234+2.234i) +(num-test (- 0.0+1.0i 0.0 1.234+1.234i) -1.234-0.234i) +(num-test (* 0.0+1.0i 0.0 1.234+1.234i) 0.0) +(num-test (+ 0.0+1.0i 0.0 -1.0+1.0i) -1.0+2.0i) +(num-test (- 0.0+1.0i 0.0 -1.0+1.0i) 1.0) +(num-test (* 0.0+1.0i 0.0 -1.0+1.0i) -0.0) +(num-test (+ 0.0+1.0i 0.0 0.0+1.0i) 0.0+2.0i) +(num-test (- 0.0+1.0i 0.0 0.0+1.0i) 0.0) +(num-test (* 0.0+1.0i 0.0 0.0+1.0i) 0.0) +(num-test (+ 0.0+1.0i 1234 1) 1235.0+1.0i) +(num-test (- 0.0+1.0i 1234 1) -1235.0+1.0i) +(num-test (* 0.0+1.0i 1234 1) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1234 1) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1234 1) #f) +(num-test (+ 0.0+1.0i 1234 1.0) 1235.0+1.0i) +(num-test (- 0.0+1.0i 1234 1.0) -1235.0+1.0i) +(num-test (* 0.0+1.0i 1234 1.0) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1234 1.0) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1234 1.0) #f) +(num-test (+ 0.0+1.0i 1234 1/1) 1235.0+1.0i) +(num-test (- 0.0+1.0i 1234 1/1) -1235.0+1.0i) +(num-test (* 0.0+1.0i 1234 1/1) 0.0+1234.0i) +(num-test (/ 0.0+1.0i 1234 1/1) 0.0+0.00081037277147i) +(num-test (= 0.0+1.0i 1234 1/1) #f) +(num-test (+ 0.0+1.0i 1234 1.0+1.0i) 1235.0+2.0i) +(num-test (- 0.0+1.0i 1234 1.0+1.0i) -1235.0) +(num-test (* 0.0+1.0i 1234 1.0+1.0i) -1234.0+1234.0i) +(num-test (/ 0.0+1.0i 1234 1.0+1.0i) 0.00040518638574+0.00040518638574i) +(num-test (= 0.0+1.0i 1234 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1234 0) 1234.0+1.0i) +(num-test (- 0.0+1.0i 1234 0) -1234.0+1.0i) +(num-test (* 0.0+1.0i 1234 0) 0.0) +(num-test (+ 0.0+1.0i 1234 0.0) 1234.0+1.0i) +(num-test (- 0.0+1.0i 1234 0.0) -1234.0+1.0i) +(num-test (* 0.0+1.0i 1234 0.0) 0.0) +(num-test (+ 0.0+1.0i 1234 1234) 2468.0+1.0i) +(num-test (- 0.0+1.0i 1234 1234) -2468.0+1.0i) +(num-test (* 0.0+1.0i 1234 1234) 0.0+1522756.0i) +(num-test (/ 0.0+1.0i 1234 1234) 0.0+0.00000065670403i) +(num-test (= 0.0+1.0i 1234 1234) #f) +(num-test (+ 0.0+1.0i 1234 123.4) 1357.4+1.0i) +(num-test (- 0.0+1.0i 1234 123.4) -1357.4+1.0i) +(num-test (* 0.0+1.0i 1234 123.4) 0.0+152275.60000000000582i) +(num-test (/ 0.0+1.0i 1234 123.4) 0.0+0.00000656704029i) +(num-test (= 0.0+1.0i 1234 123.4) #f) +(num-test (+ 0.0+1.0i 1234 1234/11) 1346.18181818181824+1.0i) +(num-test (- 0.0+1.0i 1234 1234/11) -1346.18181818181824+1.0i) +(num-test (* 0.0+1.0i 1234 1234/11) 0.0+138432.36363636364695i) +(num-test (/ 0.0+1.0i 1234 1234/11) 0.0+0.00000722374432i) +(num-test (= 0.0+1.0i 1234 1234/11) #f) +(num-test (+ 0.0+1.0i 1234 1.234+1.234i) 1235.23399999999992+2.234i) +(num-test (- 0.0+1.0i 1234 1.234+1.234i) -1235.23399999999992-0.234i) +(num-test (* 0.0+1.0i 1234 1.234+1.234i) -1522.756+1522.756i) +(num-test (/ 0.0+1.0i 1234 1.234+1.234i) 0.00032835201437+0.00032835201437i) +(num-test (= 0.0+1.0i 1234 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1234 -1.0+1.0i) 1233.0+2.0i) +(num-test (- 0.0+1.0i 1234 -1.0+1.0i) -1233.0) +(num-test (* 0.0+1.0i 1234 -1.0+1.0i) -1234.0-1234.0i) +(num-test (/ 0.0+1.0i 1234 -1.0+1.0i) 0.00040518638574-0.00040518638574i) +(num-test (= 0.0+1.0i 1234 -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1234 0.0+1.0i) 1234.0+2.0i) +(num-test (- 0.0+1.0i 1234 0.0+1.0i) -1234.0) +(num-test (* 0.0+1.0i 1234 0.0+1.0i) -1234.0) +(num-test (/ 0.0+1.0i 1234 0.0+1.0i) 0.00081037277147) +(num-test (= 0.0+1.0i 1234 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 123.4 1) 124.4+1.0i) +(num-test (- 0.0+1.0i 123.4 1) -124.4+1.0i) +(num-test (* 0.0+1.0i 123.4 1) 0.0+123.4i) +(num-test (/ 0.0+1.0i 123.4 1) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 123.4 1) #f) +(num-test (+ 0.0+1.0i 123.4 1.0) 124.4+1.0i) +(num-test (- 0.0+1.0i 123.4 1.0) -124.4+1.0i) +(num-test (* 0.0+1.0i 123.4 1.0) 0.0+123.4i) +(num-test (/ 0.0+1.0i 123.4 1.0) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 123.4 1.0) #f) +(num-test (+ 0.0+1.0i 123.4 1/1) 124.4+1.0i) +(num-test (- 0.0+1.0i 123.4 1/1) -124.4+1.0i) +(num-test (* 0.0+1.0i 123.4 1/1) 0.0+123.4i) +(num-test (/ 0.0+1.0i 123.4 1/1) 0.0+0.00810372771475i) +(num-test (= 0.0+1.0i 123.4 1/1) #f) +(num-test (+ 0.0+1.0i 123.4 1.0+1.0i) 124.4+2.0i) +(num-test (- 0.0+1.0i 123.4 1.0+1.0i) -124.4) +(num-test (* 0.0+1.0i 123.4 1.0+1.0i) -123.4+123.4i) +(num-test (/ 0.0+1.0i 123.4 1.0+1.0i) 0.00405186385737+0.00405186385737i) +(num-test (= 0.0+1.0i 123.4 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 123.4 0) 123.4+1.0i) +(num-test (- 0.0+1.0i 123.4 0) -123.4+1.0i) +(num-test (* 0.0+1.0i 123.4 0) 0.0) +(num-test (+ 0.0+1.0i 123.4 0.0) 123.4+1.0i) +(num-test (- 0.0+1.0i 123.4 0.0) -123.4+1.0i) +(num-test (* 0.0+1.0i 123.4 0.0) 0.0) +(num-test (+ 0.0+1.0i 123.4 1234) 1357.4+1.0i) +(num-test (- 0.0+1.0i 123.4 1234) -1357.4+1.0i) +(num-test (* 0.0+1.0i 123.4 1234) 0.0+152275.60000000000582i) +(num-test (/ 0.0+1.0i 123.4 1234) 0.0+0.00000656704029i) +(num-test (= 0.0+1.0i 123.4 1234) #f) +(num-test (+ 0.0+1.0i 123.4 123.4) 246.8+1.0i) +(num-test (- 0.0+1.0i 123.4 123.4) -246.8+1.0i) +(num-test (* 0.0+1.0i 123.4 123.4) 0.0+15227.56000000000131i) +(num-test (/ 0.0+1.0i 123.4 123.4) 0.0+0.00006567040287i) +(num-test (= 0.0+1.0i 123.4 123.4) #f) +(num-test (+ 0.0+1.0i 123.4 1234/11) 235.58181818181819+1.0i) +(num-test (- 0.0+1.0i 123.4 1234/11) -235.58181818181819+1.0i) +(num-test (* 0.0+1.0i 123.4 1234/11) 0.0+13843.23636363636433i) +(num-test (/ 0.0+1.0i 123.4 1234/11) 0.0+0.00007223744316i) +(num-test (= 0.0+1.0i 123.4 1234/11) #f) +(num-test (+ 0.0+1.0i 123.4 1.234+1.234i) 124.634+2.234i) +(num-test (- 0.0+1.0i 123.4 1.234+1.234i) -124.634-0.234i) +(num-test (* 0.0+1.0i 123.4 1.234+1.234i) -152.2756+152.2756i) +(num-test (/ 0.0+1.0i 123.4 1.234+1.234i) 0.00328352014374+0.00328352014374i) +(num-test (= 0.0+1.0i 123.4 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 123.4 -1.0+1.0i) 122.4+2.0i) +(num-test (- 0.0+1.0i 123.4 -1.0+1.0i) -122.4) +(num-test (* 0.0+1.0i 123.4 -1.0+1.0i) -123.4-123.4i) +(num-test (/ 0.0+1.0i 123.4 -1.0+1.0i) 0.00405186385737-0.00405186385737i) +(num-test (= 0.0+1.0i 123.4 -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 123.4 0.0+1.0i) 123.4+2.0i) +(num-test (- 0.0+1.0i 123.4 0.0+1.0i) -123.4) +(num-test (* 0.0+1.0i 123.4 0.0+1.0i) -123.4) +(num-test (/ 0.0+1.0i 123.4 0.0+1.0i) 0.00810372771475) +(num-test (= 0.0+1.0i 123.4 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1234/11 1) 113.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11 1) -113.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11 1) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1234/11 1) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1234/11 1) #f) +(num-test (+ 0.0+1.0i 1234/11 1.0) 113.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11 1.0) -113.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11 1.0) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1234/11 1.0) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1234/11 1.0) #f) +(num-test (+ 0.0+1.0i 1234/11 1/1) 113.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11 1/1) -113.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11 1/1) 0.0+112.18181818181819i) +(num-test (/ 0.0+1.0i 1234/11 1/1) 0.0+0.00891410048622i) +(num-test (= 0.0+1.0i 1234/11 1/1) #f) +(num-test (+ 0.0+1.0i 1234/11 1.0+1.0i) 113.18181818181819+2.0i) +(num-test (- 0.0+1.0i 1234/11 1.0+1.0i) -113.18181818181819) +(num-test (* 0.0+1.0i 1234/11 1.0+1.0i) -112.18181818181819+112.18181818181819i) +(num-test (/ 0.0+1.0i 1234/11 1.0+1.0i) 0.00445705024311+0.00445705024311i) +(num-test (= 0.0+1.0i 1234/11 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1234/11 0) 112.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11 0) -112.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11 0) 0.0) +(num-test (+ 0.0+1.0i 1234/11 0.0) 112.18181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11 0.0) -112.18181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11 0.0) 0.0) +(num-test (+ 0.0+1.0i 1234/11 1234) 1346.18181818181824+1.0i) +(num-test (- 0.0+1.0i 1234/11 1234) -1346.18181818181824+1.0i) +(num-test (* 0.0+1.0i 1234/11 1234) 0.0+138432.36363636364695i) +(num-test (/ 0.0+1.0i 1234/11 1234) 0.0+0.00000722374432i) +(num-test (= 0.0+1.0i 1234/11 1234) #f) +(num-test (+ 0.0+1.0i 1234/11 123.4) 235.58181818181819+1.0i) +(num-test (- 0.0+1.0i 1234/11 123.4) -235.58181818181819+1.0i) +(num-test (* 0.0+1.0i 1234/11 123.4) 0.0+13843.23636363636433i) +(num-test (/ 0.0+1.0i 1234/11 123.4) 0.0+0.00007223744316i) +(num-test (= 0.0+1.0i 1234/11 123.4) #f) +(num-test (+ 0.0+1.0i 1234/11 1234/11) 224.36363636363637+1.0i) +(num-test (- 0.0+1.0i 1234/11 1234/11) -224.36363636363637+1.0i) +(num-test (* 0.0+1.0i 1234/11 1234/11) 0.0+12584.76033057851419i) +(num-test (/ 0.0+1.0i 1234/11 1234/11) 0.0+0.00007946118748i) +(num-test (= 0.0+1.0i 1234/11 1234/11) #f) +(num-test (+ 0.0+1.0i 1234/11 1.234+1.234i) 113.41581818181818+2.234i) +(num-test (- 0.0+1.0i 1234/11 1.234+1.234i) -113.41581818181818-0.234i) +(num-test (* 0.0+1.0i 1234/11 1.234+1.234i) -138.43236363636365+138.43236363636365i) +(num-test (/ 0.0+1.0i 1234/11 1.234+1.234i) 0.00361187215811+0.00361187215811i) +(num-test (= 0.0+1.0i 1234/11 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1234/11 -1.0+1.0i) 111.18181818181819+2.0i) +(num-test (- 0.0+1.0i 1234/11 -1.0+1.0i) -111.18181818181819) +(num-test (* 0.0+1.0i 1234/11 -1.0+1.0i) -112.18181818181819-112.18181818181819i) +(num-test (/ 0.0+1.0i 1234/11 -1.0+1.0i) 0.00445705024311-0.00445705024311i) +(num-test (= 0.0+1.0i 1234/11 -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1234/11 0.0+1.0i) 112.18181818181819+2.0i) +(num-test (- 0.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819) +(num-test (* 0.0+1.0i 1234/11 0.0+1.0i) -112.18181818181819) +(num-test (/ 0.0+1.0i 1234/11 0.0+1.0i) 0.00891410048622) +(num-test (= 0.0+1.0i 1234/11 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 1) 2.234+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 1) -2.234-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 1) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1.234+1.234i 1) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1.234+1.234i 1) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 1.0) 2.234+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 1.0) -2.234-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 1.0) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1.234+1.234i 1.0) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1.234+1.234i 1.0) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 1/1) 2.234+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 1/1) -2.234-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 1/1) -1.234+1.234i) +(num-test (/ 0.0+1.0i 1.234+1.234i 1/1) 0.40518638573744+0.40518638573744i) +(num-test (= 0.0+1.0i 1.234+1.234i 1/1) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 1.0+1.0i) 2.234+3.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 1.0+1.0i) -2.234-1.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 1.0+1.0i) -2.468) +(num-test (/ 0.0+1.0i 1.234+1.234i 1.0+1.0i) 0.40518638573744) +(num-test (= 0.0+1.0i 1.234+1.234i 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 0) 1.234+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 0) -1.234-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 0) -0.0) +(num-test (+ 0.0+1.0i 1.234+1.234i 0.0) 1.234+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 0.0) -1.234-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 0.0) -0.0) +(num-test (+ 0.0+1.0i 1.234+1.234i 1234) 1235.23399999999992+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 1234) -1235.23399999999992-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 1234) -1522.756+1522.756i) +(num-test (/ 0.0+1.0i 1.234+1.234i 1234) 0.00032835201437+0.00032835201437i) +(num-test (= 0.0+1.0i 1.234+1.234i 1234) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 123.4) 124.634+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 123.4) -124.634-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 123.4) -152.2756+152.2756i) +(num-test (/ 0.0+1.0i 1.234+1.234i 123.4) 0.00328352014374+0.00328352014374i) +(num-test (= 0.0+1.0i 1.234+1.234i 123.4) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 1234/11) 113.41581818181818+2.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 1234/11) -113.41581818181818-0.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 1234/11) -138.43236363636365+138.43236363636365i) +(num-test (/ 0.0+1.0i 1.234+1.234i 1234/11) 0.00361187215811+0.00361187215811i) +(num-test (= 0.0+1.0i 1.234+1.234i 1234/11) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 1.234+1.234i) 2.468+3.468i) +(num-test (- 0.0+1.0i 1.234+1.234i 1.234+1.234i) -2.468-1.468i) +(num-test (* 0.0+1.0i 1.234+1.234i 1.234+1.234i) -3.04551200000000) +(num-test (/ 0.0+1.0i 1.234+1.234i 1.234+1.234i) 0.32835201437394) +(num-test (= 0.0+1.0i 1.234+1.234i 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i -1.0+1.0i) 0.234+3.234i) +(num-test (- 0.0+1.0i 1.234+1.234i -1.0+1.0i) -0.234-1.234i) +(num-test (* 0.0+1.0i 1.234+1.234i -1.0+1.0i) 0.0-2.468i) +(num-test (/ 0.0+1.0i 1.234+1.234i -1.0+1.0i) -0.0-0.40518638573744i) +(num-test (= 0.0+1.0i 1.234+1.234i -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 1.234+1.234i 0.0+1.0i) 1.234+3.234i) +(num-test (- 0.0+1.0i 1.234+1.234i 0.0+1.0i) -1.234-1.234i) +(num-test (* 0.0+1.0i 1.234+1.234i 0.0+1.0i) -1.234-1.234i) +(num-test (/ 0.0+1.0i 1.234+1.234i 0.0+1.0i) 0.40518638573744-0.40518638573744i) +(num-test (= 0.0+1.0i 1.234+1.234i 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 1) 0.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 1) 0.0) +(num-test (* 0.0+1.0i -1.0+1.0i 1) -1.0-1.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1) 0.5-0.5i) +(num-test (= 0.0+1.0i -1.0+1.0i 1) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 1.0) 0.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 1.0) 0.0) +(num-test (* 0.0+1.0i -1.0+1.0i 1.0) -1.0-1.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1.0) 0.5-0.5i) +(num-test (= 0.0+1.0i -1.0+1.0i 1.0) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 1/1) 0.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 1/1) 0.0) +(num-test (* 0.0+1.0i -1.0+1.0i 1/1) -1.0-1.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1/1) 0.5-0.5i) +(num-test (= 0.0+1.0i -1.0+1.0i 1/1) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0+3.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0-1.0i) +(num-test (* 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0-2.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1.0+1.0i) 0.0-0.5i) +(num-test (= 0.0+1.0i -1.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 0) -1.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 0) 1.0) +(num-test (* 0.0+1.0i -1.0+1.0i 0) 0.0) +(num-test (+ 0.0+1.0i -1.0+1.0i 0.0) -1.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 0.0) 1.0) +(num-test (* 0.0+1.0i -1.0+1.0i 0.0) 0.0) +(num-test (+ 0.0+1.0i -1.0+1.0i 1234) 1233.0+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 1234) -1233.0) +(num-test (* 0.0+1.0i -1.0+1.0i 1234) -1234.0-1234.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1234) 0.00040518638574-0.00040518638574i) +(num-test (= 0.0+1.0i -1.0+1.0i 1234) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 123.4) 122.4+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 123.4) -122.4) +(num-test (* 0.0+1.0i -1.0+1.0i 123.4) -123.4-123.4i) +(num-test (/ 0.0+1.0i -1.0+1.0i 123.4) 0.00405186385737-0.00405186385737i) +(num-test (= 0.0+1.0i -1.0+1.0i 123.4) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 1234/11) 111.18181818181819+2.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 1234/11) -111.18181818181819) +(num-test (* 0.0+1.0i -1.0+1.0i 1234/11) -112.18181818181819-112.18181818181819i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1234/11) 0.00445705024311-0.00445705024311i) +(num-test (= 0.0+1.0i -1.0+1.0i 1234/11) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 1.234+1.234i) 0.234+3.234i) +(num-test (- 0.0+1.0i -1.0+1.0i 1.234+1.234i) -0.234-1.234i) +(num-test (* 0.0+1.0i -1.0+1.0i 1.234+1.234i) 0.0-2.468i) +(num-test (/ 0.0+1.0i -1.0+1.0i 1.234+1.234i) 0.0-0.40518638573744i) +(num-test (= 0.0+1.0i -1.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i -1.0+1.0i) -2.0+3.0i) +(num-test (- 0.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0-1.0i) +(num-test (* 0.0+1.0i -1.0+1.0i -1.0+1.0i) 2.0) +(num-test (/ 0.0+1.0i -1.0+1.0i -1.0+1.0i) -0.5) +(num-test (= 0.0+1.0i -1.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i -1.0+1.0i 0.0+1.0i) -1.0+3.0i) +(num-test (- 0.0+1.0i -1.0+1.0i 0.0+1.0i) 1.0-1.0i) +(num-test (* 0.0+1.0i -1.0+1.0i 0.0+1.0i) 1.0-1.0i) +(num-test (/ 0.0+1.0i -1.0+1.0i 0.0+1.0i) -0.5-0.5i) +(num-test (= 0.0+1.0i -1.0+1.0i 0.0+1.0i) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 1) 1.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 1) -1.0) +(num-test (* 0.0+1.0i 0.0+1.0i 1) -1.0) +(num-test (/ 0.0+1.0i 0.0+1.0i 1) 1.0) +(num-test (= 0.0+1.0i 0.0+1.0i 1) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 1.0) 1.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 1.0) -1.0) +(num-test (* 0.0+1.0i 0.0+1.0i 1.0) -1.0) +(num-test (/ 0.0+1.0i 0.0+1.0i 1.0) 1.0) +(num-test (= 0.0+1.0i 0.0+1.0i 1.0) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 1/1) 1.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 1/1) -1.0) +(num-test (* 0.0+1.0i 0.0+1.0i 1/1) -1.0) +(num-test (/ 0.0+1.0i 0.0+1.0i 1/1) 1.0) +(num-test (= 0.0+1.0i 0.0+1.0i 1/1) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 1.0+1.0i) 1.0+3.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 1.0+1.0i) -1.0-1.0i) +(num-test (* 0.0+1.0i 0.0+1.0i 1.0+1.0i) -1.0-1.0i) +(num-test (/ 0.0+1.0i 0.0+1.0i 1.0+1.0i) 0.5-0.5i) +(num-test (= 0.0+1.0i 0.0+1.0i 1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 0) 0.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 0) 0.0) +(num-test (* 0.0+1.0i 0.0+1.0i 0) -0.0) +(num-test (+ 0.0+1.0i 0.0+1.0i 0.0) 0.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 0.0) 0.0) +(num-test (* 0.0+1.0i 0.0+1.0i 0.0) -0.0) +(num-test (+ 0.0+1.0i 0.0+1.0i 1234) 1234.0+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 1234) -1234.0) +(num-test (* 0.0+1.0i 0.0+1.0i 1234) -1234.0) +(num-test (/ 0.0+1.0i 0.0+1.0i 1234) 0.00081037277147) +(num-test (= 0.0+1.0i 0.0+1.0i 1234) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 123.4) 123.4+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 123.4) -123.4) +(num-test (* 0.0+1.0i 0.0+1.0i 123.4) -123.4) +(num-test (/ 0.0+1.0i 0.0+1.0i 123.4) 0.00810372771475) +(num-test (= 0.0+1.0i 0.0+1.0i 123.4) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 1234/11) 112.18181818181819+2.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819) +(num-test (* 0.0+1.0i 0.0+1.0i 1234/11) -112.18181818181819) +(num-test (/ 0.0+1.0i 0.0+1.0i 1234/11) 0.00891410048622) +(num-test (= 0.0+1.0i 0.0+1.0i 1234/11) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 1.234+1.234i) 1.234+3.234i) +(num-test (- 0.0+1.0i 0.0+1.0i 1.234+1.234i) -1.234-1.234i) +(num-test (* 0.0+1.0i 0.0+1.0i 1.234+1.234i) -1.234-1.234i) +(num-test (/ 0.0+1.0i 0.0+1.0i 1.234+1.234i) 0.40518638573744-0.40518638573744i) +(num-test (= 0.0+1.0i 0.0+1.0i 1.234+1.234i) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i -1.0+1.0i) -1.0+3.0i) +(num-test (- 0.0+1.0i 0.0+1.0i -1.0+1.0i) 1.0-1.0i) +(num-test (* 0.0+1.0i 0.0+1.0i -1.0+1.0i) 1.0-1.0i) +(num-test (/ 0.0+1.0i 0.0+1.0i -1.0+1.0i) -0.5-0.5i) +(num-test (= 0.0+1.0i 0.0+1.0i -1.0+1.0i) #f) +(num-test (+ 0.0+1.0i 0.0+1.0i 0.0+1.0i) 0.0+3.0i) +(num-test (- 0.0+1.0i 0.0+1.0i 0.0+1.0i) 0.0-1.0i) +(num-test (* 0.0+1.0i 0.0+1.0i 0.0+1.0i) -0.0-1.0i) +(num-test (/ 0.0+1.0i 0.0+1.0i 0.0+1.0i) 0.0-1.0i) +(num-test (= 0.0+1.0i 0.0+1.0i 0.0+1.0i) #t) + +(num-test (+ 1073741824 1073741824 1073741824 1073741824) (* 4 1073741824)) + +(num-test (+ 0.6049332056786565E0 -0.9611373574853808E0) -3.562041518067242999999999999999999999981E-1) +(num-test (+ -0.4763715667865308E0 0.25936932107685584E0) -2.170022457096749600000000000000000000008E-1) +(num-test (+ 0.2666481927718355E0 -0.04984768063142031E0) 2.168005121404151899999999999999999999994E-1) +(num-test (+ -0.29478659758474846E0 0.3371004337672615E0) 4.231383618251304000000000000000000000076E-2) +(num-test (+ 0.8203063910979178E0 0.28968607542857916E0) 1.109992466526496959999999999999999999999E0) +(num-test (+ -0.08207985138263585E0 0.4368723951711785E0) 3.5479254378854265E-1) +(num-test (+ -0.8659875373355486E0 -6.631430771196765E9) -6.6314307720627525373355486E9) +(num-test (+ 0.15071385783307878E0 -7.154424279496395E9) -7.154424279345681142166921220000000000013E9) +(num-test (+ -0.8969642760814789E0 -2.4070067380831727E8) -2.407006747052815460814789000000000000005E8) +(num-test (+ -0.9610362081435054E0 9.070410778399954E9) 9.070410777438917634019580537500000000004E9) +(num-test (+ 0.5129052501104072E0 -7.47841120327471E9) -7.478411202761804451427678737500000000008E9) +(num-test (+ 0.3840242289740675E0 7.793048210060242E9) 7.793048210444265928192817499999999999991E9) +(num-test (+ 0.07603066126204616E0 5.215008470388369E-11) 7.603066131419624470388369000000000000006E-2) +(num-test (+ -0.17187858025312586E0 -5.116645189173968E-11) -1.718785803042923118917396799999999999997E-1) +(num-test (+ 0.2521315816245864E0 8.603210607505339E-11) 2.521315817106185060750533899999999999992E-1) +(num-test (+ -0.3557185853193914E0 -2.0371324697272998E-11) -3.557185853397627246972729979999999999995E-1) +(num-test (+ 0.7142792289542045E0 -7.106356053331326E-11) 7.142792288831409394666867399999999999997E-1) +(num-test (+ 0.4380415886629452E0 -3.069969538383403E-11) 4.380415886322455046161659700000000000005E-1) +(num-test (+ 0.24798614227178573E0 3.972393639614975E19) 3.972393639614975000024798614227178572989E19) +(num-test (+ -0.5210677288128815E0 4.846393336901129E19) 4.846393336901128999947893227118711850007E19) +(num-test (+ 0.5825404819115E0 1.9710987361264255E19) 1.971098736126425500058254048191149998548E19) +(num-test (+ 0.9105175208730549E0 2.391166552096775E19) 2.391166552096775000091051752087305489998E19) +(num-test (+ 0.48414423368371695E0 -9.696117779740095E19) -9.696117779740094999951585576631628304997E19) +(num-test (+ 0.25780758450697716E0 6.094683117025535E19) 6.094683117025535000025780758450697715991E19) +(num-test (+ 0.9824539149570484E0 -5.4680066990812835E-21) 9.824539149570483999945319933009187165013E-1) +(num-test (+ -0.9520982941158654E0 3.2513564801568073E-21) -9.520982941158653999967486435198431927013E-1) +(num-test (+ 0.0630170624560149E0 -9.858852595793203E-21) 6.301706245601489999014114740420679700008E-2) +(num-test (+ 0.24705141169888878E0 1.4582081178692862E-22) 2.470514116988887800001458208117869286195E-1) +(num-test (+ 0.7440948700757135E0 -3.0932442581890818E-21) 7.440948700757134999969067557418109181978E-1) +(num-test (+ -0.5055970869515372E0 4.0277457257516025E-21) -5.055970869515371999959722542742483974988E-1) +(num-test (+ 1.672355787134947E9 0.0064909681594120805E0) 1.6723557871414380296981083695625E9) +(num-test (+ -9.694504381396599E9 -0.8925470085542831E0) -9.694504382289146008554283099999999999987E9) +(num-test (+ -1.6695005924298635E9 -0.34426964741306E0) -1.669500592774133147413059987073324919041E9) +(num-test (+ -6.085591212594774E9 0.5107956920100049E0) -6.085591212083978307989995100000000000004E9) +(num-test (+ 7.457486660952688E9 -0.4323787588338597E0) 7.457486660520309458329226237499999999989E9) +(num-test (+ -8.790796444526546E9 0.911415263281967E0) -8.790796443615130736718033019187146237507E9) +(num-test (+ 9.667548804251982E9 -1.266547751029956E8) 9.54089402914898613522949218749999999999E9) +(num-test (+ -6.169561898845145E9 9.627911197121864E9) 3.458349298276719318847656250000000000009E9) +(num-test (+ -9.870287253215279E9 9.004242781937655E8) -8.969862975021513478950500488281249999995E9) +(num-test (+ -8.175630881172554E9 -4.08632236263908E9) -1.226195324381163404760742187500000000002E10) +(num-test (+ 2.9069444232153206E9 -7.961831315741894E9) -5.054886892526573399999999999999999999977E9) +(num-test (+ -7.003647401371184E9 -1.768371514817526E9) -8.772018916188710000000000000000000000001E9) +(num-test (+ -6.418847599138249E9 2.755257250162372E-11) -6.418847599138248999972447427498376279997E9) +(num-test (+ 2.3093152687241793E9 1.2205440142364766E-11) 2.309315268724179300012205440142364766011E9) +(num-test (+ 8.634577667577518E9 -9.065714034538668E-11) 8.634577667577518463044108484654613319994E9) +(num-test (+ 1.711283212591781E9 -3.235019197733951E-11) 1.71128321259178090092285000333516049E9) +(num-test (+ 2.583886638357791E9 -8.199109798920928E-11) 2.583886638357790946878458120760790719997E9) +(num-test (+ -7.517123950474774E9 5.2057802142431697E-11) -7.51712395047477399994794219785756830298E9) +(num-test (+ 3.266571938086574E9 -4.4782768261898355E19) -4.478276825863178306191342592239379882812E19) +(num-test (+ 2.1000389219899452E9 -8.547158903365463E19) -8.547158903155459107801005480000000000002E19) +(num-test (+ -3.9140926801217155E9 7.387959860641422E19) 7.387959860250012731987828450000000000009E19) +(num-test (+ -7.087607465790431E9 7.96875093387599E19) 7.968750933167229781420956900000000000008E19) +(num-test (+ -8.341000808926519E9 6.9360028397637304E19) 6.936002838929630319107348100000000000009E19) +(num-test (+ -5.507940634743809E9 9.760028858210094E19) 9.760028857659299936525619099999999999989E19) +(num-test (+ 8.492522971238823E9 -2.8253881864964467E-22) 8.492522971238822937011718749999717461174E9) +(num-test (+ 1.2731765723336241E9 -5.8473937102910264E-21) 1.273176572333624099999999999994152606294E9) +(num-test (+ 9.654280758878323E9 -4.2332114049658973E-22) 9.654280758878322601318359374999576678861E9) +(num-test (+ -6.864618926120946E9 -1.245648314796599E-21) -6.864618926120946000000000000001245648334E9) +(num-test (+ -3.9916044043798673E8 1.697737588450543E-21) -3.991604404379867299999999999983022624115E8) +(num-test (+ -7.818041624198686E9 4.635421587404246E-21) -7.818041624198685999999999999995364578418E9) +(num-test (+ 2.0609929543990767E-12 -0.2126306554359736E0) -2.126306554339126070456009232999999999998E-1) +(num-test (+ -1.5923091695877845E-11 0.515731533720818E0) 5.157315337048949444413677540931484848253E-1) +(num-test (+ 4.794527092905871E-11 -0.9066947202676092E0) -9.0669472021966392907094129E-1) +(num-test (+ -8.63854477728633E-11 0.3122982022565777E0) 3.122982021701922522271366999999999999999E-1) +(num-test (+ -7.577966666552416E-11 -0.24137602092437593E0) -2.413760210001555966655241600000000000004E-1) +(num-test (+ -4.971730475882754E-11 -0.8202688719750202E0) -8.202688720247375047588275400000000000012E-1) +(num-test (+ -5.249369194379291E-11 -8.546120620321186E9) -8.546120620321186000052493691943792910002E9) +(num-test (+ 8.280786962526793E-11 5.758373397436368E9) 5.758373397436367988669233650875267930002E9) +(num-test (+ 6.370323595535815E-11 -8.470663335712393E9) -8.470663335712392999936296764044641849996E9) +(num-test (+ 3.59771226839467E-11 3.5042505440266216E8) 3.504250544026621600359771226839466999997E8) +(num-test (+ -3.945501687396375E-11 -5.082779978069177E9) -5.082779978069177000039455016873963749988E9) +(num-test (+ 9.780590963267516E-11 -5.05591945120475E9) -5.055919451204750060937350340367324839998E9) +(num-test (+ 6.323293597096768E-11 -7.208898910487284E-11) -8.856053133905159999999999999999999999986E-12) +(num-test (+ -4.549781732354749E-11 -6.095452636416357E-11) -1.064523436877110600000000000000000000002E-10) +(num-test (+ -5.372680267837374E-11 2.0748354219485134E-11) -3.297844845888860599999999999999999999998E-11) +(num-test (+ 3.550879553916665E-11 -4.374873254056574E-11) -8.239937001399090000000000000000000000007E-12) +(num-test (+ -6.746002242414832E-11 3.0803985031459436E-11) -3.665603739268888400000000000000000000013E-11) +(num-test (+ -7.902512161494214E-11 -8.907842858073236E-11) -1.681035501956744999999999999999999999998E-10) +(num-test (+ -4.1465935469350415E-11 6.244210696961323E19) 6.24421069696132299999999999999585340645E19) +(num-test (+ 4.921297536286578E-11 -1.694436650099881E19) -1.694436650099880999999999999995078702462E19) +(num-test (+ -7.879478980672654E-11 6.41757969360492E19) 6.41757969360491970559999999999212052103E19) +(num-test (+ -8.200749317872953E-11 -9.490225542618815E19) -9.490225542618815000000000000008200749324E19) +(num-test (+ -7.572981329795812E-11 -3.350367078181029E19) -3.350367078181029000000000000007572981326E19) +(num-test (+ -5.955255565125549E-11 -5.009913629288125E19) -5.00991362928812500000000000000595525556E19) +(num-test (+ -9.818180775332558E-11 -7.926156011681593E-21) -9.818180776125173601168159300000000000011E-11) +(num-test (+ -5.2466438379505935E-12 8.468830229031857E-21) -5.246643829481763270968143000000000000009E-12) +(num-test (+ 3.582774358441715E-11 3.6865211729351863E-22) 3.582774358478580211729351862999999999999E-11) +(num-test (+ 7.169296413565744E-11 -9.974881413980864E-21) 7.169296412568255858601913599999999999987E-11) +(num-test (+ -9.615073655516977E-11 4.9552491300097786E-21) -9.615073655021452086999022140000000000005E-11) +(num-test (+ 6.7696956269187E-11 4.1431488006404866E-21) 6.769695627333015423852294397336791395272E-11) +(num-test (+ -4.663397365185298E19 0.9758464195927673E0) -4.663397365185297999902415358040723270005E19) +(num-test (+ -4.77977261393851E19 0.04145189313162445E0) -4.779772613938509999995854810686837555009E19) +(num-test (+ 7.195364554121596E19 0.5169917736820715E0) 7.195364554121596000051699177368207149992E19) +(num-test (+ -7.766254779507882E19 0.5919134938460356E0) -7.766254779507881999940808650615396440016E19) +(num-test (+ -8.411122653901408E19 -0.14463225181516137E0) -8.411122653901408000014463225181516137013E19) +(num-test (+ -9.101920591747218E19 0.23349918704239836E0) -9.101920591747217999976650081295760164003E19) +(num-test (+ 7.037477746142529E18 -3.250947575909365E9) 7.037477742891581424090634999999999999988E18) +(num-test (+ -6.864341752972099E19 -4.0510449339565725E9) -6.864341753377203493395657250000000000004E19) +(num-test (+ -5.329540273290228E19 8.14869777458878E9) -5.329540272475358222541121959686279296875E19) +(num-test (+ -9.726234388247201E19 2.053976989398215E9) -9.726234388041803301060178494453430175781E19) +(num-test (+ -1.910324088450308E19 6.247052535748024E9) -1.910324087825602746425197601318359375E19) +(num-test (+ -6.079933001949367E18 6.316829148809886E9) -6.07993299563253785119011402130126953125E18) +(num-test (+ -4.499107911798452E19 9.659763881732633E-11) -4.499107911798451999999999999990340236126E19) +(num-test (+ -3.0972208018542522E19 -9.077209886078653E-11) -3.097220801854252200000000000009077209882E19) +(num-test (+ -2.3000547840875442E19 -3.2043634522621155E-11) -2.300054784087544200000000000003204363456E19) +(num-test (+ 2.124555308489292E19 2.252166800652451E-11) 2.124555308489292000000000000002252166802E19) +(num-test (+ -7.74280238703686E19 1.7289553748884322E-11) -7.74280238703685999999999999999827104461E19) +(num-test (+ -8.119446783121816E19 -4.3461802389685114E-11) -8.11944678312181600000000000000434618023E19) +(num-test (+ -4.70848534032654E18 -4.698316648967506E19) -5.16916518300016E19) +(num-test (+ 2.853799842810312E19 -5.56805968603395E19) -2.714259843223638E19) +(num-test (+ -2.9128622996090335E19 -5.153369106520702E19) -8.0662314061297355E19) +(num-test (+ -5.415993984772977E19 4.481932558278175E19) -9.34061426494802E18) +(num-test (+ -1.4652301908531261E19 7.89284449966826E19) 6.4276143088151335352E19) +(num-test (+ -8.241911630479252E19 5.377001886877124E19) -2.864909743602128E19) +(num-test (+ -6.923631123395076E19 7.100129853298664E-22) -6.923631123395076E19) +(num-test (+ -5.864213410820717E19 -2.649878514627326E-21) -5.864213410820717E19) +(num-test (+ 8.660575002861176E19 2.751926085897399E-21) 8.660575002861176E19) +(num-test (+ -3.0252871646631318E19 6.852831573716124E-21) -3.0252871646631318E19) +(num-test (+ -9.155476807340938E19 -5.552907466957205E-21) -9.155476807340938E19) +(num-test (+ -4.03382621358461E19 6.670808279457885E-21) -4.03382621358461E19) +(num-test (+ 8.842980509187577E-21 0.5028466982188534E0) 5.028466982188534000088429805091875769998E-1) +(num-test (+ 1.7292043381396136E-21 0.19490424064972922E0) 1.949042406497292200017292043381396136E-1) +(num-test (+ -5.854820918836103E-21 -0.6700030154364615E0) -6.700030154364615000058548209188361029995E-1) +(num-test (+ -2.152396491682048E-21 0.5002930268902921E0) 5.002930268902920999978476035083179519998E-1) +(num-test (+ -1.0897149666610629E-21 0.16555534170490604E0) 1.655553417049060399989102850333389370996E-1) +(num-test (+ 6.321421497987867E-24 -0.08008112131564671E0) -8.008112131564670999999367857850201213302E-2) +(num-test (+ -6.1552667309563055E-21 7.235074489769488E9) 7.23507448976948833465576171874384473328E9) +(num-test (+ -2.2311335001219955E-22 1.220011008333989E9) 1.220011008333988904953002929687276886647E9) +(num-test (+ 8.523565724937177E-23 -4.1650242034123087E9) -4.165024203412308699999999999999914764338E9) +(num-test (+ -2.4400041303825447E-21 4.435554678685388E9) 4.435554678685387611389160156247559995867E9) +(num-test (+ -3.4479065449345757E-22 8.491084033112451E8) 8.491084033112450838088989257809052093456E8) +(num-test (+ -7.919939059912893E-21 -7.610637842585286E9) -7.610637842585286000000000000007919939044E9) +(num-test (+ 4.4958602369105625E-21 5.758376768873417E-11) 5.758376769323003023691056249999999999989E-11) +(num-test (+ 2.4375297386412195E-21 9.417086717671841E-11) 9.41708671791559397386412194999999999998E-11) +(num-test (+ 1.0040647133383462E-21 3.4701016271268983E-12) 3.470101628130963013338346199999999999999E-12) +(num-test (+ -3.885093055726793E-21 -8.523534862249969E-11) -8.523534862638478305572679299999999999995E-11) +(num-test (+ 1.027951323422187E-21 -7.65508060829868E-11) -7.655080608195884867657781300000000000011E-11) +(num-test (+ -9.83813940552434E-21 -5.048380063082019E-11) -5.048380064065832940552434000000000000001E-11) +(num-test (+ -7.640856498925806E-21 -5.743808556015994E19) -5.743808556015994E19) +(num-test (+ 8.053891045717591E-21 4.0840032650134725E19) 4.0840032650134725E19) +(num-test (+ -4.794782783871528E-21 -3.431216587740782E18) -3.431216587740782E18) +(num-test (+ 1.860870988390988E-21 -3.757945694933625E19) -3.757945694933625E19) +(num-test (+ 5.445498222566789E-21 7.575823566817991E19) 7.575823566817991E19) +(num-test (+ 2.631896745307223E-21 4.906449817201212E19) 4.906449817201212E19) +(num-test (+ -6.61689881073516E-21 5.357007670385275E-21) -1.25989114034988500000000000000000000001E-21) +(num-test (+ 3.0173001109587537E-21 5.2947222461350496E-21) 8.312022357093803300000000000000000000009E-21) +(num-test (+ -8.792518441030627E-21 -1.0516787854168774E-21) -9.84419722644750439999999999999999999997E-21) +(num-test (+ 7.349451992884509E-21 -8.427997362671486E-21) -1.078545369786976999999999999999999999993E-21) +(num-test (+ -7.881179611953633E-21 3.2080446524364824E-21) -4.673134959517150599999999999999999999987E-21) +(num-test (+ -9.614117725927607E-21 -5.35667712698602E-21) -1.4970794852913627E-20) +(num-test (- -0.011326914400453525E0 -0.6668141757661364E0) 6.554872613656828749999999999999999999976E-1) +(num-test (- -0.46185382764946437E0 0.7488210697846337E0) -1.210674897434098070000000000000000000001E0) +(num-test (- -0.35834120541234993E0 -0.30919976341834987E0) -4.914144199400005999999999999999999999972E-2) +(num-test (- 0.44705025064976966E0 -0.9277893553610955E0) 1.374839606010865160000000000000000000002E0) +(num-test (- -0.47647537517067917E0 0.29158058381073604E0) -7.680559589814152099999999999999999999997E-1) +(num-test (- -0.021697999002707746E0 0.1779871773524142E0) -1.996851763551219460000000000000000000001E-1) +(num-test (- 0.4179484378019861E0 9.9990307469939E9) -9.999030746575951861270279525000000000019E9) +(num-test (- -0.7475415524823718E0 1.3993312799214797E9) -1.399331280669021252482371799999999999998E9) +(num-test (- 0.2519442433861928E0 -6.699632771871848E9) 6.699632772123792243386192799999999999993E9) +(num-test (- -0.5124988631497671E0 2.7959244812290273E9) -2.795924481741526163149767100000000000009E9) +(num-test (- -0.6870193827604301E0 4.851102442573468E9) -4.851102443260487591073418381249999999995E9) +(num-test (- 0.7609656780357723E0 7.481252865855436E8) -7.481252858245779544715519187499999999991E8) +(num-test (- -0.6301276042170191E0 -7.099314875214215E-11) -6.301276041460259512478578500000000000002E-1) +(num-test (- -0.4139053484357884E0 -2.897413526398709E-11) -4.139053484068142647360129100000000000006E-1) +(num-test (- -0.6944623060197281E0 -3.291569879873739E-11) -6.94462305986812401201262610000000000001E-1) +(num-test (- -0.2057822500703933E0 3.6505182026159854E-11) -2.057822501068984820261598540000000000004E-1) +(num-test (- -0.8792706674467908E0 8.094527736950817E-11) -8.792706675277360773695081699999999999978E-1) +(num-test (- -0.6888184243601332E0 9.127622796988807E-11) -6.888184244514094279698880700000000000006E-1) +(num-test (- -0.980711030497252E0 8.752272461345245E19) -8.752272461345245000098071103049725200009E19) +(num-test (- 0.8035082489836539E0 -3.903355151264917E19) 3.90335515126491700008035082489836539001E19) +(num-test (- -0.7537841372394811E0 -5.879942447417834E19) 5.879942447417833999924621586276051889998E19) +(num-test (- -0.6877475951546845E0 -2.3972266191169642E19) 2.397226619116964199931225240484531550001E19) +(num-test (- -0.43128282112433525E0 -5.422824998003439E19) 5.422824998003438999956871717887566474998E19) +(num-test (- 0.29538116818276694E0 1.1291858990580939E19) -1.129185899058093899970461883181723306002E19) +(num-test (- 0.9166687388673976E0 6.395175407123937E-21) 9.166687388673975999936048245928760629984E-1) +(num-test (- 0.41840538498193025E0 -2.6655662412599155E-21) 4.18405384981930250002665566241259915501E-1) +(num-test (- -0.8036940092501853E0 6.7473779576832565E-21) -8.036940092501853000067473779576832565009E-1) +(num-test (- 0.8555054025209989E0 -7.939970418096797E-21) 8.55505402520998900007939970418096796999E-1) +(num-test (- 0.3365495704567003E0 8.694519827555395E-21) 3.365495704567002999913054801724446050001E-1) +(num-test (- -0.7430322011471231E0 7.430332379292914E-22) -7.430322011471231000007430332379292914019E-1) +(num-test (- 5.102372414731216E9 -0.5073635765350494E0) 5.102372415238580007199111899999999999994E9) +(num-test (- 4.629827365822252E9 0.6534380055543355E0) 4.629827365168814268005234812499999999993E9) +(num-test (- 7.218192507117569E9 0.9781542046565127E0) 7.21819250613941476507004979999999999999E9) +(num-test (- 6.595760326622413E8 0.7339510561932947E0) 6.595760319282902834902380148437500000014E8) +(num-test (- 7.191166637703489E9 0.80792475493853E0) 7.191166636895564548650337188817616151937E9) +(num-test (- -7.95531405213956E9 0.5353636841430115E0) -7.955314052674923429931585718750000000006E9) +(num-test (- 5.438904545553836E8 6.533536518165114E9) -5.98964606360973083972930908203125E9) +(num-test (- -7.389650313101625E8 -9.983943153365381E9) 9.244978122055218499999999999999999999979E9) +(num-test (- 8.364404619492165E9 -7.600563055115287E9) 1.596496767460745161181640624999999999997E10) +(num-test (- 2.070813748323649E9 6.421052769114957E9) -4.350239020791307926177978515625E9) +(num-test (- -2.8555256820439434E9 -3.4077342921686625E8) -2.514752252827077150000000000000000000005E9) +(num-test (- 9.147878229420991E8 8.439982790150545E9) -7.525194967208446025848388671875E9) +(num-test (- -4.315772980070098E9 -6.48869466068404E-11) -4.315772980070097999935113053393159599999E9) +(num-test (- -3.5186299785635023E9 3.990046539849716E-11) -3.518629978563502300039900465398497159997E9) +(num-test (- 2.5645532837267537E9 8.566645694205622E-13) 2.564553283726753699999143335430579437802E9) +(num-test (- 6.145110896031829E9 -9.242734002954773E-11) 6.145110896031828880402485933779547730013E9) +(num-test (- -6.6836855975624E9 9.117930361283473E-11) -6.683685597562399864287956647362834729995E9) +(num-test (- -1.7472828462085754E8 -5.125838712019503E-11) -1.747282846208575399487416128798049699998E8) +(num-test (- 9.05675399397055E9 9.086705650502484E19) -9.0867056495968086006029449462890625E19) +(num-test (- -5.834806594586836E9 9.981576053842906E19) -9.981576054426386659458683599999999999999E19) +(num-test (- 3.047010922754272E9 1.1715352070471352E19) -1.171535206742434107724572801589965820312E19) +(num-test (- 7.294295638574767E9 2.845702947515113E19) -2.845702946785683436142523288726806640625E19) +(num-test (- 8.264143132493019E9 -1.6322956072452289E19) 1.632295608071643213249301910400390625E19) +(num-test (- -9.597823287256088E9 3.954126758718671E19) -3.95412675967845332872560880000000000001E19) +(num-test (- 3.229389511771705E9 -4.329831377266493E-21) 3.229389511771705150604248046879329831377E9) +(num-test (- 6.897089200279753E9 2.4428208790287663E-21) 6.897089200279752731323242187497557179116E9) +(num-test (- 2.3579775300187545E9 4.729400988996349E-21) 2.357977530018754499999999999995270599018E9) +(num-test (- 1.6718929117460046E9 5.8162277016717065E-21) 1.671892911746004599999999999994183772301E9) +(num-test (- 2.537177500868296E9 1.4856605280697543E-21) 2.537177500868296146392822265623514339469E9) +(num-test (- 6.117674696930935E9 -1.6187214719634357E-21) 6.117674696930934906005859375001618721474E9) +(num-test (- 4.1877888304549216E-11 -0.06920550501017497E0) 6.920550505205285830454921600000000000007E-2) +(num-test (- 9.61054846124015E-11 0.885309193732889E0) -8.85309193636783481398417376384291797877E-1) +(num-test (- 2.5559085051828467E-11 -0.8112181469812297E0) 8.112181470067887850518284670000000000006E-1) +(num-test (- -1.4549570208293283E-12 -0.5049325945871657E0) 5.049325945857107429791706717000000000005E-1) +(num-test (- -7.091628047158497E-11 0.61946884965934E0) -6.194688497302562955729347334266968816526E-1) +(num-test (- 2.877466355456826E-11 0.4496491857374E0) -4.49649185708625317645189543551619872451E-1) +(num-test (- 1.3041612488449928E-12 5.408018587130755E9) -5.40801858713075542449820755750115500719E9) +(num-test (- -5.379752339715717E-11 -4.009594691514288E9) 4.009594691514287999946202476602842829998E9) +(num-test (- 7.023042501342336E-12 -3.4153434285746374E9) 3.415343428574637400007023042501342336004E9) +(num-test (- 6.968174934871611E-11 4.713087404332662E9) -4.713087404332661628653462781901283890003E9) +(num-test (- -5.153562653896506E-11 -8.44732228013254E8) 8.447322280132540463885888851797849400006E8) +(num-test (- -8.424177457818745E-11 1.6817117809824567E9) -1.681711780982456700084241774578187449998E9) +(num-test (- 3.374755984316538E-11 8.893678266883364E-11) -5.518922282566826000000000000000000000009E-11) +(num-test (- -8.684123447823306E-11 -7.888825869147879E-11) -7.952975786754269999999999999999999999987E-12) +(num-test (- 7.788477523205632E-11 1.741674745286914E-11) 6.046802777918717999999999999999999999988E-11) +(num-test (- 6.546622477606044E-11 -4.7719651007530584E-11) 1.131858757835910240000000000000000000001E-10) +(num-test (- -1.8595152377503265E-11 5.7288738553553045E-11) -7.588389093105630999999999999999999999984E-11) +(num-test (- -8.184033550427558E-11 -8.834399228929296E-11) 6.503656785017380000000000000000000000234E-12) +(num-test (- 5.749469292140762E-11 7.493129199779113E19) -7.493129199779112999999999999994250530697E19) +(num-test (- -5.2285095120702066E-11 -2.0611179974216552E19) 2.061117997421655199999999999994771490491E19) +(num-test (- -8.84727820032067E-11 4.7423077384022024E19) -4.742307738402202400000000000008847278205E19) +(num-test (- 3.437676989338625E-11 -3.5368755480277647E19) 3.536875548027764700000000000003437676988E19) +(num-test (- 2.2665031619145437E-11 -6.072845659234921E19) 6.072845659234921000000000000002266503153E19) +(num-test (- -8.429070146313393E-11 5.134329153614969E18) -5.134329153614969000000000000084290701453E18) +(num-test (- -9.009531819191212E-11 2.301790665456671E-22) -9.009531819214229906654566710000000000025E-11) +(num-test (- -2.706942469371907E-11 9.282350542107287E-21) -2.706942470300142054210728700000000000001E-11) +(num-test (- 5.358266626996117E-11 -4.409057695582885E-22) 5.358266627040207576955828850000000000004E-11) +(num-test (- -7.189537285608088E-11 9.569273217393917E-21) -7.189537286565015321739391700000000000027E-11) +(num-test (- -4.160295905335358E-11 5.930867524794025E-21) -4.160295905928444752479402499999999999992E-11) +(num-test (- 6.7922062777334035E-12 -7.747524338474154E-22) 6.792206278508155933847415400000000000006E-12) +(num-test (- -9.038821102045805E19 0.04779131019959271E0) -9.038821102045805000004779131019959271002E19) +(num-test (- 2.2020595055495963E19 -0.424631558292516E0) 2.202059505549596300042463155829251600002E19) +(num-test (- -8.164003027214308E19 0.6832198147365239E0) -8.164003027214308000068321981473652389997E19) +(num-test (- -3.878233560364984E19 -0.28756619113600546E0) -3.878233560364983999971243380886399453999E19) +(num-test (- 7.0829003521450525E19 -0.6071548125948544E0) 7.08290035214505250006071548125948544E19) +(num-test (- 5.968540808784698E19 0.7674294173432648E0) 5.968540808784697999923257058265673519995E19) +(num-test (- -2.2143621795153547E19 -2.443529365769125E9) -2.214362179271001763423087500000000000004E19) +(num-test (- -9.77092538926342E18 5.903189771537687E8) -9.770925389853738977153768658638000488281E18) +(num-test (- 9.974714452399537E19 -6.980456691485629E9) 9.974714453097582669148562899999999999991E19) +(num-test (- 1.7428950527159094E18 3.68843657888816E9) 1.742895049027472821111839771270751953125E18) +(num-test (- -1.1094381875350845E19 -7.157723640671709E9) -1.109438186819312135932829100000000000002E19) +(num-test (- -3.638795590369631E19 6.9246542750294075E9) -3.638795591062096427502940750000000000005E19) +(num-test (- -5.66543282261991E19 -5.1005028153082024E-11) -5.665432822619909999999999999994899497189E19) +(num-test (- -3.901527864456216E19 -1.064153465992923E-12) -3.901527864456215999999999999999893584646E19) +(num-test (- 1.1477489418879848E19 3.327888063907735E-11) 1.147748941887984799999999999996672111937E19) +(num-test (- 3.508978072054437E19 9.238453417997638E-11) 3.508978072054436999999999999990761546584E19) +(num-test (- -4.7642024461416964E19 -4.758309941438892E-11) -4.764202446141696399999999999995241690065E19) +(num-test (- -8.307715835429606E19 3.313910202186439E-11) -8.307715835429606000000000000003313910214E19) +(num-test (- 2.704675010192592E18 -2.6840207147078365E19) 2.9544882157270957E19) +(num-test (- -9.860969100714668E18 -4.719594638795429E19) 3.7334977287239622E19) +(num-test (- 7.87799781828944E18 -6.657221298850535E19) 7.4450210806794789744E19) +(num-test (- -3.3937781740759863E19 4.783805995045389E19) -8.1775841691213753E19) +(num-test (- -1.0747572720102216E19 -1.7144708598072445E19) 6.397135877970229E18) +(num-test (- 1.3938845733158445E19 5.604369854609131E19) -4.2104852812932865E19) +(num-test (- 6.0938348303695315E19 1.1005522580049531E-21) 6.0938348303695315E19) +(num-test (- -2.4870844028694925E19 1.5391650322730598E-22) -2.4870844028694925E19) +(num-test (- 7.323118607079343E19 6.637280375859432E-21) 7.323118607079343E19) +(num-test (- -4.181201584825501E19 4.768935182006663E-21) -4.181201584825501E19) +(num-test (- 4.1225910279381205E19 6.117191687463543E-21) 4.1225910279381205E19) +(num-test (- 6.438313875980151E17 -1.4883489002691529E-21) 6.438313875980151E17) +(num-test (- -4.573961206963222E-21 0.3586300020381973E0) -3.586300020381973000045739612069632220001E-1) +(num-test (- 7.74206782371325E-22 0.23168389210368656E0) -2.316838921036865599992257932176286750005E-1) +(num-test (- 8.572446613640605E-21 0.6114581963443891E0) -6.114581963443890999914275533863593949978E-1) +(num-test (- -8.539467934859551E-21 0.33474735899049E0) -3.347473589904900182020371578704711119401E-1) +(num-test (- -5.55811309570968E-21 -0.9637216018651454E0) 9.637216018651453999944418869042903199998E-1) +(num-test (- -6.705839413964189E-21 0.3787619614522374E0) -3.787619614522374000067058394139641890005E-1) +(num-test (- 1.338539206480238E-22 6.683968625235106E9) -6.683968625235106468200683593749866146082E9) +(num-test (- -9.64078167549023E-21 3.291420859310843E9) -3.291420859310842990875244140634640781671E9) +(num-test (- -9.26536204591093E-22 2.9839295142529476E8) -2.98392951425294760000000000000926536205E8) +(num-test (- -3.647737608953592E-21 6.115300020921433E8) -6.115300020921432971954345703161477376078E8) +(num-test (- 1.4069763806331204E-21 -1.183109060480878E9) 1.18310906048087800000000000000140697638E9) +(num-test (- -6.0037865798761924E-21 -7.442246743849378E9) 7.442246743849377999999999999993996213425E9) +(num-test (- -5.994118986299138E-21 -9.091558282012836E-11) 9.091558281413424101370086199999999999991E-11) +(num-test (- 6.969393585974241E-21 3.435352867093995E-11) -3.435352866397055641402575899999999999989E-11) +(num-test (- -6.278554484817533E-22 -4.7211920270841604E-11) 4.721192027021374855151824670000000000001E-11) +(num-test (- -8.603262886304741E-21 1.7296517702077242E-11) -1.729651771068050488630474100000000000006E-11) +(num-test (- 4.104502790901735E-21 -4.8473213720301105E-11) 4.847321372440560779090173499999999999986E-11) +(num-test (- -4.449725859444968E-21 -8.944265568403936E-11) 8.944265567958963414055503200000000000002E-11) +(num-test (- 4.828216540804827E-21 -1.1712152029346877E19) 1.1712152029346877E19) +(num-test (- -5.65034940464881E-21 -9.445303840982011E19) 9.445303840982011E19) +(num-test (- -7.24107519738777E-21 2.340578690102746E19) -2.340578690102746E19) +(num-test (- 1.7659593956231534E-21 -8.048768257390671E18) 8.048768257390671E18) +(num-test (- -3.0538518255248124E-21 8.834631867521575E19) -8.834631867521575E19) +(num-test (- 8.57952908388053E-21 -5.730742870111307E19) 5.730742870111307E19) +(num-test (- -4.5090103564928485E-21 1.8907114777916313E-21) -6.399721834284479799999999999999999999996E-21) +(num-test (- -3.8487625143236447E-22 5.354282198078924E-21) -5.739158449511288470000000000000000000003E-21) +(num-test (- 2.6660110440404615E-22 3.833744224501756E-22) -1.167733180461294499999999999999999999996E-22) +(num-test (- -7.503762004261027E-22 -9.623906576475644E-21) 8.873530376049541300000000000000000000014E-21) +(num-test (- -9.113431042260725E-21 -3.5516521546085545E-21) -5.561778887652170499999999999999999999997E-21) +(num-test (- -3.4813735333296525E-21 -2.6602650182385188E-21) -8.211085150911336999999999999999999999942E-22) +(num-test (* -0.2554913394465045E0 0.27042187315261135E0) -6.909044658739340841916780452607499999997E-2) +(num-test (* -0.4489211233229662E0 -0.42892136850270857E0) 1.925518625654598642702435865603340000003E-1) +(num-test (* -0.44586465919973783E0 -0.15168042462027043E0) 6.762894083058839862686475970136690000031E-2) +(num-test (* 0.5509395670465355E0 0.3577558280766836E0) 1.971018410289428517174637096677999999998E-1) +(num-test (* -0.42780066410606965E0 0.22704747885906007E0) -9.713106223951470697784938095387549999991E-2) +(num-test (* 0.20955388816500042E0 0.605628751935113E0) 1.269118597525194529275610775776050864747E-1) +(num-test (* 0.9993471610818964E0 -4.363771855901198E9) -4.360923015803940523218504871887199999987E9) +(num-test (* 0.10502219375257282E0 3.425205053451057E9) 3.597225487658284459716764716837978363041E8) +(num-test (* 0.7768651149081368E0 1.666066330143864E9) 1.294308811011790623456907580692100524906E9) +(num-test (* -0.6438389801759042E0 2.8922130868526487E9) -1.862119524290613178578671687454540000003E9) +(num-test (* -0.7427680566504474E0 6.763974500466173E9) -5.024064194944440168218138681386184692391E9) +(num-test (* -0.8563035843259611E0 2.9100478627456827E9) -2.491884415429230578930028553142970000007E9) +(num-test (* 0.6219502737119671E0 2.8868752190811842E-11) 1.795492832679837500144381979439820000005E-11) +(num-test (* 0.6767479505813657E0 2.9324524289075574E-11) 1.98453117144053746900587234314118E-11) +(num-test (* 0.7944531541461581E0 8.282076647859848E-11) 6.579721915772496180466156449968800000014E-11) +(num-test (* -0.4662914070981966E0 -6.921260263903422E-11) 3.22732418734836218212517276876520000001E-11) +(num-test (* 0.037804762510578516E0 -3.044514833184461E-11) -1.150971602284721156705916516398760000005E-12) +(num-test (* -0.5364168049485208E0 -3.695280705974925E-11) 1.982210669686983584095600640940000000003E-11) +(num-test (* 0.10343751426551051E0 4.8902635121181385E19) 5.058367017968254798845671333856350000002E18) +(num-test (* -0.45511004829813784E0 1.8210069906740634E19) -8.287585794769196371535086060990559999988E18) +(num-test (* -0.9675158737162977E0 8.097401718869682E19) -7.834364698864051180664785816331399999997E19) +(num-test (* -0.06573561186185628E0 2.6049125586869125E19) -1.712355208919177984462215919354999999997E18) +(num-test (* -0.5574365795036731E0 -8.822383181882661E19) 4.917919103979402413863422702119099999985E19) +(num-test (* -0.4222667103024276E0 -1.8561723355961213E19) 7.837997859065477747526525340678799999995E18) +(num-test (* -0.8412207478192143E0 2.3416069046402696E-22) -1.969808311420123220453436412175280000003E-22) +(num-test (* 0.24291385591230452E0 -9.448120185342916E-21) -2.295079305344524973092760016780319999996E-21) +(num-test (* -0.37792600430678414E0 -2.3929024368177364E-21) 9.043400566424941101603791982206959999978E-22) +(num-test (* -0.007648867433060369E0 -5.3162210182098465E-21) 4.066306981313632980042734472335849999998E-23) +(num-test (* -0.7631807323096114E0 -4.534410248041209E-21) 3.460574533692296555855373976182600000004E-21) +(num-test (* 0.4735366300649959E0 -1.3895270471326203E-21) -6.579919552833457409343160757567699999986E-22) +(num-test (* -8.64834403600587E9 -0.14057280586223464E0) 1.215721987203268063989050502795104980466E9) +(num-test (* -1.5525713051163936E9 0.10621224657238759E0) -1.649020862802360033147528021954240000002E8) +(num-test (* 3.297132746298694E9 0.05318660311813239E0) 1.753632908051865357781730185173082351681E8) +(num-test (* 2.1659831568875275E9 0.11704159596099262E0) 2.535101255067452830195785975470499999995E8) +(num-test (* -5.533403510176525E9 0.37778599060251605E0) -2.090442326495477997892444645726250000003E9) +(num-test (* -2.4217306331294374E9 0.6051350227557695E0) -1.465474021787126179631541139079300000002E9) +(num-test (* 1.4048311850866513E9 -4.304799039580996E9) -6.047515936334448947178704758694799999987E18) +(num-test (* -5.070278162013437E9 -9.116233758795675E9) 4.622184094703138120556628748497500000004E19) +(num-test (* 8.452801605894673E9 -9.002885976919611E9) -7.609960904339272295066535438875484466566E19) +(num-test (* 6.352601599408395E9 -4.484034289922495E9) -2.84852834019637276707985964548254013062E19) +(num-test (* -6.565407710101401E8 -6.718825369609182E9) 4.411182788445701880089696066398200000001E18) +(num-test (* -9.37193973536698E9 9.577576231327314E9) -8.976046725088278448381480077370724757202E19) +(num-test (* -1.7766859308675253E9 -4.079350537765101E-11) 7.247724707524128390808760574555300000015E-2) +(num-test (* 2.3810136983742104E9 9.195156930614704E-11) 2.189379461049416913728349262972160000005E-1) +(num-test (* -3.313966320976337E9 -3.44704749912067E-11) 1.142339931889161000998337758579000000001E-1) +(num-test (* 6.598963960681895E9 -2.4298605961767928E-11) -1.6034562503651679888964996364737701416E-1) +(num-test (* 7.908258993705348E9 1.528909719631646E-11) 1.209101404084048656249131044486427307128E-1) +(num-test (* -5.906667889594469E9 5.917852809041966E-11) -3.4954791162514609467168142486054E-1) +(num-test (* 4.86261281419926E9 -2.3925611132123714E19) -1.1634098327861323021375513143190574646E29) +(num-test (* -9.753392818607462E9 -2.5653634777279775E18) 2.502099772078991953507318766810499999998E28) +(num-test (* 1.5861252889272392E9 5.12939252547053E19) 8.135859201483165467280698143134187520016E28) +(num-test (* -8.422142961023593E8 1.0428099441045047E19) -8.782694430425160722507674279387100000022E27) +(num-test (* -3.109042783121446E9 -4.138252722536039E19) 1.286600476173334775049764879239400000004E29) +(num-test (* -6.459303282089468E8 1.8408981660472957E19) -1.18909195659417795593544068516876E28) +(num-test (* -1.432764110232635E9 8.98766033001457E-21) -1.287719715580647603395563949195000000001E-11) +(num-test (* 8.539623949953406E9 -3.498784805440049E-21) -2.987830652026891151867478398400020599353E-11) +(num-test (* 7.336784327799637E9 -1.048985206018761E-21) -7.696178219612118988966933703567504882842E-12) +(num-test (* -4.320357143553698E9 2.591531476439043E-21) -1.119634152697768142457549423101400000004E-11) +(num-test (* -9.374098076239548E9 5.5773248420603045E-21) -5.2282390072520541300690003822366E-11) +(num-test (* 9.118926580475056E9 -1.379170270330765E-21) -1.257655243712018104094987568109512329098E-11) +(num-test (* 8.145792307872788E-11 -0.06511382435429458E0) -5.304036895613925967063321178890399999982E-12) +(num-test (* -6.1928426627437E-11 0.2526275616632321E0) -1.564482741652978543296795912770000000003E-11) +(num-test (* -8.555119338859813E-11 -0.8366318482083728E0) 7.157485304113477734096792042286400000002E-11) +(num-test (* 8.243060442429263E-12 0.3939656708074719E0) 3.247482836708180702664407610209699999993E-12) +(num-test (* 8.600529286105945E-11 -0.891441509265547E0) -7.666868807288821095008580376914999999987E-11) +(num-test (* -7.531046724969747E-11 0.24398797995196886E0) -1.837484877349259372047496586078419999997E-11) +(num-test (* -3.7666526619188126E-12 4.659322150343885E9) -1.755004818033008198811983615043067932129E-2) +(num-test (* 3.032501107241211E-11 -9.592046453776636E9) -2.908789149178678011789796814619600000006E-1) +(num-test (* 7.311626957349528E-11 -9.061108567148174E9) -6.625144566303134478698468496187199999991E-1) +(num-test (* 4.898078204161461E-11 8.88014689134599E9) 4.34956539382539434542556734824485778809E-1) +(num-test (* 1.278207138618518E-11 -4.279966992086118E9) -5.470684362336102162321405533123999999992E-2) +(num-test (* -8.538580654966055E-11 -5.191059833953482E8) 4.432428307696650304902715905351E-2) +(num-test (* 4.0761422500127225E-11 1.527607426117321E-11) 6.226745171030000570391027616422499999987E-22) +(num-test (* -9.186363051001198E-11 8.557763803549676E-11) -7.861472520412421845045812851184799999979E-21) +(num-test (* -9.89183505930065E-11 9.717968160611499E-11) -9.61285381563042758142312881743500000002E-21) +(num-test (* 7.440627873114725E-12 -4.535521332601712E-11) -3.374712644646273959960130740919999999997E-22) +(num-test (* 8.701410920357686E-11 -7.032883383151379E-12) -6.119600827175551716944456414899399999975E-22) +(num-test (* 9.866226673114161E-11 -2.814669610817353E-11) -2.777016839025002299729708883583300000003E-21) +(num-test (* 5.192240545105114E-11 -3.366056660574579E19) -1.747737587015645175992519129700599999996E9) +(num-test (* -1.372355669576939E-11 -4.819955130360066E19) 6.614692750256090679268960117974000000002E8) +(num-test (* 3.637511103766519E-11 -4.071776382810416E19) -1.481113180452716050522430526190399999997E9) +(num-test (* 7.446388208685151E-13 2.7760294268649034E19) 2.06713927911698144246650226294134E7) +(num-test (* 6.267855179410938E-11 7.471751480940298E19) 4.683185621908299321917798617952399999997E9) +(num-test (* -4.336562006766369E-11 8.143188451558233E19) -3.531344165296609191472762946597699999996E9) +(num-test (* -1.0432655006975122E-11 -9.379512413340694E-21) 9.785321714202410134613576821466799999983E-32) +(num-test (* -8.167646898574611E-11 -5.810795749825724E-21) 4.746052788431460582580726109336400000004E-31) +(num-test (* -4.33805459341994E-11 -2.4289860591796017E-21) 1.053707413137706937228749003789799999998E-31) +(num-test (* -1.384613082275421E-11 2.2174009100764947E-21) -3.070242308741338958377843646768700000007E-32) +(num-test (* -4.910905591314494E-11 -5.456657623752349E-21) 2.679713043437427118620763024640600000007E-31) +(num-test (* 1.3653011366548008E-11 -3.925911962906968E-21) -5.3600520653635635667567009719744E-32) +(num-test (* 7.641468950470222E19 0.9034599537348024E0) 6.903761184457755820350566254132800000009E19) +(num-test (* 5.146778093125584E19 -0.2791459460022878E0) -1.436702239669392041403916711075200000002E19) +(num-test (* -8.874303077863696E19 -0.23153988023519345E0) 2.054755071819368785424861291991199999996E19) +(num-test (* 7.10798162637783E19 -0.4719034863212067E0) -3.354281310194779040746230255943679999999E19) +(num-test (* -9.820386602197546E19 0.03346146041258036E0) -3.286044775256677372510003197965599999991E18) +(num-test (* -5.210458089116161E19 0.11173798093222442E0) -5.822060666098160855554015008516199999997E18) +(num-test (* 3.257626718953688E18 -6.150510855712356E9) -2.003606849878328222529021336892800000007E28) +(num-test (* -7.755105754004988E19 5.514896832715505E9) -4.276860816013589383294629509647750854492E29) +(num-test (* 2.426235084788384E19 8.685431434428486E9) 2.10728984727342930836693974581298828125E29) +(num-test (* -2.847383850475709E19 -2.412830829567453E9) 6.870255538040273498936753499177000000002E28) +(num-test (* 1.4664659669727164E19 -4.8673539253155E9) -7.137808880686241930432174599520111083984E28) +(num-test (* -4.24770317054668E19 1.3102543269150825E9) -5.5655714586597020914994623011E28) +(num-test (* 2.17116835964837E19 -3.654789326884115E-11) -7.935162947711353824080778955354111999976E8) +(num-test (* -1.8125809977916906E17 -5.944782899600832E-11) 1.077540051981345570924422644657920000001E7) +(num-test (* -7.915462827540546E19 9.762153025588201E-11) -7.727195939080587759467382669774600000011E9) +(num-test (* -4.360953588949649E19 -7.152431005584812E-11) 3.119141966351983288172806713098800000002E9) +(num-test (* 3.550776271395866E19 -6.387656982922894E-11) -2.268114084477872045705002835620399999998E9) +(num-test (* -8.278954580496595E19 -7.359178231519021E-11) 6.09263023285252303789473682334949999999E9) +(num-test (* -5.5022682113038156E19 -8.979630229039327E19) 4.94083339585058897667477175561012E39) +(num-test (* 1.1716230943203277E19 5.5764415854118265E19) 6.53348774559675813536051493554405E38) +(num-test (* 7.462799608352103E19 6.061883497941003E19) 4.5238621794310193360802344979309E39) +(num-test (* -3.2160334983646097E19 -3.8817785710003675E19) 1.248392991757108737054938769406475E39) +(num-test (* 5.868090263060238E19 -8.37300331667736E19) -4.913353923516549470233569081168E39) +(num-test (* -7.3652924769962656E19 9.725738480757314E19) -7.16329084655549342691442378865984E39) +(num-test (* -6.447063647969567E19 4.0587529685661844E-21) -2.616703871973161409821231651015480000002E-1) +(num-test (* -3.1999317568381926E17 3.015031281949113E-21) -9.647894346969533174030688093163799999993E-4) +(num-test (* -1.5005852398726605E19 5.391316601974659E-21) -8.090130116403600588996007910269500000005E-2) +(num-test (* 1.0084552719733576E19 2.78150956101201E-21) 2.805027980846861049488413624776000000002E-2) +(num-test (* -7.171404412051077E19 1.4733392992015492E-21) -1.056591195074223176150038792848839999998E-1) +(num-test (* -5.909802783283228E19 5.356071274587122E-21) -3.165332492601832012651928738981599999998E-1) +(num-test (* 8.272641144282955E-22 -0.16191056182923802E0) -1.339427975482523749443486923949099999995E-22) +(num-test (* 8.410471541398583E-21 -0.43256058128353736E0) -3.638038458816019512260007931560879999991E-21) +(num-test (* -7.887238384137063E-22 0.5589746137044918E0) -4.408766028968254895651429959583400000002E-22) +(num-test (* 4.778995446616728E-21 0.21608373898977795E0) 1.0326632047200663557809034755476E-21) +(num-test (* 3.992449163872154E-21 0.9593422165456676E0) 3.830125030315009512425388980010399999991E-21) +(num-test (* -9.700320218813958E-21 -0.42620535269852766E0) 4.134328400148261975602018057078279999983E-21) +(num-test (* -1.7901566262876555E-21 9.461674014776534E8) -1.693787843332593653628245958251059055323E-12) +(num-test (* 1.0928019952544443E-22 8.279199780524873E9) 9.047526039267738313652918648958873748777E-13) +(num-test (* 9.942869097320962E-21 9.523169242022762E9) 9.46876251650656124754254949341964721678E-11) +(num-test (* -2.7432601692209267E-21 -4.922145522647528E9) 1.350272575938808435595052562419760000003E-11) +(num-test (* -5.97929682563092E-21 -6.147792689359443E8) 3.675947731212389417723913477756000000004E-12) +(num-test (* -1.3564305221188254E-21 1.0862842413758955E9) -1.4734691006989580907776383331457E-12) +(num-test (* -5.446806293721964E-21 -1.5358504316888942E-11) 8.365479797538664267835041412208799999977E-32) +(num-test (* -1.0222776562632463E-21 -1.9781477525280056E-11) 2.022216248196737715829186720579279999999E-32) +(num-test (* 8.192540157543917E-21 3.3215076993103644E-11) 2.721158521019146605658900627335480000005E-31) +(num-test (* 9.685592607330157E-21 6.034805605641166E-11) 5.845066856067266821880143244306199999988E-31) +(num-test (* 6.671870463340688E-21 -9.07657686679269E-11) -6.055774510579551477490933797071999999989E-31) +(num-test (* -1.109409648670322E-21 -4.7905821901849965E-11) 5.314718104539438656835419223873000000025E-32) +(num-test (* -3.9052432481663676E-22 2.0306112771345453E19) -7.930030979680167745084943578652280000005E-3) +(num-test (* 8.596834841113507E-21 -9.453548987989818E19) -8.127059931212420192062869827172600000005E-1) +(num-test (* 3.946325780779758E-21 -9.084484011754447E19) -3.585033346066809630978128408382600000004E-1) +(num-test (* 5.3518824877647604E-21 -6.814116447592617E19) -3.64683504854607466529059878139668000001E-1) +(num-test (* -7.456278485417833E-22 9.61914445493285E19) -7.172301984744205963559813785437470719996E-2) +(num-test (* -5.0781537010216826E-21 9.216915512986622E19) -4.680491362427717476508990573017719999994E-1) +(num-test (* 3.2906792172396555E-22 4.571445785546992E-21) 1.504316163923729767672342114125599999998E-42) +(num-test (* 5.39814714322422E-21 6.687033308557664E-21) 3.609758975123575798079875142208000000008E-41) +(num-test (* 4.3506183844841724E-21 7.266196706225928E-21) 3.161244897538486151238585450198720000008E-41) +(num-test (* 6.910763289107986E-21 3.910584203890238E-21) 2.702512175521023610171407324066800000011E-41) +(num-test (* -4.6131515924393325E-21 5.228174479773633E-21) -2.411836142691841383820888561997250000001E-41) +(num-test (* -2.1886866436065787E-21 6.29322016055891E-22) -1.377388691069093503544474490121700000002E-42) +(num-test (/ -0.651381628953465E0 -0.9237050214744277E0) 7.051835962889135018948026610294923703508E-1) +(num-test (/ 0.5067986732438687E0 0.6260017267692811E0) 8.095803119575965307784422745290898299591E-1) +(num-test (/ -0.8399445051045212E0 0.1829250718359493E0) -4.591740742120902283769244624290448381427E0) +(num-test (/ -0.5987041550692662E0 -0.4124053212463479E0) 1.451737221187875469260813375116670894624E0) +(num-test (/ 0.5861382519823647E0 -0.7560374696447822E0) -7.752767230673855251634630463492900473644E-1) +(num-test (/ -0.012882644582824954E0 -0.4671067448591679E0) 2.757965866390787237919533761751626109973E-2) +(num-test (/ -0.7830198970435231E0 2.1690164135025935E9) -3.610022921767930828778117437420472499541E-10) +(num-test (/ -0.2339206226652567E0 2.729373380002701E9) -8.570488170622710029144125942503181451939E-11) +(num-test (/ -0.2285806315782951E0 -2.602073870582813E9) 8.784555817667757706754728345837912936962E-11) +(num-test (/ -0.5298716781559242E0 1.3509547453340487E9) -3.922201539215168658138266422439019362809E-10) +(num-test (/ 0.7287190523338418E0 -8.244205871151566E9) -8.839166121309546680006433484161854320415E-11) +(num-test (/ 0.18973054487786212E0 6.557593452200545E9) 2.893295326415727180554709812740977209383E-11) +(num-test (/ 0.5084032300982587E0 4.5431682148621014E-11) 1.119049980221104893780059617560389832312E10) +(num-test (/ 0.6621212705475221E0 -1.838873437953206E-11) -3.6006897314505184969089186237646638616E10) +(num-test (/ -0.4041791750277005E0 7.707875701307648E-11) -5.243716825365141031107302892929967408104E9) +(num-test (/ -0.09569063343466655E0 4.789751448902253E-11) -1.9978204392338054187984205729651608099E9) +(num-test (/ -0.6471008513340974E0 1.890250884404079E-11) -3.423359600956370337454713673029890117878E10) +(num-test (/ -0.4301276572683971E0 9.134844738134672E-11) -4.708647706651977799170970961042517830565E9) +(num-test (/ -0.5061027989171409E0 4.246468515299164E19) -1.191820443490291421327933820140392588455E-20) +(num-test (/ -0.9601783702217944E0 7.495754288877955E19) -1.280962973461506313537075112900039769719E-20) +(num-test (/ -0.6477754868655262E0 -8.507334914535449E19) 7.614317449272520944989386124046318248581E-21) +(num-test (/ 0.1934462826116784E0 3.6173521417193476E19) 5.347731573618163299262146929108634114511E-21) +(num-test (/ -0.7794308505212441E0 4.172217291786081E19) -1.868145391314406352823434511710862322776E-20) +(num-test (/ -0.8462346361305484E0 7.378170819620111E19) -1.146943675904374803577079154661818066039E-20) +(num-test (/ 0.9783005897625496E0 6.175045007596078E-21) 1.584280905740958108982369263614665552851E20) +(num-test (/ -0.9700832605850568E0 -1.7695051741124812E-21) 5.4822290139480091183029856440319954731E20) +(num-test (/ 0.07062591404368701E0 -8.855398515753737E-21) -7.975464223100026969579387130724758972895E18) +(num-test (/ 0.4751383409805402E0 -8.1371029771106E-21) -5.839158510308749293926976970601471638106E19) +(num-test (/ -0.5103510786836052E0 8.302178001281015E-21) -6.147195092719750272554937885528717433502E19) +(num-test (/ 0.7148807879199733E0 4.338856119331781E-21) 1.647625015115898182854639201045676562387E20) +(num-test (/ 4.180670608983218E9 -0.8621420131862095E0) -4.849167010818503318377538718886882159085E9) +(num-test (/ 3.202209376555907E9 0.008113117870009012E0) 3.946952858152361317410218375892707092144E11) +(num-test (/ 7.767843042272955E9 -0.04145956871894663E0) -1.87359475322354819500790198613468533242E11) +(num-test (/ 1.1937839884817846E9 0.45557753834605563E0) 2.620374992181877679062077123717269598672E9) +(num-test (/ -2.4205138097471213E9 -0.3737757916008485E0) 6.475844247109412171348144805246962117951E9) +(num-test (/ -7.534066568550288E9 -0.3609372553147958E0) 2.087361849632108651836399241353567759856E10) +(num-test (/ 6.098867840095913E9 3.0464612528039427E9) 2.001951554277132357084991750811780094278E0) +(num-test (/ 4.956687716396978E9 7.035407926465974E9) 7.045345157244949942198957065331702603612E-1) +(num-test (/ 6.969049109639194E9 -8.115758334653503E9) -8.587058438990264159516222429259889060394E-1) +(num-test (/ -8.0699835500126705E9 -1.1896420666819375E9) 6.783539163608157717597859343396495021042E0) +(num-test (/ -2.229793060172571E9 -2.658809828346301E9) 8.386433043838395143199282594014446842336E-1) +(num-test (/ 3.0672739776038485E9 -7.988270854370873E9) -3.839722054398737311833139439634292109412E-1) +(num-test (/ 2.477055391151669E9 -1.3522358047779648E-11) -1.831822070085178675709536653203693354871E20) +(num-test (/ 1.1318646612469008E9 -8.457695758685169E-11) -1.338265992938554414702828284241585726631E19) +(num-test (/ -7.978772126259147E9 6.210468872769038E-11) -1.284729428601367805018001112036580297153E20) +(num-test (/ -9.057338243339752E9 7.364415429198257E-11) -1.22987877726580108212627205863468836645E20) +(num-test (/ -5.341117220720213E9 4.7359651161519756E-11) -1.127777990277920421924982539741683693507E20) +(num-test (/ 5.838003830912871E9 -5.0625478501901024E-11) -1.153175042225753978331600642680269130096E20) +(num-test (/ 6.407156672927742E9 5.006339136594536E19) 1.279808758079079048751288572047629634958E-10) +(num-test (/ 4.687485139826675E8 -3.5561755068968083E19) -1.318125365504547538826162177354689732851E-11) +(num-test (/ -5.838044723576891E9 -6.843985743599882E19) 8.530182473036721969937888742798001972008E-11) +(num-test (/ 3.9279221543350096E9 -5.882918042982924E19) -6.676826237652909876656284584084555589571E-11) +(num-test (/ -9.686323716926361E9 -3.44800215666902E19) 2.809256861452760638746791455737599480861E-10) +(num-test (/ 7.301304808910639E9 1.2845297359643038E19) 5.684029419085037872687787191413868358377E-10) +(num-test (/ 4.380345662298534E9 -4.352751895415198E-21) -1.006339384266859136854551985691861659542E30) +(num-test (/ 8.239490918139045E9 3.2397577733346748E-21) 2.543242888698483402490821850315555889368E30) +(num-test (/ 3.8980499504872713E9 8.311650110069505E-21) 4.689862901910189296816144765858628505003E29) +(num-test (/ -9.425472285331268E9 -3.294031046828316E-21) 2.861379310436876111669825630018089608938E30) +(num-test (/ 2.517833161624173E9 3.6891560299469316E-21) 6.824957093669990747641669780362243770063E29) +(num-test (/ -5.463519676339016E9 -7.298583081866205E-22) 7.485726496576409428699223883071063828111E30) +(num-test (/ 1.39357009199772E-11 0.417842407627649E0) 3.335157146709649079791043787228216537723E-11) +(num-test (/ 8.58494900746665E-11 -0.6481371063028898E0) -1.324557554872456302657963676252150750478E-10) +(num-test (/ -9.310282234439046E-11 0.9146343299129254E0) -1.017923986663107128254299604028521252096E-10) +(num-test (/ -8.800556770159418E-11 -0.9305573406536135E0) 9.457296596014170681132977631993414317205E-11) +(num-test (/ -1.3361456473382827E-11 0.06420301636905124E0) -2.081125970247038707404762086321230923761E-10) +(num-test (/ 6.1406425153971765E-12 -0.3082496074575478E0) -1.992100676476244033296635444865296145538E-11) +(num-test (/ -3.6962256202372035E-11 3.089420488573177E9) -1.196413901541863127466123235969256148157E-20) +(num-test (/ -6.145126590884831E-11 -6.225608984106817E9) 9.870723661849873241350389006374300024184E-21) +(num-test (/ 9.052281678541901E-11 -6.9187138778508625E9) -1.308376359878287335554324548627653637652E-20) +(num-test (/ -3.4950245360118636E-11 7.543342567738434E9) -4.633257080169574405642456881139071687897E-21) +(num-test (/ -3.482822570743636E-11 -3.87599225187502E9) 8.985628309909063146939690605121402184145E-21) +(num-test (/ -9.42226868788213E-11 7.501937454180854E9) -1.25597803839741017709728590003874245271E-20) +(num-test (/ -4.8165035309367155E-11 9.484620130429997E-11) -5.078225026096383416618039442767276425835E-1) +(num-test (/ 6.880022773725747E-11 -9.699156104509544E-11) -7.093424107822057000929770558471489984227E-1) +(num-test (/ 1.5817962388036865E-11 -7.11651152335492E-11) -2.222712959309569253469449863287830842251E-1) +(num-test (/ -7.0140750853949335E-12 -4.4677941652531186E-11) 1.569919030725435801904141818366904619636E-1) +(num-test (/ -2.6947489262085355E-11 8.365454450205894E-11) -3.221282169723859093984652053864584015511E-1) +(num-test (/ 8.703167674410303E-11 -4.88739813223768E-11) -1.780736383435491638475146912252252561499E0) +(num-test (/ 1.165112061543483E-12 -5.899528740399518E19) -1.974923952086012268924127751659019857389E-32) +(num-test (/ 7.126386981630328E-12 5.091741402945837E19) 1.399597194293359595983101664952569614126E-31) +(num-test (/ -7.132349854872655E-13 7.70347159367981E19) -9.258617712985762871283798832641751905855E-33) +(num-test (/ 4.507266517270466E-11 -1.6192737232544485E19) -2.78351118315665136913517665604742725923E-30) +(num-test (/ -3.025128309814261E-11 -5.606736896306867E19) 5.395523930874836927233660478269495795871E-31) +(num-test (/ -5.390258677516223E-11 6.628750121976767E18) -8.131636550373975963243412569165785520017E-30) +(num-test (/ -8.484515181627938E-11 6.226893371743352E-21) -1.362559895457550846279271972989853630227E10) +(num-test (/ 5.110456708789676E-11 -7.434814854731122E-21) -6.873683889434922905934754874417370413592E9) +(num-test (/ -7.784815533665352E-11 -8.942884975553875E-21) 8.705038200698988300091363733020271337225E9) +(num-test (/ 6.06871371776654E-11 -8.4720755768444E-21) -7.163195916657483482294943699821186479438E9) +(num-test (/ 6.395725883763629E-11 3.2465500186809204E-21) 1.970006883295217146112013920243427167994E10) +(num-test (/ 8.23766365482318E-11 3.5665958051648335E-21) 2.309671211661863324131996575306264215863E10) +(num-test (/ -6.882125490660233E19 0.680553203393516E0) -1.011254587641810638505458546065261498221E20) +(num-test (/ -8.955858402134752E19 0.11144092291315044E0) -8.036418012361891226885340978581557821805E20) +(num-test (/ 4.517225460957592E19 -0.5804969398143229E0) -7.781652496570381006264991321295105224966E19) +(num-test (/ -9.741926397385082E19 -0.9037000739789977E0) 1.078004381972805693752225428081454781542E20) +(num-test (/ 9.654390326446178E19 -0.061963385089831124E0) -1.558079874501654704495847314268744072438E21) +(num-test (/ 9.50855454738802E19 0.30375471599023185E0) 3.130339727036137864357134952530976170215E20) +(num-test (/ 4.323538184184934E19 -2.6027608151521606E9) -1.661135421670382968923474255247239383096E10) +(num-test (/ 4.0554081767557594E17 4.814123702784068E9) 8.423979995384136048633041200603888010585E7) +(num-test (/ 5.12727309625028E19 1.761988796449604E9) 2.909935129316203535920673855950717437829E10) +(num-test (/ -7.335661993746345E19 -4.961351435504E9) 1.478561252736806087045652086640747044774E10) +(num-test (/ 3.7135994768593306E18 3.273427798269768E8) 1.134468118961482490398408895662653948827E10) +(num-test (/ 1.3911083524706402E19 8.651242909451927E9) 1.607986698594236535694138981270724564992E9) +(num-test (/ 6.473382688386894E19 -3.700509647679497E-11) -1.74932193257385527761113361595002688054E30) +(num-test (/ 7.25328632809461E19 6.793518758100849E-11) 1.0676773828651782212117989476182162163E30) +(num-test (/ 7.053090091571119E19 8.009021819073383E-11) 8.806431360661641824334823520600629499368E29) +(num-test (/ -1.6322872380348074E19 -1.234889420758779E-11) 1.32180842316378978004378947103470484747E30) +(num-test (/ -7.716951191497702E19 -2.473367210466666E-11) 3.120018393888910452644610629695438606501E30) +(num-test (/ -2.1174708383466066E19 -9.66632270128099E-11) 2.190565020207733610503619470750854251338E29) +(num-test (/ 4.0902039392392786E18 -5.029423690873208E19) -8.132549951322828067822875337940065787516E-2) +(num-test (/ 1.4562115759233494E17 4.2665150414889705E19) 3.413117173530803542079920263107168159861E-3) +(num-test (/ -3.309692589578652E19 1.1329455009949342E19) -2.92131667999222745140457080629099499358E0) +(num-test (/ 3.059130103268258E19 -7.719433592654628E19) -3.962894513632647141286488246687660445133E-1) +(num-test (/ 5.622979366632147E19 -8.407251901594788E19) -6.688248945610292804540334084533940238665E-1) +(num-test (/ -7.457587910839625E18 1.102755747735572E19) -6.762683328700153669243467171164281736437E-1) +(num-test (/ 1.2026615920578564E19 -3.77964792582931E-21) -3.181940793583240608441984111790776956096E39) +(num-test (/ -2.74643694419756E19 2.538907641816601E-22) -1.08173960287601117923133084738647095934E41) +(num-test (/ 8.267361397156658E18 -4.986401395715489E-21) -1.657981526368955793956856573504468676464E39) +(num-test (/ 9.876393891158812E19 -5.792612775193684E-22) -1.704998119925007613535922021885867984527E41) +(num-test (/ 3.927461252713038E17 4.810589424292295E-21) 8.164199656866003466542429981600313024025E37) +(num-test (/ 7.29943837795987E19 -4.8820727437034755E-21) -1.495151498382347474354240468822304376928E40) +(num-test (/ -7.837850970911807E-21 0.41514160181315674E0) -1.887994587070894820872902637806483134671E-20) +(num-test (/ 1.1499234744049124E-21 0.4643166529612681E0) 2.476593219457143961012942936990797968514E-21) +(num-test (/ -1.094368243984769E-21 0.9008053219044149E0) -1.214877640455251662856715755193246361763E-21) +(num-test (/ 2.4821206327531197E-21 0.22988631081892086E0) 1.079716588565493668307955174993650571244E-20) +(num-test (/ -4.56226662576732E-22 0.6695285124602162E0) -6.814148375851898788485451948577541009839E-22) +(num-test (/ 6.442796853653397E-21 -0.0419134640377401E0) -1.537166397855380228851954699451812058468E-19) +(num-test (/ -5.584403218169678E-21 -8.092869169805251E9) 6.900399723506295845105466793248363429626E-31) +(num-test (/ -9.796722996869492E-21 -3.2988270899833827E9) 2.969759471970033259328414098139420231204E-30) +(num-test (/ 9.441829923771915E-22 5.464575083746736E9) 1.727825087783076315606418411938950517056E-31) +(num-test (/ -6.419360319610147E-21 -7.333962810289677E9) 8.752921831841952013186922455457072581443E-31) +(num-test (/ 7.973734412555454E-21 -9.367577614661436E9) -8.512055880994845185202464827966401354632E-31) +(num-test (/ 8.105484193881594E-21 -8.664550975192905E9) -9.354765431108951260398341387461553707907E-31) +(num-test (/ -5.3151708182942476E-21 -3.406928289732576E-11) 1.560106455516695805992469791379650741489E-10) +(num-test (/ -7.026602845639829E-21 -9.92483846943868E-11) 7.079815824989676856562805642631867847741E-11) +(num-test (/ -5.901970468193158E-21 2.074489043942647E-11) -2.845023686881582124910812196899705492945E-10) +(num-test (/ -6.40466723844613E-21 -2.551008177490094E-11) 2.510641594550905909683475044031419810602E-10) +(num-test (/ 8.056066940872177E-21 4.645883100460603E-11) 1.734022739417072488146823616965762354533E-10) +(num-test (/ 7.453765056481805E-21 6.956136187014756E-11) 1.071538114851171096483487539186715128913E-10) +(num-test (/ 7.357434693258832E-21 -7.093525088486332E19) -1.037204295675341715303117810431180096085E-40) +(num-test (/ -3.3759558579798473E-21 9.991075630444324E19) -3.378971376908405498870850768959668870304E-41) +(num-test (/ 6.908026973557955E-21 -4.20805893397862E19) -1.641618399822784611549409240045335916762E-40) +(num-test (/ 5.181767322756247E-21 7.46986056263721E19) 6.936899664063931551045422017869651239957E-41) +(num-test (/ -5.7217313601659264E-21 5.604979023134118E19) -1.020830111326005351069300302415295512527E-40) +(num-test (/ -9.340193892824771E-21 9.147101848766205E19) -1.021109641857175884684740262364588092125E-40) +(num-test (/ 8.331002176099931E-21 2.0276444314093977E-21) 4.108709617449606347005645831416724715479E0) +(num-test (/ -3.747505523684784E-21 4.394623185543803E-21) -8.527478615259381231018127145394525879915E-1) +(num-test (/ -3.310403953328861E-21 2.3420390876737627E-21) -1.413470838617356120752866783055539347411E0) +(num-test (/ 6.23845405853013E-21 -8.933620117412232E-21) -6.983119918397872761237650028889120834928E-1) +(num-test (/ -4.276770609150315E-21 6.853299965034864E-21) -6.240454424832049912604789277138688124888E-1) +(num-test (/ -8.847946637724495E-21 6.33827952828724E-21) -1.395953996386055439061738621964402924048E0) + +(let ((top-exp 60)) + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (+ 2 (expt 2 i))) + (val2 (- val1 1))) + (if (not (> val1 val2)) + (begin (set! happy #f) (display "(> ") (display val1) (display " ") (display val2) (display ") -> ") (display (> val1 val2)) (display "?") (newline))) + (if (< val1 val2) + (begin (set! happy #f) (display "(< ") (display val1) (display " ") (display val2) (display ") -> ") (display (< val1 val2)) (display "?") (newline)))))) + + (let ((happy #t)) + (do ((i 2 (+ i 1))) + ((or (not happy) (> i top-exp))) + (let* ((val1 (/ (expt 2 i) 3)) + (val2 (/ (+ 1 (expt 2 i)) 3))) + (if (> val1 val2) + (begin (set! happy #f) (display "(> ") (display val1) (display " ") (display val2) (display ") -> ") (display (> val1 val2)) (display "?") (newline))) + (if (not (> val2 val1)) + (begin (set! happy #f) (display "(> ") (display val1) (display " ") (display val2) (display ") -> ") (display (> val2 val1)) (display "?") (newline))) + (if (not (< val1 val2)) + (begin (set! happy #f) (display "(< ") (display val1) (display " ") (display val2) (display ") -> ") (display (< val1 val2)) (display "?") (newline))) + (if (< val2 val1) + (begin (set! happy #f) (display "(< ") (display val1) (display " ") (display val2) (display ") -> ") (display (< val2 val1)) (display "?") (newline))) + )))) + + +(if with-bignums + (begin + ;; these are trivial translations of some numeric tests in the + ;; Clisp test suite. Presumably they fall under Clisp's license, + ;; which I belive is GPL + + (num-test (+ 17009115185923538769 -12047631083067675031) 4961484102855863738) + (num-test (+ 12677011568664239747 3269056182420253574) 15946067751084493321) + (num-test (+ 9315504781982082433 13857624532376678678) 23173129314358761111) + (num-test (+ 15226508728194069537 11481952022080775416) 26708460750274844953) + (num-test (+ 7461641943684774743 12249026721402718630) 19710668665087493373) + (num-test (+ 1180469445886971055 -3208456171287181032) -2027986725400209977) + (num-test (+ 18358552990465743315 221529797579218180385160273426219343697) 221529797579218180403518826416685087012) + (num-test (+ -14819874956616484359 30498815629431206969122152847973230849) 30498815629431206954302277891356746490) + (num-test (+ -11781881800334342169 112219460388643619332860331282276228017) 112219460388643619321078449481941885848) + (num-test (+ 3570694277032201957 284821691832196381859344006870088122712) 284821691832196381862914701147120324669) + (num-test (+ -17005463295060938595 69162171850264911722979835561124066203) 69162171850264911705974372266063127608) + (num-test (+ 15647113311796203488 150750467185419235519670165664526735459) 150750467185419235535317278976322938947) + (num-test (+ -14330150541101371097 -13054027994001826312503071338715966858478218093171762021549815587520723118772963817341751396703629529810372702877555022105594068768886421335353882155416908) -13054027994001826312503071338715966858478218093171762021549815587520723118772963817341751396703629529810372702877555022105594068768886435665504423256788005) + (num-test (+ 7406427184711759740 -4059250217961011548005203450962458026528281798230141192186669580689721046971433745892994467792118611646113962840750314719233572760336084100766391093756252) -4059250217961011548005203450962458026528281798230141192186669580689721046971433745892994467792118611646113962840750314719233572760336076694339206381996512) + (num-test (+ 8819522415901031498 7274905269237471130619913887005155660991437201841760414347836177003483932007334374478344594178179032728521106519295465031750530183363793325150672647162846) 7274905269237471130619913887005155660991437201841760414347836177003483932007334374478344594178179032728521106519295465031750530183363802144673088548194344) + (num-test (+ -7242932332215698200 -10558564312909325527488520195600871241245891651644550509993750377630234801225525279855157008009255586978047154906058790342845859331159009687703010657137320) -10558564312909325527488520195600871241245891651644550509993750377630234801225525279855157008009255586978047154906058790342845859331159016930635342872835520) + (num-test (+ 9794320575955609492 13380937715397052566925484435342184213544885758759259410983243841206628594840271850190097746775475837233042430565529099681550277688470325394342993771343357) 13380937715397052566925484435342184213544885758759259410983243841206628594840271850190097746775475837233042430565529099681550277688470335188663569726952849) + (num-test (+ -18404048401680891243 6690884608978704096379677348142836785900717005050936986370615083929607190833180925295418079551348559691161519822750772440155040888224482801864925665484770) 6690884608978704096379677348142836785900717005050936986370615083929607190833180925295418079551348559691161519822750772440155040888224464397816523984593527) + (num-test (+ -10763220363947284865 -30985722824355332972176356513316569304601382411274079243859710673739383446566598659878378034375348869471278415635671865753349734809209959160389615096293457362383744562507969316522225741589739150453090393424063226271167062127000223628785686999799282795143706407082119829140399988180879618548495395684946331608899565543458192773899200054228140747414544792128323269250618482622488195333106891323515989863192944848391405358725993695671970811097285270641251816244586360288952156538400321933146150313939864593445583603568771077260174826348411367609521412133720180359748539721570562669201065857989876521301209899829037444385) -30985722824355332972176356513316569304601382411274079243859710673739383446566598659878378034375348869471278415635671865753349734809209959160389615096293457362383744562507969316522225741589739150453090393424063226271167062127000223628785686999799282795143706407082119829140399988180879618548495395684946331608899565543458192773899200054228140747414544792128323269250618482622488195333106891323515989863192944848391405358725993695671970811097285270641251816244586360288952156538400321933146150313939864593445583603568771077260174826348411367609521412133720180359748539721570562669201065857989876521311973120192984729250) + (num-test (+ -12742462236537568498 8711131313747826394504271797986775572294949693272674156076339989631171694968899228610359983845552623710580616605402899155485071497929100432998183040757832449369366844015907530612334721882095163137705867337969942902346066961718232788529860214990099385213558935023241940238638069647809530490438245386869385682221280939688108487754251075630026707075310465788398213293782900699868609660892232563106662995330591906155134237356516622436517046191466823447743155250482328613449506396571170001248589926831956459700467126756876526930443317428628239358666456771112897986098390410773312792390699312960051747534683311506465130527) 8711131313747826394504271797986775572294949693272674156076339989631171694968899228610359983845552623710580616605402899155485071497929100432998183040757832449369366844015907530612334721882095163137705867337969942902346066961718232788529860214990099385213558935023241940238638069647809530490438245386869385682221280939688108487754251075630026707075310465788398213293782900699868609660892232563106662995330591906155134237356516622436517046191466823447743155250482328613449506396571170001248589926831956459700467126756876526930443317428628239358666456771112897986098390410773312792390699312960051747521940849269927562029) + (num-test (+ 9991390529516174614 7879872958436992955898278403297937595295396115022400543178444946646147916754852888072481665174663073269556311758611700754643170639645548596647557683044355930340624784190093631808382820554407595007761070026239341594197877214157118335743842022627898879376346092898666610367809537340994845045475091410516226225078052019727419030585524815982151736622865401299588936172760762386183577504972623377661437665668080131418564228642443266935225613702941906491478788336262289516199380144218708241406077806669686589734333554945412904560108150202389909124657090061223183441083590340175629756198442568877659538345749595968764873879) 7879872958436992955898278403297937595295396115022400543178444946646147916754852888072481665174663073269556311758611700754643170639645548596647557683044355930340624784190093631808382820554407595007761070026239341594197877214157118335743842022627898879376346092898666610367809537340994845045475091410516226225078052019727419030585524815982151736622865401299588936172760762386183577504972623377661437665668080131418564228642443266935225613702941906491478788336262289516199380144218708241406077806669686589734333554945412904560108150202389909124657090061223183441083590340175629756198442568877659538355740986498281048493) + (num-test (+ 831234034418847630 -744676478858160349467117341859049692149463503380690495147216354303526704924280287782902146026018180364963325847811379182950159627878800024734206345960410146056000392683000433501805629464626281031086102425271022388473812300724085127447081771317912465921636737545371909901577246384446144919253141375367648958387948463576516115079816552636772639965957498569187848459747361493535081532845254971492261148968198806736512864867151355002902241562014241077734122599581732704243705918200179789271894804233542502502119523149682814025979598424744685548054183678652651244898867735764030968089217841214778606507809487462642341164) -744676478858160349467117341859049692149463503380690495147216354303526704924280287782902146026018180364963325847811379182950159627878800024734206345960410146056000392683000433501805629464626281031086102425271022388473812300724085127447081771317912465921636737545371909901577246384446144919253141375367648958387948463576516115079816552636772639965957498569187848459747361493535081532845254971492261148968198806736512864867151355002902241562014241077734122599581732704243705918200179789271894804233542502502119523149682814025979598424744685548054183678652651244898867735764030968089217841214778606506978253428223493534) + (num-test (+ -6996572501442843347 -16567158719848992553565776505785820491834685475229611199353714982570065913508303466008005931649515528390057456882757990896824841386431756898386429000065518724021230756426613661219891419166146764347562529640689229693578574350948436847247856000438153789455857903402883189892697143647998643667467614427922009931545254965075041050860609824086811877108940020349157317276288348430058535959434983921323332907180869396258655826781438419383792024592535415693101119109484610789291889841197827977530804650015884500878613240443324806805475203272442094530735476095374446946252236490708915034012846683015547314889561060687692538144) -16567158719848992553565776505785820491834685475229611199353714982570065913508303466008005931649515528390057456882757990896824841386431756898386429000065518724021230756426613661219891419166146764347562529640689229693578574350948436847247856000438153789455857903402883189892697143647998643667467614427922009931545254965075041050860609824086811877108940020349157317276288348430058535959434983921323332907180869396258655826781438419383792024592535415693101119109484610789291889841197827977530804650015884500878613240443324806805475203272442094530735476095374446946252236490708915034012846683015547314896557633189135381491) + (num-test (+ -8920936222630165483 -18738991973681679876688842391791783563249057933653045519186959571392922172943405646958686202208790537612746921398028331540617848217445632123805070077600768524509025758950743971128222843292926773668584735575066246660802064630842300367821042873152766467703905048558085377302000898639290554395913805527529259855535801856020623830262396582180677933562523957295341539162448074423901242873918231922121053192425691524797238343327318801359521456598967984637483081312932069399045363737622797213185099130529375169698811801965974416555301085043300426947769193582129151016159057101028336667142913854943018973494705119572045938607) -18738991973681679876688842391791783563249057933653045519186959571392922172943405646958686202208790537612746921398028331540617848217445632123805070077600768524509025758950743971128222843292926773668584735575066246660802064630842300367821042873152766467703905048558085377302000898639290554395913805527529259855535801856020623830262396582180677933562523957295341539162448074423901242873918231922121053192425691524797238343327318801359521456598967984637483081312932069399045363737622797213185099130529375169698811801965974416555301085043300426947769193582129151016159057101028336667142913854943018973503626055794676104090) + (num-test (+ -243510292488206214847646757340020705642 5940577100149745132) -243510292488206214841706180239870960510) + (num-test (+ 35446324064743728955945058978206455057 -6248622708755929572) 35446324064743728949696436269450525485) + (num-test (+ -285342226760657637664173494795024413673 -11942737781617905307) -285342226760657637676116232576642318980) + (num-test (+ 180790435817422032042321866247362452865 12401641959336396832) 180790435817422032054723508206698849697) + (num-test (+ -179994871947239535956826388240542999950 13573822506399140772) -179994871947239535943252565734143859178) + (num-test (+ -308198027295905163635866438671452347268 -8790069282378476990) -308198027295905163644656507953830824258) + (num-test (+ -139324757925833055762410227358605285566 -190622873846936719063564661032771271922) -329947631772769774825974888391376557488) + (num-test (+ 332866352618304570046318203427223999347 147978646177673305481282943528696833018) 480844998795977875527601146955920832365) + (num-test (+ -39471620476300923970352914034802271156 28992893610776120142668950821916856486) -10478726865524803827683963212885414670) + (num-test (+ 274120253734611965146455315763505869288 254675910805265090692978775702306142625) 528796164539877055839434091465812011913) + (num-test (+ -122086811464559635596206661886176775901 287312583034687582188356355813963609701) 165225771570127946592149693927786833800) + (num-test (+ 288576174771266329955482943556556984728 -57843540651903655425270706396868707777) 230732634119362674530212237159688276951) + (num-test (+ -47977736580820486006305788441965482221 984809271313988066640898939725532304075331399066274624928410251834520283291912387208948664716457549646483445981126881113426109906085249657168046936670489) 984809271313988066640898939725532304075331399066274624928410251834520283291912387208948664716457549646483445981126833135689529085599243351379604971188268) + (num-test (+ 21225484205143479814642328762121362291 11839789093732539327981861490012713257538550745921177905266671749716203131127256902110452504526721633943016923389974867770082516862899595554460170417713940) 11839789093732539327981861490012713257538550745921177905266671749716203131127256902110452504526721633943016923389974888995566722006379410196788932539076231) + (num-test (+ -193095363331703875886398909106293703000 4389392021031719669078675478621418677903292147307684123866099084349756491860737402449105804868232530632178577388168068485304437343508442251302846768269976) 4389392021031719669078675478621418677903292147307684123866099084349756491860737402449105804868232530632178577388167875389941105639632555852393740474566976) + (num-test (+ -14827657635864183514988182371035598180 -7256545787852407071411458891023580461638051949278710509801472046178301830006724297747051044450550248499056073213660185258676369175307019300952192657194576) -7256545787852407071411458891023580461638051949278710509801472046178301830006724297747051044450550248499056073213660200086334005039490534289134563692792756) + (num-test (+ 54301423175725658626298504084995819705 -13385853291610595576947504757201441006088030688464261540642594993520424631577281077984278942244446266776534612440941312995898184903431893212829646845766101) -13385853291610595576947504757201441006088030688464261540642594993520424631577281077984278942244446266776534612440941258694475009177773266914325561849946396) + (num-test (+ 195114404067053480147948948510253723990 -8373866462448797623435948949281383906369538962237624940506813188612614128993186653340202956656303504523161255703176374041758276069255591562198514767063594) -8373866462448797623435948949281383906369538962237624940506813188612614128993186653340202956656303504523161255703176178927354209015775443613250004513339604) + (num-test (+ -308030589512186791277525017840002670741 -11922204352024596469278978325035646517433105521287613403902396944414655739824695945028308092245747333098422116078042326104667969967224788442970266049942774583538734406057081597034454910987815490244451193242377705191422489528853976486607580169986057592557285271953385769215318545520155212402919465580052078255078759756709086185424029620805084776442744700501748376290562843380642608395240491162047933014854466267084965223593172702334466729933986413870670083326499598274393380692146118979961818816348097032083332695128587696590646086980241100792624502607816103195636761141133903550454815591457829485684936036414823492160) -11922204352024596469278978325035646517433105521287613403902396944414655739824695945028308092245747333098422116078042326104667969967224788442970266049942774583538734406057081597034454910987815490244451193242377705191422489528853976486607580169986057592557285271953385769215318545520155212402919465580052078255078759756709086185424029620805084776442744700501748376290562843380642608395240491162047933014854466267084965223593172702334466729933986413870670083326499598274393380692146118979961818816348097032083332695128587696590646086980241100792624502607816103195636761141133903550762846180970016276962461054254826162901) + (num-test (+ -172649878347923210775992373331623646864 22180935775581457002090790736532281654456312526625354262953960635330604551829750571440878712430708012807252279301365732385899228826740712544768476577874129759972563823209525283326887563301081200476495752033290851190327066070873711444930389093339915885090143783170994309089448293499799071372787520776773788274677288230540162485916160484352398851925328125588729604931589867889917097887951581817207079060016091919559509735997493084833476849835444339835031436580214492450731100723026312163752403946315983551266206214298679421644737804098691991631489261658890937663698502561036246447760919715595005106669653475931803053499) 22180935775581457002090790736532281654456312526625354262953960635330604551829750571440878712430708012807252279301365732385899228826740712544768476577874129759972563823209525283326887563301081200476495752033290851190327066070873711444930389093339915885090143783170994309089448293499799071372787520776773788274677288230540162485916160484352398851925328125588729604931589867889917097887951581817207079060016091919559509735997493084833476849835444339835031436580214492450731100723026312163752403946315983551266206214298679421644737804098691991631489261658890937663698502561036246447588269837247081895893661102600179406635) + (num-test (+ 17539006966816771902104329685391462527 15609797782337099611892065465036826453911053690739041627254619195700021040383385710184052653282070244915503750549545390475671883312314708978681904377133928647935359080875691628246716591529028104762422990155477702994042953196747769893182153631482194578269859879402160062955490194674372351117284129320011166238130774752386987036267064693133554447596069886693581191241594745541512444806003236372840085705813835001957163976961730871756250344335996073970142337882238844723800849054637237549515249957267772181010402413375667537558243971058326641257721901094391380667244006959028327507917720426571969997513984360849930719808) 15609797782337099611892065465036826453911053690739041627254619195700021040383385710184052653282070244915503750549545390475671883312314708978681904377133928647935359080875691628246716591529028104762422990155477702994042953196747769893182153631482194578269859879402160062955490194674372351117284129320011166238130774752386987036267064693133554447596069886693581191241594745541512444806003236372840085705813835001957163976961730871756250344335996073970142337882238844723800849054637237549515249957267772181010402413375667537558243971058326641257721901094391380667244006959028327507935259433538786769416088690535322182335) + (num-test (+ 244901855797156286376563377540855746602 -22138106346578776369849317622304392466030036563754663379976505966920461958652141160336156065177498990718609170201272980114106671808245437660234479124938853665375934080221740523696180221118540569603989748587853373569525751680828044059607889572522502629277877343410298879764820905044284757389006201848194571453112545228115550224254565141563427486518108434758694923122284117299374156393942906293546318323661938734959824887786185558612820887463537294120950912969343488704744978847504513710882720654330147775174336365363311173472002077960424794151168301281665765411704505095008907760396535767621855642720080219960822554492) -22138106346578776369849317622304392466030036563754663379976505966920461958652141160336156065177498990718609170201272980114106671808245437660234479124938853665375934080221740523696180221118540569603989748587853373569525751680828044059607889572522502629277877343410298879764820905044284757389006201848194571453112545228115550224254565141563427486518108434758694923122284117299374156393942906293546318323661938734959824887786185558612820887463537294120950912969343488704744978847504513710882720654330147775174336365363311173472002077960424794151168301281665765411704505095008907760151633911824699356343516842419966807890) + (num-test (+ -119403662992279138748600939857239307122 26272999248235953724172008428088697264933069743507017434844709711501131900922919455931092196539942532993887162365511473221418376205773427597933886270411672062672089518774390132453916538404354895529975888201032175628249480896964400801763570333497287321002961557096975786141940970260074557095118887294558700145949117395512768347250531196100831164663613049206690894640391431616112104502483838173255614981302462548882276825096564828583591963617871547373532874400764134244496979962241959713525053686209002866840900623246072884125102845824992994967009109046451949348656842486048332953732384499190437432898387573320391878853) 26272999248235953724172008428088697264933069743507017434844709711501131900922919455931092196539942532993887162365511473221418376205773427597933886270411672062672089518774390132453916538404354895529975888201032175628249480896964400801763570333497287321002961557096975786141940970260074557095118887294558700145949117395512768347250531196100831164663613049206690894640391431616112104502483838173255614981302462548882276825096564828583591963617871547373532874400764134244496979962241959713525053686209002866840900623246072884125102845824992994967009109046451949348656842486048332953612980836198158294149786633463152571731) + (num-test (+ 313963939617834410089002930298454269912 23286645405607099799151331553995799851855144387826191186590140820016670502830395945076644578998873585162998873396623634135231418574284200209367505115739462344028303923666952261030907434438322884189133236837089851688275865098623902644385995630973049587854251981548128145516004461191094062488421288607625783540996659060285661398859383778209495884203323937672739376151794507745282074538961033778823733980759695886879886017489555795079194346438911010371103435094677167286870898482214310646392174423422237727456012197253183422715313378603607058548706460095379882633958651034759773864354021315490712575535559549015858088608) 23286645405607099799151331553995799851855144387826191186590140820016670502830395945076644578998873585162998873396623634135231418574284200209367505115739462344028303923666952261030907434438322884189133236837089851688275865098623902644385995630973049587854251981548128145516004461191094062488421288607625783540996659060285661398859383778209495884203323937672739376151794507745282074538961033778823733980759695886879886017489555795079194346438911010371103435094677167286870898482214310646392174423422237727456012197253183422715313378603607058548706460095379882633958651034759773864667985255108546985624562479314312358520) + (num-test (+ 2000877973959266893810594143560134441447453310844726478119781029700338468704683515329516333146806175216349912753585564808803731447160643580198590073658869 -17993015014355471903) 2000877973959266893810594143560134441447453310844726478119781029700338468704683515329516333146806175216349912753585564808803731447160625587183575718186966) + (num-test (+ 5492930533666246223206322654398877802091439062008700770880939594548305919677404080859141226095489505872709347538974725998600861651942609010590873980143878 15372278140141207703) 5492930533666246223206322654398877802091439062008700770880939594548305919677404080859141226095489505872709347538974725998600861651942624382869014121351581) + (num-test (+ -13405500833215428652808705089190188280715732437731292502890523313631564795139560159124390691283401484515088713758307366404145018349044148223082253439210893 -14793401891248640808) -13405500833215428652808705089190188280715732437731292502890523313631564795139560159124390691283401484515088713758307366404145018349044163016484144687851701) + (num-test (+ 9945195259699924701593703207751086973468898794114625092150620088406276196469184233537941913755508476427888065765634203723512911676149274871082481174186606 8699133332160461067) 9945195259699924701593703207751086973468898794114625092150620088406276196469184233537941913755508476427888065765634203723512911676149283570215813334647673) + (num-test (+ -1785165974800693006461065312083337532938610906605533088558498259067461510781028452552786542598361030690629530721209490413999022804146471920873844686294838 -13079925952361275418) -1785165974800693006461065312083337532938610906605533088558498259067461510781028452552786542598361030690629530721209490413999022804146485000799797047570256) + (num-test (+ -4861207515430071951958387366611380234482792653010151054346367776006873932152600469133110239669746470475230906073865131648496652783311445471793936775767736 -9381557743227419896) -4861207515430071951958387366611380234482792653010151054346367776006873932152600469133110239669746470475230906073865131648496652783311454853351680003187632) + (num-test (+ -6638723469626495957966112633999375479181736600737250559572415894485618850919815869703127084789143821420728194272094956858541960962483734293877093635361160 277811698220276334443479876776376776138) -6638723469626495957966112633999375479181736600737250559572415894485618850919815869703127084789143821420728194272094679046843740686149290814000317258585022) + (num-test (+ 1983880417172931934469534542170437296262471214582817006917470485544552211448284732460451903536334682269123998240709059499894818265755197559390728940140016 -118940994129137705779355371753506018694) 1983880417172931934469534542170437296262471214582817006917470485544552211448284732460451903536334682269123998240708940558900689128049418204018975434121322) + (num-test (+ -9354509264984586574958285335910611806441061705184818350015454221731287473282231343722010109181841005578131927454778025302197744540571159656556971614966757 120224841184491944160266976391113485817) -9354509264984586574958285335910611806441061705184818350015454221731287473282231343722010109181841005578131927454777905077356560048626999389580580501480940) + (num-test (+ 4389359421234641412950681847970318834150108533025088077429496538447029921663033978550089607257809597829358374972237448178553189381274150213236222139873594 106674783386899772113212633712093787897) 4389359421234641412950681847970318834150108533025088077429496538447029921663033978550089607257809597829358374972237554853336576281046263425869934233661491) + (num-test (+ -9319417879153488839579936799737117639058244394679644240663244688680826325564084529474537634510092069422987165268448907193562300482925125162731530249763801 192969103435503875767216559494769734726) -9319417879153488839579936799737117639058244394679644240663244688680826325564084529474537634510092069422987165268448714224458864979049357946172035480029075) + (num-test (+ 1394404616168163951844558734723678125985464491792846741433683801962971891047718103736551854371207400145441134823994228143957746922511631911996296931168332 -211230038021470285136061932161632203274) 1394404616168163951844558734723678125985464491792846741433683801962971891047718103736551854371207400145441134823994016913919725452226495850064135298965058) + (num-test (+ -2935941510094051560788359387128767361559188973149773593522440619832472030019457317998381634585179453958737810428870232715146002408187749944694186205812791 -1221176156661231926164756142840452419679061324806989304452215660535991083923207702827717652226257158321829748247784282139952864899457896871473184473608543) -4157117666755283486953115529969219781238250297956762897974656280368463113942665020826099286811436612280567558676654514855098867307645646816167370679421334) + (num-test (+ -1338674579024795395027232680327531457830908239605718353094975139226848400289367913459076082700361212506196070727982446232782659114647371030398516119682505 -1298372177520411182435886041880377054374169787570856408996533471838082317927648953576721017727347029007573543972764860712708420553928791798580799809858729) -2637046756545206577463118722207908512205078027176574762091508611064930718217016867035797100427708241513769614700747306945491079668576162828979315929541234) + (num-test (+ -2072456075229532951804023218627137969798924912365258263779029006567941400203608770518731715660383378937120213112973528605594220795605977413985543331908189 -9744489461776287963808523409593616918248399004543154581056479712028497082820841423941781438667661074968238703192056877665754560746003512076830245760254982) -11816945537005820915612546628220754888047323916908412844835508718596438483024450194460513154328044453905358916305030406271348781541609489490815789092163171) + (num-test (+ -2570682164188734368809161664810917340861573482754788446510182252413437925852206735928397938304353826925422441004271229738766803460790995673395984247950088 656920705293329551826685120408221577679101260931105312141757138825917579070505267306626244216341686712802796891966598838285570807961966448181138356047523) -1913761458895404816982476544402695763182472221823683134368425113587520346781701468621771694088012140212619644112304630900481232652829029225214845891902565) + (num-test (+ 7846359203342053693101523606887617345982401999003795257520576318451663998927274759872692123323796450295314377046602880394071105863527900699633560551732837 3683380639347829102597675045842249667669675715600522157867595962635108482512780509393310714588544837398923613138772339053021025559943198965234376657126821) 11529739842689882795699198652729867013652077714604317415388172281086772481440055269266002837912341287694237990185375219447092131423471099664867937208859658) + (num-test (+ -11692323148567132684205145901751681947225824260005631214936266006610207543813382900867093989444659986091234552140689684476541703112098935301322850961583953 -8534276689564199122569555420819240948691777228327984555753862457592427992599992931175844172478864477440165366128106812103785256271256853749622592560655914) -20226599838131331806774701322570922895917601488333615770690128464202635536413375832042938161923524463531399918268796496580326959383355789050945443522239867) + (num-test (+ -10734754884168724884333968138739681643742524619139397687680049322697740991391014196697040576174049452737571835233123127815762146577096625434481167057340772 17059878151450238567815178684522345445687980385106446646013863901583786249398194029757376950491550197185231926262467028755342392379269039238766592672298850588065335172902157386017520689203005559576263548017475991638498600879259882041932152385436968424098224966518534467302264172016376096778201462205990822825056602379115848799619564610033123837036507127427054121975400703490855123544706355545059512146550901507159940126280812512339749605195422987937677650572797378799103456094203126081464905326203083057134061673694975250599375795827437561275156235513192978645909947341297774926450637694325145427434486258223666250272) 17059878151450238567815178684522345445687980385106446646013863901583786249398194029757376950491550197185231926262467028755342392379269039238766592672298850588065335172902157386017520689203005559576263548017475991638498600879259882041932152385436968424098224966518534467302264172016376096778201462205990822825056602379115848799619564610033123837036507127427054121975400703490855123544706355545059512146550901507159940126280812512339749605195422987937677650572797368064348571925478241747496766586521439314609442534297287570550053098086446170260959538472616804596457209769462541803322821932178568330809051777056608909500) + (num-test (+ 1982582032974021971225071139786536402936929744496433027195224299475980201425925452469321205602618940472354066218156609448199804973454183972974358405933935 -5591374624026484498020036332218412149978824230210339582240360391202660977358546150723165491729699122647688030937226316069237264083850854032732663284717882873051337566653841254365703461654061656817936193716386141166210237666314879751427421825450110467888973152907618520704486700443275358649289847595635931220181024199692771066498714511145489237541761266539978351840438236927937894376002981658065431416811632941197501676956304254109064936038146674412392128883565757325842468006824235119684861972224857533964558963441079998949499582965764591461900562931342373507763081479989957632695010603500633322408246084430203281475) -5591374624026484498020036332218412149978824230210339582240360391202660977358546150723165491729699122647688030937226316069237264083850854032732663284717882873051337566653841254365703461654061656817936193716386141166210237666314879751427421825450110467888973152907618520704486700443275358649289847595635931220181024199692771066498714511145489237541761266539978351840438236927937894376002981658065431416811632941197501676956304254109064936038146674412392128883565755343260435032802263894613722185688454597034814467008052803725200106985563165536448093610136770888822609125923739476085562403695659868224273110071797347540) + (num-test (+ 11532228364136654310006206557545352284448588590560137249197311142901246089838098630841794341370689745410654263817911440601934362503092628725755210859171724 -25776236925500995542036591604259749301547568770017466769502569415611770276300787105037848049555500555975152877716727294374436703766730618054071617947449695177320842403963009384468257891933593584757723535299746543328292715942626303315235241470269740287031317322772461137186093930239744879822272349431389779234805703118929710210161489122272898252221025966631463842234537744822906696719691188223105175714602909117904182229960075276443648211003011686250829474364425483901920822837775032295913486152631638908227467242772081310515646217115760180349854601959031626524004201825198439309850266508687796415478396821644422350208) -25776236925500995542036591604259749301547568770017466769502569415611770276300787105037848049555500555975152877716727294374436703766730618054071617947449695177320842403963009384468257891933593584757723535299746543328292715942626303315235241470269740287031317322772461137186093930239744879822272349431389779234805703118929710210161489122272898252221025966631463842234537744822906696719691188223105175714602909117904182229960075276443648211003011686250829474364425472369692458701120722289706928607279354459638876682634832113204503315869670342251223760164690255834258791170934621398409664574325293322849671066433563178484) + (num-test (+ -2603756427337798371354526130541868239006085657393372011847827118826669474695402075575479286172808099892726251004549675772420422527946534088483901153485670 -10844269742362409682236511127219508926736627172993604953084481596070757241623728297275447608738915355190715664012379562650777199088096670239050254578284071100042116609747208178716191571268815994455064584659920497876052406993834873124981417288518101426395560764186717660091472734401090302285129741058888303693710456902635092811413971399734306158050053239768185860958896447298052082493590498954512083131068867270078638929796561440903919430094619437872896595720463663570751134804664228918188923926951933302878771189484614604311920655871182974081898031051411394311700207305532216445616083858025977851570522763537300875989) -10844269742362409682236511127219508926736627172993604953084481596070757241623728297275447608738915355190715664012379562650777199088096670239050254578284071100042116609747208178716191571268815994455064584659920497876052406993834873124981417288518101426395560764186717660091472734401090302285129741058888303693710456902635092811413971399734306158050053239768185860958896447298052082493590498954512083131068867270078638929796561440903919430094619437872896595720463666174507562142462600272715054468820172308964428582856626452139039482540657669483973606530697567119800100031783220995291856278448505798104611247438454361659) + (num-test (+ -5929887196386997518766568868806997104240129372360669348628384183712406620199102166145939206783172815805659513128544493795329100599632286529420772709366102 24544958491142793859949310604465694574872439331169358241746200808802938771527900616394258199996170862256988647191747967628756772368808644819831481350919782560499270148419601775750932556119448001824346026042068416905254113155445053931789404515589532235225580737103411251232560863878948880220469490014568323308965914171394449781093816607870593225534700167342589927524232815571862258490314644577819742372918446373756857848586825568514909823940075182825283229026250682015641747568282510036326125505522447591703308661608718100933027549520132308555240654655887041040427813131621391320267698106519650611462269033902177180035) 24544958491142793859949310604465694574872439331169358241746200808802938771527900616394258199996170862256988647191747967628756772368808644819831481350919782560499270148419601775750932556119448001824346026042068416905254113155445053931789404515589532235225580737103411251232560863878948880220469490014568323308965914171394449781093816607870593225534700167342589927524232815571862258490314644577819742372918446373756857848586825568514909823940075182825283229026250676085754551181284991269757256698525343351573936300939369472548843837113512109453074508716680257867612007472108262775773902777419050979175739613129467813933) + (num-test (+ -8848084327536592532063677611386811805244460767433749071435930786126721080365289638381557872263825830664387392539638767251180242665642373539064690745095464 -15917950175678012281826361248776190984758236997789474333609547749168308439513527143790323694526378056113636462939674273462177686456811495629631337058042159570336251822399402513133598701991665209363955263097315081570618652783181494594400709239428597117944511110842795526862595552977665064029517628515465251448116061875878430407784298951946811321795808932206846491091803276390661869369638950672478828532423383951689632136029256108992610781912267083149156104328033893238864631158195280554850035949666897861529711006187241710164902350100555999894332438423857208747342184052953230247487231455921360593096823760117493579248) -15917950175678012281826361248776190984758236997789474333609547749168308439513527143790323694526378056113636462939674273462177686456811495629631337058042159570336251822399402513133598701991665209363955263097315081570618652783181494594400709239428597117944511110842795526862595552977665064029517628515465251448116061875878430407784298951946811321795808932206846491091803276390661869369638950672478828532423383951689632136029256108992610781912267083149156104328033902086948958694787812618527647336478703105990478439936313146095688476821636365183970819981729472573172848440345769886254482636164026235470362824808238674712) + (num-test (+ -16314775600714318471451792035636584056297958597339492996728118376578145765736873313518831390349547274517050864260054903974054712997529177834428786007341762649083404743713562157667828894017440065599882523458121037421757904691003094608420565550031561905074671735751685371533975894842331113347413787808917193134135744321547478500861021485075363990553639161661734684228250909589741380076008551020384304303171431833670236949934603973673998262066558668396388979463892768199916011368116729432353268535563246463324517035331079693172060671712718486388759443825620676228470068291448236914050793177812037679396721657020438979754 12553426083939460917) -16314775600714318471451792035636584056297958597339492996728118376578145765736873313518831390349547274517050864260054903974054712997529177834428786007341762649083404743713562157667828894017440065599882523458121037421757904691003094608420565550031561905074671735751685371533975894842331113347413787808917193134135744321547478500861021485075363990553639161661734684228250909589741380076008551020384304303171431833670236949934603973673998262066558668396388979463892768199916011368116729432353268535563246463324517035331079693172060671712718486388759443825620676228470068291448236914050793177812037679384168230936499518837) + (num-test (+ 20637030084881771176788188367974505419050866216433677435050410899110162793040751338330447574748263391136356400036001988938659722098883893353523409458775455519257672423829361150611806294256710309281788819450225670112435352092313483086404714074567539245791066202051788986426960935796927738180831688497683293306590464598379493141645539253898709000874685535467854788184424886911457134522632486730390913239660179785071885982403741669161655812015114272497907946919026898579927936299607156006210124954460880383605958519412435713868501997649784658832599101777001703519408664662715322044086646014163774269660274683400619225321 11620128128044940816) 20637030084881771176788188367974505419050866216433677435050410899110162793040751338330447574748263391136356400036001988938659722098883893353523409458775455519257672423829361150611806294256710309281788819450225670112435352092313483086404714074567539245791066202051788986426960935796927738180831688497683293306590464598379493141645539253898709000874685535467854788184424886911457134522632486730390913239660179785071885982403741669161655812015114272497907946919026898579927936299607156006210124954460880383605958519412435713868501997649784658832599101777001703519408664662715322044086646014163774269671894811528664166137) + (num-test (+ -9838804688358141062268493389453191808060717708062736103828856866310283812230958467655270667206937622979717683919584610288962829724022506216738929136418489468786902364550847498615864720240589837282441807174290461916292258263929411081218952357662703079709351365960916688275651864441386750529258343003652300629003597744958152243494244227986280506395347894285277364095898602965258114321853474000520432831298793365139040664543928707100657375292032051256485942532600998813627925626928634068613637417702688610315924917761411247617905738119218110678854564441914784262998574445847209847985439514580300936248281049628734475702 2380166482232871816) -9838804688358141062268493389453191808060717708062736103828856866310283812230958467655270667206937622979717683919584610288962829724022506216738929136418489468786902364550847498615864720240589837282441807174290461916292258263929411081218952357662703079709351365960916688275651864441386750529258343003652300629003597744958152243494244227986280506395347894285277364095898602965258114321853474000520432831298793365139040664543928707100657375292032051256485942532600998813627925626928634068613637417702688610315924917761411247617905738119218110678854564441914784262998574445847209847985439514580300936245900883146501603886) + (num-test (+ -30961575335426221869515496362216292453766907587859856766456625722888557357647164641922707199324601608700561081422636642523431947551124957385652791834855425829101761914145137205962610515642614866296480715893528289170482422505734612327038754622917335073993027434927547277037587173529054849390646376806910407207016292483185533697336599641898250465186168797820802225861771331652801064811222606773495565340386327294310913503461903243119204619412324538886439122443769008953829820425376589389335553937319588224864611583436327810214798652896733118881040503785110481197462772022447173744898802421806800203373153221004361953729 -10586442965055062759) -30961575335426221869515496362216292453766907587859856766456625722888557357647164641922707199324601608700561081422636642523431947551124957385652791834855425829101761914145137205962610515642614866296480715893528289170482422505734612327038754622917335073993027434927547277037587173529054849390646376806910407207016292483185533697336599641898250465186168797820802225861771331652801064811222606773495565340386327294310913503461903243119204619412324538886439122443769008953829820425376589389335553937319588224864611583436327810214798652896733118881040503785110481197462772022447173744898802421806800203383739663969417016488) + (num-test (+ 8835746018617511846981408800319983340292665114153404569022025834059427359831684523399830234196625160662387716033871154398104436720494608541518837969397374272734698261557358249258503982414578618525420572597611597792132117034895074841909295420434392963714805547538976612884853497014341345150095544449860198192757839489063747595073430612069212219930749783824683135433987509303139260133564905961552149844964215891730262218278214035649706577154652729844092199333026620127958228847111442161350881527928460177763370427262298116900358910460957772350452949782281117704005514462730290063772968929608448642592954601418753021512 -12227722924075527556) 8835746018617511846981408800319983340292665114153404569022025834059427359831684523399830234196625160662387716033871154398104436720494608541518837969397374272734698261557358249258503982414578618525420572597611597792132117034895074841909295420434392963714805547538976612884853497014341345150095544449860198192757839489063747595073430612069212219930749783824683135433987509303139260133564905961552149844964215891730262218278214035649706577154652729844092199333026620127958228847111442161350881527928460177763370427262298116900358910460957772350452949782281117704005514462730290063772968929608448642580726878494677493956) + (num-test (+ -5455184800550144006991157215735481579353213544152145628297990102571936052187486515129266239245491863623978659179559754999567936067584384479787934704340911556625153536160778495579370425428019248950494107696016864499055854257192071541354806671987402367524770228296322497224645429524493838356022616251290117624472061673033274133156467148770562815676767117605001434288573911556053311048284534341905722947046607192815465807736361991479044698448267471087552952494477144251510778491315012457514838113324210534577956298926109164909779987221094000880908857594198276812276890284008572664102792405452379662935026125770444036994 -7349798942312432150) -5455184800550144006991157215735481579353213544152145628297990102571936052187486515129266239245491863623978659179559754999567936067584384479787934704340911556625153536160778495579370425428019248950494107696016864499055854257192071541354806671987402367524770228296322497224645429524493838356022616251290117624472061673033274133156467148770562815676767117605001434288573911556053311048284534341905722947046607192815465807736361991479044698448267471087552952494477144251510778491315012457514838113324210534577956298926109164909779987221094000880908857594198276812276890284008572664102792405452379662942375924712756469144) + (num-test (+ 27233955893140063612427006607965940109569052437681267421929959186535416115028420267622879017163568256526042146282241931623674996867133390355390677118211537487769195270234259640386625552763891339073878417517169618832945750393661600092643257470064376916337734385887099957095417541169462231630821139075814859604097878094729685589777579267192538715202397220666651307185763054526407234767132218634060693076054116575833737797189157152326979078121760900891899319809724675232853322526718686306470372869701173824664984405178677187081936624687293494821338781534163633206006387449585716391843039459733925494003066841874935048611 -66646390577667468207341453008390168215) 27233955893140063612427006607965940109569052437681267421929959186535416115028420267622879017163568256526042146282241931623674996867133390355390677118211537487769195270234259640386625552763891339073878417517169618832945750393661600092643257470064376916337734385887099957095417541169462231630821139075814859604097878094729685589777579267192538715202397220666651307185763054526407234767132218634060693076054116575833737797189157152326979078121760900891899319809724675232853322526718686306470372869701173824664984405178677187081936624687293494821338781534163633206006387449585716391776393069156258025795725388866544880396) + (num-test (+ 15030400024888781078933103028897733817304421960545019199443871381537070197157227994520524631721701055962609956080413517776229513420814407790533237358129529547793422514837651333555776540939235592155512951229106778709351772195248438493792786143040421233061520515971787881798980515709417481015662862327435825812557205663033601853937647320838585333754027488605638576977560072206293290493215523194883494322543800546276353830683084405428005815296131527861252717516620765986589669237487765523936713749717927502645633123584240464131140829496052170285171610845098023517906586134613874506419828208611247177336492131262918439281 -164048419232636429449474429717211197442) 15030400024888781078933103028897733817304421960545019199443871381537070197157227994520524631721701055962609956080413517776229513420814407790533237358129529547793422514837651333555776540939235592155512951229106778709351772195248438493792786143040421233061520515971787881798980515709417481015662862327435825812557205663033601853937647320838585333754027488605638576977560072206293290493215523194883494322543800546276353830683084405428005815296131527861252717516620765986589669237487765523936713749717927502645633123584240464131140829496052170285171610845098023517906586134613874506255779789378610747887017701545707241839) + (num-test (+ -10227062646189307616073129048534031298512434237226774743330733206156788005874968173984804649812506029813402205606562016228122184161577517837608957023376079537037472977098465137152327215807765130656192272994478964341604278041664840636982572214751638093860605132350960802560601354006634296348422600320863531059118477125143903734159707623839282511184908969206873548650544269932394344952983661665472663102992782521888857016369837211403335306200813816060883478434441858442549261115972947741929087886423170398410216855322384956160289855500229952405068604320121652911887067414460828300146993858360430784079225137421074839819 117460076430162201914796277915447781936) -10227062646189307616073129048534031298512434237226774743330733206156788005874968173984804649812506029813402205606562016228122184161577517837608957023376079537037472977098465137152327215807765130656192272994478964341604278041664840636982572214751638093860605132350960802560601354006634296348422600320863531059118477125143903734159707623839282511184908969206873548650544269932394344952983661665472663102992782521888857016369837211403335306200813816060883478434441858442549261115972947741929087886423170398410216855322384956160289855500229952405068604320121652911887067414460828300029533781930268582164428859505627057883) + (num-test (+ 27989453264793973121573869640708223239762902243991948581280654553806618470632044367386680716040316895884976837122054709584963028986161694425215067648887944710852278135008221491665079705797192389681328802747226171436158375378499411314855257919224316919346771317457123252623293612958336691335423245293660257386649100685560072354549579281852792682734916555498283053758141666658137856828164206947320523255487437004565021167276952652515632644458005291855624829941937578229983628962137595011570216766689546500517528191189928660433013004254032861383790553611840534023221000900694995707453499030166286828319347894538505334235 -59175168207571178843658955348404514921) 27989453264793973121573869640708223239762902243991948581280654553806618470632044367386680716040316895884976837122054709584963028986161694425215067648887944710852278135008221491665079705797192389681328802747226171436158375378499411314855257919224316919346771317457123252623293612958336691335423245293660257386649100685560072354549579281852792682734916555498283053758141666658137856828164206947320523255487437004565021167276952652515632644458005291855624829941937578229983628962137595011570216766689546500517528191189928660433013004254032861383790553611840534023221000900694995707394323861958715649475688939190100819314) + (num-test (+ 1178650930337394440162727078866515771626896502845852711186000991913866844090831426017480263676964607121490209778220339316756171449922437605552456088105443130477974682689512446683178356259305893852096425478878588001446154476458310269704392486398646169362313605456233489086567865316333034897433650974160168545492823208575634152241341906068149887959566983066154182855136114289266802474404127414747112706158621650063987662749553991791509795764642256261917497984177610694405881831052199417235241109412927893781778469398975117797578753730248539151297798807326284978255001046995523851829184120171969918537718488250577987049 -151873924489040812813761508259707631973) 1178650930337394440162727078866515771626896502845852711186000991913866844090831426017480263676964607121490209778220339316756171449922437605552456088105443130477974682689512446683178356259305893852096425478878588001446154476458310269704392486398646169362313605456233489086567865316333034897433650974160168545492823208575634152241341906068149887959566983066154182855136114289266802474404127414747112706158621650063987662749553991791509795764642256261917497984177610694405881831052199417235241109412927893781778469398975117797578753730248539151297798807326284978255001046995523851677310195682929105723956979990870355076) + (num-test (+ 28233332719950979786871881804755080223325040620170668729385709165879717973040387558150293205758215739710262749733170837042434162049732587908182282319848154049410849721309988807368466228286699721201975848741931128639324322061892706638973259354962358866000024260698793885547287093369940035337370984725857550291339492871017395328145015077506882578124550084937438336881072124376107623716831044079223921566902242543198986921476998895559488862309653154914291349588095330683589871173449191854284433182368052817373384461363574550061788800329400860372148193491004593903732351395815409821222597665222975816418433744748143385431 -43245950360315656184924888243641533635) 28233332719950979786871881804755080223325040620170668729385709165879717973040387558150293205758215739710262749733170837042434162049732587908182282319848154049410849721309988807368466228286699721201975848741931128639324322061892706638973259354962358866000024260698793885547287093369940035337370984725857550291339492871017395328145015077506882578124550084937438336881072124376107623716831044079223921566902242543198986921476998895559488862309653154914291349588095330683589871173449191854284433182368052817373384461363574550061788800329400860372148193491004593903732351395815409821179351714862660160233508856504501851796) + (num-test (+ 17311283930487575047109155431670372891723312431004343097275158353815289445461275098157423001160013464866170709729134076291306322952612660169010483426086431377525432637844274608988581691477819008626983761905899834444008235608280930166913911248710072733217113558125600345343437000427963292980921009445490627620344145866648036116660335905940809860199697939729919140888034303887423527841395304960072549430314367914315102150378504502158659627719016733307736583749830415574905929299482373462584995162798576853564481617711234957058703455021082855018642616999836886763535412642684228990890160568207941504887072856663966242787 1954009743321912552050341299974626734964446274711484506734354360114801426013796892421541915293157994203607853436799102383078659985249097057923578528366737) 17311283930487575047109155431670372891723312431004343097275158353815289445461275098157423001160013464866170709729134076291306322952612660169010483426086431377525432637844274608988581691477819008626983761905899834444008235608280930166913911248710072733217113558125600345343437000427963292980921009445490627620344145866648036116660335905940809860199697939729919140888034303887423527841395304960072549430314367914315102150378504502158659627719016733307736583749830417528915672621394925512926295137425311818010756329195741691413063569822508868815535038541752179921529616250537665789992543646867926753984130780242494609524) + (num-test (+ 1135960177108146621604027872788612991247811085764456406834564014092038611848908717507207251239454266163702244932570537009884467598603226302482406831131219148530146321028801515381981782506355042255201016953375149829517466449677312249611502599434850555618739830488706171667035140895674806873502543300909514568759918040129665855731078258004983486524477103833885001539135541445685573269814159175744401893663504523858005835387122082112362666991112899837534230326730196110477118156871579503345757821268248575583821695674912517830056856597644827244194658166928026249459511837772775196175188368236573504643083995409774002567 -5513982495816270388232134254127393284677692173792609278582774509636977743203029647121158805174638642867428501907786521939155900331399058909602425073976766) 1135960177108146621604027872788612991247811085764456406834564014092038611848908717507207251239454266163702244932570537009884467598603226302482406831131219148530146321028801515381981782506355042255201016953375149829517466449677312249611502599434850555618739830488706171667035140895674806873502543300909514568759918040129665855731078258004983486524477103833885001539135541445685573269814159175744401893663504523858005835387122082112362666991112899837534230326730190596494622340601191271211503693874963897891647903065633935055547219619901624214547537008122851610816644409270867409653249212336242105584174392984700025801) + (num-test (+ -30369736932762868789456108597366835061749107555998091727589163626331595118680326568212941898571309672187038272915036839449380083450246957904300051802617002374912724325419651633014408152565340519439718081357147324136023867003917288524338643759680061563616479323818330115572573568245719292922176485298767387601922362893307843067637295955606642841006993776777666041277965868780958830666697755738164183356399977211227424725670822944234275611849032230010745799964550976844117943559190671369193871330514473741920389633762695829790016565565261170688485790141638094160105909405353382982945608773290740598479367828342651860878 3451570547959142767282758882796967240086418127970526029661337442068316209707489088420708984628065070358319478649952710478991064476168799556496237099109563) -30369736932762868789456108597366835061749107555998091727589163626331595118680326568212941898571309672187038272915036839449380083450246957904300051802617002374912724325419651633014408152565340519439718081357147324136023867003917288524338643759680061563616479323818330115572573568245719292922176485298767387601922362893307843067637295955606642841006993776777666041277965868780958830666697755738164183356399977211227424725670822944234275611849032230010745799964550973392547395600047904086434988533547233655502261663236666168452574497249051463199397369432653466095035551085874733030235129782226264429679811332105552751315) + (num-test (+ 24749014370880469345815230363662696846133977441600857690896762642529872426102613384561609594131771018575590861342023688138502403609639138062665279129058939911797019091643704220495944170754490238422880589600838613701783818105188827633578438439212856537589855796204839275633245851474930725845096235668385012500773524750522781174430369067441632028068262240870795850561389232369373523415592833273932285308223863420210049445377497367753786125779044716949754454461623397410528064697616617917065021866397277409044449982605591256067763430930720398889239414812509701319783809830072841056369381573100589260104551934136733317845 -9461623592584966196513107657889418526847060851423069480904645009418813160370721071067349946095573698635859409908288864150475056170059858850823883834932131) 24749014370880469345815230363662696846133977441600857690896762642529872426102613384561609594131771018575590861342023688138502403609639138062665279129058939911797019091643704220495944170754490238422880589600838613701783818105188827633578438439212856537589855796204839275633245851474930725845096235668385012500773524750522781174430369067441632028068262240870795850561389232369373523415592833273932285308223863420210049445377497367753786125779044716949754454461623387948904472112650421403957363976978750561983598559536110351422754012117560028168168347462563605746085173970662932767505231098044419200245701110252898385714) + (num-test (+ 19070246171469235561279483225919489206942407814032615339351735800304747459507922411906751965555240682457214768298108831815622470433175555196912899313888991765436434867025639919521068437191248198117664398275835972573354886915721765715992151871453808224011999677700078879590132676060988550961950472536029228350169237717222998397029428440792110955380302156159849645211726041489206565536560827557279129751110297078563108009278363910936720061216511798518178957070787710331228500533067546198458251241005176280410230146430275074766072259256583499095689284871987010372039977403712023630453400259082684930755893684499232318008 12330599952818018622104330691506128012101935028731995985677032980931398338453806827555760801312052792065671886621851470997557806941112316627790755867100463) 19070246171469235561279483225919489206942407814032615339351735800304747459507922411906751965555240682457214768298108831815622470433175555196912899313888991765436434867025639919521068437191248198117664398275835972573354886915721765715992151871453808224011999677700078879590132676060988550961950472536029228350169237717222998397029428440792110955380302156159849645211726041489206565536560827557279129751110297078563108009278363910936720061216511798518178957070787722661828453351086168302788942747133188382345258878426260751799053190654921952902516840632788322424832043075598645481924397816889626043072521475255099418471) + (num-test (+ -20895998178036569919774658790651496115060841511658297683195804524712012347695091074325978179977718571444320688167469052862702339462089668992243209990795362064005869602003990235714500149401994013174762139297327430396441552225926368085284222509085197484452650071390132794942944512235132641643003294762547138305644086106533258432786768644384855008506026923783604514268955071498269812887794817192371944269611642901807443894686178438687102834127061425955994253034824027771176714559050403098437684091684851207513969915720607528045624635094984539637789113651579846373399975502788877555747414523231999341294756679330384323996 764238600803843266244444637050072967342049538611688895792923539838804953492110953673720766879606601435939162680753428779068917662740403667549850724878795) -20895998178036569919774658790651496115060841511658297683195804524712012347695091074325978179977718571444320688167469052862702339462089668992243209990795362064005869602003990235714500149401994013174762139297327430396441552225926368085284222509085197484452650071390132794942944512235132641643003294762547138305644086106533258432786768644384855008506026923783604514268955071498269812887794817192371944269611642901807443894686178438687102834127061425955994253034824027006938113755207136853993047041611883865464431304031711735122084796290031047526835439930812966766798539563626196802318635454314336600891089129479659445201) + (num-test (+ 6243894672855694190803081952962387322599009058758027960092936187687064819462191583137945440936085088260632250436567758576422207449236613172605950116622271404444221039084346501796818945639456207912207604248991842124079786471250102192718092353598850889806607728696519257402580732995770031331187089424192803722612735557735028710899438934171272639518928194764526910590046378401600819132587804143949995694950116915803127294011661411525934100144319021440919928013617766507409909846670172516021888661284467975865076091834094160862228180625536450124272957206172214541444266874056050295270719541605687740822711659847211976891 11877496607682442993105675644902145742318375725225741293060927105303783712520284640625374957608051032540491531573337817824773543104969422017506696018037874641947740606655370938613842356322585858034851150595788166740174872996252792014218946552442572806242471174234462119454014379628228878122072189387777413014452140618318641689597452676091677588204537830401725113931418426919671512011822864583481449136550835952005765386885680701637038206002172218712504732572449659704181315669255320876647592649071711438131711904976335957846353867776093588236311654631696625859173554395714740218099921290128795607292259527492722462071) 18121391280538137183908757597864533064917384783983769253153863292990848531982476223763320398544136120801123782009905576401195750554206035190112646134660146046391961645739717440410661301962042065947058754844780008864254659467502894206937038906041423696049078902930981376856595112623998909453259278811970216737064876176053670400496891610262950227723466025166252024521464805321272331144410668727431444831500952867808892680897342113162972306146491240153424660586067426211591225515925493392669481310356179413996787996810430118708582048401630038360584611837868840400617821269770790513370640831734483348114971187339934438962) + (num-test (+ -24023960171862805266003610953999097357395283354964456554686635290239019705581779621120391229617494503580661676939681517550103414632840981987397485411400553792707518662609532504246677658012933762605038799352109564432278094548068984563394926376371580465135388578139331334464060067790936072127680597181415407099723844313625277987147283697141407959289588588489162704824409673099509423520008795428217612706997355591985894255450783091681112776112997887084157623388943538145736618168104404283342039105202585543852590302154958791010622670839015475427693311663800177428904406869645066988663292128104453773413982185343111560886 -31939808827732134714870375774276102357277346245583282398423150631754622253109692213928642228787888509211781331649081002266227303203259124984426497846441848502574293640959494009564992092503141598640200823656998243767453860939156780549404892392521391484933772285520949470194562525777116137058001008184603332597820522016200623301007194309404025522056113671560767212894303567191067178003014955596425115379852712737129325098876542459702682095445350281859042779889411325882123213577906096942649941285655935053362468972482748617111598313960198743596285343178242282172686940700127068972627110105953098737923773182254460772630) -55963768999594939980873986728275199714672629600547738953109785921993641958691471835049033458405383012792443008588762519816330717836100106971823983257842402295281812303569026513811669750516075361245239623009107808199731955487225765112799818768892971950069160863660280804658622593568052209185681605366018739697544366329825901288154478006545433481345702260049929917718713240290576601523023751024642728086850068329115219354327325551383794871558348168943200403278354864027859831746010501225991980390858520597215059274637707408122220984799214219023978654842042459601591347569772135961290402234057552511337755367597572333516) + (num-test (+ 14513652183174940741664411990199277445706189147726874603036586212536012746892966848269748909379750612027025331446918381470766609543142456872580466135425754204680927122749772612276850998180593344389487924747722210296498854143380696064338777945015153982467675141485724865534995199700908286263993697988986805404864429385840512740226775506122190698806967785494289035976495492863456705096841250592980439363856397663738211335801835896091823148249303370609165910779981271035234045185574995335952208702661648744928539539455138167482396767268362221492607154709559716065850417221174683768503217544145599044845325824451589309835 -12814535978730024053359592817368712576084646962861720729844389627130663192435154658607204342320327460695280260731620465435530495952836598646143907272825807563512741964987882356778796849529260646503692618525570185450780889283642116889481314560395290434301143877809550098309214046129802023655714098730144464028249594406616074059558969757405392170810220921023905546104487938441503430332099605473144930508420331873995741851604525954472341693863067199617721032815462094767522339305487934030130207039176659398466616780628644572276059410087128533031562978399689702766028716401176531098447698206272762966470643604141938670152) 1699116204444916688304819172830564869621542184865153873192196585405349554457812189662544567059423151331745070715297916035236113590305858226436558862599946641168185157761890255498054148651332697885795306222152024845717964859738579174857463384619863548166531263676174767225781153571106262608279599258842341376614834979224438680667805748716798527996746864470383489872007554421953274764741645119835508855436065789742469484197309941619481454386236170991444877964519176267711705880087061305822001663484989346461922758826493595206337357181233688461044176309870013299821700819998152670055519337872836078374682220309650639683) + (num-test (+ 11356479761814008572465147431830778885327227506593483181241437802252618729479905490826767363633131720717461693888023278837835457496021519184903984385091047829540007466025527592005114414671285638168997562037691602144751434208304408870143450743278437854754504713023422097017723330207792526222436928747286558205279330508360438281011315147578105966454344087225699378388309094140949428028313539634103047841948634832398526343605363013644180832752120081735152285507591096001749463421326282317713079361827765412853023201330345752038722069405404812511739634687282327711258974520622248165974215116400638833123609666501349513623 -2451734542868054449539778460457497703609327132304922810342762480808881050209276687756391911546806187586640918078231508181876445466503459873508196878629364924241891220686182517218825181707207808769770392864734466652524094735160185556148554260517746279303022469784592528209667497664672945900929888144529727881050106027775707933311860110618130543481573815538047460723253898548348335762406437618625388229555824532715231231491787570056329865617082709588903922431713098922691537317839185452018617461891748518176708607861270770493263960554805373552348256747200291438630960804647686832667981625018361034564086859426490014044) 8904745218945954122925368971373281181717900374288560370898675321443737679270628803070375452086325533130820775809791770655959012029518059311395787506461682905298116245339345074786289232964077829399227169172957135492227339473144223313994896482760691575451482243238829568808055832543119580321507040602756830324229224480584730347699455036959975422972770271687651917665055195592601092265907102015477659612392810299683295112113575443587850967135037372146248363075877997079057926103487096865694461899936016894676314593469074981545458108850599438959391377940082036272628013715974561333306233491382277798559522807074859499579) + (num-test (+ -1814184401790217165873937825605141478060935014868566665644215718762341535891730598045990231798382966074312671040257824056876679135909008140059087311700216658095793352051583071432744886316274989901835606602224927350560604355249919901932382803472476702792978322468747380191775778902733911968522382089332819162367884984027854067607561808704316828316820133400099093450636968732151876570835173932998599031643640476109466728761033062776578175554441947411139184426213290292577467587355369954997241091769769542810051228504545831588488726789173405585678190671534386784806998695797717346491308862362775748058331375692317599945 15466182953987394334491149436346080039471412309427279110582769586053943302670765125931570041904640518032832554998553018838321871748542118021556398569294085708441934948186080236498081517178574839977996802813431873543309853609838200338534343580791382510179184571852290959723696010410340740895530535423959476873857191548113125728667781953125153120447892632916574768078583174099545013854248664119997703948998871566374080719541931440495888606776561795893839624084254684939434035018741535261951124673664746010067859317726891535170781460914710499572006592206360512398012457295755926986236618644330364227754380084585899275327) 13651998552197177168617211610740938561410477294558712444938553867291601766779034527885579810106257551958519883958295194781445192612633109881497311257593869050346141596134497165065336630862299850076161196211206946192749249254588280436601960777318905807386206249383543579531920231507606828927008153334626657711489306564085271661060220144420836292131072499516475674627946205367393137283413490186999104917355231090264613990780898377719310431222119848482700439658041394646856567431386165306953883581894976467257808089222345703582292734125537093986328401534826125613205458599958209639745309781967588479696048708893581675382) + (num-test (+ -27127130599753372624001250456405972983012981437652156246797208697430661165612459362971759027335854588888552031022264244768883843080959804690580574272908031271224646245152017114094021048441971097191444782106551075175878815012595015584723250801765859461211934306789890718268168352614164589637346918581658850565274510502652089457352942736418509881708568727739912127781455473660768550022762222130489047215089836402367851853412705556570667960548570630054608024914653686223423908494006675057953013815512203710764854485332282975729323105427143207127239069826750682633272289409910001698385240596625059970587393681128674617278 5719655139276246085992066702308194672442413085748146924567717361937179810269300239821879673460959112727066470468217892213025828988023367028158410455624528688729907493639908638553730770145274142147983721694721139760883483821883267129411125364089207412089113869427479340283853501026803387874124668123626271531796990801822527792189514551888019206405597994403243358155410088320317141454525417323186389587327532772638942220300149829241141659063128602316305332848477566686425551944956989370838072872906293845914921103561360871571846865478762953536949621421094416539099628942010528483544062050170673327754206501716239719529) -21407475460477126538009183754097778310570568351904009322229491335493481355343159123149879353874895476161485560554046352555858014092936437662422163817283502582494738751512108475540290278296696955043461060411829935414995331190711748455312125437676652049122820437362411377984314851587361201763222250458032579033477519700829561665163428184530490675302970733336668769626045385340451408568236804807302657627762303629728909633112555727329526301485442027738302692066176119536998356549049685687114940942605909864849933381770922104157476239948380253590289448405656266094172660467899473214841178546454386642833187179412434897749) + (num-test (- 3872339191937382556 13437882608410293981) -9565543416472911425) + (num-test (- 12702320881720530101 13823645380834800545) -1121324499114270444) + (num-test (- 10222969257152373972 -3454292165863475982) 13677261423015849954) + (num-test (- 591233951053628288 -17639978232337836611) 18231212183391464899) + (num-test (- -7878405903223218778 9050739027069287469) -16929144930292506247) + (num-test (- 11347120771894057376 8443917396834074370) 2903203375059983006) + (num-test (- 7831959259127703467 -257470007821066702597399141202130667973) 257470007821066702605231100461258371440) + (num-test (- 1092406341647857980 -325710450166845666190895573961860069495) 325710450166845666191987980303507927475) + (num-test (- -4220606126689357919 73461013742902296577411907972196819778) -73461013742902296581632514098886177697) + (num-test (- -5112059189225304080 334306213789148650102245018234146620793) -334306213789148650107357077423371924873) + (num-test (- 3093346224554776175 -204967241927023874963787190016588249299) 204967241927023874966880536241143025474) + (num-test (- -5735747638156472357 -3881750746805128137401544408305666047) 3881750746805128131665796770149193690) + (num-test (- 17639095392510638323 13312205908441007415860933757605397223142073616822325142416364932887680287063250296996056787873086490231950036662943632990219865746131453861285495087665017) -13312205908441007415860933757605397223142073616822325142416364932887680287063250296996056787873086490231950036662943632990219865746131436222190102577026694) + (num-test (- 16304056910692545233 1463591032326743052350022746892396184459320617971409440301562638996633667625451301419074212369365394140737678584830314878769698416417465834928609990708982) -1463591032326743052350022746892396184459320617971409440301562638996633667625451301419074212369365394140737678584830314878769698416417449530871699298163749) + (num-test (- -10347586523508777315 12614325304787850623826535169596975975360455924114817820074336137897280818245940873677389644701038550150832199897314137414727161192173691528917744363375331) -12614325304787850623826535169596975975360455924114817820074336137897280818245940873677389644701038550150832199897314137414727161192173701876504267872152646) + (num-test (- 16875252323587344863 -10230183557696638447600885112945653217398839137450096120772416948425622105048400944465287395231588821521217980407867153259741079758527788318592431794213674) 10230183557696638447600885112945653217398839137450096120772416948425622105048400944465287395231588821521217980407867153259741079758527805193844755381558537) + (num-test (- 8574302739232756920 2945205250727759066959418729185252318153395797902208079569164623770839848878181416073351760975066439564334127158302281471631001294503759011790017443478716) -2945205250727759066959418729185252318153395797902208079569164623770839848878181416073351760975066439564334127158302281471631001294503750437487278210721796) + (num-test (- -17657597319577965851 -470389901349206124503884936612357721199915776516939967013182926735009022045917047211666512521578494339222795740836335004070464944715357800461845632614015) 470389901349206124503884936612357721199915776516939967013182926735009022045917047211666512521578494339222795740836335004070464944715340142864526054648164) + (num-test (- 11472336850218354926 16764018932433717867649699977474298016589762238077229911249331402108995850754999065988360217500238643747316139204767820295123085026049273617874157749889925712672510963712964034497935503076689670786498045302562704435768723916334451317158760704743066709581593570757498670622547878516907127632802801541072452593999435195637193819500375063696114131057474475407791672955417184592088612921927282233762919112197264895445408873539746256555444555901857369535350160665235184955438709679669964546134487688796078142789125799020704969226557493354453298489954288702387159956161243151013189140749021799388406290339231792790773612376) -16764018932433717867649699977474298016589762238077229911249331402108995850754999065988360217500238643747316139204767820295123085026049273617874157749889925712672510963712964034497935503076689670786498045302562704435768723916334451317158760704743066709581593570757498670622547878516907127632802801541072452593999435195637193819500375063696114131057474475407791672955417184592088612921927282233762919112197264895445408873539746256555444555901857369535350160665235184955438709679669964546134487688796078142789125799020704969226557493354453298489954288702387159956161243151013189140749021799388406290327759455940555257450) + (num-test (- 12682607562584942903 32133619583510009354538204193505267426986629771080807813988708187761849276650847958886764459302043799013813125903744946349479743277662066609741649009023451783267511140245797235200413941774959851628239089013586399425314412329003636059313583335807925401822165199322334470452126484173417518861322963430951772895619791799137157183662289329901964728384697377777905235894234370773419160283767144177627084271804319157013765325677633945370597318765372346484383325176768117059688792498687750479618961541872574768601477738410497806623403054372221338126223825515939164627992974469102910882915893925327931884157735553718792115929) -32133619583510009354538204193505267426986629771080807813988708187761849276650847958886764459302043799013813125903744946349479743277662066609741649009023451783267511140245797235200413941774959851628239089013586399425314412329003636059313583335807925401822165199322334470452126484173417518861322963430951772895619791799137157183662289329901964728384697377777905235894234370773419160283767144177627084271804319157013765325677633945370597318765372346484383325176768117059688792498687750479618961541872574768601477738410497806623403054372221338126223825515939164627992974469102910882915893925327931884145052946156207173026) + (num-test (- 14621880654476679971 -10075923784619510279100488003620810539888599376089081798647754628017452762406215094511315867213396543200861274584884759429891242650999761503100661310915213260386281412125687376866399124849043409890009033179987278297335571911640353059036551139958369871790768643514550179661619387008678118363266091945225880595898524898713646458647465935791224159084684209727153050053537752111696883536364966526666445737103854446009305531519860527938394412863332757413309423156200192973778629503534709731073637828912608835085933003410694216843775182940057891552358942312728978810053715387504707194992816961400377579655168106377696154728) 10075923784619510279100488003620810539888599376089081798647754628017452762406215094511315867213396543200861274584884759429891242650999761503100661310915213260386281412125687376866399124849043409890009033179987278297335571911640353059036551139958369871790768643514550179661619387008678118363266091945225880595898524898713646458647465935791224159084684209727153050053537752111696883536364966526666445737103854446009305531519860527938394412863332757413309423156200192973778629503534709731073637828912608835085933003410694216843775182940057891552358942312728978810053715387504707194992816961400377579669789987032172834699) + (num-test (- -3220156644655019630 -8347829670073174550775641165362740628312221836466572623516708794243074870361401136762432100726575330214254748615114820602945887237367461962207075265579588481261313345359877816874924645801358760718027997416917747796144940020489321523749233377708490614979453376328244189926517907474704635785063100359787580409065317918203485474119227673185211436285930586838616288721370975925191964611302275354365110550116042403226844820172448647475637867255305805337047967053177320593337377763657329816935516961201488840745892529800883680912275812320160312651894919502389242002380151562481051684439333368396132543667539444686619670713) 8347829670073174550775641165362740628312221836466572623516708794243074870361401136762432100726575330214254748615114820602945887237367461962207075265579588481261313345359877816874924645801358760718027997416917747796144940020489321523749233377708490614979453376328244189926517907474704635785063100359787580409065317918203485474119227673185211436285930586838616288721370975925191964611302275354365110550116042403226844820172448647475637867255305805337047967053177320593337377763657329816935516961201488840745892529800883680912275812320160312651894919502389242002380151562481051684439333368396132543664319288041964651083) + (num-test (- 11628988978410243120 21091260149209133824278525560739673446778991946138130571540201996950100883736332286627324787663044982195445635023357027423513202277912840570399895946346028843517588470258087913846945044832851780108963206182331994065720076983528527849542421619745503796476103034657238118665288185878258232226731582201217795631247916614224227701409259346052937919425072595891571572960468193421257458185693656090215937518204243652916583730260295885562094977775951577484951577581277292356830523013216949489797535362720471761788697932265967910160407593278848113303674799017334692501935041730808945554336564957621028111014116286675587727714) -21091260149209133824278525560739673446778991946138130571540201996950100883736332286627324787663044982195445635023357027423513202277912840570399895946346028843517588470258087913846945044832851780108963206182331994065720076983528527849542421619745503796476103034657238118665288185878258232226731582201217795631247916614224227701409259346052937919425072595891571572960468193421257458185693656090215937518204243652916583730260295885562094977775951577484951577581277292356830523013216949489797535362720471761788697932265967910160407593278848113303674799017334692501935041730808945554336564957621028111002487297697177484594) + (num-test (- -15960716439913426281 18799211173341989380260980155501104944815245973352765317821146163884181375747259542484535639646490774929026134833947975785613727050541297797675705933339289016115326958150660323801621778641184271728990164666383865587422591755046779736996211052149338115836473967202556153668963815595875844414662034458693455631979862997316049580586739835122770408911308146605671192538040301857163633538268589024651373766021087864982140201615461513687698136663128896835597598904095187715456109340116329587986878167776146023396961265667934659006280575496363066974484893764810659481361856335795455814679851690737943592227795474197104696127) -18799211173341989380260980155501104944815245973352765317821146163884181375747259542484535639646490774929026134833947975785613727050541297797675705933339289016115326958150660323801621778641184271728990164666383865587422591755046779736996211052149338115836473967202556153668963815595875844414662034458693455631979862997316049580586739835122770408911308146605671192538040301857163633538268589024651373766021087864982140201615461513687698136663128896835597598904095187715456109340116329587986878167776146023396961265667934659006280575496363066974484893764810659481361856335795455814679851690737943592243756190637018122408) + (num-test (- -181065640455671431985325539445069267017 14120143334024043377) -181065640455671431999445682779093310394) + (num-test (- -91295299684959299024846233061686623774 6891102275697080803) -91295299684959299031737335337383704577) + (num-test (- -252582289949155881579950873916766853744 883304029266526072) -252582289949155881580834177946033379816) + (num-test (- -10104159950635417603045689770006558103 17251490913777465304) -10104159950635417620297180683784023407) + (num-test (- 288463495341489091297108607960869684860 -16376960611483226267) 288463495341489091313485568572352911127) + (num-test (- 204661965092367792468062569536290631004 7774991291341524479) 204661965092367792460287578244949106525) + (num-test (- 174559967167400201536723778015754014369 168183438971818617783400303174116396891) 6376528195581583753323474841637617478) + (num-test (- -253300708624436983509156598368557395374 -77166863757693227553099778725240875400) -176133844866743755956056819643316519974) + (num-test (- -38587765028356074196061530813295290944 5999161273284748726648331130480323187) -44586926301640822922709861943775614131) + (num-test (- -236400856885875891058508662756360145662 222191413471626205952456600591947275777) -458592270357502097010965263348307421439) + (num-test (- 212937903940173587742882129816769611096 336470165768472077447806282475185249734) -123532261828298489704924152658415638638) + (num-test (- -264812595676159375893264580577855253845 -247068943830535581577267897204259299723) -17743651845623794315996683373595954122) + (num-test (- -1725732715479127274526681751197327660 -2279805492899538651574406423954277869507456204136276822451602661149698386520868702017367409743272511010382761246500508887739763323997191435566266331339917) 2279805492899538651574406423954277869507456204136276822451602661149698386520868702017367409743272511010382761246500507162007047844869916908884515134012257) + (num-test (- -220007189346579184019349894240059989979 9116030813176547770422918633286023943039811682891023288884273747820892639481842291616424036020927750322528731882517057595815179415042385175627374957565803) -9116030813176547770422918633286023943039811682891023288884273747820892639481842291616424036020927750322528731882517277603004525994226404525521615017555782) + (num-test (- 139683266109784685815165642637380856544 5782493350903499652295971390391981928106911831248674750993968151944332845911526084530951283012280786005612601970108688202931002414214353708335212597807345) -5782493350903499652295971390391981928106911831248674750993968151944332845911526084530951283012280786005612601970108548519664892629528538542692575216950801) + (num-test (- 239160165978290709841254489756277328273 5152132850125501873897264811465207492706871561577273155117982457627773151595716641409297120994045059130053034927464958986304380141364542178714472948085275) -5152132850125501873897264811465207492706871561577273155117982457627773151595716641409297120994045059130053034927464719826138401850654700924224716670757002) + (num-test (- 315772704643232632782106484978382006176 -3689252327480456512393153800679864208480329729627292260734151097785848947569336194072922395859496552999163037466184616218582046814434719444842678248982224) 3689252327480456512393153800679864208480329729627292260734151097785848947569336194072922395859496552999163037466184931991286690047067501551327656630988400) + (num-test (- 82735713197488344149642668226610301853 -12473025194535761005577066561696471986140205263843017221991729197337093872383371857001077050460827652296473928714097816492579684543651922277865558518876774) 12473025194535761005577066561696471986140205263843017221991729197337093872383371857001077050460827652296473928714097899228292882031996071920533785129178627) + (num-test (- 63472235942371758467270296983419551089 -7866520408163137968600317959735552406794938230345293650627055135268307695389903092041438746530663083967329111232451176014649873249349534808700483360707382397988918594143264031213181385790969271527978925616276399184489007642142996251807222768397530946779296600805549276528669432847672215219943599871223372831999133812100481632278022608906065923652981249057846548868473376683960144009223047416366697876553049362242497225174860431577034875737250719899362881567590934060155436179316063810148362442197071642183371654740845983314705249832168923202400873364289483910868432511677656218937984504828452980698439495961392749596) 7866520408163137968600317959735552406794938230345293650627055135268307695389903092041438746530663083967329111232451176014649873249349534808700483360707382397988918594143264031213181385790969271527978925616276399184489007642142996251807222768397530946779296600805549276528669432847672215219943599871223372831999133812100481632278022608906065923652981249057846548868473376683960144009223047416366697876553049362242497225174860431577034875737250719899362881567590934060155436179316063810148362442197071642183371654740845983314705249832168923202400873364289483910868432511677656219001456740770824739165709792944812300685) + (num-test (- -284018520801241078671538235859630240269 -5529748211779294240854894683633173443789067073881249229985499707296461959655918837051490512357840133495603640185675483847478587849599477020706893805485599954539589062532211767295361120129440287144117406526027552427750375526095104163474774446716012360038076376952619723549765229763943818011605991300849052030142173100367582906381575666628005795818339029350398340616624791399526643991489247585213423174803853961438830286737553181353007081438503238779644371968004083452645077716952159339978836669723137339898471600546912430030276920763475622536295311290657163861398519747560279682401429552174530714298081464588450842581) 5529748211779294240854894683633173443789067073881249229985499707296461959655918837051490512357840133495603640185675483847478587849599477020706893805485599954539589062532211767295361120129440287144117406526027552427750375526095104163474774446716012360038076376952619723549765229763943818011605991300849052030142173100367582906381575666628005795818339029350398340616624791399526643991489247585213423174803853961438830286737553181353007081438503238779644371968004083452645077716952159339978836669723137339898471600546912430030276920763475622536295311290657163861398519747560279682117411031373289635626543228728820602312) + (num-test (- -171812101820192353275910956459431262142 11401673303315394031728944442295528921842441448377692701102691446500671963119794838260543877466107345474902885032629120622020177051592733148817057943390167845763358795044702079370835841331467130719834250134674578757640577473495192331790176510774020541399177011446664359866582351045889299070080989390219063301859447807907203943168891690028442190793548699886572720360741686677780644932612683647303776634496172481504075784427704287335805355801794320914944330891519283383694196486986108936857630373759865062862204149003789919218681050221366182434949855054760827976853645027544605870235074909890698574792562001595287630131) -11401673303315394031728944442295528921842441448377692701102691446500671963119794838260543877466107345474902885032629120622020177051592733148817057943390167845763358795044702079370835841331467130719834250134674578757640577473495192331790176510774020541399177011446664359866582351045889299070080989390219063301859447807907203943168891690028442190793548699886572720360741686677780644932612683647303776634496172481504075784427704287335805355801794320914944330891519283383694196486986108936857630373759865062862204149003789919218681050221366182434949855054760827976853645027544605870406887011710890928068472958054718892273) + (num-test (- -243638660221338112796448050030955119997 -32214383478080953899491069562585164652288236626686985994647827422262342469970423345510055643470262764747630363450204055220886177681745412924556264758690138113272748656941509018308925555317383307928766093730384151056027828368474245304944063213926492719166086055718735381341569379006804236876950175122702350552198046290567043195716369691666842524594399597143281611765509174168738392889075290806378316647736667077047013214732267367344808724905727602402784621437141760604478301412768904784950365257469208085143467704875589485635570084387755189599791857576855454112556762755762408826226326879491415484319411662301650468948) 32214383478080953899491069562585164652288236626686985994647827422262342469970423345510055643470262764747630363450204055220886177681745412924556264758690138113272748656941509018308925555317383307928766093730384151056027828368474245304944063213926492719166086055718735381341569379006804236876950175122702350552198046290567043195716369691666842524594399597143281611765509174168738392889075290806378316647736667077047013214732267367344808724905727602402784621437141760604478301412768904784950365257469208085143467704875589485635570084387755189599791857576855454112556762755762408825982688219270077371522963612270695348951) + (num-test (- -126332081511349770866908261827634312283 31497387372874133218238910173378055967910722258532087598053588964599898753455370244114881403020152175272452951858324158004662566613339529101292284073176382818309096142522412043073218657587031893636358434796164444941535757484360125937835242214199979245499374972029624710574236962978707708765065292759037309958875006017588240959790355958632745299212449602934380927677385974488564420550408281673927387615657765312151272852486266800510090872812376232597458154951925709496664568906509814364388823105469855516803225244972466742963619633076158367569109107733990828830121948130235858799809203410103682003414364238243553515261) -31497387372874133218238910173378055967910722258532087598053588964599898753455370244114881403020152175272452951858324158004662566613339529101292284073176382818309096142522412043073218657587031893636358434796164444941535757484360125937835242214199979245499374972029624710574236962978707708765065292759037309958875006017588240959790355958632745299212449602934380927677385974488564420550408281673927387615657765312151272852486266800510090872812376232597458154951925709496664568906509814364388823105469855516803225244972466742963619633076158367569109107733990828830121948130235858799935535491615031774281272500071187827544) + (num-test (- 219979452670016849533060110266815720199 3900115048441644499033281842448985956665866771934663536385503692700586024397767816761943054115584011069129310718114010862034970648115172218305599786238607524420973404711138276011261135403209178420948996472570042497859127324157786975578751148348046315727383390370594954695454631662061021971027739429505825056455676233533511412589936865597034183410893428831818716136282201523804692574965779771140320669492229416601369453681528301333865290947482219850340728455965391492610516639151652595539203632139883064874286555941718154489936421274731413286355640404192677546692090304496817063325766995908926108582896362623757323811) -3900115048441644499033281842448985956665866771934663536385503692700586024397767816761943054115584011069129310718114010862034970648115172218305599786238607524420973404711138276011261135403209178420948996472570042497859127324157786975578751148348046315727383390370594954695454631662061021971027739429505825056455676233533511412589936865597034183410893428831818716136282201523804692574965779771140320669492229416601369453681528301333865290947482219850340728455965391492610516639151652595539203632139883064874286555941718154489936421274731413286355640404192677546692090304496817063105787543238909259049836252356941603612) + (num-test (- 585873325961105129055557280004608765382109855007674169500308242261038324959928764512890600512016613154122762798104714052579267789493643522748210870974797 -1855792162818946202) 585873325961105129055557280004608765382109855007674169500308242261038324959928764512890600512016613154122762798104714052579267789493645378540373689920999) + (num-test (- -3026050092505200332789765255096964033685859497096213532090644235603419347590512426830117415222669642053441336442247132403948783838396746566100575461602162 18009081534399282710) -3026050092505200332789765255096964033685859497096213532090644235603419347590512426830117415222669642053441336442247132403948783838396764575182109860884872) + (num-test (- -11124638695599888462310706699308855434715251048597328942409434888923094027849143412724699165971400546471660924330688750607774759764580214088920441698992069 -4827559068742614723) -11124638695599888462310706699308855434715251048597328942409434888923094027849143412724699165971400546471660924330688750607774759764580209261361372956377346) + (num-test (- 4950293428090696283711882613183655723616682297360442241017758383241177602498881186549809051670562038601658285833496694108818253845693871318067007752043113 17597810481352184048) 4950293428090696283711882613183655723616682297360442241017758383241177602498881186549809051670562038601658285833496694108818253845693853720256526399859065) + (num-test (- -5733769947958740467479139247420201065087494801172241127791526686385518674532830661413722661802560247463032020003355494614502034002778775472609306735864748 -3892174127829225880) -5733769947958740467479139247420201065087494801172241127791526686385518674532830661413722661802560247463032020003355494614502034002778771580435178906638868) + (num-test (- 8320894458193427045187598554188178307429755504967209344418448624882517461814957461249858674758807195827056824653471934409067429988676743031117653237018365 -12861394200627120797) 8320894458193427045187598554188178307429755504967209344418448624882517461814957461249858674758807195827056824653471934409067429988676755892511853864139162) + (num-test (- 13033402737450594044106258936169013897237368708138118260402180886096095497725071502601849887805439844083105685971731015312020770945603825344926844435936044 236396022362585261770052671762207864597) 13033402737450594044106258936169013897237368708138118260402180886096095497725071502601849887805439844083105685971730778915998408360342055292255082228071447) + (num-test (- 12170667278114656173974716189098171384426379753661081475485441559687661443127166543908925678856145097632475832903680828294561265828775791256812588754280222 -276673555533799047589626400978981416789) 12170667278114656173974716189098171384426379753661081475485441559687661443127166543908925678856145097632475832903681104968116799627823380883213567735697011) + (num-test (- -12755594876262399860618168642932232021734362385933348033134635580177924615701078617214764415318471507488803810365565826229169313660087149542130819663319659 -157671440495648010763311068579191828684) -12755594876262399860618168642932232021734362385933348033134635580177924615701078617214764415318471507488803810365565668557728818012076386231062240471490975) + (num-test (- 8664063140780163008577373335591938905735059211566906376953760862047748343846207426667781783874718320339071949903053785280430612875488847226724390758938740 54361107931665215623681874454167019934) 8664063140780163008577373335591938905735059211566906376953760862047748343846207426667781783874718320339071949903053730919322681210273223544849936591918806) + (num-test (- 3699576825118349347309026261327541749454660339251578894574483235547605815416603169143590292164644149607672871236942391817131531474661895913650810587431606 -50508350367572393968128467319633674717) 3699576825118349347309026261327541749454660339251578894574483235547605815416603169143590292164644149607672871236942442325481899047055864042118130221106323) + (num-test (- 5626548453644136572409808769267055618695663227750732922630041368983808478347120771651822300668480671524976882745306794511840379704578900504784165956486985 170502882789371639987361620116696459267) 5626548453644136572409808769267055618695663227750732922630041368983808478347120771651822300668480671524976882745306624008957590332938913143164049260027718) + (num-test (- -10859007735074693411217019392659638207496329895257318665547454149984863458541990037760564769787816800806064437172810158051442267508476778676439633382657890 -7558060977666720080449823996328496253877735754811271086853901493753796001778345391546991917892931500169890406340928835457635973812901681485438886367096185) -3300946757407973330767195396331141953618594140446047578693552656231067456763644646213572851894885300636174030831881322593806293695575097191000747015561705) + (num-test (- 9842028993407961669727766131360795288615020071102475108883839785397865740828387076847892646234215787999498419839351470775471313077046438080666908734795616 8259939762466350877481193620364896193464602165170783019804380181692322874550956777598992104871440502758410340359413403619753571535498118388286469082729503) 1582089230941610792246572510995899095150417905931692089079459603705542866277430299248900541362775285241088079479938067155717741541548319692380439652066113) + (num-test (- 3122315115429970622394662815735050825423438028108957393747131991771456957037829402044934484343765915727397519247940959221091465331254497476137639859816450 10737995515603450913722681305571315249864367824351372254572936648132763616823019940208526402092654554035074813865303483747097673960803093638463005072804384) -7615680400173480291328018489836264424440929796242414860825804656361306659785190538163591917748888638307677294617362524526006208629548596162325365212987934) + (num-test (- 11618335890332522671268040181306950825004789685088262996478365976802329054158653675768163009290064139158450983598701977173152384425333441365287895694522192 -13130287008197231017935223399369698658354829835061356451363818961959486828237111511740029441613108087354987794332115218978284937263725126538295501305403242) 24748622898529753689203263580676649483359619520149619447842184938761815882395765187508192450903172226513438777930817196151437321689058567903583396999925434) + (num-test (- -4829477140897377009195646150061276059814366801005389903693533021027427566117360765323647260121062827801190746646296803957067548167571028717513392985791293 10716557117391614298810040587314742187092120526669273567183969821384063434473189717686678450880765426943205955814024872764413373364846268902370055526485180) -15546034258288991308005686737376018246906487327674663470877502842411491000590550483010325711001828254744396702460321676721480921532417297619883448512276473) + (num-test (- 1560421244904974852620371975782132605421448226892487453928759432083522187778803424020804578027100625536441377609275030418285893555753560195716001014786650 -11797558308994912054526619290334311429749533070145154703018977152548370444659962978040151671210413666186432921816690953994784423526183449271023503069393845) 13357979553899886907146991266116444035170981297037642156947736584631892632438766402060956249237514291722874299425965984413070317081937009466739504084180495) + (num-test (- -7701347923966912534344428538744620884561375267012102797292378941649984539207353887059064943586048644516121387166836442084007442716291792933061162738380376 5290969389374230541016502448421359606252744677802288901830045825873182202718418905866055323957065013553046698199939002159982374580735362593037515863844280108947533575824820196689891621498006303535207762625068798755031433921940066544809959896067184147997503827988613858484669349726945188167613248195147619673963531690938913245110754715059472477991342216448470339490385593605806518967792963339193162830698488489270925945408227996742278697477358272529028932771642478870844024835907350391770605391526921411004262446196112836319091260967898895009427182171643279100998182191816962677328417390867021108292139204864164048286) -5290969389374230541016502448421359606252744677802288901830045825873182202718418905866055323957065013553046698199939002159982374580735362593037515863844280108947533575824820196689891621498006303535207762625068798755031433921940066544809959896067184147997503827988613858484669349726945188167613248195147619673963531690938913245110754715059472477991342216448470339490385593605806518967792963339193162830698488489270925945408227996742278697477358272529028932771642486572191948802819884736199144136147805972379529458298910128698032910952438102363314241236586865149642698313204129513770501398309737400085072266026902428662) + (num-test (- 9733743430220591762422540139212426729307515492818443460852332805653889275463385649305231919846970974905736816260992940027028218064265519723018527155353151 -29407855293830047984154639411082591337348779678279017647951764366455421210163494489475996514661359700145916243499452007595041420522019751347743105082745321262372977262641488359297167392118038994384136863563032667040671405618315550876997904307423736276844997706938133936081058323434935833614475654922773162140266784233792639117145232791514703532554345086520312281500696798706889025860427142771458666376271994240028586899592254884476941388776984078337603148583453255593120138178690189726206775893096279000909079330468718593887702543025737308336025198677457129910473491269839827087491228569718246503140134413881896746751) 29407855293830047984154639411082591337348779678279017647951764366455421210163494489475996514661359700145916243499452007595041420522019751347743105082745321262372977262641488359297167392118038994384136863563032667040671405618315550876997904307423736276844997706938133936081058323434935833614475654922773162140266784233792639117145232791514703532554345086520312281500696798706889025860427142771458666376271994240028586899592254884476941388776984078337603148583453265326863568399281952148746915105523008308424572148912179446220508196915012771721674503909376976881448397006656088080431255597936310768659857432409052099902) + (num-test (- -276731217243271862683214238489380950428392903790808046630969592255272629537001990355375434170910931115552132394269672247616298060929507021008951190291387 100289083769237476480554074865040988004216167545459907207847010762380733541100608695693297149249375537088329431700364201275915507683345148401600569951338052791424407090330310974243070931256108167365334162914085216447196038922091547331474328250886730614683299908003398886233860613008266913065047699535081030427106800418656336608005860846045905149012346378286475449307630537665901621055008855374148058291266835796203075976592585729940879567246284967856356337849150102261744547461816282538319258966892339056695718919291240188920586288417893106046698069355647145603908383687239983874164793005765733782432717429040621674) -100289083769237476480554074865040988004216167545459907207847010762380733541100608695693297149249375537088329431700364201275915507683345148401600569951338052791424407090330310974243070931256108167365334162914085216447196038922091547331474328250886730614683299908003398886233860613008266913065047699535081030427106800418656336608005860846045905149012346378286475449307630537665901621055008855374148058291266835796203075976592585729940879567246284967856356337849150378992961790733678965752557748347842767449599509727337871158512841561047430108037053444789818056535023935819634253546412409303826663289453726380230913061) + (num-test (- 8505070389896098095621766692413480203366379968950158493268895987250690600795955783113900096527432416791184386061684833478921638080978014176210898461637606 -16410711613672171332126342754193842244915477287016327757357714698751777287458963458682349581881560880814595167244857846847668988374679430572782121021084683986742283012573569894084166107235597351093334125816075658348307113218478800035703971671113417712009419861470917307849916674203301497919242668373376352901312309673053175315189945730756118172940886476343290174961420986113367531057713782438374928471960914578818951372282574754612716278516397754222547513576728677459134022062202283647690649100602260948409511070624300011106517649666031530376191755817891213910847547809248990517666613043010292627100428536737652546738) 16410711613672171332126342754193842244915477287016327757357714698751777287458963458682349581881560880814595167244857846847668988374679430572782121021084683986742283012573569894084166107235597351093334125816075658348307113218478800035703971671113417712009419861470917307849916674203301497919242668373376352901312309673053175315189945730756118172940886476343290174961420986113367531057713782438374928471960914578818951372282574754612716278516397754222547513576728685964204411958300379269457341514082464314789480020782793280002504900356632326331974869717987741343264338993635052202500091964648373605114604747636114184344) + (num-test (- -12618010259109779267590315037969998053964054382853891516547435925972388025118492931596200697357628900783311183940584302426381939302632641549019984810957030 -30500906828861638007306362171210132987300359439962044769219457463653547834815716264412200930088623097530758080891972640000479943534665059199377729854850415258341537838023739964147532129877743393965857370995558748807382396090020006195649251292012405690725917389684473999400905751109361754679152179983739269026226054012963756892488872262522587481931950410504651253101938824790285623805566521723062029033001745636445860437154344665483641408727637784045030118212476306906983993748299291616038887011943864441807818857508443930272872365334665976442185494702520760793786640113779099219233665607521784524244604432396247693263) 30500906828861638007306362171210132987300359439962044769219457463653547834815716264412200930088623097530758080891972640000479943534665059199377729854850415258341537838023739964147532129877743393965857370995558748807382396090020006195649251292012405690725917389684473999400905751109361754679152179983739269026226054012963756892488872262522587481931950410504651253101938824790285623805566521723062029033001745636445860437154344665483641408727637784045030118212476294288973734638520024025723849041945810477753436003616927382836946392946640857949253898501823403164885856802595158634931239225582481891603055412411436736233) + (num-test (- 793528769616879938852241178439496352527042950647521648629732169156958768358523029837406526207126598190786120139491813624819360632811627576064199559812277 -7357484069649002655190557040768215614708659708788999334802985986235721030962928900092675952032143512196279092521450986819067071570862007086586132687661085824939677603953832219860573980632016025218580608321648907608385784471745482257672314890331358256478273312255285010343369949412955387472116587504557483184506548209831317705115523967163525846685455369176657510129844566195941925821733027993620517287411895496215426174909366458092382652675628195464969405904518323018004882611048769247228828875493680284766874334247375868318795940759082324831733175858991629741478124633015067484305547002438816473086042218906532116413) 7357484069649002655190557040768215614708659708788999334802985986235721030962928900092675952032143512196279092521450986819067071570862007086586132687661085824939677603953832219860573980632016025218580608321648907608385784471745482257672314890331358256478273312255285010343369949412955387472116587504557483184506548209831317705115523967163525846685455369176657510129844566195941925821733027993620517287411895496215426174909366458092382652675628195464969405904518323811533652227928708099470007314990032811809824981769024498050965097717850683354763013265517836868076315419135206976119171821799449284713618283106091928690) + (num-test (- 30958566711373255787092081401292877738974978442987704470984765018293851031728996862405055424093249924047528792113585028592262445810946419909807061004531455817427671594281537965628880611732831524185850161910304038646992464838306728350704966234151134620041799373762432970330864023007632010865749239024802839173884778578927209741320635135275002489733299806669933393428518104197594560039136096527206600870299327752296492029012993590212340409989598323540081430189567580333356380487749078595746626408529223195894600223743978246922817054226858311823994547784553612982586322603593335538875728113115443554199017672360091721648 9164115638960783470) 30958566711373255787092081401292877738974978442987704470984765018293851031728996862405055424093249924047528792113585028592262445810946419909807061004531455817427671594281537965628880611732831524185850161910304038646992464838306728350704966234151134620041799373762432970330864023007632010865749239024802839173884778578927209741320635135275002489733299806669933393428518104197594560039136096527206600870299327752296492029012993590212340409989598323540081430189567580333356380487749078595746626408529223195894600223743978246922817054226858311823994547784553612982586322603593335538875728113115443554189853556721130938178) + (num-test (- -22540807692474380279530794404584230073523360203115293035869063366926380719566516089428840111682263403627532047214106171892715667227836310498366393991106231487046533598391969789120283294510723096483520917309134391072655861112766764278247568027435618337967113341863713181603534251049249873125130781073437913954718595729437608729446837417196899902194261111827656247095442897532040935029872731410799530408713850806239149348700486268275019296069828199088780767614008685960242354118969741283398882689239770114582524756296906388861630890288875920861344939520380841337675934551587994259348267613541166769237154904791412049964 16928681651977808800) -22540807692474380279530794404584230073523360203115293035869063366926380719566516089428840111682263403627532047214106171892715667227836310498366393991106231487046533598391969789120283294510723096483520917309134391072655861112766764278247568027435618337967113341863713181603534251049249873125130781073437913954718595729437608729446837417196899902194261111827656247095442897532040935029872731410799530408713850806239149348700486268275019296069828199088780767614008685960242354118969741283398882689239770114582524756296906388861630890288875920861344939520380841337675934551587994259348267613541166769254083586443389858764) + (num-test (- -5403850875869356031749551669837202919756114555261706106905659104903792701565965475066159243529680606410723686422444947172225540145977333194008702465610630608545009270872541652430806931212184915840724378685979865349848151917650322286497417985248678815214889868576385900691591784772762893647315325310416150353725001943778473686980157692817497562783521120544549784746647104651038037129984152623720529803205580894126664077380391379306511348324442512538418658728022685805514196592544294177914956734669359073791151050869328577099869772182315103156047405800398706114122356939316464974680113324979723289916823063616573634058 -10755560408227106818) -5403850875869356031749551669837202919756114555261706106905659104903792701565965475066159243529680606410723686422444947172225540145977333194008702465610630608545009270872541652430806931212184915840724378685979865349848151917650322286497417985248678815214889868576385900691591784772762893647315325310416150353725001943778473686980157692817497562783521120544549784746647104651038037129984152623720529803205580894126664077380391379306511348324442512538418658728022685805514196592544294177914956734669359073791151050869328577099869772182315103156047405800398706114122356939316464974680113324979723289906067503208346527240) + (num-test (- 16201587974698660164372991183566748501003872177894450603471850345714117528335101264234127789041855420954511595895378320972957964222386731614839583078498685801156670229700092209313747849610762975747730086443186821337319452128253859293962343891549207804191088925361935683615063225197130192492652062735684739784075955094308092423304262201429421582566117390598395895220976999990205945523225411701169301910362640419341608407294018105959688929256136725564385243617240412649023368133778798063226772467915584333795357813292935080009919284755332034998122912861893282865727947810588086156919649131720183722427134042574317487793 -126159569916621842) 16201587974698660164372991183566748501003872177894450603471850345714117528335101264234127789041855420954511595895378320972957964222386731614839583078498685801156670229700092209313747849610762975747730086443186821337319452128253859293962343891549207804191088925361935683615063225197130192492652062735684739784075955094308092423304262201429421582566117390598395895220976999990205945523225411701169301910362640419341608407294018105959688929256136725564385243617240412649023368133778798063226772467915584333795357813292935080009919284755332034998122912861893282865727947810588086156919649131720183722427260202144234109635) + (num-test (- -9976758107386398142455037422077809088581080675608340830198269021688955930541332630075972471934165382030070969307731206728197760190279942894255740733209190331510591013089699837164445642396864912572863786290237335963836376543389815671640509582958465164874961381137096877288362944469137669502842448492172241151419831252572392809173900377271652074261706120638052379886108764460001026094198502028776365675088466580595870167840105746912975236851293882732079317535103041585285239081516202482201377111734010788198635874359396626004300532752450289119192633850562141516671742961938277967783337559307443617308447853505824391099 13449070890444925581) -9976758107386398142455037422077809088581080675608340830198269021688955930541332630075972471934165382030070969307731206728197760190279942894255740733209190331510591013089699837164445642396864912572863786290237335963836376543389815671640509582958465164874961381137096877288362944469137669502842448492172241151419831252572392809173900377271652074261706120638052379886108764460001026094198502028776365675088466580595870167840105746912975236851293882732079317535103041585285239081516202482201377111734010788198635874359396626004300532752450289119192633850562141516671742961938277967783337559307443617321896924396269316680) + (num-test (- -8570952518585194406209873586517687582701183275108243979199329595605282282125006489076327154374449108678257552384372919282846744626955206382078850958298637157198962032090439427286914716782317030245513658212430127586764421559372214829010306717557679285031617989735914399954286846456953917915955558448774972943731602144914068097214910567329340361564904028964471241318105967747431610163083002382821902859161510204381788262611298660559327478615315484763561786397041779926288206767156863141140852268323253657685018587945456372648431446464389004257999049529945532453598011773843788498650935959375182414447893892341891463988 4431555062692055371) -8570952518585194406209873586517687582701183275108243979199329595605282282125006489076327154374449108678257552384372919282846744626955206382078850958298637157198962032090439427286914716782317030245513658212430127586764421559372214829010306717557679285031617989735914399954286846456953917915955558448774972943731602144914068097214910567329340361564904028964471241318105967747431610163083002382821902859161510204381788262611298660559327478615315484763561786397041779926288206767156863141140852268323253657685018587945456372648431446464389004257999049529945532453598011773843788498650935959375182414452325447404583519359) + (num-test (- 4117976000917214601143188578494558474138167055110060832594841842655428229500889876131794484851166401425675703592388271925904534237338595998991043982676292549088043959446082382516734793718348862105938692342851330680670593768890094290655852108130945387988863730762717733881418314989528719379494082656897158942547008663543153236129762264443358316776532465284014215413819415615612452225913947961681691310132286840303081453109375175436902292224029179426794714036524361081174901146731799945483243427138748119832116750910126386838614645397770107366925613473924955965862778639046707637382775371488874447622330992324750207465 329466253508616383200261654231797136951) 4117976000917214601143188578494558474138167055110060832594841842655428229500889876131794484851166401425675703592388271925904534237338595998991043982676292549088043959446082382516734793718348862105938692342851330680670593768890094290655852108130945387988863730762717733881418314989528719379494082656897158942547008663543153236129762264443358316776532465284014215413819415615612452225913947961681691310132286840303081453109375175436902292224029179426794714036524361081174901146731799945483243427138748119832116750910126386838614645397770107366925613473924955965862778639046707637053309117980258064422069338092953070514) + (num-test (- 28857935543824608075326348244201981931023939250259142606733822094071772153858420201297951828741003977413353359215638528196235956061529059419904405354390715114239219947402126760298132539402386106279333968395498788354937020337343839325588433318100331044091923709732742795159387846354148919054314582749477292946200912006940503778924320301062789466388997936618573519744795661160190636101768486096961991215006236190655062992372061052426455063703038765465688361316141792840153608145888307784845264037109867657483109819380082597605481013612040648149090345778910883349230476481347645708269410828528742743794495302359380494607 126536164564464424337714470705049463978) 28857935543824608075326348244201981931023939250259142606733822094071772153858420201297951828741003977413353359215638528196235956061529059419904405354390715114239219947402126760298132539402386106279333968395498788354937020337343839325588433318100331044091923709732742795159387846354148919054314582749477292946200912006940503778924320301062789466388997936618573519744795661160190636101768486096961991215006236190655062992372061052426455063703038765465688361316141792840153608145888307784845264037109867657483109819380082597605481013612040648149090345778910883349230476481347645708142874663964278319456780831654331030629) + (num-test (- 3146199586408378667812619157270468624370984629500707476575291934586478540055436137993431548830607708293475788354970610669452058906009873485175438772484599603993015239438297747261356407887781450787482447252615210880612867127689283653562498484594955015919746443263740095372831444793239911996227663006098501180972347442107190398034048225264564325230296723559400768342331039755765597288518435463475921534765025262262798267314969774604439319964638461636007229819888743218820584570149249791727508891676067767073852694327748467914037392778283816153183422263956621516748627574334199731850712255885395479903525322397561293553 -169494171680584797187706369710105239124) 3146199586408378667812619157270468624370984629500707476575291934586478540055436137993431548830607708293475788354970610669452058906009873485175438772484599603993015239438297747261356407887781450787482447252615210880612867127689283653562498484594955015919746443263740095372831444793239911996227663006098501180972347442107190398034048225264564325230296723559400768342331039755765597288518435463475921534765025262262798267314969774604439319964638461636007229819888743218820584570149249791727508891676067767073852694327748467914037392778283816153183422263956621516748627574334199732020206427565980277091231692107666532677) + (num-test (- -17024716654716744558842421452239026542281806678754026383430912733874686056449261218428541803113383766132449624540209841726047308927951820311213785345168358108138304716549475322223600292513384537980742126687035576531330089447100646214364923043445903103768701639992829171572718403272488931980504461938688955457870904289239032709146514866818331202329982821151580491257491540240579366183525075936339515949345815704583685855315810611089822402567649542290589282153225725537026309623090382054078872576985425957096858376112688308214148412270019118710904983829984589093557307164347051152307499446188262820058714564165108542508 -26845770031559702758807696432929071597) -17024716654716744558842421452239026542281806678754026383430912733874686056449261218428541803113383766132449624540209841726047308927951820311213785345168358108138304716549475322223600292513384537980742126687035576531330089447100646214364923043445903103768701639992829171572718403272488931980504461938688955457870904289239032709146514866818331202329982821151580491257491540240579366183525075936339515949345815704583685855315810611089822402567649542290589282153225725537026309623090382054078872576985425957096858376112688308214148412270019118710904983829984589093557307164347051152280653676156703117299906867732179470911) + (num-test (- -20875354448001792153279041347864644172439177882677780548397567327274288309764204295853633150227327732322157811413794613378828291977852467550695289535036337326494269114787031260705326469002279939986228049380615128280814933748700667874022724707001736732724010699175779382411342385842744973636495738468838244099596215421975861650998954057316519632062827510021706536194961332185926551767127180751211669386674770139039516623606727799489291663572125587356845055646322930167536458093283930082765496058330805117442824718962237069840252138957395570892073194575112213410604881673785921789655406716271370732069643455590690035701 -321447426701397438572265325285879998363) -20875354448001792153279041347864644172439177882677780548397567327274288309764204295853633150227327732322157811413794613378828291977852467550695289535036337326494269114787031260705326469002279939986228049380615128280814933748700667874022724707001736732724010699175779382411342385842744973636495738468838244099596215421975861650998954057316519632062827510021706536194961332185926551767127180751211669386674770139039516623606727799489291663572125587356845055646322930167536458093283930082765496058330805117442824718962237069840252138957395570892073194575112213410604881673785921789333959289569973293497378130304810037338) + (num-test (- -6750548706930727136186675393752693335334383613941059024795513640678178119089262068912855951615043660442324823673049951182143778744824110223137384940032268718291241014850714197673735719784663896993460156686600813524168487673234842233781654493200950459723884918456280719440022930492599128086690014332139955274261568563155723011697763382009890186816226119314994799655369791620499988988986590903148198659095740939986627235565633349906453726759224441608018598520571182643709143072528030332708598472074166415467718451869993686505339408706320298338691467040585228617379086727764240955696690287600957842671916189752415855520 132223863177855649509430852484092802671) -6750548706930727136186675393752693335334383613941059024795513640678178119089262068912855951615043660442324823673049951182143778744824110223137384940032268718291241014850714197673735719784663896993460156686600813524168487673234842233781654493200950459723884918456280719440022930492599128086690014332139955274261568563155723011697763382009890186816226119314994799655369791620499988988986590903148198659095740939986627235565633349906453726759224441608018598520571182643709143072528030332708598472074166415467718451869993686505339408706320298338691467040585228617379086727764240955828914150778813492181347042236508658191) + (num-test (- 15737797902964168014939893286340956118635524170934156177365242966267432695262586636031957242055461736359478270642576860414422844075672388559647477705484719667060463718865742735598799928335211410004369240278699196301127699945374217439676378682879115442203681638050752745036508637214733712716867800216723838016099572951915042604603457902610639317648800296497583507890473114507231814851908526534709496988648572353272479026750068932474334642929727977996779536604912743446197670724757690108283368934769626461285961947257397454619164856011847736479229692086038931510067165282571276049292116713101550911614590774659556899356 -6114512833799784097991148713266650451765474382378581896952003894922931741133332233338460555227243451198289670274036744955599177213449957470212981501678055) 15737797902964168014939893286340956118635524170934156177365242966267432695262586636031957242055461736359478270642576860414422844075672388559647477705484719667060463718865742735598799928335211410004369240278699196301127699945374217439676378682879115442203681638050752745036508637214733712716867800216723838016099572951915042604603457902610639317648800296497583507890473114507231814851908526534709496988648572353272479026750068932474334642929727977996779536604912749560710504524541788099432082201420078226760344325839294406623059778943588869811463030546594158753518363572241550086037072312278764361572060987641058577411) + (num-test (- -26633154627863501044020127597209297142657179797586777727331879111280843451446814109347357601013807189824906954310855123313836812409388745541128842840054310853220032505914307470215180950497357091093642400638925719682307925365402618310180378684705799724964274776149984064608716300479893889145492885897234574442542501896696821902329473018442082678749291668341477914681413039643187020003425962922948452894682558162414623956491734656939841377698702802567258906642912449969621455596132708975438173455827361542712483153981422051943690720556013580161324856788091093465837542336129629269227369781823515673967591796132853515009 3321161637038961370471515250185392889390643163295535903347391615170504064647249127732639364682803744773593849851778894972403397573953564801884397178069327) -26633154627863501044020127597209297142657179797586777727331879111280843451446814109347357601013807189824906954310855123313836812409388745541128842840054310853220032505914307470215180950497357091093642400638925719682307925365402618310180378684705799724964274776149984064608716300479893889145492885897234574442542501896696821902329473018442082678749291668341477914681413039643187020003425962922948452894682558162414623956491734656939841377698702802567258906642912453290783092635094079446953423641220250933355646449517325399335305891060078227410452589427455776269582315929979481048122342185221089627532393680530031584336) + (num-test (- 27668394897866653012794531261739800318882766882548843941974485394983434533400277607364280566269718161470415771058329222680901477416257843578362127708934184467195154000133252468684612556324066063725677629160438683034201285122508880444372096430021219637788794365539396242345208611990491721052691567092029622640533057073151980959055665792776356282961971341363712186503783566960850166774438868528799819047163739437906559674823146932668464230936946321915236658512741918196732794332451120218658490129307932187658010681746557120172585093207839141764683325214902696969028472942954863209641597556494684135445935915485525220911 204625459185084436546676461283890328511903949966691877662249903659689934813784661695047569885195881142676761876303280806728760511429260843727967794322777) 27668394897866653012794531261739800318882766882548843941974485394983434533400277607364280566269718161470415771058329222680901477416257843578362127708934184467195154000133252468684612556324066063725677629160438683034201285122508880444372096430021219637788794365539396242345208611990491721052691567092029622640533057073151980959055665792776356282961971341363712186503783566960850166774438868528799819047163739437906559674823146932668464230936946321915236658512741917992107335147366683671982028845417603675754060715054679457922681433517904327980021630167332811773147330266192986906360790827734172706185092187517730898134) + (num-test (- 18944451653774463090918576081661764936021793389045063662102219434278236461286997354190032851092512146937346521704215170240383659165117708716738711782597164244188741818096207452074083439983059414271417130274747048227795964884943105011205424198661201055104372863019759130697888820715782179466491256695453118035286889359217448004524564796840711987314064158194625731263591557915838970249677548534895064545467992194029425250039951132361639559343536937119283951538321037694842089561504643350632756961329867761604760788760440497535611072991056505806805291706178639395690245460397975614715123591611301423752799666149495108752 994321141213369910357526037382331323092462599623554452705525887587326552002660849455542761618020243106424015447778226642816634338781654345001677083881111) 18944451653774463090918576081661764936021793389045063662102219434278236461286997354190032851092512146937346521704215170240383659165117708716738711782597164244188741818096207452074083439983059414271417130274747048227795964884943105011205424198661201055104372863019759130697888820715782179466491256695453118035286889359217448004524564796840711987314064158194625731263591557915838970249677548534895064545467992194029425250039951132361639559343536937119283951538321036700520948348134732993106719578998544669142161165205987792009723485664504503145955836163417021375447139036382527836488480774976962642098454664472411227641) + (num-test (- -25075128489482657321316021943980016828761861550379828525731288423212311433274066958090940464803020097932875912251380196071686918459370667428905844496548191635733867314315152547202859654044591981512687559437417616479425752991419002108503390319869665933757684966460526631533822984311725217788657567199485442486045019468844265484117570385156844404625735176559901986920712550964238722824122000259551821135404274194791706113272773768366572120227974096419295159271316157215551931810740200836725504693738229444336470213883741520460842708733150362983831267583568258736572295448486287825894301201018490203520738439038977754991 -7402949251688548738762242219263594861535354011996392637087346760786292549376145193266590582054224293289596877537643409310483743293801574030358189880866069) -25075128489482657321316021943980016828761861550379828525731288423212311433274066958090940464803020097932875912251380196071686918459370667428905844496548191635733867314315152547202859654044591981512687559437417616479425752991419002108503390319869665933757684966460526631533822984311725217788657567199485442486045019468844265484117570385156844404625735176559901986920712550964238722824122000259551821135404274194791706113272773768366572120227974096419295159271316149812602680122191462074483285430143367908982458217491104433114081922440600986838638000992986204512279005851608750182484990717275196401946708080849096888922) + (num-test (- -26509487378481600038412836495388065888781507388737194948728047318975269277448073484403390476243134990463394380967295356958474984927721196047241216945988250219075749832868804186657201899994373052648345989716938779173325348547767647529160988985542438998030764420175306438858518207072038513664360905985908879070216069156102379349899544471658754952888660878997691670566078979940005195987259493512159628198906090101827331841914429358969184839073862821059400943312264269215878469013316796620921077244799814690434355127994011220041638393750697699141479399553359747084811371804524490919966410379714725200415331414459870271869 -9247155945465656153397925559476432992975541781462281935278489123804934847762489500833913193183733932905776020790478662969835879365116238125565077744775032) -26509487378481600038412836495388065888781507388737194948728047318975269277448073484403390476243134990463394380967295356958474984927721196047241216945988250219075749832868804186657201899994373052648345989716938779173325348547767647529160988985542438998030764420175306438858518207072038513664360905985908879070216069156102379349899544471658754952888660878997691670566078979940005195987259493512159628198906090101827331841914429358969184839073862821059400943312264259968722523547660643222995517768366821714892573665712075941552514588815849936651978565640166563350878466028503700441303440543835360084177205849382125496837) + (num-test (- -17010604274474750006607667808593883725990508452473783283717890546525148212376267233909567638545898628257361383837671935903199638230375408397752251127816717091041943873728526445398525706450929660366518707254053655364610471112296477865068960744948010561798109833411657930112293904378353445961131058136287425064317621271289456901138718557297733713446119244533144377470099270824020439428168481914824420861176457152299497728390918971852021025089592998997807574907789524112450146545688385954763667980124432645276563626082835790429598328230426471161191074551543308732791287559033843466623138171520961684959997180979203053477 -17319079025684619178510812811805110270463447771889107440996086020812918555191263705580533644731591929176480040622705607552852994906782176254877135818109655911838591767583157894999741648979817400330572419476101372927546509769818404491634583907246692993992514876697330603464497645633398167129555001859772111887143352351860130929715392173452396253437927361301990735683539169040916027268831202732178553152351117118606495416985612909248422655861312689027789401950549626643389790516560291620711705848717875304929186131258525831197192620523261738944873398924939726689336762464320190834794155527335576391767307110012289717973) 308474751209869171903145003211226544472939319415324157278195474287770342814996471670966006185693300919118656785033671649653356676406767857124884690292938820796647893854631449601215942528887739964053712222047717562936038657521926626565623162298682432194405043285672673352203741255044721168423943723484686822825731080570674028576673616154662539991808116768846358213439898216895587840662720817354132291174659966306997688594693937396401630771719690029981827042760102530939643970871905665948037868593442659652622505175690040767594292292835267783682324373396417956545474905286347368171017355814614706807309929033086664496) + (num-test (- -28362352496476494327713713233021518136860402239251781438945998574753662942796270292818595738100959519541952077905620088422871490191217157269435052965329201030095268586136492980900212955645939325800541690754639292707053269767151001292253701853012092829784482071789669480438026889625605099744553642207773753943711175375843649210118677569597324789367425691177169929576236753018329085700397911235750600921874606148324025962628852167093806152864269874177214562322576097931390470469397118268354868919899638376323751276807304678316688836173746719723312665764603485606350244811113608471530958617108833879194264695174468397461 -4081062111675377984305281082755054920741203741273067094307824323728798665450292976016160959354997082250970415737745853292134965575242789548167162064123232363464302136338349828801951197252612093077640695564825095503535921549690447893467349156939791370286866987224201115453216606688305427702274940837032716124925028835914047967887674858015919302546781010326385758988488478290741665427521820112231266659657169118374988259423444686317389869729817643396097464874333968181509317307320406521221309011946212308190273531009796563611621389720223920155554879800901239072885025170342349379379336047732368458185953903872634982504) -24281290384801116343408432150266463216119198497978714344638174251024864277345977316802434778745962437290981662167874235130736524615974367721267890901205968666630966449798143152098261758393327232722900995189814197203517348217460553398786352696072301459497615084565468364984810282937299672042278701370741037818786146539929601242231002711581405486820644680850784170587748274727587420272876091123519334262217437029949037703205407480776416283134452230781117097448242129749881153162076711747133559907953426068133477745797508114705067446453522799567757785963702246533465219640771259092151622569376465421008310791301833414957) + (num-test (- 10367142604728811799331249565431331488313655422005202933702176605382043644320209814639311439871418581341534233560256605231366966869093495784665834232350567124110194965198962966795893926025854156729633358240069116588609932539289897499402463770167927610848388138020589286461244557962368497723086593344721146859584146431437967506007518396464517349944129896971137720357645026281243138165214047233258394590454775153944241555543594427555914116439316287902470043292624597940465373006598913770411505099332700167695871387948271302951230983772351549087620538875967635100644404345317626621438913980275970160864401622986870735123 -13323117602411502623386235160326625769048477819798659261203460002048250420188223753407093545503703207645050883770850457071863684414849353264890601744588860687970804808452855795406182324143949747985869939791374195222513169904228914579995165180964917538177994190229733465224857616114628815752065632238207474599531507602861647623695058640735949593381112671690796335596142010430124683781417828023076027476816068202219709673411776556090962187853799456968290579708094595903778622705850818245685205707447012659247018940946510378371952655457988959551256869060428488498330109152756599450626641948447980234503249330875085656261) 23690260207140314422717484725757957257362133241803862194905636607430294064508433568046404985375121788986585117331107062303230651283942849049556435976939427812080999773651818762202076250169803904715503298031443311811123102443518812079397628951132845149026382328250322751686102174076997313475152225582928621459115654034299615129702577037200466943325242568661934055953787036711367821946631875256334422067270843356163951228955370983646876304293115744870760623000719193844243995712449732016096710806779712826942890328894781681323183639230340508638877407936396123598974513498074226072065555928723950395367650953861956391384) + (num-test (- -25321281404861286799950777949097462701962113587443565138655462269365151737118518315058035825695270231347401755128007072923189452859397209062457461602335603630181865680063451525170253746137368267674863889514153713728814272332433431604233690200451816570240227260445028630591376891139306370205846627093813889699170594185178241812081296510140572331372738998993116117098817936927692238682202717231675283209016857095739468507690090676681400453024293870135659990528969837132054786661560150259115734877162158755858653364070279937027014730947342216816307219127474721622123875699701715404820384545693058511056735799834754890692 -15870257059811626693754498423136372480069134596343998984549199283973854570508228359295418026089909378687774627821225399931314225867711515277913855368473873536462450935842786002269065816311054834857109074848803122494252885020527074586145467185882674518032764708782999568002770206995683800833252068328835778749976046128872525287656002968632147457840467536682726059599593635219947081138082647985895437016641903078766878782632503812736486529143041369932038649270950453231711525943737962179463585338023463992816994328519710963267459007592689204838965317062070771191372220277256094361390952025057574056586665509010902583686) -9451024345049660106196279525961090221892978991099566154106262985391297166610289955762617799605360852659627127306781672991875226991685693784543606233861730093719414744220665522901187929826313432817754814665350591234561387311906357018088223014569142052207462551662029062588606684143622569372594558764978110949194548056305716524425293541508424873532271462310390057499224301707745157544120069245779846192374954016972589725057586863944913923881252500203621341258019383900343260717822188079652149539138694763041659035550568973759555723354653011977341902065403950430751655422445621043429432520635484454470070290823852307006) + (num-test (- -10064759312484387184876313010284016458560725440641239737323234767636591183611201479885347260175161165340917225306019885202675573016295152797559983194160634880140345743489989007821872426587698574795394887035658449467358615185057180305109018898637903449135520486663185036663238956537895356325733583128141439025002140924158670346599492383552938312402521066705186885506193758499006001382444818328802338159713646715901977137011576113434170842422373328479181457354927400927267448788528116619711184792932525071391797130057189079431487557270366699175956757661488296856660145077706273571985222726397848614141194988258117115194 -3689074607001776735792882994440038588887963294487080609346609068733026224735369468180206799966728461935654851527895876039403151156669223687679382665269013769686991783531091821265184956524448064027733731862929686596729449196238312997460578818232100254940830907672953344544031914926653652310468671685310332327057444910423081752028857828828473637496272809899061573593874011995802487442092326045415689987885712749026491545159340468151000027397821404233369034594141219014219707193746581364791219277489927025992135462852894714639406751538919395016165215641239054420028872350709704191189169571752512626755385998505584006855) -6375684705482610449083430015843977869672762146154159127976625698903564958875832011705140460208432703405262373778124009163272421859625929109880600528891621110453353959958897186556687470063250510767661155172728762870629165988818867307648440080405803194194689578990231692119207041611241704015264911442831106697944696013735588594570634554724464674906248256806125311912319746503203513940352492283386648171827933966875485591852235645283170815024551924245812422760786181913047741594781535254919965515442598045399661667204294364792080805731447304159791542020249242436631272726996569380796053154645335987385808989752533108339) + (num-test (- -4621513851362114851854472268081584822344822740665629177305004335694395719163541988311496405455186973857145245414214464449674464879082042971313025249648887349614046805778335573547862191522938924075560443632614665169520240664970180760364771373836023824195690134618554368845612471858027311791638881380352344527105480173917778084361560336490212845414303819150625355111300877737042696291233444311426721588476948565949641149735838580313236869041013210454558557732497012037162735013212361842433337324577522358968152852532145622765032318936569346015498130151789662274686368870963891262060214274101000058555635785833724062234 20283847238128227963042817384468009365120280641032764409860857066215336820785816567924217697745867082423864450685360959383940995237907453126362378908108545669654749698030305432673477271848544313029448526561606175059997663752601262173667861202924953502866611309434183496911206954880840674239880495147451496219568787221129244201657487090244435562896841733049066453539864301122516559479757096183362477594406691085946787803323712522074578611082872627361465163804239673539339633332349145205596371287028267780080937728455742966681547897652607170788637996317683436193829274172400558140357237480809582038468874094877651383053) -24905361089490342814897289652549594187465103381698393587165861401909732539949358556235714103201054056281009696099575423833615460116989496097675404157757433019268796503808641006221339463371483237105008970194220840229517904417571442934032632576760977327062301444052737865756819426738867986031519376527803840746674267395047022286019047426734648408311145552199691808651165178859559255770990540494789199182883639651896428953059551102387815480123885837816023721536736685576502368345561507048029708611605790139049090580987888589446580216589176516804136126469473098468515643043364449402417451754910582097024509880711375445287) + (num-test (* -1412797070596191471 -15492755620416346417) 21888119755986895161222137392796809407) + (num-test (* 16686841096925954110 1491135775021813104) 24882345731730524499708005167300657440) + (num-test (* 13262412958100188045 -18379071970155621919) -243750842254847872704698616507823758355) + (num-test (* 889503034794263569 -16600674457216690894) -14766350309325860687849239111838240686) + (num-test (* 3148165694020236318 -11771070679825280729) -37057280896113409834434531491271315822) + (num-test (* -4443818546267181727 -12001052312087213799) 53330498839175802532024121011435050873) + (num-test (* 8305259347214213793 -229351169208067535459370186456659711595) -1904820941859811670566233132773219565154696335396051029835) + (num-test (* -18273334758510166901 290047155020180552782039318570071650475) -5300128759437251944808204783222405076790289915320785927975) + (num-test (* -703280433697652940 91110448009482115063492795153459771021) -64076195390496041906141380919369524419358692517527451740) + (num-test (* 15279634596127882146 -220998726467849290098339792307263567896) -3376779786638352686104608499923871317791563686466157184816) + (num-test (* -4472497681184076830 325612942672822430032905460436166528379) -1456303131067722058341139305566346079551678140995111358570) + (num-test (* -6180420673489141029 -161157288800853703711204405567379740552) 996019839388256252540244286609069684717518686623358308008) + (num-test (* 14044956603588468379 10163190459901171254101452124764637970005230126310661589196828892266636678427020930101076689732526935899135126391465178494895371156141265424428405590113790) 142741568963316278148132287599703960511135825069792278910440475692913696263448088587778211787403889397993501704943449376875999977937418748662459138952952917221024170426846410) + (num-test (* 2133283347509865817 10577710515843519541178984366353275630877942729579274295972091544607384358263130633386329706527832990861547566574369528634541156662300858851752195966167381) 22565253698228972909216255630133478029433774404794962869038558824053350969301054394347471181756471783852326407546652836376109109470959746153989521923555764579738243072315277) + (num-test (* 7812722507014599311 -5055959518947106416800910724733658104378582281318226107212861190073091017493970778425583956006925004399967175604321778956828368132273155364830637407968648) -39500808728232764770485117356353304373275127104839804121600969932458363071148383405901570717732548020267052999198017578112731079638156026910705662052515278317807704170401528) + (num-test (* -17560801708050275829 9842515227842383346577123873881045824143545509071137371075701856197189100217561683579562062872293951325890789283651221922663521213150065638405410634222129) -172842458224605375239887212582262805312641302639067963604956593404910080268476692854082531021580381176489626536608405283010496488558204787140272050713264572452317265305619941) + (num-test (* 16743386830114877156 7347065846171565625701636575261347705942035850951855454324853850791855951431141198155170102434274509450315416946729031216385536668189501958761688618635668) 123014765528775807847206414290825117502032199391400884957413813554539073118943905948723779020186281150198999824020769031248882909461419778092564985979904308229718874140000208) + (num-test (* 12697192948029671719 -11416780209809507417142822520376617951137069007568339428552592261458272400645205700952156716454820410468812274673183389934216970221062627926131479014990611) -144961061169197993494569769162151457365959287966302572862364500950127981616038900865036521107816831702945678695331078399461327412574397914795455218447174498277798426197230309) + (num-test (* 17005139720743105479 -29990519259587469661876904501488342396062731024702923152492275204626478246142153608222329335341363164148761307659972897552084842238285026253664841395295138667328930482145590159132144957515157474957872335043653264146346772142483721767458961320947069718037828473530001033848282453826154763424789967441239969918856795769965946388666154136004597297855416503729657013008165049478441197537144135384444157408972370236442813734429031404855591324183846423588871065272526864866155918285777640819778251612915859290336548446745308788013234099839998683451658620461972798204104633072664604846231692505409653434538208644416538994256) -509992970306921990341332390474393215554862069848994183152714032617297815196921655222705396130464246880845576204295466273071779248718654338767559016551390771145212884412809612574391658668778295682412755916528976282396155832617323980694289208942491001345059122414240884660276842648466533488559879226195446807748573906940273568334343093922652142252689341425941673567630236228358747411926991658260241924294146562230425295426217833820067881064577380516936937782688004146531121831211284735538742160763820814174631414364095096099434285754767091040812242751724012532803037860394426031234340719537172735695313262283511554154662650333168783128624) + (num-test (* -15877530153400521290 27863984127681242643954505352420303514833683768731313003271701952957204538094398204984051331105594788039352443762851136101330385230866919393696564428736685568762923746771275677491379334452751710169529933675128178840986001684425353245791752781476028565228371147542431713985092322787978914276414008774443194161599919167210582437024618824616489802661351916633993681556274980075051797120207655478780052593534285265078265845445633803877185868676955831374479850746658711791169579387317321983669227930929736238215792068273805543745311609083833407544342964285215427999724272264458975101474080574470499647168865409458531868592) -442411248181132450919255517905812929771246981404050821923231762557171158858876183536414772404562764742655092127161703706239729646027465795612501446223663310668879007072125975886873343449629108246953385822769744013416908613100114754904323190537317463286500657291202287742354250227377164455244103312266617146454847578457073139633297517170508179596166314955134347046515455569689877574427319658085169791949003021426613961459610227430636932814700361914589752207776142403364490846294795496119883683491811246550808038342285518518431538295199537270236275774546666026424361019715280652576803278928827199810150387207105149968313623040090578323680) + (num-test (* -14162897687527555611 -23016403916121951319848021112075986869602408568431399211927062304968548663313037929311574133954267816204873252195499803324830278637331653769648377216095499136975244697758388851688873078022850203685120154634090802825656419418077380419130449990938627982123188424119187922828250625318327074513352279785514062876718714640725789938556578327139793467832731546881422469843509318627826856881082450937188956068348931459011923844607158528494902828851692203126881727638511348944908726926619613375594042390434147948508706733126737304560579515324106834237197081860910657003346633962662773394999353766192391746258372744063777808796) 325978973798843759388794644178802841408656469654887121096165875654577046313115917671847505813174070119516580105483409446057747653173640660143855580491229746795572929387698247460831363721394707501497262525550824977473864621747159715947297817600227665840640555029633517390896890601028716769035575763283168066843141870124768085499453574902575378368669494153555135898430469356384416638130459557518713454927909937610851489821263029886989981438507377741962130296498574556444168140838201069779040087521405032426995145166201901368032136008107323350679784004016321425234898132080844200202007395427054392280809376612533414505539109579739614954356) + (num-test (* 10844738523441551664 13010289169828379103330191247192587220592807931898339555723704078985668371901953113936581573750666143303899278973814509164982887504269303358034042953769514772858989849512527461308415676004712388964136857232374888643347097138114199889581495448978914022318770898259317738823514820591042321773469959130347470144905381758960436645008051488666423115693738341045851119808222048272924385188356021826450267608127588500233526688704136268009202730309974485584784539415807259862449203760469406037505772435323036790641520939576046423540699016607317147689982042035523118533555744274806239272109508745089640043900389441390176681340) 141093184161152226992592021994885140117836445291515772908453669279294934817987511015413332614094493905560980363483549300117114491702466085602279965168041684355125886388302948336158133555051817733078300668260616983283027038746214728386770752826764135491650323133831923154477800324207350667020747545837613879364064704092093040155243919335078139087599906324684688427176309081290932504214653249366429592335409761783188358003723753633106574740731573467850133547164922532633897844647383889253777956821171583261238607289172489135768839436605233457738153233579088224808850428203888700116300637190661108848906846940291749737998056247719674749760) + (num-test (* -16402132873169057380 8202725117980211375579199554494319645475746305836527475507064811368616698686329266053570766100878145903342129595869654087772486685252653587846560946850102095086896668181099435964053041678323706849735936082196618754721606824996486473796843333331029865501790248862590712245450877098960007272754260813822886287008295409755783478345202299352891066800825979067590290793893933819913530599309037639082839491869155044147367415785329077864525961799400923643936705317921900308490987828345313709179960659814100113658528990241758360711799009722683007157350272749544178688961738222930753008443755881419398858537860612954576778456) -134542187307192759584182063854799850608007421111316277594191532129597970622559949723743396309231347084450105499455916612009290113746722460358793168839937004812915757145655285798961178877391232945062437277255128401572171216279188126380587081673725314534095093062983435026047851041796084651601813918099532876684901239903769891552275465470747567830660442193995685219383258617057944010709906130655663966913354414611799232001438943448374556294933488875450563987147224709383408815994320229340710143082135667640802837699940654151297907451396297241124380508001357553893328703788960812706653503939250831164194874527033594779746890593262611805280) + (num-test (* -12094905083549825231 -7303327854122277566083382629094740392048421584433028903125893639493993705575691832165314461496849401726460344615713884253150283931509897329926825128629833541892164122168618243719393446304446866677253728405617434021389128710195093788280203239300086905325641224801020413858421914412156234316517981228056539721130386645649016559425091470643854813419057026759188125291655398451427686659900364573485593902992038773538760663063071699966278379037038361219424927031644750173900916227834573604566165762753650347331082640552394430002401423199016978155236550541225512734287851807727860645247391524620773399994302380387697957581) 88333057189654571362020288527489792875655269960629008914349561689924145109953656394378545526256758871407020025766992398117775520525507898420898102744530402370720932219749861094609497366188371774072368034971851022164946370916317410415503705484491514312339956381120953283812334833067601825812118392757289250628861166579446800637104996060739031010579056633535166403083327528575504427815713481850979373113173151813491831551023902022537957860211597622343157802805275942920911544696695931809085743355666792408029743911424760065578742910735408262758198787195579745280191859776661700139596074108035867940154338953640690242795671183308201526211) + (num-test (* -81618231044418675360403541307856740187 9751573706924018395) -795906195858402819552264165081526765614024708979523739865) + (num-test (* -167600745660011044249531125104202473984 -12960244919927910377) 2172146712516287908809731894157839567367040369214826131968) + (num-test (* 90306383312124738690336097936949488486 156109477991590792) 14097682358164298866835386043901377722456291173827620912) + (num-test (* 126202800261728727198105694812165074067 -17404362862588500316) -2196479330029905727399352310201914876903532806486592905172) + (num-test (* -80093647977875266525946940496137725572 -9499399805878278852) 760841584053111508349403804472960020663660465509267203344) + (num-test (* 304052889577333477963637861956318521374 7233536405885618691) 2199377646072361697737485358722028853038393128548297401434) + (num-test (* -124787646062877233829165925777950698937 -125798384154373172164515376683173327013) 15698084237137783175768362160964949930745617334715009097620154581879012485181) + (num-test (* 259623502197082370239517374851053110076 307089583871541575627915295134832918432) 79727673252974285068387698133566605944659309374400074880377824560177225320832) + (num-test (* -245358177397026033963771466683003477163 -285087883756432161967673595037725276963) 69948643556453419103498093570621669430956866597291662675473644085666220495969) + (num-test (* 46731711386059374483493216849082745840 -216522280665540473581476116002923812173) -10118456728713381305690589407461434638634240429858378588644634276171257110320) + (num-test (* -301422430661955757433852743238845048860 -737194742467573013847855072675441356) 222207031145790358162820429948896977201848379524899474475604149595884654160) + (num-test (* 109781582310220385246795023904554278713 -273317662617851276579672019029762858338) -30005245475518685175699313262818315773200953201653075289648004177366787958994) + (num-test (* -312236719893391897821327608828679767006 -661158307192284418474080017860142217763949256471548515134335997907628404839044913830388499435166012788226998900468665646723366842553747501004752506346280) 206437901167986463762021023207669068873036145952740267172145693855475451354717023377588805030022300923600718715029262618794758202955817341818233889201852381575043965927328029955969846754837680) + (num-test (* -134379788461141842858846278268259347105 -5535479645589936472405910397299739073641612836770238183712206042659632410776896398062277742229906915852933418684231779996404071421767274180368154310128427) 743856583805332082970350662728998610690268824090148728726850517499798631519601137183443104910590855501252539324674812560702657332874686395923181633958702249128106139207076314713649515720653835) + (num-test (* 278271843790644800793473851247546123375 -3845690285506025443856370771250487683891303505653819308540635173436088084480277686684743918745832832765066355874381847690771330587033980524869033600561589) -1070147326395532917564114389205677334125034378502074943828571411806344559859053091006175486397820822872698474899835730026158782698085673635033947150554253148685482702599776833910878579880042875) + (num-test (* 22345490710865165412267189692679994671 -13168094845644809414256057134926669929759930873747535851687323456073141938879368460977723280750841588750507348317544461824280674332488497533955177541413394) -294247541053147552931885013427268298282376074124656716577088212043667912662239091316191145352314750820026626159649861330384837204227899202392764926604802655267738710003310052268554637728023374) + (num-test (* -223445051950608517881717261787296926498 -2609806601119499724524852022247741111662431776874117401343811680374867931883996125145979162937751368655661775097445043144114599069842524778189198926688379) 583148371568187658089071213924575304457465978545376486297236105670932990897420147110485946155066725440999079357995678147717407410446012970360780626554347417807723098476525833332400212113766742) + (num-test (* 12604140228725912459681435851589379433 10671266866958584640992033560488052420339425977492420594983497264069815016478448589306666811246532193922229713077112601565462530332258877522384022088660628) 134502144009302626262781543880199144227907004673612064586081220538754991037447647926963488301214672345398823354945333417956344119228084327815583754032364976497975702972112644238248704660063924) + (num-test (* -221289678591114384943252477126208006780 20020996887149770966522122735176842174467884990518978494604707026520269232864200848420530223248762875769520715632742683760311747174524709550334825291720803698613541109690224185041740294906022358446325921538593105347423518731748623037078340006459454656405997570119591344894717789372844612253617591807770017562530034107842444403952657949565007792107071767260484233194674888488789619319597151367813735192433631007526015463229060702510632792171187339118004038505860316305860704455466207113207893106982258864355430481457640304138738182009363353560090082819036973601710432437342931523433079941958203038050750205966472435692) -4430439966231074415853738608900692925851705818190624801199561884242897308817127146763274284287396980593383317678766559004881552228480591814939402896201244425805503258878061459604511214900528594870260206969839682573246490602076070316760182753341371682323914671418233629420599310422437691170629449435494697829163966912842611408632129590129483811802031178053300073562716917597174161526976287351465154825036851645956354853960835948518860624747958440181683978083391663149733813297698623499283645627889274004656942800842013709298338912226207338477579862672216831422765369078886850523202897989792734789430796029206661261129141144642117177625405158700499049991760) + (num-test (* 180785619668676509441152734583033930295 -11909038209406834057075682058438206007134213485822042209417443270921391661498900475635417780140585878716264253792335317341527677051828500780153492153490249297998660274828986996948999762620400587091118252205695562417522111840305140989214300921122857271717052213225664738544344394774362885331856170636862181712515248810239601812262573113794334115259873527539564296101166439562124016438281173202196876398090029995104489712272260608848551754611421227761245487365953257890749115194455096508613617028024932657498899001119282498614739316599704645009607294747043489655424155986912576002393048535846081096337705941547991821928) -2152982852345560218506186041143281789706715672110278207735389192913214838321097754496849942223194392302524369156102301165660674797665128931611291246607346536492650554391248756408556789391955568308599431054809433808337036546281323840555452571430884302696950144068129601527530304907460164571704857360215834011779559395577299313379666503707563751314135201994045874159291100986903645360754621200008830207429980872071814202801994486961737459218017354210479544121100423399040398021780750351097082070296255480707530391964970754186799748521538525274241709676878827522138880241734356460339681718690408853314007343934035505873192699052380699509877559455199604508760) + (num-test (* -196121729286794751535600080816329923561 31755463535476988506639447113088283661031267977524968610501132544098607201258848456920865390506381665724254592728643925608893982794532243733117636645689751360224314774452374503339856173343683819017479955914451013484169313685311530532055735999039466721411777061709328450052490025363788971916050033904534189719389237878257877112162843506491071470067738867693853480174965212750301808781573369342701195147083717623066339671595077736036738235636996351642097684597005928843274525502529735435418805821748637387888409663397547514467435322454217015563134545731593492200855670248739786405074231658957946422903165662016649229286) -6227936422881500100190187768375947805694946596622670066116457374856427496311253030141271922822486386675428302332027411428470488965226898801659352566022706152307022438261392466548357753526474097246042956052374187605144719189465046544498482461077851578811186829094445089366592317045580466302238653533114619908864036973070346979261546801894831273337217021756025770590122176562027129481076270727248949609326868225755958667670279949371399535144788247565199415296122873444199709788941984099349149684384486618280260678252604631431089580057102263617056951788273430713908768738965854953667135156866028646584137788146112300214498814212865170902491169332389942607446) + (num-test (* -149247491509558553673630984739524508601 -9241905448313719916485289537122695595500213295294799660583133638026091750542612875183284894676615989153030773719811347110864468582634048542108726080717551794580656021381515769591713295631818532114918070215760259364277583650102628486861397602958930509695263902920994329409932518607260720657755504091822028630927071374796474717671220452208310602827254296323761245420486376569048549643478954846020045263141546849795367522490793641049509748005893155533480849922847230018411440739584477452313387881413141538766185123978087175960946255649923135634987656065468774634483495944248865774633962770893338531522570776854773975281) 1379331204929344851843348280532786532350930013132149419346606977890849868537539899667631713548510207947097949976792337278764045110931774279794402312944786743575421497528669859045492875676005849752425421867514661792129580445000023570590786705609341859529483054902802038173138834528021423393677908655442991197348183257271932188161681770513283703502340499171444058119260228931558784004778969491586252899270869275893402714040693571919281494643765571068045362364213060063345212881008657925426024923296369533374671614852576576041747836643356665301762059898161073609265572267138950725010661453917338098901465732991316661901878681888138048552901254914604845891881) + (num-test (* -246070233154436622785727814428081917418 29761582253452470642591719346200231425423204062498655510037025199574178834762931489817919404889920159374886981199608181795387339523762458361385170203883094308920011218315748466148953320570427838912637152446837553950810011344492780712558515815917745810385725989241835877316836808088478276603934260581342710503593237081689944686263274319354100341139245512159619947319496638082702549196795236216458749363904150768879765280332386830831409591769966706351022328535490587838695167807967607003680703048770719240872629379640571077329748828739281770075441660330884779539288220944313294762143588847790653176774089774033399559617) -7323439484151992757431054484912931979861244043627630118213112440051387392428853497035249623931234821362770902740177541812170377563064854590834087655133962963430877452052749127605572395112726398103244974178157574726551814002744001021805127518246639418981066588073652668879613252372759895389345727455380224104332342029151667860553645106555190741775758687650292791318963679857313030729683299101577207875499929500963723267185390425716927303375831321783415003339099100562942730763231688479910689887284950156875532151104047755803876078837921949287811575034368641167438367411569736575067233548122814012421044943430647665260439418887639347030312118291762161708906) + (num-test (* 203826295936164259559522643510940430939 428315860474710981601019542870649234168732095026625500771233691514247613083810271191136212287636290276352210600151884730196161003906066671915478570992925366265552107746965374246537358349673161970290367972281768471743836339191023211359427335141701167253694144280251188008871929010775436125645541749886873478179599464478734149706121117222690271210887178499620737860802605991262799781279373870647695125320153193063528861104479576369448865373971847676465682752435142074973627172566791961541105525781297462635428308325033717669972726101583722868689418677558787287897456521530400671342257419067050354522203242849353639864) 87302035331271280954456598486072605056704393103691656908943847729634903654600322194677794243221825233700566108459784062758955025931450719283517278054268553004951352280583820782976072352456972931479389375165173986780482062859853305469143408707179895843295115510597584169486406323435925707638987591151227843652210256611991940374072593149367903739596883229844326054223707236369465710416960023659329202073724249764308867733476242261506975691004092043954515337899900837434270833782490145948781128533218641649564543508314976001614187701395586824982250794852925954991265270537649691628899148413763865280007928191637215283244406869662872539567459561720369352296) + (num-test (* -5899540498246269366107488541138263797694914692322476860852796858749106720144552037986906792251681094769894732746138541066810195167688318229720888479512583 5834015210744942902) -34418009003174534626858248456163154666511779871358190892629413477534042866009573638264296461516598238780495750056279721797403178867717911762916049857737963922333901125535866) + (num-test (* -7558198374656605586076446665394545534375963428962439959101805545423930654069723860456022097647139432324162475685494459942871728608277717748075653794546685 -2079670855873590264) 15718564882684481784074014915267371190416032453294568239793060140651422710113447422494938907375595456199203928496644205320139985222135619659630853564447794621716315309474840) + (num-test (* -9442744083812363570102321552182535031605446031706376100893354933468482520577272174689455502380973733378565213055641110431767353396963744600184737808983381 -7204974197101757391) 68034727473703353914019458883709211780958983263702756416891835054494728840771498925306650413027883039860202168095834137357212487561983607389479135319040711944281262212918971) + (num-test (* -10658732210276096534851972646242288663170038580488752611749460640657411087860047053151548660331707024718100598181073744715506934778234716535781332588396176 9193953347013373121) -97995886679587166046252015742839992974979220158813197140160489510432960510418039749924861744197553021702396544307690217470606424904065359660871469041838900287446937257585296) + (num-test (* 3330096979672637104536573277593029682675932033891010715180474877149733802060455951241981993421466123791200840797318740359792251505430948855600408060492000 -9413190658845804679) -31346837782105095097578725347257193539696338226258990009265748336528353873277500144838721882313026604404426563737656928378230261942407473822851842589487713775609448642068000) + (num-test (* 2224201331350479188470378485954814766783857696988331736807430786504130570570323948774102396158334805040994159865821844362926631687258969480929122732089195 10226747830478556903) 22746346139936030910929166328517425029735137934434969334578972386859485783192993228082340012742115893176871887387993591191632260444955081663604449277961804869872353878963085) + (num-test (* -12394770820700925077767705800588617445613665027183406054209162910642613421436080064653443098327137503596792411463268187212855350864330592654862321763110243 336135860956209890623046930607725140868) -4166326961171213704571179876442248501325782360170764344978629523457550315208845439497110652079907652744850691289494398473488033083739905461347650605270023127087625641779424751335704552988710924) + (num-test (* 11792778994619176404079667787533709801900490264171877873621265044313417667869688303207909681289642260521608966405181881416781694320672906600599581862090088 -197661229068721548419113517262926820105) -2330975190212228827672814304508257223671550753091700552243633152084831515892056240354560520878171696176381845689952044935988868477421447557890739834031207059212175922089523097911477486879619240) + (num-test (* 11608994516281296345925963401821217560860934641820086911326880657644311461955556832927259499969983808078591149768068360172431078248807463030805586293656663 -40654941048774156019243747229920736005) -471962987694958552110784676392477007070112288398143925079396435246284471999814508543057304008480666763661066976653446723271982094424149279649226771823800871458389214002872916339341019732251315) + (num-test (* 4821517917539756801293776911844480642406562140007084392649374723119190602353617113036081438891134008988421494142194891002983491670246762173236312873933599 -255528396376819316172341014108564420589) -1232034741571035406264710387186737842510579499938716343220834781077329515145216794636313459582844773420679078031627466542930137302257934575129329529129776153159694412903937370462708576694469811) + (num-test (* 7638751115643228563298483305056828584775811590562130101723525925933790010789130133831569153863129513189315440899053288261039147463032870669035935364282061 114438828287750304954799140618669114911) 874169727255956505920153418854946321208907128396839975975317705220623267360648189969313978740314703015845506506608054761304647627635292132043887080298168302864314697920637105700927041824911571) + (num-test (* -3653826017463740005170218884285271512636869606149686475539243914909566619638259666405831445823138528809165270360144267462878986866506114069923299116957450 215752050445782448772085819939961259625) -788320455239949216234629350585027855111249573063377172522422069903710014529292638311216050777840734448624510386643245486023092483841464815987597578151663227035102742664709136512524899527956250) + (num-test (* -43242564273985683175827997542883970694363047476880657467026050730764924897992516355909421962249292250047896135687573746158665836208681548975073555418266 4424346097667245771102179669235543742385176589624011161914909311078645828684936231569739522607200308028372644149306431599085361996722603718517735348761218) -191320070498733614136284309000213964486426347688040889144514933290125387693498098446328694172047943298442181705949005984031677324306763731212307716485454004382079159622650481983102917517993601466178931324415483972311904823997211920702201161092866663969163567426868740120661073974542958600768774774949607988) + (num-test (* -5093597555679260616199210906198149266592665304134802327659606846977583233938836318559188141955851256260954289429418183711191354912372372976165948043123133 -2240632735861652612028397136046974907251405868353380459030143407902436514978447480884513019736738955326732458088791830752499716417751919868492224207936623) 11412881426559848135724717164530530041659963797467536748076144863846600718211858527283843975968920120508569299672573958424908957105703597501013710262110218780710678312197455759181436286391257283676806548463507528765947919856827004176416634630489598937924092540289712219714362500246928243091408698274649199859) + (num-test (* 6049789822056553589237940133475342650218069231558204589924996117723031491205673061674252841792149409384720347601549237626288416453061224734057079515141650 -826416247951451524584060567988229017033981218652490450160817307801130685352465013890931297548015267655971295627931896259998420078888499206031390299169584) -4999644605638856588581238481465237523157457201817697008198975191261856978252081380810200468420738807464233192102972784271159116426108806200426852134469939032473362689081653859652824862066224063273799612269941254948709760659691148103622071316554194507524610166457990087959160807415102946877307193349131573600) + (num-test (* -1175978338162966145239180473229656000174129248706173549637767835154921467129547950144109700900405904250603515318348888619371004435353505449762899046094747 8633693716102199391202401198009047492431980605560930404972542822133579985462906768067706391388213605203282586546130434156768523403030127356256666478340720) -10153036788469908062299722391986722149392791936544969945546931764708792252481931153733789787389051773529081688846141949513463792442701686406966696738286561777611293604311491896230769507535896070984747493738525389837795316954065260075941524322954935690803870500012809797698319359975893462672845329776468197840) + (num-test (* -5083395547684319640767882199938390155755986838939007846911062687871291096073452055061784159768637502151635665247461348347470360218957222873087414506633886 10813098236568616588240471432239693891825284805405416395976866126102880121934298269375465735278296789484402954117593716698067735458182402220278016922449294) -54967255432446073625448401244836956268872685687128644401372608170106281377801209665004925733448944141633739594240156882328181133879414641109484442890809130544146420476457200729843868300396656004198615619691952536924980482714767859804902602805398865249514544806725162402291122143659939645240358379962457176484) + (num-test (* -8944626200084865988157251013718979706166428261352840753194709093968177704853157211364231059892647813839391802007588961807572842923682104089512428902387812 3814836951264415657788614449012480613328314590744410079075164918748648723114236698412482309581077603776489883375576245233128800002373843611668945838558629) -34122290543331565327874124324135450224668275222811493728051290368641401807963502623692504750924543845019291736982354932620821594287780848608647686402233097059022704206628297180782771812500512744911371653368388270442874670230118309469599458827222162362901084328510647514081302476000779049412605744638457029748) + (num-test (* 5186176030253526423885531264483408352469356233262336223619904269047786350470477526433506158542551137478071074193659876898065998079440819597952826155782068 21428324964794197485898135923805540163916541943812058590308650649384013587098638034673796533027113673143959572855470411726978105342739938341516634354246514986124789451866589211982659199267654387148420461876524076040233779391563396552267276880650559148637067641021059664960876301072636635299261389450890094318429077561092553337025096293793433968243940381587994428364726938534453507046761494257538813861046058298873206568935790790373886840765817404479239485444563488020955730741209738203470138117422899051269778988135668626686262669881048094388220931264751830393793846372816717368806996496715219806062282836392457741918) 111131065300898907482632501071313138589398597291097276435916516379173430095773463468344138866282820740991088290299992221985607057347883717514843661030457396422379155394966857856069231504805779448809986906434617741485942621643754096548512120178021034054648207248963478122178145159262707381679354401629366698488021743300737044695960363216253889163551918513521913593214414139637549577618641974388739304727218804595402055185824193445089425262833385286117064481648652550355832014346131722965510192584901901111154083186713580209077544982897821477349293279848852596241762198202012197892321827305803333334823616660229870976569043453639028059771892706354703750763908127611939169337399882784092285804830644630059487027413697220038110815990084742241055099963659761569486906596326424) + (num-test (* -12615422028124847936088012564413126213419674293830655240645918456932358053670311316461359727921727680491520480380615359506308571290338231702217134487397730 21538722931308708400287621200994476771789912594554241036641406577761480056366647329031140922034590767810855360008375309986798226712928670905618807986829790199948665185268081173685941421700542631395958882077936923141152528333121096909688700106365468854487023847026564219531968849793109908193037522063952753477768381591929787242143631287330811801315216116212154423972654430356675401769729358415036943501470085182304183033246682446978634892995900678975109490698283226559860736462409705544079080978470202336645384768211440438501339641775269445439018148409151795830925198162301321965042997632479354427154223366199106583051) -271720079725309675925162538296715595434811519956795637977932956405490708202732964133816538801099235844279338645471102896234318181092598033040518838847055114923365599862266767493227393553801736813141780001130539648588341196802606083178208108557367013886856183999712817955194261262279080641101769944037282423238147653270651419282545398168930625797556638625301898893565965773914460998322350526545278664715332414172614761548301364063397364632709194713561073496860524124460861314674679928692398440036071116570829193414179054372604203478369755566003622621281005164747628075596444178089558747835994702060740334079222508147598079351187013336751322569865313532407367116553748939535664259669808534100091049960040092785009707220249025633808590643620557093069849490009472441113874230) + (num-test (* 10381022953674450046578890619826448644067144294659610359943634722044183130638243233110364436029778310048006743033299956844491228999113516347401915490861208 -20974871685432829994714153210121536409377362402944992609230062091789259307033495284524234519701670462495676590513192861649457148897274608767543942797542628100823017887236899471151903799837558453043431373811892813126194662218472834650841742305925226558315372771353677064933578639099452438843500601586038910108679737480263349221244638463171088589123712367802373159421798288708123925853179931628847579314900787361946716531755600236755527982132768286927549323465697241340003870259800347640599467922823203446834792229595507968354687630029075884034263531531423883902851487995214646322431057626558858528344843531280263328354) -217740624416854507100100919338835880277259264187442792458843251425095703739537223785767883764746809214920580060316177442387941385712712426957388995082877226019966428812240179251716274377143798847348759498926420314709056615470455134468678662646006408843897699718742372199854223008996321568642038054564397441209859567556502098420151667437837356649730396360374136203172669776530655738388121236079327354422138744456395348910073462618440421257604563050031602590345028438897601523520973759458890228893913090702884911857207117714231568437403212806578764580006787626657709435954760239671948147344463295520930250155876010414461245194991189183956653772752290656063730950237649394743456230607077768595983629559996700837383822873994717987698780007691157576205450973669241823945091632) + (num-test (* -3984492646329789478973994496812455855595578196959138558282015917391108383154917581748539892089090551298072688793487597623310815918942283997753800645644511 22199897116873160263914990610762123553075230334116099569358672964060004245706770678771431369917479502828754815568950371273785689812698287446020480951417047185190067265849637510591502642000414540862689426343523077229502494771352820057572619644085930901096534031496492870227890836816886496090287321502805172125273822231241073590840684742085641304915656543831190976008986490532066597410386596132766422026234488163435487889876791504407434387555507637783709991326338482319227500686541368087892665100076351075069628862376686619537655838590687615291898971286325099164241688147975845320979841704002364545072665891829427213069) -88455326811459002089798581395024759975871889172872668466370443703433800509268320055453743803627754859670391415348970278548381190662701716228279482045339649051139909543850883613464992501666524385524517648069873862957915620016943364950043289963237718026629805297916194484838158010754666017024585366330526135823515744339445036315966714684052345462172808299142368905939297220895721123725415007532441824406115746741972351142687017849809593982432484296719999502992792447259391592152463664807498752410740679664044620898308783634092355737296495489953554685938970593890496829484673393665321572846542839714620847185428664388282452532264810310019327395691530430185946743995669191791841546685206884247468693248673484055915613115527492005264289557719000245333079386593840592027314259) + (num-test (* -10672574004830373997900438516438419278676753890756925443116289034080220708922677740383425352837266631691319394850521121221541344600832530724104047804922665 -7307684417326792807224298894786988180161884427390942431653062127076829842696634441114228528164049031680536693195116703321494895319862805505304314401000204515985676763063862569446064343853536464020413910728442475032187317639476018710375702206456631041987826826225461927793241495220512935434301833094232834266749666697332380140380619185254354273073522191066457437931022783436360434167505326773192959291779779370530770935758482422581712556111319611455306383173529090289274267200543081481693078804068524057891845603351773722737987393428313340760607600482724483853560340630587029610437280601010173185018227638972500038072) 77991802747865927212086621295493124451256238920588746597961055391511562690441964216934615500942858653797884925704270904527938466874924049039962754703188019915846345804228044693122758075602494985337649496117180241872910247079655077012999375809878184011356481981590430241786534827516536543734645410817621964035091467871491521760928486006653992134635010794346993161329777270345449763927429735191213854873362673179799811714902439637861750855639857969259787075469241319618538795721956528400353086156169058060112255274542232054021662809196965752800525093125763127895334967094763817500702626282397394521201385439419885607578137159972521677923972708827090645776826953976605193554447841693259586575931864396484621463004541561908426383260772786784541411548146173991869741515701880) + (num-test (* 1420855003086789510813111205540636553863493314684153860389816109865085846062678305775289632805233481596171530412925552158799875183492757047174905459819169 13897739053062356545217161606361735964779941697726983959749295377836209520566715597422965426908191354971972501742952706730523748574796773473606175934144970768662226027157110240776527834790487577863781140089347362129598158760833470434895693782503529955845076709376071972727346128409008293671217324995682020009675316075606538241192607139905488719485728099428376369506685875348346231688684483781160648420909364963718027571565217314827671844485031440079254478598236877074793221578612249882886835580737423192061550370069895525711885220268707201966615936769696379335772521903910689934596134239331592980694745008817040569590) 19746672065138309742065153069587996891492444461032276894328314121573439684229636534026409362850111716212254549198595854140809664451286626009917828620279583631575940837712663100442879662416765138504151063632823014639305658882804073655537352377258786105147057375069447099908107785635606190515362082317465738205179108333064680370909383338688734129396788764959056886328471374018961975554190739706996184818378586233017775166959010668462907838359485424792026496574369912033757997469014639705459505746723512361959074802456098328538419933637295482429555127226978561859965498424173552676019033370307387047798600024901453757451579262061785051932535359410827170361533603618131510421439128567361259204833501190218719779570258541358012741265599985490513564378203502703406698160470710) + (num-test (* -25117824099635104147178796272946098711514362630774369209876335291088434247131228189812265510495277875692804180473811834186270331245779845635089547499275113671007257221593872123397418355506777725721168216892830217596134983713752526559153149600553468865338887605949011743043425900799896245185282419637806859906582214420191794114207677635194054239563071023206500505880052007267243210206807805387341085613436600843317096291021780624738422589234020279836961194869688005260369009833026575446099544900581955685627511787510900479881434909308757027825050977932238481841909425598834367032841935054158448815026264505726593064239 7846111496222858966) -197077248428250572361351389692146917243277049539013604789802566767174747369897711991559940484392921619974209620152008632450612546796556905740493507885376190913893140368029841033442857949219716681475253727058707723386016055991276120001690579154370788782636181079931076758384034193266737114305362492836167078199155929937891579224024229182935372106924021709421948701131654358516297806197381566809357458374057189773041520552821330635689748583803171230633654728360451100477472934847975252390985102859262992904778849652221553818627134153578436315973777720706502751232660284910468721430874674021521629540714057383398858244828214000543075116874) + (num-test (* -12000343217458212092754251360179138661969968218789048702097501439124892987400633614429800307263114371624489988815324366411323242909652002510513570900627875514001409309670202055060404640758548257776155562167062337394219073071639153822126554525439988062676648294108951003012550815746564810508912122306190725453386412796036693387315128514162061147675205485143205925649214342646148112549805850530430229663418469577245456944558387628002442451042105749848177325651852669794048215063957689756465788955050513359977166122710392613631703123491357791351447110169966270916789849428298930624807758982400706608788793481972190953569 15463017349709835150) -185561515374029078700596518575548896805308728003103939537818954646551372890610870275966055765608887701776880889777402229764948269089126750201922167386201171243298907675542965323275634529293654817279957832652909009385491998537031060285890512199675273422070784691446251899120095880199298512230290860589352290462643231396804350623684034400741386070220057232978556614620855818271117742675632435727751812101639747357642295230273344552327870600519422276996860893842363996198017494117619585153346745838853026029459826407782259598477529242420507010652705302341725948095720110508044256096963772599572721279996322424269691990173052929936294150350) + (num-test (* 20244597897909303129995907707212050478823487084391413473821544089492035634291726811145005824559631386634261268723753786161463497881725871168747275110149007801865428978596190887145324535224079986377522166727137028753272158887188902047835658826867304220850429481233026043496635847568448251753504834367809877190895369288045026559783632709799678639927825194847005181499299410953860627694080906167346078299421796974815616608326704894611151743720515377248152215241639534004099341398238713597030368980166731393247619511322804984829747216779359780372801101821087516269912916462719248736442644433057333788741151270815989388229 17931151643499274580) 363008954869078360197158713265773114114991766614027768774402465306840646219477262855625957403406166192075865834283840624408916170935610374573318606346031792128003204902147985329385955814330782527184421959263266167048755628089412213360508944817963403092490479480264538027768728303095523018598016863928762335410109567604756183580676503045557867957273324581082608248341332512325136675167966306268035077761004923732568405295901819511346235524577361289712297365403327125212199451099538443576479787130510546755789504852631291774614010584650672707483555436445926222945298928326313943231688436271883746272589347954697213098866117569339490918820) + (num-test (* 18134862906191691435095953372467318196853760384894170022863300447691250350836421337333332682828557871096554531436829166444150586004379181099133295174348038948038399079336722004125999533719492457544642570217406286811480006881054375314838605871238868968956868878182133492469763282800195060849734382249696543089869191257451321764806079423169235271658993054867624410589213892458246001270123109841429271429275464249821855221014782727398959126117031823977229309775211695677345378510417534328974531801634095862859684508240122911023047425473036305928743193594967362216559973174709883576295373749738633873828863608550295977368 15082354452174510460) 273516430292774638949326170314933525797985748367549139070674899956657807928629067317576809269188258819686207094298714770978509118959142516619521080722291318367607601498107007447014759288176261262818034997399866363248136237609824401265450913244758024085739876914482935655100890803279961929047974391299795570244708811454483314898873277493486428279875241232025231140855860469097028388778917980779775554139507550577255217032521719099071084956515691364008526064349956553916033914728254580848198941020806723485184338914882588931083516851849558411503129184026079582257756707601984686901646494090820169212279581209612798749779318126482639269280) + (num-test (* 19213874382308276075905228027166553836726993832150876980655958901416537033385379180983129528081628446454583401834309285184752924794893846406622935494758142810049493348116192315865522516744262115026742103678965417868790607689989205765793528434388393584537260717130892518011447327847533083474230074174308157934463971640826422302901570010591182715932658037868980053012095115562188975692530473556182305847290196895478280679341869546292639446526021874910117953225154204035612531584978136604161393474554294315903436682283787080297348697922389355209790646124024053098888687638640826064745026930980189268652291562437512941810 3155416591710364359) 60627778016974262766014671335614995348970065077989108071534610098195400001445248886220725085881796599270026085183075312353388418711598523030563716616967792282609748819081238929738105086199457414615236966895805539596649555457494710621217412773036416007129418290246899690911654008867819945724649185574237527152410775686803449108977881160831441280833577932476667657759420192656716352190871667386955409426879693856001112340390304980532208752863058384169885129364117656404549585836664647784765508649117301622797243353610345828189312360124462238989888436478381583689386509617357901461416012201469794664889076397809504626996523928173064949790) + (num-test (* -6561903839860415551587224953276060627466820222543175464705113686962550773423611522044145975606965294164125376820288981286542044306677764776675868357117109664125730405280822770267329297542599719353907954399688197248115043785617436343303277493146049939491224480136371029084354063731401026459653680017632996944506546122253686805764620116169065663214526857151412139439538335533979733329962892417175374550305659302592107472151941922230309227785266745974334776462642676959433923828440435340579340133192678341787895007461237846313005612116885419002449356480017828933592324336731295317076205553526568668826499450826560670163 14908715577157091280) -97829557993133908713082095435440645457469053259814412551982534425389603663024461131358343104414088618618030154957456050473312402460589893359522167472060177968099538846750606564761307960896264958539903740023783283814849937681270591589750181462708056758506230073751440847913386576449367635057595344744119561166438538811561109125506233466453974371464999669336530949393433719456191822836826214814780222021267726528396849558417851727452246676857867278196266042327956933753121947589485377148388716839519782819642328655117625818256334190717182923260613562191698788004591479576661108985313450029332968584240383859113741485244318702724563478640) + (num-test (* -10378013547095983701124686671659666242518351347561698092030999302329372512356819420877395264401390796163955327080881297568412490286247154759694714275858127906305200295043241717769593877683535229411640745872559018085757273530771413156968541499388413497221629366848027355125816131586610997516488552323667400115617175682996681969687885201321292153656071894385242141321468096793766926179134511319941715949712230831768643024119693594235207988046511542691719002262040067921088838755337917414526554050602539873232518619281766327369577617796816586064895744680567067970817494102948032924671421242699225194947982378019119315136 30004910492448871409155105619400474385) -311391367570036811050052853596227388481520279736812036769684195465110674594690412517879149770622679377262288447706750813509857551308594851067359841826754786725926298013483569424123912020079066150719085450400229896983461212531213110847425940968466564079253939695853896434719530729030897976597410468081535234663568150722646854183317007227669132983719314653861536414057481478039579810285535699518386214012059191958557306338432321511585867535008319640705419431310336566447165302011113284064246284641707577414470505948868362067233709611758700034131461348997580441628136979257037186480770286846026250437141175360847735150981343952303257191661069675154710791360) + (num-test (* 6311357747888359229575837883366949670125882865462293491587368290797766017168248637163030339387377997726585769250585768079027576213724941259801478313127113803503561717311996500019522893295813684259416551410025111443510215766297835872165689077882298506134885487991732718254835036694083204758447948541157893533099634169589161496492972953698758234452126564385255035294546278732684663873459439615228706684138982066055370429797835904846166362278557095045056472775166294675997320598469599722704075215700819354957397052721573993997624711445698656580401684113096559767093466880001548887739825916626416328760047783071058963451 -212654096583990292869707082365869207538) -1342136080095566600483524091094048745061145155430997807005186206704767933140306297188996797343723817220160636373424666345108189275851749622201429179882167381735732553825696482751584102093819432866729465599060815670807282181979889263381844726842751894916887860819210652174987999919869623292751389157233409465756974677789790982740267208982768450215563288024088369480574425410032306456026930809228182100949940216614156925537929648841127727165386031716586596638254705402653861723407930666152691102484352058909219619985877341630210918347460471644327858114815713557305185589162775699323253049631349906791700893878999711846225062306568467992135934882289075693638) + (num-test (* 25104391676237653962996674810232896003857294806799086059884413856421530328279649263948893056601611073815235439115612155497964541323584159786678357898152394779494741995735881624055133443980324145256438160990490767324719276757840825641421547232460969806196141938571103617707677351907526127993230143577974386169402623023560579220343920203666762052525898442578990183400559087522259053245822827313206196194989095468393682721753147596892214609346047051670610252732846805143964713621673722554204896154742594858056891979146566683467510164875593192581407047920719605560716270697985110227952698114701527191421628561835164291236 -205991315859231724218751687295926841150) -5171286675233738337789203670843122752625713948587464573381323151628930998435518250812603433784823922283042037694290795352461861058217142213862777203850665369756106838860420507328654214723398688455622487003912073924323587826356928211672752672052670663842775836967587150049181838707784871641183683742967716787111671792311389517753578360293551031540853470719098360013225516593755039537796518619542838794169319227197212817921098393499332268929332950035803734983497370378852859829228973012039890600437082235032378948656232679080766068869430262740600476498399803176452431728914806536862849281928869092524387549297345184969051926149006293586531930828748109161400) + (num-test (* -25971587288596053786734900662696128734726180676323130693160397208008930123341700520454723462226657743365779183466120836187720332442041321870351823609046027805781414454998487673927365486893294110931852680018706479684281928396163669935417207859889405108139261480861908067489849403284000981453574189898304616775302917687860062501465417706095450121596418236563421425311420755550335597318818628123183624214438801254105808079227429950505879366254661664881055965092586612702279548151277733307180663770432418397550642136953750720624507617115504303570076531620003848642167562950736271141440609700821621532583527124386811144839 -182748557863603655835821910989658558236) 4746270122419629115710902425435990509747636609113505336611751359043717100752575149404352359855260443259846554733621122684788488984010741203981300775978945529551335641218319619542248418128319220383298229263331638090009313676486209764655429828385994626323209879925281409485074778611946493692237774852428345451174837474328995186242262565013937544898941834362941815633750896882758939509605799422068815435202904271722442099465950700886702949580264958171808372530471918175963644209760378395316412115175988232945569517230829200985652504383431054550902852797293952515652017940918628980037316292352828228005975466732028971159947131994753006597870175664981312344004) + (num-test (* 2117427896392849163304163145095251890404997781812823978967013619233450901604407363671467658244435728579079751353560538034596183240362499870272373308111405924505741579887345118857908796509418246599428633956038017783178050402412769812823236255234302205027282366926174916871858199918908361186936687654278623156607813451034087735179167324944824913226799346886951212979149617678949292799645035425029596869092844906629996914674904522806258932192931217652241231736891642224851547474205131131019084734780208254203537633402057673465583362982905095029133132240839391503135932501785844503813910210348239157828902668852795945482 -296778668392678698960782643314222141731) -628407431508980610909134894336322264939705333430111861505965183839156278363647883745193463537783397824947515214540990712455315080515980803996660089847066076833542492719707493333185909990202372284811233272987993068106356248349054482194817336258302692039392400931536481136340269417905505366385505196886218794044229758585631131853635721528813397816307666671727692971421531381290925317161326036075629905443938124481334173158440927555118173661486114828362551889594188958723424604273078091320087897088472418346754088900034854230711982602435635574895960156993014703292551046970069204857846207328434544990709459402656908170089318995291341536347275682867153109342) + (num-test (* 24743327715258194976385899813930363006464428087412805068703455203318769863096919192538751530954777047772548306936907016751357570434930538612382851621309732767199276228580401695793317612267605312672263736938703887622824117576912830029817460033437752668221355377879837833796222831371174014543622739933433581963103361464022058091243110136610854806189138108937004805781857031030005354158991203388998364340053773883952742645161560754545458260688560269655272249435540890073696261770299845722705104648358053080678920468895189601731801025555650490534399590288852165862135571140382055044665678298182909026026068995867606241201 309156501491030456401354118244509785044) 7649560631695275371386748526795333430293346807872366006552933839286343590101586516802834568317627508914888989005968805867728947519409222814667350103434422356009252082456906520988877859152125402282765775845766265340707473525444185795403554160270722809642681642831847296672303556012796775586274347178092325226458743113317655523655255626670958156216225968018208281266858684283741496986683426354716284780229004376492833583965647875097951642088252875535823145900129967026856898970545720526282798418382467634180690243423325770596949644122541224189780082061715230852249880601371985342796525016176048518593825361248232406051886794538203297084423942036889326397844) + (num-test (* 31345149697924857384985323414506591310628538098830133854928154990821019223495435414394178930529373634315044777562902565397455028894455733092896622048288278424884040917250546068175763309233883078972879622697667174865833277342334219810618450605650614585133187005110148963483824629405555603493157452295284935004578187488673124814714326405406894084902824045787647963172437833905574178160343833139650913077173865287057167288286708807322607983179910358234015596109655900840652230258122852488289951986129788952718105898226951651151495867246384586164892018870981480003722043190639707903266193064807571586900961788679579912089 2067227180806746570739122295766566373146995767544546241400900414826379465803168632854028593293108913670556431832056563218709444199286888840721753894461468) 64797545442006646811970698282511426059102976298051534827345388707272469591333019870381858263624490336448197115781363489554169207652559213486772008013638214870324260793199674746523791257170452738018910619029072942848422098770309928561867618844814267276213608306045020686764830302020953883994906997293368193331696747777630621086600981981357507299729947717565760536305785574555255589190221698706036770081438750974356437738060098906046001271392354762036427049946092656701257615490057677558059955825843182799904828201890893555678855718728417223845757559310912618029462136640226686626513375024547351747669476392735304999046232068947570708757930233036922714350584650744960478326257916948676866148362166017752159953504981324652709881831381637989229842766220141292801807437886652) + (num-test (* 1965759082776833678304908699214846485256126608825750175641683294458978302204367346739996602241053060915897480812220051082619942907491598551933638540412113496542245474287364500698693202553692963910123752514310355402167440783023542848697962967771951714434359320001430281377747193083851165947498546085410216620013287853719686698746328198021011905482303248172483782066908570502837009924228011993318265674390462360820566174204659723461994730913995303015012684826295802887547970851558451858623353950391701673651959262042520584275132971807158231859672678070714276061110616753309305801080136339206017351200193800253572481467 -11092241138073130060021642325471345789108575712118027611362686690749327689527135459714040658411176246054106270789083336195599640521602432629024562630323934) -21804673765518097879589124792137157558586438669762099454880024920520894260754279593873244443852337739758694535682558790532827482894104906218015712179591886600693703465749571299271429989154199263793230178266758966678432691901731270899259065726530463438316383699558373053423999416350780342222940065486831353604365192968606300436304827279383661172824549131179471364227618431414928702407510473319879188990689163932586727702195573766225861364297410904859137393184592815970592502081722125458353280743087607273547490382023433724488604177909671497082747464946083901888849483505451426245881736990810339421864101129619181017696837017966116165703320918568645290788634265522956017905246042460811062666193790657969385648522736090098231379029903772234867701846824572274796526421531178) + (num-test (* -4067457132547237558852016696244696525033953641638067592741078194074861352472861925779476293767777560910963786727886946479865734639031042985368829200802420611189793957001730656623744670821921724417176679009632346904384261431052972127975733031277489967119978909321422086102208644766894305071609385305464547231057263658903212521469801833214062476735046735467944834107695748433481665714184831786462886261252526036621257865158497049125410241033365487816324425563483999957660557670189397770488996359512245971368638615503320507431381893539767352426795415898379765583574977542068222040889423739693921998717145084904555464058 9635268828818063607505341812331931088336041632536136269505180222913464638532245578488168867093853062326136774925531196873279749483997619950077042084971972) -39191042921786100943542578352486285322085069425292685238158202937549417928185097567102615300826629615520476316505465412722375794150552330462353356124896483739321653441446703127728441315609093330694305784991844511900128172079464896650958648496336601612657347012294121239821167759496102233234525084695798195547141521849769350204659392602605928907953707277320590923278178152903602506284861018886300148663530071056792375593665422754923886137410482547324901798328311927545105456397213670390651819229021443747424183114992653572959318104053511452473611466305149349027962240989590453237778130260105665310067480846969449221473610614214933278048389171979184119355459010233147440293881252851501522689209874112819966647846701257081192324007280573826673895648273593609466000383382376) + (num-test (* -22047771987573494284336211037167956208924595972749016352929724093971147687332865088249749580556015503923927321586913446367676445848750229391300778587369581738560634537089081840938984779012854694220894920437076215176060179241185151442003472788530160589267677502568156006531439509890061829154786579353177129190813899423306499631144919702707240832059008168851983259611724134448165201725432622521420667808597545410136493805873769372831833878868603946583848422310946469083400330960925084024624317866822897278934924368888332618046649078771617892961267312226309927786691384460940015979582201446635756024251269978545916298961 7481502540911026808093162425787184755732317118387068406204973030847892995155568099553397887864257088525242568880427634318737874025160499293315047534753494) -164950462146458057264341765173378248123415893870534274075422323606836246718538063890359159423074703472625232511667875897808555123518162244263016096627959208397334135559180524195701526029092734741010866589515172934676451385008535538102832400604699294088534999994990970130226363762230944961249818769566697211068918154629209895730969522747736738946126971914549491889482944152891334838234907190697109929512401661529882587076352559260375439428815896053844621297552401396168240947357044985051323834074355418902009161796886350497072010833513601114819625605048943438304411954380599728561071485061414856047768286383287807924135081902458690495890129203192613070824670256334683011083767124852354110322463725619194174195587835939047474059288568764831570274891727391545546467943319734) + (num-test (* 22607201423790553279447786193696575272983924506336369475058795405894123712509544256099524616893423762658394830755129501447553593365768543361107397299007141714383407862976654294384881771985218996697067215804348472693636567074361380875512341556932579903687576929186215185312685712277482751425466251201421842248749944123326048360909954588266368306843116245625635467041934524547983478110533044085242847795585598341867070787331785945399446665919396062565614516404861115244243161694059679274045050270546536781907061002623188435269769778378780371158624481539046590932125320888745103158180784231722265376331553893647061533815 10075764395489719205294189472045365742345400155046712954334138069917417587273618147303160957788995022989479371576840422540097479703418600112174202202728054) 227784835187493343385594867881830022845566753253174983274076326016001091958812135049265213053390506720261776960833046225700903422206015373488419693650378821159134369608830936915027161415300759990632038898164509761337714774392506802504397626551196717184785586630245704512525844329038355790338277254618639554796026366029578805283659986085947726260520495140332204643887370987929304924491772630534558682402396784510750317396488402942581973350428066695976988812610467654886227733900635715495731445319565054848075104982244316563526232071957624002266648721592744376122065531440026836549316222728280595228806728872537793522244957258060730038589170810090676474272044568671474692128168357087077816573419470273384256552275636517940058764711467508281344270125535855785388198570146010) + (num-test (* 21997874907846585575969651776904015812729615626636027149446399573806943459105370044846476738175828244018281160136531735881270437472624605280356112191272531838028896521621800558410217146758345955334174583639352151367532676985598470747138461153212653362188252002768647808852054182649808145379073620834551216386805267446360709820441771932135218282126427988826945094538034579367527908530151926679515746133600376612899354099328788736038811470295396365432559354070365548930628714861826464935305416998192532029724853617023971964507955475554955277722555849603716733374588174421463022213135839490633927005539569058361144905451 -1400498192750070094581812894241996480373581610489471746158083224360249880335094841398529960182484181641387946900090289855375996313447832474435929084180606) -30807984052781257825246153008277875918087659020905755686964119182052911551148620538090633516362197112383237624321406969368641524681503231262834662890145617622830207559490089313283375890353617292096501953380469351747504928597461154633889236826060654886877907382241867167198409355653371944304660938495445848950444683274236538890057643038410268234731745456035923559528706349316582901179686671568504971088561096469997823300883298811440849031903066114422309644669680078733839046643542078157684064686933779591609758494599988463628362190034612412739669041368897594110022347872452261447359402810277413572637740870748949093642723240662839444216981630862346445890780016393330114883270596630385367407921496982236074288475142085411632630374714528706189796772213264952893973677883306) + (num-test (* -270155241925436273159477510619232592261228150696806729750247050 15545126743930076938536195287546926534964892301082800206802745964245668351235397 72127079799316080210744562119267314209211162112457416152560774669179705347659265 58427280233475514109627698916382980237252687770812483048907352594138577656301900 91336330475502063985843547526216808965829995610054777216888670176112782119332811 99495081134815818196404370468895496198561677002653930126818668800341380375657337 6904264296552316628911621065724553059847235903647375662685025031963599691416829398469283631386160328944460790101458427909545198569619131058877708293713734 -16074984786353617526516141164566295497596312655026144270863093715961484079732496604871734572736757225277596743795506589617891195569235287256031608792067121393492186703333733526879481948463529609113624075923052999494363547340563039654910799974388353472433635130983731604982117092991918514078659590068643956240711810902756784590442416249652077644077280371860780741318193975770906075446772544431670392964384669681404295839302410058434872964315897505894833409101781069230919347279857855594782111721176074849502391457684148683668165019969667481755384384017844104770253558111588611189351637275389688093074751942960310850074) 17849860827147993486644896214424106325295064110723402251474432199595968349198253682890653243676378684005650871261983711134190416277366473221365848417375107498764965893729640224952922241531788638514200018520970345581414705756736222535562338748426356003659523260330725662384208724142177900990027225665451069059291754155591197426279006090296512196415617974140965334686090032257444820748820516976632201388937358434205022475303705442914044454220818215336283948743042841946229853366515552653568436171217572212088935263340599371830215580988184775240338748954666846379831467518505260487989636951404886967842600777836444030434816421999334066711024026401362115623932221335906548647785232855815515579448393689650116225664467056283988125816950714780486880294535933597118808163054631168063568847830481653855357008353733414826165759079092633441356914450038756281940532159493763482047244493174370100586359619040444818634156576789665732998111907245928253704097384811414269835758656988678207624731164159069547745777423464124959379113843649940896359346515513936964849811155238140671698227057228045173997904545787593258286212427476788605370334985423461194148838623911634821153061693257996982252745844329344589168264774527631972524787804330730506700000) + (num-test (* 6411564443509812216548163965666668398784964137255201222920640150 65325385402074288043601436729391841747319174569548241717675134253657593233436152 63305037198546989906433329294566491017476837189978173607681765241525113921707860 72383582945810879300930057856704905379805338886592055772943486702915907397618845 35525980101796892634292856352740658817031405780112750352735419884048051630180860 47579150292602967366908574298176357632207539947399443701205872093150879604391127 7775494633965874654516687741429737470333189902121089184439228657893110997221737422210698789286625633365548095171257583020272703565350668755439139356570 -7847653632223099338936161226557020783515367997970448568586056286591257384101422312757649765574456754668588904917800060981155642916520580540801153603733496143328839018174649200566737789874193483124577734129346933208306772618814806884416239295732454033604210880463262467564639515484363761639994642888910703066277724414372379965872478153546766131136324967950786993982228851928269842355632200589446224738709869729930285189047112131897218464505263042012855229737941639093204086147932759923796947642895167078971517834730472596647456786099215405165290569214043431009370032818978995463168133051136053246705694337584724712230) -197949741939898550383903354028842356745461597695099989904494711851411610441324234089773644533872304737431480244289438922163630848266242200711131210228027234579469457105291847132071566876246332653149194709623963836885480655282595345693084881617726426841183231475364991154699746506928116505297453355016975688761948609740314324443406930215518937775475617384099331839748494157863510168743547396262979908353122625808170296763676837551973930928848463398657587603606321137626467028732193151671337338929938959296176472483674270114824853018199281637976410726195357458134038379491704909997939715446657856320452698914513791221947734373322868574099599391493563479057703049036936132407025278683219316357543078875410080612067641232277376174351958080693019953378024732243763129075732499165068171168470237875348580987967740148512425201518758344757030205911031119619416763996490581551977913711646761182756531618786226541010835120092904291975494846126923510483263978074437667987560077422810120462938292680423746968095994108344184522240467647491991837793653579480334442342102339933473270535800619630342940590477752278184994533764839125736268376640933720554199782388890444619996919031351334561766248781813883867406045414518951152508504891407920000000) + (num-test (* 1669833986019218156514274418186396165434871163342486930502417566 58528969848472951398118375496887849181512821636583415470809040929690124231959506 50098163184827557635697120379841225459445103589988345336880332217224622666020381 90445522698871905833766573423181067004916996574451008349087758531794463581708977 92366726802191504770638415639612204654473958526592425718659284841373421985393966 69096133232785816552402133765198624674167660496399099321713067612475604030259084 323971624832697152056406152359288553860210436839331005469891386690556929684663075996719803995137130737141925308417709520389528780839777347463558171582753 2635514624483961079560488004237441873979133312246005082134175818331132377114926863102436691793380965631848192666106793612266994709357524826644421074908075389316030912936338175907209987972553710900613011802455058538786723149316934049388525865455871552882282353445228425640452635081303490379594663330152071465360003249884180020993032086861074931796165970076448856988084523672973069824258299029863033098237556417571526135639288006133579174344589248428714474318969988990720790226604664141927030250855550010512291136517209169959021730625428868037074528890516086527430801590050720467893089085308995719513895962750896813152) 2413207990093478676325592386500172980330574558867366638913149256222218924700401110600319869300256745035993991818342784487193857053589994816247466074246569162659879368383295411190237107255160498774228460295857931362161062884154872938368166514128474751716517750517217000290486110198899480877593169193610813452614906598055909439037075588626529658637140089909227353944313408987644743661503976835580507054926908821206921014266535160031749397432350114673787218438589065861056449106115395189057409933330355574558853874223262465965933679584884152813357065227868165556818717270584803360466149860292769520737249610469675917864449261901859162854558012721179400237645357401213337423255109839806528503425658270050436129019270883446965562683284298538825840361267548675967778385927410390726055957928634152514415917053614892441910675109517307682075989998558764742821214685548219206933043196677521610851950501225469125512893859254575460130829051324112015464552874242522140166275233893076603452098841950130740353331198999756316969161591691095397245996664755249875720008141774247384884623389430842799829690618405724986702942913150258769060684255363816662231923570491001519802836627028431389746450987110456127797025006251203111629141890634728548553728) + (num-test (/ 10105597264942543888 14352488138967388642) 5052798632471271944/7176244069483694321) + (num-test (/ -17631701977702695093 3931860028646338313) -17631701977702695093/3931860028646338313) + (num-test (/ -1606495881715082381 16324360910828438638) -1606495881715082381/16324360910828438638) + (num-test (/ -7960193178071300653 -10280747961248435844) 7960193178071300653/10280747961248435844) + (num-test (/ -11544909483975853384 -16041992360613233027) 11544909483975853384/16041992360613233027) + (num-test (/ -5758820541298901548 -2596462557714095861) 5758820541298901548/2596462557714095861) + (num-test (/ -13056342734667572546 46502284983183419157350605242474199851) -13056342734667572546/46502284983183419157350605242474199851) + (num-test (/ 12668118634717482325 -338544675918656078399121171905238525746) -12668118634717482325/338544675918656078399121171905238525746) + (num-test (/ -16738429327795346815 164053836541028518093058940786011794219) -16738429327795346815/164053836541028518093058940786011794219) + (num-test (/ -9884600460121235549 -53914696297933680001835530599748561584) 9884600460121235549/53914696297933680001835530599748561584) + (num-test (/ 6753521264659576004 71759828079371803409570464915096122874) 3376760632329788002/35879914039685901704785232457548061437) + (num-test (/ -6072478784520825268 83641961138289700975241455431547940418) -3036239392260412634/41820980569144850487620727715773970209) + (num-test (/ -6708950756971973620 -9847903810677323447803434015107261150885944735136350527205856921771320298384705376646797569973415403097847060539915279223391112430240736564839483430569706) 3354475378485986810/4923951905338661723901717007553630575442972367568175263602928460885660149192352688323398784986707701548923530269957639611695556215120368282419741715284853) + (num-test (/ 11263779860755455072 2292311486393743282743453705144070351222990311578446825826935237655927864700827857707370158936582804478427014131790879562565658386819339761919809732496450) 1877296643459242512/382051914398957213790575617524011725203831718596407804304489206275987977450137976284561693156097134079737835688631813260427609731136556626986634955416075) + (num-test (/ 9956488981426387585 -12351244248621474338537656633137999145154500022264356186225225426288301330225259889671144104952158102155582320296061124840400655528634050137479515338944145) -1991297796285277517/2470248849724294867707531326627599829030900004452871237245045085257660266045051977934228820990431620431116464059212224968080131105726810027495903067788829) + (num-test (/ -14875992781716065391 4906952781757522095285156014969507916562921709689447567404076064849249737893410245743456952512717420040816186768213920574809530298070437840356629617118643) -2125141825959437913/700993254536788870755022287852786845223274529955635366772010866407035676841915749391922421787531060005830883824030560082115647185438633977193804231016949) + (num-test (/ 16043178952268979636 -4962728781666935768923030490263743715131420507991284894489828489607808897271220927863958149140648859077934323268424257800724618076505149638049461104621679) -5347726317422993212/1654242927222311922974343496754581238377140169330428298163276163202602965757073642621319383046882953025978107756141419266908206025501716546016487034873893) + (num-test (/ -14889985628902581941 3075736124701105220602924325296812116294816310089906623707854625135862902005059305428034753787024827094954645083406870532379125275086885405969947540175361) -14889985628902581941/3075736124701105220602924325296812116294816310089906623707854625135862902005059305428034753787024827094954645083406870532379125275086885405969947540175361) + (num-test (/ -1719613957783789857 19860562547348050982501313785551054055826630539673708970554435103060535649825139319625648954889488501680865494719253019921780044205805557658109807483499994523398090829033362953135186523580359552555144614353929273831853529446536288544481045105104526669277307473478898498061888931858821517694257595658138564305517447595298378933983614114298000880741350618424855028965861930329619462261269994651112266861896630584883581092431090390354633458596611690990999635499563944625720180529318327647519405136188243979680965052005899543797270970540925042201315580510136864931200059448645464256385079735225156720340173280541113382758) -1719613957783789857/19860562547348050982501313785551054055826630539673708970554435103060535649825139319625648954889488501680865494719253019921780044205805557658109807483499994523398090829033362953135186523580359552555144614353929273831853529446536288544481045105104526669277307473478898498061888931858821517694257595658138564305517447595298378933983614114298000880741350618424855028965861930329619462261269994651112266861896630584883581092431090390354633458596611690990999635499563944625720180529318327647519405136188243979680965052005899543797270970540925042201315580510136864931200059448645464256385079735225156720340173280541113382758) + (num-test (/ -10969623867482498359 1292477254230352575769754773488799598312602810841892384475535212194939033905139960602724737178675944133847094464739764817257836826367652752931492512753561670732296265459534230949226553571982695924178928914002527460943582374603078611662312521259541641138419845784008028215876048965254023368247445173694441960256131358058174374542730502334351759171930973722361567186133851896057677818979314942434199157003833234473048838906103902832115569853657335216793235394595479328932380393044485884605451918890395812628720641212850763944658735838941829604119213195707479940053016354291972875689927240247563236506479099606571912595) -10969623867482498359/1292477254230352575769754773488799598312602810841892384475535212194939033905139960602724737178675944133847094464739764817257836826367652752931492512753561670732296265459534230949226553571982695924178928914002527460943582374603078611662312521259541641138419845784008028215876048965254023368247445173694441960256131358058174374542730502334351759171930973722361567186133851896057677818979314942434199157003833234473048838906103902832115569853657335216793235394595479328932380393044485884605451918890395812628720641212850763944658735838941829604119213195707479940053016354291972875689927240247563236506479099606571912595) + (num-test (/ -3716891004757979686 -19452372993227550502015765258932159656814363741878583541173956168837566077148160901999018823586675966076058615847408138956450751813058209394199427182041779436168298455103717521843644244801542056954603631432685194627158423459586845252167819811850263444712218938833443253125954475476481099092216538126519474183531297423759923656571895377587989169731023397615799830371852298135015608612181670362528239430952907458704415974164085176066242388561893721949244663406941558257051263727439679525692652639731850971185056484335828001005009903973037524233097329857690857731943951449292814500362180170793919266389501882641682782987) 3716891004757979686/19452372993227550502015765258932159656814363741878583541173956168837566077148160901999018823586675966076058615847408138956450751813058209394199427182041779436168298455103717521843644244801542056954603631432685194627158423459586845252167819811850263444712218938833443253125954475476481099092216538126519474183531297423759923656571895377587989169731023397615799830371852298135015608612181670362528239430952907458704415974164085176066242388561893721949244663406941558257051263727439679525692652639731850971185056484335828001005009903973037524233097329857690857731943951449292814500362180170793919266389501882641682782987) + (num-test (/ -4863232114852441787 -22963038454503597269981750990033903654256693514059439027985256604978917966584414065892146187253799108250061573972673983350956191446047978392921074610323648301008272837432907303975548030552369880338022067315042332692023645592417869181836251486577977896077712912433381480614752789750181208326525834629219729662085632321271870762094800588296544243340047360684854239747242066367921596241226349790282723168222543448385227922748241223520686047460119733024390425165073367321644498280127168757335614077882325524816799960018589278475564547840614315473357481582710826551932681173443524724802157570101916268510464302946527662720) 4863232114852441787/22963038454503597269981750990033903654256693514059439027985256604978917966584414065892146187253799108250061573972673983350956191446047978392921074610323648301008272837432907303975548030552369880338022067315042332692023645592417869181836251486577977896077712912433381480614752789750181208326525834629219729662085632321271870762094800588296544243340047360684854239747242066367921596241226349790282723168222543448385227922748241223520686047460119733024390425165073367321644498280127168757335614077882325524816799960018589278475564547840614315473357481582710826551932681173443524724802157570101916268510464302946527662720) + (num-test (/ -16248276650501285553 -3381199474840825715485713565301777938368574604710714363907009216856320913536015299178065264912798511857598595067318796576494480424838898250138649774858742984769125731728430552285782315111538920026330816414650913188340281906359149109963139438960274321560117812365241840204034925444652058916966934904097509799291744775242863360284348334605170437300543978049053839829106628489146216325576991696936733592366926096500684308845306493636196092408597450926695579897293944488261001228478152650490677071497874746121221519036861983646423005753475340900508665494162949119110128646472783016552527735050067363030838015919512260159) 16248276650501285553/3381199474840825715485713565301777938368574604710714363907009216856320913536015299178065264912798511857598595067318796576494480424838898250138649774858742984769125731728430552285782315111538920026330816414650913188340281906359149109963139438960274321560117812365241840204034925444652058916966934904097509799291744775242863360284348334605170437300543978049053839829106628489146216325576991696936733592366926096500684308845306493636196092408597450926695579897293944488261001228478152650490677071497874746121221519036861983646423005753475340900508665494162949119110128646472783016552527735050067363030838015919512260159) + (num-test (/ 18296946401228630959 3302341071702763311560113831030141639804425031433511503765833897787925467295486187687396312611805794369889470239777040624530990622212474466940548049117664906468330871893337410618797113677420975837622378808494314918471282099855916016026079371666730617071364751834080179173620476977670099126230223862266413091012344741482772771219725893630556702028108027870656512750807359335108428687238687397060104669074315031780019301768744978815422943986587389425726602444937024004102212071953113581935989741954695450085391443134273670514145585869912689150728183940456773133212037846765421397201956541430155664614978559762638030787) 494512064898071107/89252461397371981393516590027841665940660135984689500101779294534808796413391518586145846286805562009997012709183163260122459206005742553160555352678855808282927861402522632719426949018308675022638442670499846349147872489185295027460164307342344070731658506806326491329016769648045137814222438482763957110567901209229264128951884483611636667622381298050558284128400198900948876451006451010731354180245251757615676197345101215643660079567205064579073691957971270919029789515458192258971242965998775552705010579544169558662544475293781424031100761728120453327924649671534200578302755582200815017962566988101692919751) + (num-test (/ -60488682170925814337492051725122486652 14880088785789146426) -30244341085462907168746025862561243326/7440044392894573213) + (num-test (/ 126617729996196635247771282957911941277 -7166506344996883172) -126617729996196635247771282957911941277/7166506344996883172) + (num-test (/ -278675896803726074870988122161067771390 7744689831802931490) -27867589680372607487098812216106777139/774468983180293149) + (num-test (/ -283351838662873779255871649630248958879 6912311315831153835) -14913254666467041013466928927907839941/363805858727955465) + (num-test (/ -9715584046609700027352634666499181378 3368831995960494221) -9715584046609700027352634666499181378/3368831995960494221) + (num-test (/ -137493547985106345282009151869389470397 -1916381539906956855) 137493547985106345282009151869389470397/1916381539906956855) + (num-test (/ -328662747577960331872949773416436800743 -231069430804205460334599495337085157308) 328662747577960331872949773416436800743/231069430804205460334599495337085157308) + (num-test (/ 213595640581249636406536485951630735277 -48492294677143227478357598229530842959) -213595640581249636406536485951630735277/48492294677143227478357598229530842959) + (num-test (/ 85922846498729014445816145204889624189 193533957681757355413031965695625196813) 85922846498729014445816145204889624189/193533957681757355413031965695625196813) + (num-test (/ 24053342958857142686054803491202486471 196417511107100936775397820630955772553) 24053342958857142686054803491202486471/196417511107100936775397820630955772553) + (num-test (/ 102038936612518756467074084117019701214 -111946989731587760700903475996379168167) -102038936612518756467074084117019701214/111946989731587760700903475996379168167) + (num-test (/ -3006867214208872584699983438179656913 -234257597822744479264249663225224173340) 3006867214208872584699983438179656913/234257597822744479264249663225224173340) + (num-test (/ -279839802710533516603863620922251878907 -3244112647743502769852782626803305310331045534071805654982307107362388474314396636799597033636575215617240554815450017779373048313695795886893032630263219) 279839802710533516603863620922251878907/3244112647743502769852782626803305310331045534071805654982307107362388474314396636799597033636575215617240554815450017779373048313695795886893032630263219) + (num-test (/ 123635964546481689465778244982425098404 7701433613491146708866098469269971554817017737111287276993583150548359764165526640986060909954451793171933304569726872785964805121981749276421956645830854) 61817982273240844732889122491212549202/3850716806745573354433049234634985777408508868555643638496791575274179882082763320493030454977225896585966652284863436392982402560990874638210978322915427) + (num-test (/ 166158110049010486343321316578688184578 4093720847216792748840371965199135052196058344862447621818024731938681519017878880275303125899149558774718190527651555811733139227128378041055212888819294) 83079055024505243171660658289344092289/2046860423608396374420185982599567526098029172431223810909012365969340759508939440137651562949574779387359095263825777905866569613564189020527606444409647) + (num-test (/ 147416259636838312272435267341375281181 -11266711292262839805944890501811605204323255169233519804446548849178247889563130015168799346120099052214488209897402054530713234143622703174309015777885801) -147416259636838312272435267341375281181/11266711292262839805944890501811605204323255169233519804446548849178247889563130015168799346120099052214488209897402054530713234143622703174309015777885801) + (num-test (/ 102557200511608632541115941654031896919 3866177549962722728707550488877109233779215384377007088712280650225992470307822792085413087509167847767889824884877044539352696974351192629898363157976511) 102557200511608632541115941654031896919/3866177549962722728707550488877109233779215384377007088712280650225992470307822792085413087509167847767889824884877044539352696974351192629898363157976511) + (num-test (/ 47794953079190110032282671989549362415 3802290983508829335098916118339496411537222492645529399519373082799614656011270200284796148989094312601047370399228868583158444769807910513767845541589667) 47794953079190110032282671989549362415/3802290983508829335098916118339496411537222492645529399519373082799614656011270200284796148989094312601047370399228868583158444769807910513767845541589667) + (num-test (/ -169956065319483471022234920202991103615 -9934427489865644196610501807375648335352544234206717324511161205173460054921759084767897792996557220898467288533128078406604709773449948420404563411793533441010236017064154469575084055359823982786110746700747423674942932421964955746280671982635899487781780756099620799397239156211815110739544719746684712086075069101799537802834839550142629064374734870047412916259754010150500874430055034366305216104752636211802195447299210332237598443674867760860326529472901775427058078447963316168327741049511844237329137194533000697525539835371015163158135757326482343130221118201740819963770851200676279882978581431999960842565) 33991213063896694204446984040598220723/1986885497973128839322100361475129667070508846841343464902232241034692010984351816953579558599311444179693457706625615681320941954689989684080912682358706688202047203412830893915016811071964796557222149340149484734988586484392991149256134396527179897556356151219924159879447831242363022147908943949336942417215013820359907560566967910028525812874946974009482583251950802030100174886011006873261043220950527242360439089459842066447519688734973552172065305894580355085411615689592663233665548209902368847465827438906600139505107967074203032631627151465296468626044223640348163992754170240135255976595716286399992168513) + (num-test (/ -83006311763073652927964071041666508273 13480787677843057038436344704360462056114592749322481662307876594244244638227291805757775026215166740035048814729231681821563443093991755779505400592913963236010573873554317250153995160235771659208137440518282824497744092608999871327127239673370293239927529076145825972430101380272357235582367639159280348164804218713823424182167974242317526959809443701996053548231667727254858428867000011055354779789221097183515832386890638024105232865079002765479933320220378271026425568216748186200736499581088153390350474814123049637951929317200314355414551809067125550551841102097159644340520444983020267926123546444838010089690) -83006311763073652927964071041666508273/13480787677843057038436344704360462056114592749322481662307876594244244638227291805757775026215166740035048814729231681821563443093991755779505400592913963236010573873554317250153995160235771659208137440518282824497744092608999871327127239673370293239927529076145825972430101380272357235582367639159280348164804218713823424182167974242317526959809443701996053548231667727254858428867000011055354779789221097183515832386890638024105232865079002765479933320220378271026425568216748186200736499581088153390350474814123049637951929317200314355414551809067125550551841102097159644340520444983020267926123546444838010089690) + (num-test (/ -312626207169475064151212222217866488926 6989069923898656093413456232544365450599471748502878018530391549015151484336014906416216966193568842618920902504390187814247729346977677905224098932673981665869061845335443588666641982676550205160521286690015544764015602751932938178737949961754714143180917985455875095030469699198116593730005119922928175789172042067281849364217595912265452199938281052984802042194034638773435768458457616208103331213440768472281882976004050012769415198321241810008696147179275528426468408383757692656341606162350211696837361434874035354680073309142183699892959618671515841112321607728427286289324836870027735590091451421689980776552) -52104367861579177358535370369644414821/1164844987316442682235576038757394241766578624750479669755065258169191914056002484402702827698928140436486817084065031302374621557829612984204016488778996944311510307555907264777773663779425034193420214448335924127335933791988823029789658326959119023863486330909312515838411616533019432288334186653821362631528673677880308227369599318710908699989713508830800340365672439795572628076409602701350555202240128078713647162667341668794902533053540301668116024529879254737744734730626282109390267693725035282806226905812339225780012218190363949982159936445252640185386934621404547714887472811671289265015241903614996796092) + (num-test (/ -151709660794612786408772973806200383563 -26960472721919005254400858042130056790831511338891584787669209989714807518625849812230185079206081782191501696661436514815190623849929065098497737155759771863508038766934134444191240792356114381746781342181881402424707118515655119761011977116554236461222788625158348668147995099157685699761135150772589445239536582228655532345059046596356954495360132444243748421428095867292294626357084961338288369883088525401649234025290736504802104065029036642533076183281468647642956623788270236516849523210698622687255735945678505925047193818483603361307498423724202227256505312543145618362906047473400380196192622607541097732443) 151709660794612786408772973806200383563/26960472721919005254400858042130056790831511338891584787669209989714807518625849812230185079206081782191501696661436514815190623849929065098497737155759771863508038766934134444191240792356114381746781342181881402424707118515655119761011977116554236461222788625158348668147995099157685699761135150772589445239536582228655532345059046596356954495360132444243748421428095867292294626357084961338288369883088525401649234025290736504802104065029036642533076183281468647642956623788270236516849523210698622687255735945678505925047193818483603361307498423724202227256505312543145618362906047473400380196192622607541097732443) + (num-test (/ 138834496986391136939574372853300933725 -8052690543272184576133758511645801940246473546142520821850130421981395129853341888352999304040698251945886555605291324954368612109314080471658982022831338507499254609048475429862437003158379101603576571787302167207044118847876475134352180874260998595377014195145760071923429129767580115085764485254455919915567128572731355497418831212259648020550107573824886521471697331410754043280744066090848295906051303624846301488010249980896364883452154860562864255354208802313850527991005497484253401461375477060954782095047043919500670383372218536999834862885439984085848342867301834247551832677237328664699302165347765799113) -15426055220710126326619374761477881525/894743393696909397348195390182866882249608171793613424650014491331266125539260209816999922671188694660654061733921258328263179123257120052406553558092370945277694956560941714429159667017597677955952952420811351911893790983097386126039131208251222066153001577238417785769269903307508901676196053917161768879507458730303483944157647912473294224505567508202765169052410814601194893697860451787872032878450144847205144609778916664544040542605794984506984917261578755812650058665667277498250377940152830784550531343894115991055630042596913170777759429209493331565094260318589092694172425853026369851633255796149751755457) + (num-test (/ 276499207940187081393841843387608369874 27347897028734618663428054896349668572244941195143856840032842195489553215406302254043947382368793914074147314353589439281000471813879502242851166670252197853998033813694814376228360691543987661407996785043637351295817024680721181205269262470473172181965930243852520386958529041036476807810647578694133804796395977642274699322030062940721165202488695975750512485574440928370802874677938542169620505668128224812441566912043326338714451629730522324228356364241376445033028898865300103247057378058702233150414643818049655628999871012383236520330575609745427181485617250755214922048672375947942288446974485524776744246517) 8919329288393131657865865915729302254/882190226733374795594453383753215115233707780488511510968801361144824297271171040453030560721573997228198300463019014170354853929479983943317779570008135414645097864957897237942850344888515731013161186614310882299865065312281328425976427821628166844579546136898468399579307388420531509929375728344972058219238579923944345139420324610991005329112538579862919757599175513818412995957352856199020016311875104026207792481033655688345627471926791042717043753685205691775258996737590325911195399292216201069368214316711279213838705516528491500655825019669207328435019911314684352324150721804772331885386273726605701427307) + (num-test (/ -8979365591106781219797187096315899769868799444656824967426553299158070014074001230883484015880186603742048949313393413640240595706939311540002219411120389 -1698360947072008877) 1282766513015254459971026728045128538552685634950974995346650471308295716296285890126212002268598086248864135616199059091462942243848473077143174201588627/242622992438858411) + (num-test (/ -12831814656788829919185319784994714617782749504716966706877579983082880759985031662545957372565411439648298939198657738497464024214657609856476819270030801 454910754379715) -273017333123166594025219569893504566335803180951424823550586808150699590637979397075445901543944924247836147642524632733988596259886332124605889771702783/9678952220845) + (num-test (/ -7834266257250691217409788323211914445703052638619784568844628449769010091330019095736167988675873769434766592786720961949649685040028101508217441360672222 -428418418877192732) 3917133128625345608704894161605957222851526319309892284422314224884505045665009547868083994337936884717383296393360480974824842520014050754108720680336111/214209209438596366) + (num-test (/ 5737805823029931079838944835405107564434908634489801628049345331760087020955028323378020396677249341204498685189403657652738071833877470777083253103936452 9588993061977446661) 5737805823029931079838944835405107564434908634489801628049345331760087020955028323378020396677249341204498685189403657652738071833877470777083253103936452/9588993061977446661) + (num-test (/ -4001605821592542867351046644170905984672346731784670159062281252096012802838642896466582343641124674682428297533953704119505640938363392225910275838094045 15760991890495426717) -4001605821592542867351046644170905984672346731784670159062281252096012802838642896466582343641124674682428297533953704119505640938363392225910275838094045/15760991890495426717) + (num-test (/ 2876630161532936743269451364955814480771395635620140205538288339793482694260173239474830738010159518887660000673207712630507802368373928478641773477534499 -6788234478844960330) -2876630161532936743269451364955814480771395635620140205538288339793482694260173239474830738010159518887660000673207712630507802368373928478641773477534499/6788234478844960330) + (num-test (/ 6230070442453337264527950102774203962152836811174649694700041895216739851602598854067104967963392074425258687296947909484969927078206601660837276754799333 190237375887614033974333796608341639595) 6230070442453337264527950102774203962152836811174649694700041895216739851602598854067104967963392074425258687296947909484969927078206601660837276754799333/190237375887614033974333796608341639595) + (num-test (/ -12098771374444180013224380531550204930654718468097503123335711776524055419889032578894177605164827523969169377266342179411916625188550162928371789854647472 -41681385674896602840749705069663453185) 12098771374444180013224380531550204930654718468097503123335711776524055419889032578894177605164827523969169377266342179411916625188550162928371789854647472/41681385674896602840749705069663453185) + (num-test (/ 13185465843955116174925558412278612918939024395488172088108029202384613698982949554556435640011161663974075894844304583900497170806796813871943782330552768 -155202352609947911537719051033334010254) -6592732921977558087462779206139306459469512197744086044054014601192306849491474777278217820005580831987037947422152291950248585403398406935971891165276384/77601176304973955768859525516667005127) + (num-test (/ 12784980722915659825738808684740823452025110516624579136271791852138148426775553817114893299569867520414470532361018804123866264934222335562072872489963044 -249441012384365373362771955533424187237) -12784980722915659825738808684740823452025110516624579136271791852138148426775553817114893299569867520414470532361018804123866264934222335562072872489963044/249441012384365373362771955533424187237) + (num-test (/ 8517839393030302736298983538193047531846908718502576675615969705563208303329257882565359266876007571790337440612227785062203468682754778416335180236967433 -23101645464137481399279134347982485126) -8517839393030302736298983538193047531846908718502576675615969705563208303329257882565359266876007571790337440612227785062203468682754778416335180236967433/23101645464137481399279134347982485126) + (num-test (/ -10157767522292361462005308817460390811646115952647174687477824271227382383351453540195549992670001314693794150879368708343715654899952822395459036505947192 -25611473771508763579433379623726126173) 10157767522292361462005308817460390811646115952647174687477824271227382383351453540195549992670001314693794150879368708343715654899952822395459036505947192/25611473771508763579433379623726126173) + (num-test (/ -8580252632668820290302987230726290672170301642399871646484841866604753910447257372311950907045477729554307803379310475132687855999835211879267570997069974 5347050029330174629945013741349819215851040371727058829687387719215168997632386672310746837193930669173408831178932364105722911104309540550576485594530627) -8580252632668820290302987230726290672170301642399871646484841866604753910447257372311950907045477729554307803379310475132687855999835211879267570997069974/5347050029330174629945013741349819215851040371727058829687387719215168997632386672310746837193930669173408831178932364105722911104309540550576485594530627) + (num-test (/ 7706102251141221799524762336156378964168657337573751909064577951085535246905735244239132983582998872001001594454632956803416956154262109939446710205558308 6334400709835247308796432875490978646658012545184955441452799118298109610816693049400832749087993843490999852355789914065232784070007399786089389453289854) 3853051125570610899762381168078189482084328668786875954532288975542767623452867622119566491791499436000500797227316478401708478077131054969723355102779154/3167200354917623654398216437745489323329006272592477720726399559149054805408346524700416374543996921745499926177894957032616392035003699893044694726644927) + (num-test (/ 12609622044672092190084693450911157599596799695538449568681964257744962273690941575572590166273187189250007688411096790312605666562908125521094386992971478 -8237858212652788898158635047388584411011830102060269605835391741772914864422465141467281143809161251942948659243584296367296559912373856433388249393853968) -6304811022336046095042346725455578799798399847769224784340982128872481136845470787786295083136593594625003844205548395156302833281454062760547193496485739/4118929106326394449079317523694292205505915051030134802917695870886457432211232570733640571904580625971474329621792148183648279956186928216694124696926984) + (num-test (/ -9988492519236282081446302885464711911055350309732728352574982611126604133339499170845224383282665522673248920309221355720665956477799939031063172954469785 -1878204914631111607000020160429571305542722711529281855381736226230242796648854769713662269068364131804626863789957256573308715572826753755672493154125086) 9988492519236282081446302885464711911055350309732728352574982611126604133339499170845224383282665522673248920309221355720665956477799939031063172954469785/1878204914631111607000020160429571305542722711529281855381736226230242796648854769713662269068364131804626863789957256573308715572826753755672493154125086) + (num-test (/ -10729942326579120947061030583094707809945059776287551713953926998992375520903658867971835616518813070294302895655369081976222497359056962112544408591462495 -4917625712783289245414023733273041940212797202855299465496072729329693853584860839801663152618595377553772371725021213143455497822882736730281253858119747) 10729942326579120947061030583094707809945059776287551713953926998992375520903658867971835616518813070294302895655369081976222497359056962112544408591462495/4917625712783289245414023733273041940212797202855299465496072729329693853584860839801663152618595377553772371725021213143455497822882736730281253858119747) + (num-test (/ 8114113595157517238445304590338354472776364877475201453112450680537221171989478096363668912966343706408770932684807802285529572133696646343108263717309148 5443953102973235688784499815692116502566847594605098596244123647428188581304528525010862185203718640610834003873728718183528722470626702382993497913086105) 8114113595157517238445304590338354472776364877475201453112450680537221171989478096363668912966343706408770932684807802285529572133696646343108263717309148/5443953102973235688784499815692116502566847594605098596244123647428188581304528525010862185203718640610834003873728718183528722470626702382993497913086105) + (num-test (/ -7125100205152691887479515774712530950031072786448635736036405923401522078562323494262148946679985384635556474075282302608446439950458673260234175964199684 -23871420315894180764743988478670341498770583257649869670486332228804693253344466615199983955886679924409910043885402198203427975742868174334723967563526738510726448815413356678504144193747696164586135745786501041060322480940451156015256191962506052700295351077719851275026974629635679531161390660244641370183176979934485671396035404817388717005746812037357500295693454623478902942336087760288091719793968445716246099043828787040340339906538864570506773535078524092440112404847904632624419421052178754041718790915772437556681684830937503838434712179830722395832238257078212535157309743054115702650740005055678387806081) 7125100205152691887479515774712530950031072786448635736036405923401522078562323494262148946679985384635556474075282302608446439950458673260234175964199684/23871420315894180764743988478670341498770583257649869670486332228804693253344466615199983955886679924409910043885402198203427975742868174334723967563526738510726448815413356678504144193747696164586135745786501041060322480940451156015256191962506052700295351077719851275026974629635679531161390660244641370183176979934485671396035404817388717005746812037357500295693454623478902942336087760288091719793968445716246099043828787040340339906538864570506773535078524092440112404847904632624419421052178754041718790915772437556681684830937503838434712179830722395832238257078212535157309743054115702650740005055678387806081) + (num-test (/ 4801495919363827077158204249631885157347198552733998896638174958434968555935827788499392382851493568264006507028024783408190862186734863708684652212703744 29234959990138609668202089052356468732793041824333219340488007351402997202222578434579705387840772390513345507274006495462445058795870182760749392281528881636623188890883479914921272700981309656920982410970774047916714087713562927554033500521877735827036675598267184309367127514966388636440710253467328441763131873309183205727440365838789320851968108312559316922678357314418486932673434031479515016224407618177089903730349114511598373251388750023508633761000320088841886505077453257141723747388913336375142897897501529451618927178835485127020789481918641637409265186365292847057986276062625965612268181771076051892980) 1200373979840956769289551062407971289336799638183499724159543739608742138983956947124848095712873392066001626757006195852047715546683715927171163053175936/7308739997534652417050522263089117183198260456083304835122001837850749300555644608644926346960193097628336376818501623865611264698967545690187348070382220409155797222720869978730318175245327414230245602742693511979178521928390731888508375130469433956759168899566796077341781878741597159110177563366832110440782968327295801431860091459697330212992027078139829230669589328604621733168358507869878754056101904544272475932587278627899593312847187505877158440250080022210471626269363314285430936847228334093785724474375382362904731794708871281755197370479660409352316296591323211764496569015656491403067045442769012973245) + (num-test (/ 10769619761532897875307527770350128978615798426116103116325434914975512103385205123955114305107607195469345895102375220593168903042839441996791318999499708 -7224105715967976893083374742254251507019823877014718307738328810406361200631626366722837314776666720638271529652546975342143108973422364041422652163016078890272393678677152791565494865444430757858556891645947268886646732022748338160528677218733159766121781240328812893374941548395710123982510227501927393735585082736583984561348450061452997663109932611188779299623613963995350679177776686423432406091192517292522853783968685873925548901506191291253596763183277703635837071862492572256145656312023955675669362656148946145528559574994353884313568526553663370513565393821926602014407548325293145102073923450066319746913) -10769619761532897875307527770350128978615798426116103116325434914975512103385205123955114305107607195469345895102375220593168903042839441996791318999499708/7224105715967976893083374742254251507019823877014718307738328810406361200631626366722837314776666720638271529652546975342143108973422364041422652163016078890272393678677152791565494865444430757858556891645947268886646732022748338160528677218733159766121781240328812893374941548395710123982510227501927393735585082736583984561348450061452997663109932611188779299623613963995350679177776686423432406091192517292522853783968685873925548901506191291253596763183277703635837071862492572256145656312023955675669362656148946145528559574994353884313568526553663370513565393821926602014407548325293145102073923450066319746913) + (num-test (/ 1505915608160301518246681692927442986955390537144107830770082927276722640395785957392652130911646706470337068266772174699405268120590454296080828168261019 31152879253507543898583880698200027990847289346701738353567402100527465991154555548630544962150902011282973749886327325250084401181379196961322399337408341296727915922288276602390334861175305055229766353672502691855637668618950047400571070157436221479289152631256433294884836727331457389922838951144187501751190662594278336543502171639899940796536926507796271202659224890656712231014450702948847764643603683153113663072089256293587951842007583210791100743318865647555912543508324790181772321217524164822106191538518498016236866957803105254555578252294418243701672226181762763332992886540089416888889135117147250495261) 1505915608160301518246681692927442986955390537144107830770082927276722640395785957392652130911646706470337068266772174699405268120590454296080828168261019/31152879253507543898583880698200027990847289346701738353567402100527465991154555548630544962150902011282973749886327325250084401181379196961322399337408341296727915922288276602390334861175305055229766353672502691855637668618950047400571070157436221479289152631256433294884836727331457389922838951144187501751190662594278336543502171639899940796536926507796271202659224890656712231014450702948847764643603683153113663072089256293587951842007583210791100743318865647555912543508324790181772321217524164822106191538518498016236866957803105254555578252294418243701672226181762763332992886540089416888889135117147250495261) + (num-test (/ -4912349668310730778272626761660101328812783790262451913449395750351147048676353891314609774894027305081515542385381430403698808605768281804457186380542764 6582102431028556562269167182029950958541569095123705594954788174046339660437206159173417583841743892857066740116322758515837624700881569925244230209567223461401193316695082415261197843574563450002486582967745135870782254839990479649574452750850133306720341823136645982650022199634379361313745598455049448887744206616434903460504591098363901961758069797933831934878649993183747273660007900662110776570580293994733189753806312784239743585453090900671308673380802381312083077891736513388250097195232616017027333586286786139736783210630705878401429301217589001317082952461701571026008195534878902572422952568763551674434) -2456174834155365389136313380830050664406391895131225956724697875175573524338176945657304887447013652540757771192690715201849404302884140902228593190271382/3291051215514278281134583591014975479270784547561852797477394087023169830218603079586708791920871946428533370058161379257918812350440784962622115104783611730700596658347541207630598921787281725001243291483872567935391127419995239824787226375425066653360170911568322991325011099817189680656872799227524724443872103308217451730252295549181950980879034898966915967439324996591873636830003950331055388285290146997366594876903156392119871792726545450335654336690401190656041538945868256694125048597616308008513666793143393069868391605315352939200714650608794500658541476230850785513004097767439451286211476284381775837217) + (num-test (/ -11503235648135220410087372678575470255397243144180272745183844970864347348074104828328211521698012119761674096067066173927209129755062269068090560678650614 -5548338218081690289723998288742945948643693817491921699797822887914665364835947234564530865119623677435878746610856459141463506776423054050179729345956931675338102809929977610828639446535095411122377961067651902947030310564736893080382424590568134091858634304377553326990788802662029347894499019277621467098333287442862683493159356014650672092060912274570436879076161496563079759704321556494898013269338428360856068237785049960484767969682269790642298701577934519452927652996671267126348627432295779183359417597868330923329974640383630473044712419371517153268338860560601603043892503067815822312755611206254762903436) 5751617824067610205043686339287735127698621572090136372591922485432173674037052414164105760849006059880837048033533086963604564877531134534045280339325307/2774169109040845144861999144371472974321846908745960849898911443957332682417973617282265432559811838717939373305428229570731753388211527025089864672978465837669051404964988805414319723267547705561188980533825951473515155282368446540191212295284067045929317152188776663495394401331014673947249509638810733549166643721431341746579678007325336046030456137285218439538080748281539879852160778247449006634669214180428034118892524980242383984841134895321149350788967259726463826498335633563174313716147889591679708798934165461664987320191815236522356209685758576634169430280300801521946251533907911156377805603127381451718) + (num-test (/ -22964048032108117904633365483799091488990853392670636861794813863757795874434768543212887316456319246155824842161717179767513360050328383696194174741889496306018655333450647372293193335577883672679165775070112770359697627614883420620410888137853011387271594559450892054491963940112235887802995117234918878648066362268919389271696465517050425727202664230530633207566444357393843669758809938086228366322548799235049875711702216182219182908217345405023677260470015666831191434586902791186444958476491096759363292487221288620810273243009200212776634572092195691654105986099646006756823055390654876878195583529521482548988 10644501761877612307) -22964048032108117904633365483799091488990853392670636861794813863757795874434768543212887316456319246155824842161717179767513360050328383696194174741889496306018655333450647372293193335577883672679165775070112770359697627614883420620410888137853011387271594559450892054491963940112235887802995117234918878648066362268919389271696465517050425727202664230530633207566444357393843669758809938086228366322548799235049875711702216182219182908217345405023677260470015666831191434586902791186444958476491096759363292487221288620810273243009200212776634572092195691654105986099646006756823055390654876878195583529521482548988/10644501761877612307) + (num-test (/ -19058897134776675884737764093896349427183484738023061956638485191239529906311503740032626797095131123523175909943402828257449376045336777553758951620699386266853663342003969442142858702229701661125904623724248177901462857013835790939020450746503125344631958534655024089231193396521561965297735217497608287565163852923704017958259400904834287026933197193592591423799328167149965328232560408884408251535373934831244856695227539243433290481951528897142697352526450162440279318507285454432916819060795455956931254810171588139618689138022062041222735056137988435900866680084665165131313435515187611756148824388549448126467 -8326067459929079652) 19058897134776675884737764093896349427183484738023061956638485191239529906311503740032626797095131123523175909943402828257449376045336777553758951620699386266853663342003969442142858702229701661125904623724248177901462857013835790939020450746503125344631958534655024089231193396521561965297735217497608287565163852923704017958259400904834287026933197193592591423799328167149965328232560408884408251535373934831244856695227539243433290481951528897142697352526450162440279318507285454432916819060795455956931254810171588139618689138022062041222735056137988435900866680084665165131313435515187611756148824388549448126467/8326067459929079652) + (num-test (/ 25828007361450952719858846443651616751980622231808382804245407702688699228397920589229449608543284896555585501243582045708656531815385828908740757435341854996277769645696261182122648194952548457487178342682313459444433667556195761154944956714756269417591048771194019245925463541886773351873002480266654825771525233808830260734678788520487541379982691221386179066818743751876186761036101255542680066874888848011074569355779905086056095043888696435054884292698783753890317487209955316141370052511469715869816445031102161253514609763532756500340262263800747279044587806090353812452308490155782240390040070679663451429071 -16419739031141199968) -25828007361450952719858846443651616751980622231808382804245407702688699228397920589229449608543284896555585501243582045708656531815385828908740757435341854996277769645696261182122648194952548457487178342682313459444433667556195761154944956714756269417591048771194019245925463541886773351873002480266654825771525233808830260734678788520487541379982691221386179066818743751876186761036101255542680066874888848011074569355779905086056095043888696435054884292698783753890317487209955316141370052511469715869816445031102161253514609763532756500340262263800747279044587806090353812452308490155782240390040070679663451429071/16419739031141199968) + (num-test (/ -1669696848499325185991294008037906453080648048592518700324899343297324898656645662186964240087582483813312797482298159224575128489696846451225871663856944749639170892311973606684486632224811435175199158920841554176114937196187087530038509898368755036744105403511353564606301040888877621412514452110348953863172547944175251415725815533087344857665837809749724257466399374547882097484009980477192931829030533366309859182367479867549644502538060694266048652224732348150866071381652452605392696555259221463464108413747443898588713629829490175098280805280460168541344102200890646453100478450456898359263676257882174308268 -3154577849943484396) 417424212124831296497823502009476613270162012148129675081224835824331224664161415546741060021895620953328199370574539806143782122424211612806467915964236187409792723077993401671121658056202858793799789730210388544028734299046771882509627474592188759186026350877838391151575260222219405353128613027587238465793136986043812853931453883271836214416459452437431064366599843636970524371002495119298232957257633341577464795591869966887411125634515173566512163056183087037716517845413113151348174138814805365866027103436860974647178407457372543774570201320115042135336025550222661613275119612614224589815919064470543577067/788644462485871099) + (num-test (/ -2215504974719141921873290809898041836016933916943403987778356628123168736190963062169230280020568365292362281642280014010817115943641228422541948070912910166283758843455538187697141038676028739959626556519808411324617157646799936128314485433146912658200236754847332237438334421065771940922444296618134121662770699950019164632463150784605652351782139277998735272280336096528241168196650073301607171613955878761317417480490869592669781417658461696905996344800864447403426286476662235990122025654999230690604488053668524888833992415515434190712628587043474760836969696399229242018051635699746048823240033842587927229964 -11305319675542865070) 1107752487359570960936645404949020918008466958471701993889178314061584368095481531084615140010284182646181140821140007005408557971820614211270974035456455083141879421727769093848570519338014369979813278259904205662308578823399968064157242716573456329100118377423666118719167210532885970461222148309067060831385349975009582316231575392302826175891069638999367636140168048264120584098325036650803585806977939380658708740245434796334890708829230848452998172400432223701713143238331117995061012827499615345302244026834262444416996207757717095356314293521737380418484848199614621009025817849873024411620016921293963614982/5652659837771432535) + (num-test (/ 24358677073350645219370308521851912760304925518671532565724702185818845784332554892130070740233218685874351979772556877899278790031132507391155876157108663291716896413773711734271947599485714147026138105714458778787734198938526335256418673319464023475137997251085298903419563039860433435847755093653670989129405749785476487449599232956305952768800154351414655365461746574761818724131185410194605648466196476174400166047788352670171627261342369793028465418799251589432585363577887467959594667618177199696618852093807640490831859585621198048572586882398004957371434677752931134884039120875470266936204172511104679441462 8754800987327220648) 12179338536675322609685154260925956380152462759335766282862351092909422892166277446065035370116609342937175989886278438949639395015566253695577938078554331645858448206886855867135973799742857073513069052857229389393867099469263167628209336659732011737568998625542649451709781519930216717923877546826835494564702874892738243724799616478152976384400077175707327682730873287380909362065592705097302824233098238087200083023894176335085813630671184896514232709399625794716292681788943733979797333809088599848309426046903820245415929792810599024286293441199002478685717338876465567442019560437735133468102086255552339720731/4377400493663610324) + (num-test (/ -26302114071841994464108666310942614602208671348774320769941579409198660404735714925432808094014718434192516800374483192192707032773903982752997957629389083405320034044554226640590549491188742685901503166669355807243735533977994184111229208270447279559478659750835531593667003322059717930484363943660175452777363121025595100592911646539549735930625865256846706785601753749996181113742254145758187876411260965175520035400453360390392991183382425735199046574346992179663247011131958270717402007532256308394559029768974932620173103778338779940189812875680687510582798628982957687329572431433891809534332514765287899172737 196971971351558855568201373145365478995) -26302114071841994464108666310942614602208671348774320769941579409198660404735714925432808094014718434192516800374483192192707032773903982752997957629389083405320034044554226640590549491188742685901503166669355807243735533977994184111229208270447279559478659750835531593667003322059717930484363943660175452777363121025595100592911646539549735930625865256846706785601753749996181113742254145758187876411260965175520035400453360390392991183382425735199046574346992179663247011131958270717402007532256308394559029768974932620173103778338779940189812875680687510582798628982957687329572431433891809534332514765287899172737/196971971351558855568201373145365478995) + (num-test (/ -25700334917103749626396366612061842558162882395534131493737229591609654899446089376271023701490708870843231350129849819430092002268875830384992877382393956173037794109904701961390126146975281052960293513473777226100954163054292968509501976296424278813632162404905591038465215586347229260479401862039805429711982871702185657527199220459658257385112793877259572278229045135617281858788415643567614198333459934599272409406206213115625226065750113120833933806486512117533453281522448845990642550827848765145774541658722594353290694745164913189694785762218575339370800538946514325662656804799046877175035545715523049884960 56325873113907570153638933263921340484) -6425083729275937406599091653015460639540720598883532873434307397902413724861522344067755925372677217710807837532462454857523000567218957596248219345598489043259448527476175490347531536743820263240073378368444306525238540763573242127375494074106069703408040601226397759616303896586807315119850465509951357427995717925546414381799805114914564346278198469314893069557261283904320464697103910891903549583364983649818102351551553278906306516437528280208483451621628029383363320380612211497660637706962191286443635414680648588322673686291228297423696440554643834842700134736628581415664201199761719293758886428880762471240/14081468278476892538409733315980335121) + (num-test (/ -25716495567761925495340309269248196976121711927176026606462843116646034561721958499564011513233986043633061335866265799467020807570689498961190839877265773450484494789052182300993137822542881883769593344810286970036960228835955266304979090841345697560418139960733748874044680214388098802745248923989851173047158103142988835055585349795022662576576434371181693607267864646932929998659458265265400181839509356921460222604661909947838434113964465769102604033848276159366897885013231683417270877512514679528402888899725431524867260144325739317224922955028035417867933390409466302057857579158202739536568407090965929352402 -92089830031261826185903006947297196357) 25716495567761925495340309269248196976121711927176026606462843116646034561721958499564011513233986043633061335866265799467020807570689498961190839877265773450484494789052182300993137822542881883769593344810286970036960228835955266304979090841345697560418139960733748874044680214388098802745248923989851173047158103142988835055585349795022662576576434371181693607267864646932929998659458265265400181839509356921460222604661909947838434113964465769102604033848276159366897885013231683417270877512514679528402888899725431524867260144325739317224922955028035417867933390409466302057857579158202739536568407090965929352402/92089830031261826185903006947297196357) + (num-test (/ 6427758281007308443295844679532867042370757542760390680622584758338041709910068192973790897624827722686313216884084305612889554116246627679267186323854642904894988936981064543865794245002470271142875081223308666588659587718561791667575945670118263124267218395749059879636505504607358472659126298770422135028955713148882314050530771750859372048576074912599265823577267962213046012777760882389021047579367276198483178024744924299929585515193595330026399302022065656106472153858484998010254767462854235008343139218888170221421046454280858208068658907389288543063912721882521711363713136166478126504226820360347652405439 80854661163518168674595213426641201760) 6427758281007308443295844679532867042370757542760390680622584758338041709910068192973790897624827722686313216884084305612889554116246627679267186323854642904894988936981064543865794245002470271142875081223308666588659587718561791667575945670118263124267218395749059879636505504607358472659126298770422135028955713148882314050530771750859372048576074912599265823577267962213046012777760882389021047579367276198483178024744924299929585515193595330026399302022065656106472153858484998010254767462854235008343139218888170221421046454280858208068658907389288543063912721882521711363713136166478126504226820360347652405439/80854661163518168674595213426641201760) + (num-test (/ 1960728263483597985471065015024594804771170333646104429205729831998416939777820080209106943861368202560376682136488253096512360698625765514606930980274938979705620987031595592685578710084284618125325617453699875318678007463857705931376750632972266553809944621631324385690517092215690694024807784270742388108802858889381036105223858467345514041786882957807868961085072340965930749117411726729713477739990680381647988935514765113077094375924848051541167125595015542791382355149166582367766443782842193396221676952668624805183924877889696428989259842153378327156342464279071638070457876940165186524833987190050817072048 91266493124541431873557009470479491083) 1960728263483597985471065015024594804771170333646104429205729831998416939777820080209106943861368202560376682136488253096512360698625765514606930980274938979705620987031595592685578710084284618125325617453699875318678007463857705931376750632972266553809944621631324385690517092215690694024807784270742388108802858889381036105223858467345514041786882957807868961085072340965930749117411726729713477739990680381647988935514765113077094375924848051541167125595015542791382355149166582367766443782842193396221676952668624805183924877889696428989259842153378327156342464279071638070457876940165186524833987190050817072048/91266493124541431873557009470479491083) + (num-test (/ 4941680418946960910262990974014623728051861920391294141439502190044830922127013115391726343950340163023958511659132792063033185693862678433421115681422259770928656196358763089894449447854011668445981430826871764812047994423858851467292757304285634515474652989618200442851239459073981986390515468331839802701176644729973346052528164203299481240263263697394061787580128379398464090163611942724580936445878570184925290925246112514015572149640886198984723311273144361235138411362294735799814160816806773736605477503201836095726740734281001021071803299510239436683913500734680524381145064985356627091311888606290704759943 291575320383555320391938911470370670502) 1647226806315653636754330324671541242683953973463764713813167396681610307375671038463908781316780054341319503886377597354344395231287559477807038560474086590309552065452921029964816482618003889481993810275623921604015998141286283822430919101428544838491550996539400147617079819691327328796838489443946600900392214909991115350842721401099827080087754565798020595860042793132821363387870647574860312148626190061641763641748704171338524049880295399661574437091048120411712803787431578599938053605602257912201825834400612031908913578093667007023934433170079812227971166911560174793715021661785542363770629535430234919981/97191773461185106797312970490123556834) + (num-test (/ -17803449239532304707372697093467431202778585961066204978641168716990033159088600623106396534094218402005803618121159982050197012697237961155375180768349707725936023283589475384693590539312637333226292265409814019687105755522332846972859860649558844229320481883408457674560284773922666633054564243260924189551494368660033292970122831009582038986061326503238023206238467592238752824663935316307653075615249537594229930297642710570473007696494702367783692850946455203144153509057520651038068881755863521371187245025834292163874467913915588768778393773565536027848586260129438664753479013894698439967637389690509120223682 -10962227285754340409566802000064407225866105372406170304563353147415988225079632767886653994299800743521362563345682593189107807948342418743229049299449088) 8901724619766152353686348546733715601389292980533102489320584358495016579544300311553198267047109201002901809060579991025098506348618980577687590384174853862968011641794737692346795269656318666613146132704907009843552877761166423486429930324779422114660240941704228837280142386961333316527282121630462094775747184330016646485061415504791019493030663251619011603119233796119376412331967658153826537807624768797114965148821355285236503848247351183891846425473227601572076754528760325519034440877931760685593622512917146081937233956957794384389196886782768013924293130064719332376739506947349219983818694845254560111841/5481113642877170204783401000032203612933052686203085152281676573707994112539816383943326997149900371760681281672841296594553903974171209371614524649724544) + (num-test (/ -11349783565099575757929584771389010505157850113880084607145768380886038854233583951229136273631022011781914171912628263930864052254964518914857757025547156428098062812984733912827827545722979442676567330004437902674729872754963478834939047061999292143602525229120558979819117729589695377623970606315287270030693151486803968345724658003068961239204812937084581894755863859944500186226990319892122692007317326534880413455575446314965159569830188583093978564829748603480193166063624130610256395632946002879039047154077629561745862713628266069928068634042545592328263646730943717246953000457159714049930890865576634096206 -5169948998417532948043886408019867395123131165917923418040862036041756675786217242743410895008311710518018466892169868028617239526646914529999134517417939) 11349783565099575757929584771389010505157850113880084607145768380886038854233583951229136273631022011781914171912628263930864052254964518914857757025547156428098062812984733912827827545722979442676567330004437902674729872754963478834939047061999292143602525229120558979819117729589695377623970606315287270030693151486803968345724658003068961239204812937084581894755863859944500186226990319892122692007317326534880413455575446314965159569830188583093978564829748603480193166063624130610256395632946002879039047154077629561745862713628266069928068634042545592328263646730943717246953000457159714049930890865576634096206/5169948998417532948043886408019867395123131165917923418040862036041756675786217242743410895008311710518018466892169868028617239526646914529999134517417939) + (num-test (/ -4372008041495429462966226028389793326873997497126815043214338280101332483009650104005998792061125254101227371430911497751865710691604158789733634394053254604723940088324934622768312096370232736965692181452463495731681105253628558429524788376108667441329817524961077744083376843098018692898745743361309486938506049017980865957895278210133305721083115513131884239744064081819033733041876411992332060293539102545847193260167588667810376670587099064558298380310132769718526554738650709745767046942440481512965138461694790645096012018276362849398785863823724642554436182185786302301222529261914437437947741031113015699315 -13213007132248918651858333568248204618745148942720942572088217188768868803339938910599097839075045781852237705726227293430250507070717570662238736211897310) 874401608299085892593245205677958665374799499425363008642867656020266496601930020801199758412225050820245474286182299550373142138320831757946726878810650920944788017664986924553662419274046547393138436290492699146336221050725711685904957675221733488265963504992215548816675368619603738579749148672261897387701209803596173191579055642026661144216623102626376847948812816363806746608375282398466412058707820509169438652033517733562075334117419812911659676062026553943705310947730141949153409388488096302593027692338958129019202403655272569879757172764744928510887236437157260460244505852382887487589548206222603139863/2642601426449783730371666713649640923749029788544188514417643437753773760667987782119819567815009156370447541145245458686050101414143514132447747242379462) + (num-test (/ -24003371850945507239307096734506644624830254935119140199726507920301383328662376914775504920527918338079792692943250446679097229950654636321252144129692109999375967030689211646504258922323499994340282315270808545865248969923421472430657741998787024263629527291510416193284540865950122841477102934165296344839654902079279846705581902668360663987722715177845485423354226653585575109653937253382583158263755381721094429734122004436184054214443676096492583897635497699417294183504529284810360226314491839533303380490277211336049582128602304906849999737224506976061216780230350942535246958957024226614847691329767208211525 10686139440491678930358521446524488461285005495304677740436234635584738003880529034339295291091217655777627375148264449580064000634364863951333061091724053) -1263335360576079328384584038658244453938434470269428431564553048436914912034861942882921311606732544109462773312802655088373538418455507174802744427878532105230314054246800612973908364332815789175804332382674133992907840522285340654245144315725632855980501436395285062804449519260532781130373838640278754991560784319962097195030626456229508630932774483044499232808117192293977637350207223862241218855987125353741812091269579180851792327075982952446978099875552510495647062289712067621597906648131149449121230552119853228213135901505384468781578933538131946108485093696334260133434050471422327716570931122619326747975/562428391604825206860974812974973076909737131331825144233486033451828315993712054438910278478485139777769861849908655241056000033387624418491213741669687) + (num-test (/ 11114571678097117920369007866358540243142633567044843952020632081573546909920632543585596494530749645890342978505657174505155646987551523455565703297238406590291026899487431109110746657023874064284362499621762851387854720746040865741433394111425240861542892218169985953747711593827913014379823797703717216676877313898809377467394109623799717556800777662963842899812297087284510893865429864819927951428138755600792987191034272014681606301885821862650098620488569288170357746018556395309910262410994899971436293672676949544989196526035130226777567220128838888396668158456237490064462262193759918857287915854681904206680 4808076329737968688023887165061921594706561818755147855784713748545995818001333418509444774306288638038607173052166709335820929501845348060033808100812677) 11114571678097117920369007866358540243142633567044843952020632081573546909920632543585596494530749645890342978505657174505155646987551523455565703297238406590291026899487431109110746657023874064284362499621762851387854720746040865741433394111425240861542892218169985953747711593827913014379823797703717216676877313898809377467394109623799717556800777662963842899812297087284510893865429864819927951428138755600792987191034272014681606301885821862650098620488569288170357746018556395309910262410994899971436293672676949544989196526035130226777567220128838888396668158456237490064462262193759918857287915854681904206680/4808076329737968688023887165061921594706561818755147855784713748545995818001333418509444774306288638038607173052166709335820929501845348060033808100812677) + (num-test (/ -27971792815424016824370019866875377333122266892537700816201893161065327053508379094007350664178576160161460501442627646041422270472469587140689725524176629653056006769618104516779694726446739085332330345789012312708713495757968594985567285237456431009983022526625885024663335598317191838389804118084831445251467492693688286258834282078888862754754572546522075833632779922232880101875914894393005204887265821991459415144492487189071888581048779385051174007698853920104709378859053075296413813207007405843448595681090932498329066591349910723578718333092115184652723310842559914379989208301125396793101430807658654849482 3169580893680227534064172567436590084742349042688765883461923377455374714865282199177755353861979892274552092801376364846717140845237173266602633583445110) -4661965469237336137395003311145896222187044482089616802700315526844221175584729849001225110696429360026910083573771274340237045078744931190114954254029438275509334461603017419463282454407789847555388390964835385451452249292994765830927880872909405168330503754437647504110555933052865306398300686347471907541911248782281381043139047013148143792459095424420345972272129987038813350312652482398834200814544303665243235857415414531511981430174796564175195667949808986684118229809842179216068968867834567640574765946848488749721511098558318453929786388848685864108787218473759985729998201383520899465516905134609775808247/528263482280037922344028761239431680790391507114794313910320562909229119144213699862959225643663315379092015466896060807786190140872862211100438930574185) + (num-test (/ -138888658164471549506154385143989713534453638138516110941977029 48484067562152384719540184707188444570280914254129306788137384972303743285284814 56428088099244342456240635263153370817851703737803685168591843059886944388583310 6984617762898435035101945891920384937438416626357047934508608980105797822504000 90193136183227859939744547239819443586783276313678017953708293432043879247302040 70539472782976230144489157899475475029273447055080677052149474853222128626227832 2525164589393997980217929709704832829968554364529060039097810436136432713906553063644429644328565051224269893261942396763235990073001625976866246420775436 15614337547041181126817477188043219628044963126229393225781917631975649438502836750353253851523795212263078850399716875892512719059737913422781999218667136371648316387382440793865460028660248325297931269646982047533754121791358966254514009830876592200454797694143082163294323565673200905929297174223061890100210054105027025488322289599106119653451218493916291922340123640475500240519924011764050880374885136181582395113140580448936759383024305870622004464940344826337458060607492042593813585998516868215921180540240201095202617277388950504036371411600204964284568597705251929695275183521036281637399204541958859605054) -138888658164471549506154385143989713534453638138516110941977029/4793535847709521198063287553243915170068914691727215964454867625024011698922303669226389748584276840530192157568469968220857898703102351955898913589325705637953049380748829567692600765708909637920797057370082064005557328769108356548100875674196976079597658854339583183901899349355521527519781721778545444496852540362424465770767219571362842157786846795990148969989617793004579188905882473140017509154008696803103206996067638134383708975696867028865870695941933200225325283190379262695816923376790224594063264297952504481719779782130509306530621779762254864669078635401870023086312919956154224782043667754741333688780367667466505233610011253346902821033707597517691608103391952937194719540981992469020284583499872663129517095879706480339710037976698298522952071766717472040399518290905103777436461474880898550115925718887748413534479076504168236430697214654069473800915087572730747027455509241250627470590715812698745630545585772046458363388764449879417348554556621640336029897762172500880501074103433267444717053504878282494505367980026597725927414511391047010801407870379019921551218005714825277162504166028680939100225793768617321830389705750902850499916610355200000) + (num-test (/ 2902267908619179684129536324641634394442732593027015198805855082 4748067699021154152763168285921806700655154833226062437593302484475663167752990 92172802787151156076284963978247829387076983213530315481815585776147505007251090 15808981285029107672090190966349736198141855760941720122983980047623201110025085 60559202289239963744584432021634662330089323842876293477363484160210450706125345 20641717016962556495214267565148984505293698026059157698737040675346468206231142 142380249473014630955299439077662853963947100833592874440361316474000948841420058017600161066408668117933232436922811486348705081331372574460204309908598 22418721268614574393232189860262616514600143215945007038687873335656746730488694050883006164427390756358558140145027011322151188565843290717535647848841274550496431839061217253488169143292339455650565906288959125935798633464526818546688779845699340483771625364583343140648892889571715648295855169294054985996834093294240640072029711789359793649773566295329912082241637482772608479106201840565936084243727069954911883243252762742415647868355726139789907900798435783365130277592703989608678774745914668128791639635886550753850811717805962562157686110637810320436812644047534536168343578232389700410352900247092236175044) 1451133954309589842064768162320817197221366296513507599402927541/13803211377640454778526029288269623376813125655593684775595099045285713415153039020789267800416616529908688645478733023490751981264976732618374046330204398361829051480928696426688037404239513603403603849882719851670264413777889524531938606364925013854252374108222701436535488401321603495905123597139234414735397259257280679663147039651553472142280954446675036289021783142392760217244908768132158498744301278889276778209560846418263599491357632762902447742083022806085077053406738681250354036208472026046315736408632370478801849290705001622808552373129971427533249307210975612625050706661691322027927380443494854794852235813844542319971019369687589916047377092369702778251658652143114091304960406840026816351348391618676357634544120732441610431417230403811846208113160343697557236265319994702483700922393762500190362776377442551539417224595247790865885105594005740401824824367904020732469833438717527758468635665777261969819260766044978137909489986407113029460354144391595512642835261443393260585888868936164331461486646676578398836326366036777321522851855085808626766493197635871100152761464712744017549919220291986785134521319127277292845352756807452050073157340000) + (num-test (/ 7798204144688205291220879078360728451593323170355809361079096742 35808393784851478122520372074317359817820799318259895240196875729073154197251420 58532175726063855694248618287185551673975962776708803423334853085996022345828434 97834368697888769536063057370864051207348099191057106781292664602519775900739777 92489021460656714290092899983209031746574776013841975324837145038810562509209529 71083733375588666647468985607775761710974844539643116636307037921671845148256816 6123989271760127932230015643359630675168106436173654465119508990415235040641894537960236511442249258231302028977221206744158863083898145166446430168108 -27418900206398855942064397259705713102524342707255992250395147550519659429645343464288092288218160406382406024735131578979728501208163782063519839258876833755387025755815673514708453862847139552613587001235204464673999898312854941659541050445981594990466469147364579547089805525464252876345032296745312923488525701877655352034887018931755379078328147999631937419977103372927428613463482328465834563846802083044643719319690088670748858904291298575733560600669924511028715689681303059001186388754140003746463568171428267337107394361025465082282061651196456268663181772211292647101192148287507051053367729008997838464209) -3899102072344102645610439539180364225796661585177904680539548371/113184205287561573324139833190653102440730360395399197973956984769580868365256138025034414373155098575475566747215877030265786675432252675717351889433714136838615056208470421665419618669892136317438270826178251174708190860235979949204785938786562420189510825909814566675745650194525647207897976611434325225523578368855952217879373499055292850828774005130267218801086474623429504045290678320168493275019256514768273116059350700654655821674309331585233552793659038912697151359657915391954687630783641745610431060563252789714638916120291482852533638921356624929690158752601417722733222880768367060672103351737811624242610815140332559619520810810999145535251960674284283045907801934328911198563750515779896457101601178888594882087326241517566336011980952110586199881600553269825310575512911473547251704677890770772166895623118832621335417348044312911888377718725944255218219811801447500167145561774582342171995333086224230231746597452848775656030037837271428187450747141983599129861631612369300880722326218963779650411119279310045263996988089484063433088077868691314162108392639864773907107325220582413508233901954483499166402135445110435112499264825479433389003494762240) + (num-test (/ 6291885367078853457481986049409245691302078375827782321496819120 20959289231548357352292073342856567687394126070322865796282035211176720583560298 24366038587110130209541647226271577368736240640393242419005751016119649778306566 40118119174220166901790237425673316895032570534639145502274313654443256239236466 73598137358602854818844747625643480865061277528564461120022408463105339470504117 36695182446520138181079917512512743290981469731336486456411609014364293489978544 8671667981598505073194269824535189054936442262459158402875147736469644925300845122881093216273840895555488593258562684601176239455526568314028830532770 15920064019095473156324398162334173238735268739049399738654357508344572552411935473846021991360836375685872129737682603096450566258725052013769725919038955505690389573813769125933987978360857342250911865713011888064725725934341157729878064563080803955584985269499994186472079783942404183377695242296289152788154908185130552013951432753148997632323578507137074131845177376689609114975253308906745794984371839952312988353950198030866538756253618535421214253194954603293145507537939731320546686208032528588232652963255550963088571344119439249328480867640436815434047309164687808223851012490130534705427647158409623238123) 1439421788255379275215959765325419043929720157723371200401/1747562187028503746686299553853635643553063923188506902759251937250022196751705340155682655202720363192751787186892107863159676381018035068965958466119538181810433273947829904580526582292369320932134048728374142501965682147541817431447933591106030690334465450755701191781243754499216697336293783127396687916725975251100500896467549458036395977769801208905203001097425041200299917628353220804629035768571072498715030261324138691471497255335498185741379289492513543474304524261634247519034231348033379344777678679950561777846684978640375273167561174451700942154388980887510088060818147834369595669846115248027925007288445161871535514130090907585140894883683709507099726386549038354860875469377442908932714711235823032704493155679240378374325069782368108779247450762222838197717507164088182062062215767468125843278459189085290703729281279344184417197883359351058003644499215541300350121854220342250451978930421772367851329849662028719768708399155817754711362398236471946313773603716759409265530444582884661320404389499624411965234669344882203618613097197387901166904575791500958722726774956950592290330175936039556139052663816485140080963740296685158607671768592) + (num-test (/ 7377598052472799909620353419322603137723415431070641423056433630 50990728761110292768803869421408199244526424730838143228662194914314857136430737 89434155113971221138805303763480423496687322824531744020762041598590716339098287 91343386111124700155689622654961840380754244946720984970313893805578518003516073 5641075230099727784981579696383316732450130418277879081291954534985607255267932 91040802121912074401640073226003257602385910518707524375098380810792151468159323 59272268188012925764499414539835790113036863511169317924034366016920114706179376837448098952655862721652129333873020625135398431500899131874782270590048 26690053756452308398721390096804652429111408747235998849320348549870126230712525274708597346508961935323823048352116439255386668122483555236157562141222434006899926132549352821247340442387991613448730451171206857242290791156220288682675982609964518905569737166444127835826079348146626921864776959482079234994631361894786436656768739968380067890165160954836874044821979903056957225885565092422439358816023307475581832942250031121721325840673134241504501661692722633100336840768527354183989544434614842654682324213774503456414914613412547380720171088896588158750436205804689590730033393056191028424154915201435563063992) 3688799026236399954810176709661301568861707715535320711528216815/169215718032454146095901737002485678790901914179482864125777331106759302744215797822810809511498045518338288799757661725047129775976254373463314416017128993811694804386237923340900604770406784566473173755998386770282409830097844352035251738093305402541509197084964701114515390028814839744480965823142680384744649624767291550851759670297818996073873968006960956353033659153219390871979066743795530136868490210455800714335529013059123604101460242870160400211866883478263106349349114199154533363251799944090298252763172390952446660627602934622584400932001701907172000401485323481964448487312714644861543740014645407417493588261100128985848137181719614326345024112347151970444057551896842474702539258687521054961314443551837168457190568932765925484427579811571491887599619302241390226818415165012748654917331557679228501007751078584244340346651276906088856205294333241792044902850102153793417101337667969641035858108457362954650972654353600494166650067557014544136240962457086782865870886529792004619668808741311540795514394731398977642092124679638585188974746423756335151669217754388004341907440529525288302872368689364872785975840444000802518095138062596107983803117056) + (num-test (/ -239344771695510351349291992975349015183687755312261264640655565 59880027487583466136533364102518649070390160795136023810470091681171428955831193 48344457085007359228086666145324485903333773379391455489556219681156342646858065 96824393663737121700189215323825147927318524415097221824671795011444303522438090 73240728471954064253765051525185557601431281145369716902120469411886093226662465 53476482728312567840603110355495270554470432250981685279567813448298175801364992 2468459436652089730331798017030410049989399340882712030505584719342958436741536069714790640546086933185494149096286590992747248311590137695839482679011866 -20583944357058654336975302336113341974001469085102805363209530168831840401111182124827636905521584509677325966689931599005216123375088335255672290604710305325984961984791919524676460851699284525672773368217606895110240237523696098521003978238685169880199868729577660354717875890521074505342309726366304528678619465048659607726264456481345739318939431629704180230985397408136331466856633265343276511285483458860216756106887559724757372775728879136089013590836231272961497930729470443491032308329051560641396901204040829291495325588896591482909336032903587307512310970849256645908744180630660878534263566681640143534823) 15956318113034023423286132865023267678912517020817417642710371/3718709813392127924163278362562751486187605430152002432053108623099406465632705761508167478249438322470295467114170871555665890539409511492475240415534629792791729596612426725326976353265532166735941330128195885206087665506220364347120981130748862937276841801804372097254983242962029582754709606117339082763083905960784323141929645331591164015455383939302728076410053178677168172481507115685831178503426055335630689722163467637005123748113214310366231893390818795405612007113310547901224920768646006621130651182788173442625298859454337696280614462941186626306295514630883052819172301830539345633711941340491653447613466053205836875456839023743314390098829184111583809697328393569588632000669468187410368485286035179259523632217543401146996259011916302393091677624838641658623073752023082344005134299104409908004250830639232078441523519412192782367689826532215394196055149255026188549091956300108740792221660678858924234682223183500313556198187095251404633698868186071148295957994257417049500872570631774233307260384902571112475241073598945295745287525486108978093728296107260155093397986671349139935376427469718767763295900745932105722655724205000829205748307261900800) + (num-test (+ -6069217517368004039/4076344942716985944 -399587800008780737/578697755310708616) -321318766345655960630110128852941297/147435729263904928853096856396980844) + (num-test (+ -41285036778370718/305793940074617155 -1396094619926552183/15846027887642356854) -1081121118676718273499338028514700537/4845619302294419132297197085940230370) + (num-test (+ 15975644088444536091/18063939613598316583 17501188199168431305/2979264551795273683) 363736076920798535449296038324193823968/53817254956563877935003279344562385189) + (num-test (+ 10197734562406803221/17452826108659293487 14639450560606090654/236781760961536951) 257914422508077920978698094723491089669/4132510899763835955061848877304138137) + (num-test (+ -16810360766832230069/13652857552883800956 5011749175730438558/4169057419710079215) -184295743992738197672588473692806043/6324394120121667288243293659228081060) + (num-test (+ 2234573531734039025/1128831476977636536 5842177084459535064/10255356071975483971) 29511180623959738330730559435115466579/11576568741659658592450950022331964456) + (num-test (+ 2268894928233321367/45672733521488298991909987382109984899 -10510750087507287356/187832098427494353069556175466145198255) -53883392376116199828369509984040539934420061636271022459/8578805378260910951788610598591490227836321974082207035230408675959411151245) + (num-test (+ 14273433611429514043/7774518083776389556784045601066955324 17247074371340283485/225579726714102822702316919752160926694) 1676942472465190408518249346164012571239098147062478293991/876886832336064155131767120243155911448808491410701588797601053820468509428) + (num-test (+ -384768590020206817/26284423885474502132625533495652664626 -913687410374243983/254477371735734658619949996700223764026) -10160887225658731404416073535892287983824191154410167550/557399258996959835387173465565070652935481894323496556880024318994528462023) + (num-test (+ -4465222504572200650/89674568206322981678158378582739708537 4148550863841320780/74302497820894496090312266744880513261) 2118016946376507498169590394563632549990739165791772590/350686547828419379316750498534703170285368675911953477374458878558215968903) + (num-test (+ -4466938407638238142/281859125741189685767904931589784285893 7302241525893379697/204618108204962312932373858463395271264) 1144186926000295881841982161759159994442430111060328362933/57673481089466829503954266461746705742702466399988738560842837126631263478752) + (num-test (+ 6692616266348342275/280491911593106290120490189988812804382 5414100524539959087/183579771905991028181574615911067652873) 2747240373316006570071525025488180559154305534334705425309/51492641151737853299832848099101317109893853469394209716061486746077629289486) + (num-test (+ -2794289802081124319/15768464977850217600859580216291365931410230647587457388598921425875331529149 10869776169503285673/33805119742344157512165738805682358903614971418053290198565741206390317449856) 76938383491719886409504555688515759257937029058461512747558964579607347503639994773101488934213/533054846729186819415263583890627325668798847177803707144003483502948153457972377767011992167761176556555806720273883868208938866192358148729990609852544) + (num-test (+ -253222140119290489/2123024034843473393742534167007121513293496410591072104903085284304117612082 17957334013642389787/32058972871090153103034645121513493401113378486125580864856088310966601405847) 30005809992231287609744177955201962181880644831204431411802631067134766877061419104162728517351/68061969937719269465960475690278941280799593161143759512261685488134507341176789799765185182008442410081522124548392827986923668912612728349293792643454) + (num-test (+ -13318881947309618/3105936147298438543619802738126617974207009907186580731552500517452462642139 1850968757748704519/36469179946212878965111748233319050931475015876401494718861814560453153824935) 5263262069792987469108717688485565287648879759118200779949761992573778798556738644541735401311/113270944257273905484832818286307416845956086746130199501242465128236430928807948126409718436237517505516279133169796919230385184900609912160483959935965) + (num-test (+ -9937822914683494298/36414156259035675966580098631253549474580108307284844243190992829476777586283 -13712605099585970325/17758145954890657915358548152198427387923366136638180213650029984340849686198) -675810254607579372158951115566887998278519717754376916387787672973408477396668549189167387350979/646647901672150721610792561233068038707362067627156669418022102308446036384411330678972562863413004325878365438890328206637571985169324874284800419222034) + (num-test (+ 2479135971595944301/28169711053558469409458629766960029324030958129245230797895768033968717159836 3427244662960653095/28446538857424788738244844756675951434179713170118835630969510829753715142438) 83533664807147783700314944003289704497366290621039272787320536148072960487262393639109696219129/400665390043739792096386856839000624247597803909916773326187593475005945995926511155915226239317839405221783416485999405286913042389632370302962776360084) + (num-test (+ 14865500635281371370/56222262470894935247131881777606182311286871927285650835673424014252462156319 6436092572090050725/19282524131572095520593158313261757267758159099923763177708581262473988426947) 648496060602737474174747620183913927791943082591316359990137585798909535115053578637078811588665/1084107132826611778585714784136700465449309125114745313342842325649687943726086785657821763235618936882528385000712567133180567926723616940173290425928093) + (num-test (+ 340196811925805824067049620503247332111/14422464039094716975 51285507111580975533385007190438537498/3230944134273302873) 1838820276033673324738967436225477772648372110186756083453/46598175588880723338390245118389369175) + (num-test (+ -210449319160504160992731982827917332322/5436857856220342451 251628249079137248539965770847855056283/4323109210037952829) 458271632943884346915405609513071881239303671882386130695/23504130271893362375786510953364243879) + (num-test (+ -40984360445255688839942109197081457275/6593417935076565019 -138094174027187773198981391229349265879/7135512300754720691) -1202957011856131413678873259651070808566709454882536663726/47047414779755620074837011989046108129) + (num-test (+ -289704472880230079383856507128133962457/10452740760651010288 -55251460678415911958671096669490155237/10333740726609314202) -1785630052601050832889834016432677758176770083879794496285/54007956451514283340719766211063255088) + (num-test (+ 276702099951674677215621541062877777467/3899918017008359516 42623843937285717338660228144403811741/1973785812353331893) 712380176058162142132059442064597996057720566915757732387/7697602851312240113570356856612843788) + (num-test (+ -323480614013303716597188084301661616596/12957985934572321773 -72966206939397711493108854138997499334/4539020357040680881) -2413780175334213399707013296172687953960842714316410700258/58816561943270580900205343368941122013) + (num-test (+ 65443777543319569578713907336699651721/218804857459609839540825438673960136766 -61986861924091374470669233802827103921/65997977315012279293170493460332070399) -9243869541956614722377007489838492339200370508580665293676272508698701352807/14440678019033825487758061900150103876633207457375858942267120523885980189634) + (num-test (+ 75417845823236070411341994633288547531/70553457686181702397810927701121800017 -7132208259849175775323757110664708879/24379326462014713478002790304943339422) 1335434330716260509518880689691257567128541829706203586134358870209350816139/1720045777955364955754847231620711706115121721983605654691934662747636370174) + (num-test (+ -144692585186931942602350348772472248638/135233395864627580439431775527364081053 282512666765911374279543408363363928190/317835040256607665191397469890906044457) -7783226336195038987381961251409043080655184208289882004756343793157154115496/42981911818671667582796085276418080952868666330715445603855323471628969373221) + (num-test (+ 44888992584766727877549626240272070725/30583318432547259097085073976959329092 8004917623696885952432014881247978821/22005016116109025986417835664774768346) 616299974987760892931461886440810919939264155149950328291076750435394215691/336493207496148335911511951044490614757807556827643881435283379298939260916) + (num-test (+ 78378756441281199312006031491361997668/175125578595003447448566412156266355477 41128705932035853424044828385766740319/216359823601433445464965619660717081261) 24160702340946845080381231961736762955784254747832931999121777482667650876511/37890139292913914697800186893609983979783140570423836226844401085057321416497) + (num-test (+ -36669293296367265584135816683983780855/7341750629088488427994322429098120058 -110335983484012479290765295565662258281/5944410911181873015545360879141666465) -1028036623331099574157832708037007047972965676333418398303213384036005227873/43642382546729990922161061763293407461832155878510163500678954788762454970) + (num-test (+ 228535455883892721240720366651075744967/13353170075841095813026701300679754576855418298534901819672803635370738730013 50622643250826426975012800479360461693/18462345430382979738234695697296360785230118465695284267226773073149552698303) 4895273294635392498665165879164922265508724130843670837390305811645771221742112327485665544066552056189958877583010/246530838530831602270074647792752210668736478466245992891169449973883874207653264921203783108295835419855394180777469634862446033810927048792871560267939) + (num-test (+ 11355068601761731966774720678777239425/4604724775053993730579400400679579947095967462408565975449642189823843820753 140083339434585694465706029861026468774/44667214322013486680993684507177513903616004462434123967566781106229226297333) 1152244506542792151980649054527153167035843960949499862764543674633978109831264344257976000890169981044543787620347/205680228421222079539939271800361418862113882206694593495620042859527547538342323521609420336002641308832164587573546802806916292021672743366881933951749) + (num-test (+ -1347509007210283053816302848714698886/1127513773036247565111791991337919355855664936242166138889250311777351432819 -29464928273311615445392112247506626497/61933028109313748081628643142485450090725737246358993405254280723087421657760) -116677425670791909053501267317366054796703074907755330120413752187834449333299886015456661052906469074533366060403/69830342199092322009251417145364324484174202256910311362396720371574344280505889954115533896831727771442604285956749924105078563356474162416148250025440) + (num-test (+ -324250487660721070279458563122233299722/81069650926979269606211148691445887485067008319429991878657612702576019034861 221744296343315457943731256980089803078/69422237643162665956763790134527973903052044485041686255401689654420090859107) -1511153903564243978242173323335554031611949546418082039382510246845821774680210236992700372319944685567533765722032/1876012190766999122356500320654631447623282613780323887424324139799202291067983209550065997185860196433399782230215269625922714982832188312141580824109709) + (num-test (+ -5518324152042099343909980322067306333/114786626838714403445081775763480415805466836213320421844559660900880511042496 -34415425451618992284220085078832944671/96012285963709194218263616278916829663708037691620330613749177799086889040577) -121088040955051148243092870850103339772063863319219725752028251933576579890093496821887384992074112246777968211161/297862876779681729593084954525306275464788137269287692384941959703420459939692410434239827100068259769782676124741025632728203586961467995819025176090816) + (num-test (+ -14763921690861243371082340598041267817/5580497386043551028888310256097864185640794395615400088682607872958152738111 -37917865546640067592937379176813765341/6460563866107795917092814416816176677900242086501650458839130903088333290440) -306983808565398982164654624310995401934900925070311336095043743767915008644459192438083753301097540174379867380331/36053159767181973313125557585868206969047484351694148822117591172786449966899079869470557965303954072842600790897257698854023751399649072014440219958840) + (num-test (+ -50167218239107621378232529938205077788547946059832391744348095230748591585676/15685777859540025727 2959973815535345735348053015389999235839609978295604181643547897863515739931/7556072538495923601) -332637648328710384664787658442281566361265475773778265650094684540358159241317316408573560734439/118522875329417757148187346888166482927) + (num-test (+ 36275100136090483878026478935942224245036692059657264537598788566553406654319/7192442039871568876 31833552596558882106090352174644817045294359487590746360517241517440556146007/5115621724114081523) 6795584791386081942310910570767193224876510928834120433155946649367201608618436115134135392229/603177258173744207443043238127434068) + (num-test (+ 1518304705177739493483387141342904186483658277690975456045607777812450680478/1837349761252804045 -98159070764971437450169149833809835519268242923913777966502463698396945141091/17238232824535200528) -154179655228376218743158291724235398278770272999447263973992852061897564252670941977524115620711/31672662964580000612902147746364535760) + (num-test (+ -16820231344048323866426670709751443650129113909724546927974450301780935205864/4879137683452153951 41987219452495799378686134495924115238909423831017150785452046648616005475639/10470103987572807938) 28751853386830083847297108941057082854166610198448421498169760256533906032780671559334244751257/51085078915429149801779227663330863038) + (num-test (+ 106981694162678522688926793970551228214793665448093395251834862896418045995969/12359470989873920972 57736849967187961211538031441400807467468650239660040144967046985609433512403/9148121311784151716) 211534804819567028232303054650327703050869189253958355919997046592895748577556985792570078031065/14133242495605447754080611005730273494) + (num-test (+ 32477400086615533920132766925666506741908300936974348739732763951610256880146/9045135183308696243 -27444990730472195954051975667481893116650518055101159075033425831129583042846/14815776448343565085) 232934248044934592851252865496377968609159820017147884670610366058217203617961573611006127074832/134010700820948737148715427669965475655) + (num-test (+ -110053921687226074580746319073262192216481755737797790655164396095655530752161/255625377233605953547425802301922658850 104095037267817888539158192425982072195078148060302393917025130946535913363779/52156238014583575190277280296975732513) 20869334635774913818120011435677143948904421430726712952150525645851498022294865158343391008006649321440592131083557/13332458017563665620865770931104425383051282278510599570476131200251352190050) + (num-test (+ -29732769078100192507326444863945498799317005912797369958801703828462203585495/153426302667449722633466432797809987061 36094569840376017510791155197897623093337784636438580042046806320700826250193/73286165979315961333009750429763545174) 3358855747298609357265422062476767573626163217619249414656940907348235709105513077913806378841119674678021275101643/11244025482879487592663298816607141776071841230792806495601092332558428993614) + (num-test (+ -5942892427460131788264792587455286675871284855854073854440582948253436001319/42136930106315714728428443448730580823 4013357443728612356640061171485791666303136232331145404661874650095235381569/4039594279673425548586623641599574814) 48367895947790658831309709091377784501687363167039737892874371817395083020674648576881857510385191335175551957207/56738700606823969419119152217721454504573192499839513549171731025354063974) + (num-test (+ 83833896550100013648317056712064289497247852876055488793078639582729685477353/188580876675619574786621140720273228537 -94310653397371924313725082402708514144086936359594289802762093989853507835016/223423274286761439988276492107364036191) 945257965914081840217765265999453398105151083284254483307155736205796420255026737575918161700355729594975143830831/42133356934734885127066999419230498520039134905254787577957770920054881982567) + (num-test (+ -14753992026457621496269953958381833108089826525439816493815533773338622353285/187171041855711408638339193132645929319 41340837577662628944845446369855468662228665858415210386857356535970453143469/322471558852595372991189266479896691326) 993354944176102401496932276511264091214577507066786487301109889019709943488537161608732610457423116833164991120567/20119112546425211128699888199278894685207186285215928241217590790016852128998) + (num-test (+ 1370528773439579327226257222995383030603284075640526658282329726447335048230/305600505683287165495713194488435114383 65450762047588146235054351616480175308174618406941901794570541085963681607527/78934496562987400429145916504112602768) 2234440886428442112499564751364146150136438855986167755259621093816030535881959724370423862435538502079424185584609/2680269118389404699570998335430047660909241475691839354273569734988880268016) + (num-test (+ -76890617375308981455205142622328108690129081798840077873315966300000409208129/15716637731576156581128288257209679492686622162926707938907282962815471734862 38716252217351070567267262306332875768795464072349655597599997486613800623507/8966639693620677733207403249675415446338239705879120765911896990394928596139) -80961151400006413290662155450270992168701818633203071886556882897757813544592915596861717853520674107309124394292702460320442121704840951425284048212897/140925427734207212133604717335369986754855062343668899363006574618520848268718851310007161609443093589067206438198588881828988648068282656538084484897818) + (num-test (+ -43290760758277846058307167265569849910514905939554272559141355223092464986939/39390771697068809730875092892395235497943839933482798653607450783947201796777 -34021960935937170163894986285771504067448629886312440795733904794894095253649/106500928228745564800818258673435811176493306775154643113582742982704678574998) -5950657500399238361998292872481533631424138885403498309639150240712482075115081624153513501886127772738596607451116548616099047843190357858736503567640395/4195153749384427435979718872073512266029328962522899010907363614544821318917440413166534226890289043064894115954085809567292470182917919104836361549181446) + (num-test (+ 17906146982204022925114071077515882010955693727109005464426577098738402001871/11978213712662686419384559301746021856683603106261241838035626618416021524231 37108371752538653389309509075248119316034595087990649061240232817571629131708/23044877611981158676785639370406786635050056158699399001947422631523989139615) 857136973087880657664203854652754375000000796400911171478039451763440064550649429609696307332611304395324153178602635490321877797571177424460384122636213/276036469018466057777760709173569478463866562650149880633721199971933767458324034017734890892482223472007882939609440193626728031771767304374122564511065) + (num-test (+ -77062185592993847534024832256462395143306675613123510837298699277378172890089/108133793614758275822883834459865239455798743725021300772336023406871185253111 11169356025540464491224577661206910726665825152149521753528516637690366838655/6369000033300801574913390611244042297918207179453133439308688067382050608197) 716975776667538986425481530620118513423964367153518065425241139444161780269039780459555836804116752462325735011822817367819625929553250251515977390346172/688704135133337463423649074673019029541747166391680122270752018123634233590688096940261480888455237095078029621363428114402137147558304641222314936350867) + (num-test (+ 13583698920327742567560325715281067532806062839142769830536738488850089822247/37364394142255392010559408553278838878570049727027927213977555360874308098434 89809462356450792524214360688853318641058652796345720882094866396911421360072/67457610947238032712889230619376608100793287037427539672885124981055281513463) 4272000026182362299819817378001862956001381379478285995446709640464951377212652125169846305230835604666564953883168949950485767679005929254184987140738609/2520512763327523955464432226120154092742373168521113224665257966793820057379494860454732800329019773731110452438496395974166220481124541266348389100216942) + (num-test (+ -56124163112538495128545947597589743957824668875494126834084658670528264380488/4752969512023182700122983723156599300062332404522277372984645779569746369511 -24794747728228571193100294011820993825205231022194400752319729320185378063197/98168688073468429337427023004226732413974455700654808087001957859427678524065) -5627484141989830997868845457242226973925524393512774885292323552602180052845805156311097870316601631410500655735815037997645271136502511615781690896430387/466592781448509275992390948177487068548424631274164031114910250651063315574511979617153568070687706304645818907382693929886654490427484894987856595782215) + (num-test (- 8229768172162771789/4094631553683915058 14916542302144281688/9648520391570031013) 18327341244785642013243791303754634353/39507136041685332578233153660317693754) + (num-test (- 13554976081719376860/5850035209629724601 -6813034992928443315/16012083383654426278) 256899901877002811987490932642058619395/93671251573905451634945335611797465078) + (num-test (- -221798849980968127/896588178875000428 -10118632981534633697/16809799818197706916) 333990778095757160537366868413422249/941966737890699707694484674257410003) + (num-test (- -10398409463665680242/10672871071680021919 908300169382593227/1663860017749090135) -2076589873614048366639515256135965791/1366012573135328609279238070700513005) + (num-test (- -2198518713248421187/494031967775171833 162489257999262168/3608560229859558061) -8013762081101965644053022173225152351/1782744111192743850497670941715295813) + (num-test (- 4025149216228566945/640594137312937394 5467380276809034025/15813352732084653151) 60148732603712157399679443099667862845/10129941051434949990590527231467828494) + (num-test (- 45649282670476595/278386580761220266717341154184065537 -8637266763647548631/320617180101036447149595031898805939080) 17040443444897688379155017841073877168061229451634462447/89255520501631886327999278515127058459530587144975987720686743155549485960) + (num-test (- 5648415331928005377/86815630814151297970860026950116430492 -3858618729527320883/27855468652821710859204555976171379400) 123081918822962876101148539477322308270739795776139149559/604572520679633516300271119677141637780408278090307422820905500994965166200) + (num-test (- 9781572955588417059/112881800445343004034168709823458687843 -5059688483724168531/4577416283528891230944530353546966748) 615921077060787960354561606126348783111829996215681822765/516706991472571912574910836774186280180852506048696459094758451180832844564) + (num-test (- -4967914039344839478/238170260180199675500515253723794945205 1851848905279976507/5731170327270969184071911155742503278) -469527297115675955424190428047537920421409443442551107819/1364994327983166854234805393053180119374354994464588574791772715189542881990) + (num-test (- -16853061581795824324/96404437352723357070647888504166371117 2887610208906060444/32980643277330946266739822018299212963) -834203249643667606680245846951263316484378801689149307960/3179480358681967952651970543397987660141008737601948320258541111852875189671) + (num-test (- -10766003534404571638/1736320411127247334175538439020437437 -220564366893542891/24024005562370344889629855466198025799) -11228676451427374102904112111967705085778332338188090365/1813624835433832784217556253227924899981441517333394378436857197512671181) + (num-test (- -4039872531792560303/2717817538621352660433068255065439787147153801016478776178010367557953211548 -17969900169229544519/10371230759745501411127733226376204123221866394120596070959771442399588297129) 6940459580028931824293913174633904994365279610168782399332846513086074139209123514834476635325/28187112855925579976299840753672542065528422968220885043792832460046226866036339425358907691441054924266606457279617295071355282523744922239122018045692) + (num-test (- 11905720953886477738/26349991043344773150817457299711471013733618033386232710348739943906972457535 -1868508269239354100/7915113871665192715310471309271830385175189228544536787145345883401181858893) 15941145914794937177093386304443205602552827651536706608400845076162777444155363739893353329726/23173686625047977587990304423741788120258508897732978034793987736019678129860415537604628640859289817332994555163435451240013483415438259775849311623195) + (num-test (- -2449440712560236858/3924161613720467738425590715321110829708355586356453490516463081317902575263 3313932993860824279/18392642760231276916239249302906853654153090246504347205856270072174622214792) -19352032211145724571420568734409847660231095572377236173431089875006133635431666731719362137971/24058567564857748536604240288023690440577404826273237225585673569644473540232022448230431237781096357243673961302816983638647478040822458289501843963432) + (num-test (- 2375854596996813469/17171542567603713573317138241061150416263899780234956304631913156611236192733 -1690236091628058998/115698505401619203741389026136939663329574241316722960060260525901879106902321) 303906786920788985464713527121698374469813384178920405503303785899916213843318155692692663023083/1986721810512032345893371071989737461519340072368099757524397292434629497187713075053126253107235936414498803590298681018206068059043963268488989361033293) + (num-test (- -9066703779833220052/53996509329904595759286231403247566365148374715934463324003880626270687736687 10104829441267883881/34350188217372122913844475743718288066233853695548819225257606841719829170673) -857068498550946301314281599902676812596945461499639532351672507051201056365247232693696093577243/1854790258563312749374056592838765632813507083399863975139987272744324437901043103651094837595789610803765303659351781344942305171362498886075754606580351) + (num-test (- -712905705954993103/38361275706852471555340413672243335795384295466685977818182375699688812583403 -3487523845474404757/24004509207225606167828624323100421869226668573968691661898194620137716910067) 116672912187985693533424614379662678476187446315443107971581372764612623068602629062267386180170/920843595906060126846114857872490000269306626188013726759480780006531676144330596572087176480154495471428384288229491172449159350622326294294528887818001) + (num-test (- -104068455909264700529593875361271227125/3443783531459345396 94266182755532992545775726171008609186/10986871169556601787) -1468019045636814162670978305715811638938423723806410280031/37836405995984502494576730289263822652) + (num-test (- 6250188382163250356218308848100308290/74975517450841979 10057222263694104272437942231238950849/1377150882331486572) 7853407001895533030925726629648778749078643531548391709/103252600010686800286181264132405988) + (num-test (- -325869560300902552275820653500571757882/6390430580148850471 94468553562411191993094256419298214695/11908765973274803007) -4484399064985071999330976874105690617426359030318059422519/76102142247451389303559481900024166297) + (num-test (- -93570528036598407567281714804477572547/1681213810574384291 -244906502561054838674546679498356325029/6878656438675875801) -231899320744132980638168050942881155823492361410591515708/11564492202898292712047439710761442091) + (num-test (- -81411835730261219386583131450337332863/716127167248934 305772198898084305417824619321954306670/5852119619187572757) -476650772889757879179369019399921041943854248979406203071/4190861845290706865359628655691038) + (num-test (- 8378821874364768218652992773582270365/264620166167099506 -235085292482743132422942426826553295351/5218853722286899445) 105936154887632142427944491040385766054707164161382644031/1381013939193345109641609957531174170) + (num-test (- -46932041053326337601984043288899377207/83004348019257810472659105973646518650 -172752976692389001100875729845538600392/64697064048458368935602368307247306331) 11302882932785858045495103305619355060523322049764297548269071809310077113283/5370137620102451116225827082734739449691101289924623877117727128768254573150) + (num-test (- -5215113722152182902641295804790889582/37267147737183802417372262122851319461 -174324915479281952095382231256728338942/198797486533978895289571841018885549001) 1819946959828587625889363843813156766676787993042778284071188313098762447560/2469538433480866339929667414220581052912334718874062150193407525506073469487) + (num-test (- -308468863588547635528373349890793262605/277175417813474671446046438490775760091 -88071245580784145343997181342216325733/109042592277517238289414020635536175644) -9225060231388102579469362745283215538990500777711808852192407359260779270917/30223926073985207174135233898799350451872811382182855106546181559011381423604) + (num-test (- -139281160373255540085888405052544101003/21590054032847718908692432707921390245 -175128181843395150044469443628898278945/101874815793501611839718166887463701141) -10408215647857282226079103083273257459322595128147732742048301223816698452898/2199482777568107961766315941206227462112836158088743951492692685709912769545) + (num-test (- -13653637423911886957204229566898836211/6724361745919744069899921221745423919 60537422461958273742622747790343370991/323722395245687564470126807800714703749) -4827063738484690108652046326448960810791170812913084889649499536314520788768/2176826490887613088066161490358401961235974091796973399049221882998503572331) + (num-test (- 207284509647982883454717074874778610186/315575836476247924963087075944676754095 59454580888278446469281150437143941047/3799382139920332759258392540934029749) -17974876032324524053425850245755672169670471578477359535347261991433397414151/1198993196898275844180025803639723883733761367273976879884312817813487572155) + (num-test (- -149255714031984711085009662216310611563/61209488724728410476016289765233999883959861482512968048939594260689484910535 -206353007879160639705730135450663155/12341134377195982958424940281067948493740598784362073339140017508008773524522) -1829354061323966095884091779117676852909282652562065419187935424186237303685407507859167669375269438805585201409961/755394525511335693198081866608161950899365908489933659716533239785460293292606918153507868614180865950008697266433342863460741791684603303270127798639270) + (num-test (- 286228990947356503137685907205210886138/64525193112922470913382853022276019736227442678252533126077234112153953877503 -93778927468512815169462456699065596479/70019706577332037325570327903202382111804035215024271930215402736305222068556) 26092773364888269343302672267572690894453186378630697330693315371426642609003667116358459590920104883240139740188665/4518035088612517412858008269349176355736855744033363257986123715832709510554983209440815107866748014413528943649032845277041680450752670951433682692095668) + (num-test (- 128067958966292694713545212085241612749/50804897676960765097908813878456128842417954009101908722816951877006748778869 -331437715897535092432788513322484606485/102911257177761006574263802557003927106564530572416215828322919550454967864323) 30018293903870953799879886574342637699455128356488843398998059810000258259055116602688738404467489640369684487419392/5228395890723542025866546462435908982096651119675992137235094920338650164475761939608730060759309002063498665792819192135030537577109853650729817121390687) + (num-test (- 27065789167947870065829490227927612633/10795458608984562931374526676297845621730864739104955678079256994070639461197 53314096352440087811254806167289750292/44807028208492548064750449353871285104149154384082409595945081934090139448067) 637187458285170434834128234123875152637450428605039275620795715002449318075555518355578432548587274399560043210887/483712418416385035748598509413117409273155809870339120248356475239836262578288026980177669113025449532258001487616187498682131415946755647640047843156199) + (num-test (- 275528434092876314751862670579225752027/23290954563951481764306221308726902093226107549717031306984541394996363441752 118398743375843543978994815511147957868/26050691402435592629863948804505350954161759382372519491414484055670238339031) 4420086456754111377514058698455330162869575963826459083894390154200727636413353382047981846196341965799691593361101/606745469813648893293125236863835131523556569847025597910312571817347251611730291043895952533706547565767925058454286630395458711598751591845070996622312) + (num-test (- -263828172858355421790882308711676546531/27836884730007976814146538035133148053942251062564400015534567388490010158584 31580638196736633522674344981675107601/26210154715367115936541726366619494863883445533448748701891278370021519416412) -1948520953518189888695889830515156795224640917019574042614412953331052369986548949517168001067643449389746489215939/182402263891837359872743630675214135004512597266032306942151126033873543370078488920825920736994254287019873146147276876145783659805845233146169813070152) + (num-test (- 43029409555492054023102681165249027816896930295612442385573977041111849786681/17478431621804970398 -63831159286570708329826084149841946467426290005331979697932225104261019322894/15909114936773208135) 1800228375210677909820927489860838061135888931548234366640994061734196466170531105718785437541747/278066377585826623354880511023167787730) + (num-test (- -34677827126365037739221949705076349308552841821108642369491195428278121711851/12321935233094032355 2466652720703038662112375481129216761044838204088317060529010755963314905661/458077759838279587) -46279076433142446690218423399092373290016631287423134630356063713373023144989129659854095947192/5644404488448083755690706619714037385) + (num-test (- 75657421640076548917316021979547903196453821552146142751737530624725671569062/5416811919979369403 -51031635143911513328361770575139950616395278082588474953679149885798666896870/16274277637120569843) 1507698654622877634185545368063085304919907004898369478770589865697455127479301592176158803465876/88154701093808389139357381843158713729) + (num-test (- -86696779369804422745383183615836359604633179506005810847902134850836986706763/15354752711854066426 83875579121692496325618937810567731584819474189441279434601944065565889174333/1890321146489013312) -725886765676185953186290796464189476910148783977596698524963064505627422317719186476684911836457/14512706875163632554860591439823131456) + (num-test (- -2824584270835350806110810310308644313069326027498380007733023821989145840779/3128200028313826545 -16485532380752962986834975164722153533427821569516340079793116204530103476885/4044901389917631001) 40144878017198534388242075435853869853984060096218401720566307902396394251666454424383286522546/12653260642466969643085415999628721545) + (num-test (- -71140717297594692514165816539390347954764512441693085945645019026357644035048/15130773661553937219 106518314860779634188990156539381479314908411240039365434170935270962911954978/11202282371121185733) -267626990691150539404999353980899804835901788880218020004516046839225745741587662342920970677374/18833244338916713919008552672213388503) + (num-test (- -31372444086039981530710911528326367048894875160807395940269724829549418985367/149682691887362386596593782520991059630 13980025800771566396092717430902170466939197897483207383178768135899198010674/143215924045734814208985239450703841431) -6585601463869631351127457963734548845246885851328680299125624347680443020577881573937479731612385878788264587830797/21436945032301618223045694723696447349670080755369221855700055538448185530530) + (num-test (- 60002561005149795132492915799111287923312170708430066011808292212167201814322/16346766380600148228286881361520329811 104734497917913613491539581495799848702023341599268915776996571583385896191203/61937476024742321910315674059586179787) 19844918952732846654680216616282727016967753441473733514766184661191061075852141231786969917096326062063227788681/10024529215648371311559365663430434349900555024451481776473735938354274557) + (num-test (- 78980655687309201443760271907411093305339297143458162112992101000746746121121/24094471248783344167514231679460830840 10562090177736342378322146805187203837437609238688017154037816697523731420573/74961473522415640988394298626742882726) 2833009175986364875175323375606672657538996734036576482627590142336455915129629838687125527863027857335645122892263/903078534276138789186206765245648729133926893901427360507431923032322034920) + (num-test (- 96507496069338193466683209170737942070468924698476218759487496209308948365/19252547784216386872197161331387216893 12563973560096321588715986952435909079270363887929001032891628645353358046011/79879611474172059435223762585596250921) -234179520035021783886726161079163865833895106001667476480293126893061678147610754451356994012799045797572757769658/1537886036891137155393554113191390737924110193971845147480358562685078008453) + (num-test (- -95307376781556674397571761484869767912211504027346871580288574968524683908606/128329921725822403056205582017133271311 36170894925879686192917617159219095595164782822289198001474013555499918728596/240886887357120796976726436320063138705) -27600105449672599524131749634403660999916186956076872373762346977331203119722064380924286397976905109959929163304586/30912995399316310109755266138690547023211992922143297688759057498082990192255) + (num-test (- -22104893896795356297688360407985617971036912713007110938688208155601366216839/5790727918973991999188987227357894380 -2339372311396919406471876113751500811577555408710269902369834593304924842262/12937689744925498650506694361349920911) -90813196841584888136609582546105640167792279132393576014002859436259486025871518847027719826829986116492656710923/24972880404321196721702428178050372850585634300866259560981343234830460060) + (num-test (- -3426218098660813853559652497557253942819662042768623922183022792185928242671/2077407536662385613357832628600529321326686191757127715026249042748302985178 102639297566540827510784861997871251414598617775200449087621943894148321803293/83089038429507982364103335021257902316010144851865721965726693103637274338545) -497904817589969304680335736144278473886197067420059149312627956679073246109792679236301202959163792633927112737045328517845259242265445360227131779644849/172609794647490471018785535271654901168315737813115654161745630290269473799997219289162551586864155467201760250711449118429648095083028041134558889086010) + (num-test (- 1543899448831604569141696144740105016328586790221799945430718394112623114412/1094690716976737526626281319975432667416762320123576900412499904933271786567 -101835025746074730017715423582062511397387458863000475669454309217160145993/55116548932808468782187525862059393507883043749327746382569396580129398962) 196572266866178229534134252625134989714563665559807019513454337864363053729628560611312158082929567528955985669620113192156991984486011150099776316375/60335574468539540262844259780498204139853746803235564167348945699931512713417761400790104247218084745081610815218855896912895393599203789305655343454) + (num-test (- -37581128364300495505521143552535972339959603365602244668159915869829949338997/42947503543372015019662104425995959382231280059683481488692141811517675950053 -64888994735350842409379226446854438865448614840503930577860382883594178287934/83188698741706753136718468601650233481619465918167616089202536622553688681087) -339504834548876267781536981106771553482515399809961247195394672491113984585270709765073243997043174508213253440272888923497173265137136111635177948889237/3572746933977957867604303713153220827104741303667912510494658617478381525690274918494624922428110123336345510454960178899375325287131764283538305257747611) + (num-test (- -16230533405187239318665866908175768720879595131719076634847964191318368133798/22572606803697929681675696479626869642065470042484269772607381297011844085929 -3238806615045730440879378702226410558103197865253164974472379309242480970831/7167633180423354812410246140643720752789573307606828791458541239290047771821) -43226201536346598702395278529841763047400215735214225929426206339139243925579733185594282160061132691154727543083543034702325848468839969037250195569159/161792165494835249202675342837643048016103040739685489755239980324180308179745586573032524649518850731442178659412287492012066453331740508600962908806709) + (num-test (- -58154703770626762920775801228739843350302933064569814497417973139312614069763/25655935043535628671780902110427599603857741303802203417196105196580175051005 2291927744682353823611191393035210406213286149316388597509251757479544491322/2075117977066796442381930295725401140983312287419314083032058820231519915051) -2848879691864593463404526996418656511058536739346277043463623510210968076493148319480555434626780964688210750895957968447300033820091387019574369485421/845064952814266442598400897276554701819815257830830535600041451476645443978805142044657833921127247033533628716506571358424324423237490438402971304385) + (num-test (- 16233726784138742204308718138203086218138595789383817317246449554340898453104/16370584482945481446847872945862788646563748664837147378940234530469832625057 14431071141710676049963542765626402177344958369162454874051268130438178883381/21166786163219212747261378458659387864767326410261049063051557406799162784072) 107370754167217929909136144689909613387440429633745577224054233373886366171618903318258855919060113440621302505589923655976636732694637334616990468681771/346512661117421566971293748815177161526095870176610277140325665174756629068111228154091043637596506814557119477231243643171068111260010676990408227692104) + (num-test (* -6520062188352981842/3213004995534018829 -3812444292971845716/15284944374811818089) 24857373879807849010516976362973488872/49110602632729971801355498746248797781) + (num-test (* -844583948128454879/4750740551331102615 -1309778567130405125/4885884698278749707) 221243590680205607733892613510570975/4642314113048197066962569716783636761) + (num-test (* -4579815856418431271/16947444571374397297 7990245706938186906/12540719430158043191) -36593853985314806270746820601513137526/212533147427761354206383017714519654727) + (num-test (* -3587966953201943536/3194797554208122281 975954052071387816/2707062718507963111) -3501690886675668292903668827990357376/8648517352177231144330968693325176191) + (num-test (* 710265334225408429/567023629756400552 -5578988760400430103/4131535930210536898) -3962562316545608552741467762441538187/2342678499616965424161446427863567696) + (num-test (* 18305319006789031727/4480148641441744463 -1641093267260986094/16028097657311023719) -30040735777106040963634910981471804338/71808259944297590021537032075729917897) + (num-test (* 522499067029593907/142530390958606446621834761330018829110 1567459634764499377/31663510497342378306792964160850079086) 818996196770998943862055820464495939/4513012530308148429025282037949729145117603192483641232823845248212618993460) + (num-test (* 6214041481074460220/139497414619784295310756757536261769729 12187470171919324678/129216394212432939561557938117593031955) 15146689039532873328968703771155061832/3605070583825050709361064709099418651298807367637359842488375232197429738039) + (num-test (* 10022419596195177499/91129297586760817507648681092594591108 239769653037576215/24086455608554015268646156321002022494) 104481394312031409685890479072416795/95433990476618390508514520731482064738017476445225501421324446942302103624) + (num-test (* 127731839927226607/59760640855511386051149338950192132591 3679984267166095161/269870724770589242613062477043917992045) 470051161348371979221331000573148727/16127647460431744118786930146746069875784110572380855085272434637353123238595) + (num-test (* 4919926511230586366/29288587285987487013553554568227355149 -2914615432991234299/34407808954885309804037535414452526052) -7169846869407694119621783007930483717/503878057947370143933800273784055481319429768630967123178484618174989420874) + (num-test (* -4322680734125283661/246950524730861178141734701180345535020 11581515233057355754/82204027418720951285150957025638971309) -3575942340708251875937466941988609671/1450023407574517046920597087724458064116343346221474061477327267648859624370) + (num-test (* -5552456004563371781/36434418778024040927761226774271610950778609263056622471030041615086459120568 233319937833204741/228703279535756717601739981368829304509550463672786894384479957768850829340) -1295498689806330283646616799874813721/8332671062513255913250553083541810221054209355142441164334390514659539371361850837178162594438925276666798780352514152276296209564179606228713851865120) + (num-test (* 7279569964232187047/36316165899095632459738478614507512808578186173163489609755035948221062420580 4568992288187244990/18279847281938710983382796940666233712517527808023718591530848159479207220137) 1108676634263212048809114991909788151/22128465550033953372731954247755694375180631486898426116907313824243654714198100644737500721615620412852035450119116976232805701601749863504629937973982) + (num-test (* -8689289043809733973/34365105035540924847908154205433563929060132734873649554594240958996510665976 281724695877043289/3383396067954681850718083474385093262190311835985400909911383280975222535225) -2447987313255021583629117408894957197/116270761252098802423406562021935246701911690887646043563899994409915142686943691634418411056232663942535537938126289647041118885713303684881867869004600) + (num-test (* -4176416206981759902/47077361360975682486641492558477246171356187409295624938308162261216397376441 -10870319933050648575/51626085927005484523186190379579228801774286705829757742503501130303410401261) 2670528255498212232918897515060496450/142965876637554026205455979922464979254073063785755559223760631646970673683621524411341782655829702451013418009338618833412062193643308417898164204593653) + (num-test (* 4496049401725150702/8024116634872885909638996643719901973664008349644172107626390134736213108465 -5231341280619167012/99267989241776204190444307671763754306088564051099822830201760217121508089279) -23520368834947889555464127765407042424/796537923785319116837266627763277272873506235001122453584405648384893204423914484193595265931840447141766909166026026228531619859740155558402735330646735) + (num-test (* -2488955833769033882/80573015130339486598712021266263458487997757617589137912729682647628329090307 17723590657579960683/79078600039601362101827108583564759878924923849842119643649415446502020994810) -22056617181258995266120581914227430703/3185800618738432636378738398589185111057563002909241393794402306079667392482341108052833514927720630087013771419748846412352850012097731569487991234153335) + (num-test (* 24410613567363183821142175154197794689/2233491913446620869 -289777146895293391500645889398422195537/12394177861163531771) -7073637953514043162500219088395995153310329907185649946877180402954938102993/27682296026727883467940485833673128999) + (num-test (* 15029397898618080393623393093137341347/9939158597399833599 268484092305118852707129202725716126526/9752180454987984749) 1345051417567645337656755504737828287428006597367109244226136136424901090174/32309489404196149853047846865649927217) + (num-test (* 175291724581304230067306380062677652261/4791591464449055089 -207911166974886786162808240992513636954/957635297799905137) -36445107018739410292029741836217649994267718828374576884161821761303211252994/4588597118993154438342028473487092193) + (num-test (* 208446980882041538439350888438428103817/11756453246592156788 -99855903858077543170703702663212319708/7775813092266901197) -1734555140205305628415286772698507060801514301420325900368570916304368260453/7617998589456250715053087609460739603) + (num-test (* -49595797981179247160347259926801311825/16426101929443877636 104499598328969971414586784725010079457/3085074725343747115) -1036548193567594227670217621556353400490405002875929378150074378019016735805/10135150379689493069951723318357604028) + (num-test (* -288919818051255959565698296502103975540/9373352185361138021 77343596824463059344208562767410464067/8355013728778983070) -319229970313622361785032672064391711775428287673147624981393545586243098874/1118778374191039878067165437747032921) + (num-test (* 301194765217764762175383920433701358543/150076401641721289621709469985978858175 -109319143590504335906407585568245068241/158084148208214805386290412276525928977) -32926353787549066990014316879429253235742017240010356390402491456481443332863/23724700119685440084214937112355810539035473428177368317381421021523605836975) + (num-test (* 14575317438235510996984657523859363247/6747043355688580686998987940004831062 -98472042392613093668204392119412188287/152397803267436514292317070561082866275) -1435261276663720115408306632770383012566806521695455296458086302958691687889/1028234585957093005711368462502470683211464374115746651290896689614112234050) + (num-test (* 7543367187310376010646193530301789591/61115754966424662873097894247178344192 309940239796651595482411737112678240799/200261667764086238794802895148430893795) 2337993034909171213000031444662193658341848356694420878002930517675329723209/12239143016237439360279809707749702660797878084581096344749106125186707088640) + (num-test (* 306232835922656327867425959604977465100/55646521674811091128956181530575055283 45245255551837746690160535427248646677/3669533234425940180962041078287629087) 13855582919684583969821610044729507626133731299765443289084519977056998472700/204196760665922729081584465192637337445710456706084552841012480810023816621) + (num-test (* -280037880297253633994139513185953058494/23798550327416056573646642830182072429 13967268482262630670960486883264178489/7947215947745048068401387767511847243) -434596028812829556627014314125713048434599389957141408329542154357763726174/21014690966139335562014814134594464675233042588696546668504776333756662583) + (num-test (* 87160410649223805266866345018804635271/204719779683096591635231158476535039583 91197762560765392928084914476898132964/277206223024759381433146631560580134513) 7948834435086720002947247338196997812861466884983039250681993725808882173244/56749596904412078223459353928850191672356004665473536520452927516595919428079) + (num-test (* 272801380449749740391855824723351316848/2170368723435176720708253536680067463416474841046765138040214254204061862261 14545537787709209389572055399030228996/8381323291479119825335849511027103148981778425333781230074116361235206363821) 3968042787871071204066360146704950989545352280096012736206796950415592924608/18190561932825050861659739926693806725838682397154479213760300500132465705680046683155463862909993066621811136554677896021527098482779305371951555659281) + (num-test (* 58980225701104541897366713189611773567/10973700523953435846969235385386214078292603476932194022615006557054104506344 21633357583056027790037764923811848217/41236459355840549300942497778444413350482341379076368704834339005347182486274) 1275940312921345964633100864283753667394719832288287163056787891633576680039/452516555639171997520308257003811683819837367444947027711901120987864272999978391252372420644671039873982401560595091423172287702745925783369137325922256) + (num-test (* -39569537110370574225194522625562874655/36290593978404925051095380486087641410218299612051669925683823165483928853304 39273660356839128453616088747231247259/28875229647500294680887983884278577441525691250738380954940513956990510132534) -1554040560950035541902707236381071410695075315482961522429891905381129320645/1047899235170633560739863801929205639611958070150694189488499584527041043137082563721218908614201921449076002548982308540689571766482794493357171683792336) + (num-test (* 8957762734053174688386697837976422606/712105675122280831038408324375785815130945929819518342973925027507219300067 118977607972668646264715307919875588738/36563306353035936296510796886853084280648109576589600551753305930842020963283) 355257727628119695756412145322380851760544279491883270008434507085780737076/8678979318410478400681656718586483785992423192579006235728835173903750764880944673586689792087386144715446501744012435157310426693657188196381455479987) + (num-test (* 114386050140129336980347743358441052599/11994188887964574384037137314302737861703229337059619512751326848591488081229 -50822174853799566513638003084407139228/97406657802317796912648600328217961853548397771614449630742570869667560514587) -5813347841057137571369557065847591420664634372223088557679866032754664253572/1168313852626327929522799656188055465298138284154709873285311568978496136227795809646907486798429717114923178357702460243511883684964123937654308495387423) + (num-test (* -22147677230189664783449572410799931501/75580058176304394102183955194485040346816524663599269056794063928343401057143 -127672554664595215026114551202414743739/35777311684781371234035985601066874920871049301826919955489852676067316906014) 2827650531865200718433745248471704607394596478050653604940563621773668622239/2704051298527551014378337257898371613519363350219566689647796093438747503077807722203668806231503452508016974614236112792032033672965127824348803574358002) + (num-test (* 3468729773587632113679855593063165286551216344725198121609354788619580819847/7106612002452012151 20863200733446307102600190583661606839853255577505815215312643683864543217073/5700246487811068117) 72368805556440529088812813715602124890901251289457147618293618526488567540302416253970205832659523238561757581481150988870947074663135867252252227647831/40509440107213064064897416415172689667) + (num-test (* 43306673717838918980731699770600730039727453611468399058203483818093233880231/6173575908538565981 106634227988568775671050783423559067905086861634892257032833451008548321218936/17988169594879808463) 1539324572884864883885215269788177741067901747630436643318399808029602335378536990210735234944615096105103848497832537965483619535769637171783464984418072/37017110149885307295697375341989232401) + (num-test (* 61636028396239445662576777415312348317278054920190931147781159688109244233565/149659999183936017 50280832809996410949441105432174396823883728565382915986396125237655209339731/3406752842984125790) 206607389257567119017662603624829733217835095238758046754428174885007999774491792658838812826043033826701244157167565054600950156595290052398436186551401/33990308513391731439280046802638562) + (num-test (* -100579490802304807750359433955474958462342659278486016345156932756807754105945/15683759624513404963 7314396152134987983181095955389244247502417255088677055075146925285457081540/950287995699608967) -735678240508074701153113537069655056596152436111651040530896921701439724727486696483134676487497031899584038731663111390949471467249259023050011663755300/14904088498613295322494450308817103221) + (num-test (* 25984831699359211750216710442693374608159925357093100400945034699383345074385/10463598404993207796 -2395913226491242076662067669730978955981403048697660449593722338244504668974/7015215522730452775) -6225740195664363384298636893730784883811595661227613249243163802476751022407971476247993440178871949687923603921101094083879668063131450147131783163099/7340439795432595812648347200273983390) + (num-test (* 5173661857391320950903772549611256023540539838210520778403003347430938670915/2590493168574884173 100300641976357496491877756123729102910724064566692821682523911939220592349990/15304416107565779147) 518921605664943617990486317157527087053001312760892500249127957517476408720600460633868004681188890038115877413554399588737851074382787744833707113540850/39645985375676570588146199684023740431) + (num-test (* 30299639015164203561126609159677900559022306879488518544803392527841364186955/97638167801975054493877206805944332747 -50150465496280036231382225902610460555496341860773955714344071185921583266663/170117675960786609061777750278261277482) -1519541000979732808188648781832621044050652591754537200855596768903085847105531546641139177813880505696192826380113425984545675787584857974943247950981165/16609978191541300835961154615181304582159561006676548938424954151558306303054) + (num-test (* -34494394944257769716276791009665812125094062960425641316440943461722789694119/69239821080832171466311153221314488591 -68027404272124217088707268142523090163964888591405843143848585935878552833247/257149529774225346004390673137885895872) 2346564149995340998782934409780604815295734898030424565252099571337345550054284934036215402972664245125313098735082896555892607540059632597741979943574393/17804987432587488254198543762235568841018786223139145264591718687823557996352) + (num-test (* 22330754509472350470460807673039908304726422770752644988051418230315708975569/141163736844241522445115344332946835969 -3776092949566234532895208849184634613770861313997034923686862122594334787771/22367110097535579962848998753563258272) -9369222740190326741203615957382420344247102784278353165345406236082475331042528539717966581690645628370939381978953360215380653092335198860022382107411/350824982641632215769272917522017419782283768012468846380070797128085153952) + (num-test (* 1376215273451682681102140384578115142238259557166158859699272578561460124263/3593386179017642636485249017714833669104405991325015697577507088650274886871 37146275008876311604039415809582675415172661567487888072055609579242279390723/55424998453085285819414374477780690192979527887019008768378662580126754826472) 51121271019052119686352858568900325361226598163234091421115939503875711782442415328681175322030659510284806538410228985354770913411724825992699509412149/199163423413390889071651575953261174839972499014963134990506980080139461063269751906284862132821075544766093817070661266293471833091996501160433036049112) + (num-test (* -88175289711320073148300791156190227927348022787624424521937188958291199926437/38194742314758366741668899229532351990874883495690656157862650973602784662629 93421911195279228911508870033119580111709458306921869937709821511660370035352/66371395138592894543765954603571534463846496049156722497129962530412046587003) -8237504085028962150049531747535213236460729066521397582683209771842938254589363802757604921456170821878391951762499073662677974506165863935238701489400824/2535038334389561782321790943041741331416028402594806464107449488311138037598457377927652600804722340759363172755193254192462811091332303758223034251210887) + (num-test (* -88364214910455569163017945328431687038422451206033411348821431934742389780753/43010507830592044720656702803904712217809857004582018186125828892174875808576 10405170283887792832024806983921158923908589830001636723872220129826733402834/4055629711949631304631599195955105801456753694558712994574702123032807265321) -459722351572673455425943766571506569631562018487574498847133029199411842205331593858852090421782204158679934054007027833206633183796877753882057444427001/87217346741895687976684378003169607737518608233754137677854312677618987931466495788077930577814677920791330694741284253568592140275298729115088619596448) + (num-test (/ 7013212896988366906/12397903473277899947 818833870013215068/2125577647443895255) 7453564285301859120853045020886215515/5075911640537211768265804260348400698) + (num-test (/ -15781329068048599432/14942574238341613337 4388772934226358350/2640112802717985697) -20832244458230302534551181278529162052/32789782692450857054331267544650656975) + (num-test (/ -9015230453321124271/17425619133302730035 -10422000746814766599/14972344381173680534) 134979135022768387806775446187867640714/181609815620990738305316999098032100965) + (num-test (/ -14741075237791868512/12448692140900938227 -1090381863721238817/1060836378253796023) 15637868866825840780217685066084527776/13573828137487503515304766902031557459) + (num-test (/ -7371815071140740177/4722722556038701367 3872455829192658988/994203944294825175) -7329087620340161131469364260313555975/18288534491791723206480607737200436596) + (num-test (/ -9856364379969390509/7988230468709836259 -7208901117187058135/7430860779232874136) 1093153305924514768551484985555671272/859497963436269188803272225817371895) + (num-test (/ -16740689272507881147/56924866550406451570641164619431212169 -14712532880452686095/143481612520580129383584255576273223983) 2401981091525408257128502717450566513166280001357873948501/837508970838236191644285394369194561392491093277901090055) + (num-test (/ 1874027699956565000/65960003455647360668413772300355814843 -172394881832672950/2006879686300828197846469567507151887) -75218962452157875130617756878839223573611935155763100/227423340028380523596387094039260091189651621559491937) + (num-test (/ 851521912886492079/58839621451933520132430725102159653727 -5525838657334730480/268863138354222710211869290179088409033) -228942853876053297959532391872114722003932597144466549607/325138254802036127673497464266072288930584674567672498960) + (num-test (/ 2130823024472312937/30463932363736038600114358208342163020 413938864244113775/131673792970459944919771618253738144891) 280573549781056638388629087822719475587456644826399754867/12610205563054396144647765193069861697742251186477600500) + (num-test (/ 17234694073181371137/253506951459931119968572673772742357160 8407879684613951161/42697666588937447817581914537644794355) 147176244259806896721181660841298454615950364713859506327/426291189417673978158704851675227114861497071554451732552) + (num-test (/ 14739301038477826821/4801125431810347467140397350459581435 -1752125940488995048/127905197451270157484305628763539243969) -1885233209620217720514367144506571751170505057476450692549/8412176412616337518572109406238500578932979745867733880) + (num-test (/ 9194848570227974720/45448499872046683203864930109076126035374684748838016011669264943000310475483 -4572473918523931944/28941042619577200519536336906341131911598596429670188136734086846500956354149) -33263563043940787786171015409141766453199063320923723716765930467953050399983260590187417389160/25976510037621464639740779963549572814837984766154635046133743883024710122710674726552171566119) + (num-test (/ -2662376868940711929/2674240208804755702377222409224408783678596883960539287029565653749020338064 -5046618244273151929/26826013625152995057141957222948811537350409769204161465077735924332004069058) 35710479080747854012875521001477955195584454274704368888444222736697434540936425667291700196441/6747934713661461716612153292457811722283965560031580498434684530869001786777260513409206862728) + (num-test (/ 646980248518054663/28444849537262537816809349756569888989442483441699293309597267649158853799707 -10174938507557455325/16470612178414296088079890015341965945714023680627341561729034923083435428747) -10656160760434978971303471120231114671340660575734505071429575384684610862775940451177787597261/289424594898370460244167952344748286246980979584479610186308309369583658143095854438992150589775) + (num-test (/ 1268676597518744714/6024937921458004492480888468749320142603908196076058575752452561172018490893 17823595902143962912/85935047374548136904062562443188289405155329832270007415035044821925251080203) 18170630585125644385503771892175817370913744757273904248648000044618805359154885235028182716157/17897676474595109057512045856227678061218241143085827332930191066967148125532813505892133626736) + (num-test (/ -3035741006152688190/58890268425224581569217175195410848521985674465189565646495474378301884202047 -4870935665435665519/47998868922405332801456101880162843269583282603435159879276723163289928325531) 145712134636693761356266465698326002831562744975420904782663360472436650653549187025441059178890/286850708819506259357726384810790881448875152111132928069815447961129371272624891025817707117393) + (num-test (/ -4420263280205408439/38682162086456801604593696710774835436326970692840048042132553053971380151628 -758651402628235427/1755534012040040367913026343944696058732638465867705260088080517539506722166) 3879961265286134914514096239640695384126081133972137242327715997675029567458817030555062379437/14673138261791601182714628661554161812345431143865809776872034934342213839184709418896670662578) + (num-test (/ -312487180249669742743295380499853180353/9828632991038934281 -86131955660561774942466932680637336739/10268762916730341592) 3208856768501438660232746468300370677374054716853273141976/846559380988100144557815474234956961169507773676687849659) + (num-test (/ 105376075880566042097567073713047434893/11411565636673693365 -220737802783327232867818580441304577024/5817406274606660773) -613015445021032499619145665530563205764250055719854552289/2518963924957071797477174332253152325843619212749200245760) + (num-test (/ -311533429150518992652072799089375050497/4403073054828470603 -320230219907951760832723580313293021909/1370493254961533625) 426954463345823097468320537904981772054351338526938461625/1409997052618498081840381197699863669488222338862641441127) + (num-test (/ 305676222727436457375950609916137360009/2001517485431820526 324338803123828318219640932070020543912/11123178903397935211) 3400091311912189654145957985944153094384781502787164376899/649169785656371151621897383467144093766684841422885937712) + (num-test (/ 8845112929712368402815105446090151026/8124751572615311799 -107609110538267962880281203537194473336/8714443449141779053) -38540118213625599008519681983731393728094066419546629189/437148645036763776481446937412401903340367189496615845732) + (num-test (/ 152921217721894690043853278309581658066/11705615305395353865 184187448038871874764725486848823516773/4171619104693691390) 127585814672335876029018138907883882524550368713261650348/431205482165106014329333719781838993214328411764819575529) + (num-test (/ 16414254293541341780725162107696242521/155838132618727968561620486302365154071 323320173010032367023620851618405869489/49801924105617352177018959505967933104) 817461446577249670665800625691379410535771218196808189195363718417488315184/50385611999847495177988476252475899813264458225659097815552272081452203039719) + (num-test (/ -188149667625860588508273820953820709614/21438745582767797684161462130971215025 128458309657689922121539794960212789849/134174286369366827879740776978166655691) -25244847384333405496229128525982900130397411994350175944375943735942831513274/2753985018743617742875555653653797261370358442640799457019039857068516281225) + (num-test (/ 1218460641064115152742257147372113443/1773382194117714970762642066492794929 -105212349758139121832338365854603836112/35045896682356785176328011712384921341) -42702045738251194875426595475683618047253961691478453648029952948483687063/186581707662369193907913729212042024270164277319717456729276609131940676048) + (num-test (/ 1467722271775252460214852151179762687/1747611358981474614363356529179985509 25495740211005247928144692929451604259/29615224810946461612486375021101910565) 14488975012885720730598332784736375353299643425098519766594278819666029385/14852215066131169889445443721709162270198753408805825268529301698140894277) + (num-test (/ 6278399735526726207674375684072448068/13890681759576280617381650633747782321 -112063146811220963294237186476216238443/46495820670393894026441353693945662660) -291919348200099113895651901892723884699250237261456280525601785996696740880/1556633509331345870779770006255469001211806559199158615405344674499795966203) + (num-test (/ 248406099260780863433196593538936526373/315762135750029127758352280023694126018 -24578051912523675039725210046249323571/3033769619337997374435389027823294736) -376803438597807975522050212312559316811899647514236724224019181136008036264/3880409082236781853269738100403484871805889674074731389226471480469265885139) + (num-test (/ -305871752543087256004326578375555909668/80170799467978436032303243749692785696371676780847080230403479135749775915991 -208573266832391890136462745593008906685/96016271562601269514856687672805175650907293023094157826925793080307407361434) 29368665255505841438632782694581946057561031972462112644657516768267440383833513431444679871238206541553985530943912/16721485549600848123731461311227384049611071114404954309505697259277905994635125654414916826332204568970567318299835) + (num-test (/ -171651126582338417143004525987733942986/48126955023093310081685702171788275811688444573315712039582092051531229683107 32570134112026732491936310765048378699/18584159151613423191553551933672204731023422884196280183931777685641069715348) -3189991854959918631828923606391779823799241149346421336570141741355492000935500642040047513113849334779592681149128/1567501379505627719887579027549074087653888429037997616626567546431482074522690424133509833932668944596793898937793) + (num-test (/ -31304786393644787215292629624842492472/10539846271603297974613179098685212701091372728582260780054561526149580513583 43496364289252206338797704034889660065/966865502932307025364733802774045297740949567802356684866342045679773834966) -30267518040679809082934454680954168768135550720881039440573156734314284479043791824457029301083428211405425375952/458444992982373700837242411005687390212275114474481688646320865335043970683786989531994936463047685893258985162895) + (num-test (/ 124366625369659591476708994326732418029/107684759001536292829359995221778346870065030877016948429894748600664800488759 -90949754058598173499067700725927605729/79727020098830307921496202496061295138733611655702270828135321391380898414003) -9915380440470549523296226431396644117384598256053664887332801972488440466568616812942647849957495261151611303260087/9793902347049141646079571573977765974008832433473016883117384010293158932212528563016145547341801740792289848500311) + (num-test (/ 26792084925762094333829722201654015569/6815899891200140342329613369008754659665480100088941978786466272502677117648 179968988142253715757129058636648023126/97033837835570527321466682927970125702018459951415339098532052222053589117353) 866579607987744230609336186273867662887766686833260209925103055244528379635362816895584608387230956963010276689619/408883535566062149539621907018509777969515872715944952500700527207173412646715462423653890585029605025758308909216) + (num-test (/ 320794852821756057819990044473359503428/42380074203350930293358543616207018031675687905746455222111844144668904183229 -11813439835454851567822019323728871339/51852159737956631156972450987013128151750117741949546305537111598356497409240) -5544635317209327550045071802859986261979158492907374734760649234578367469399038563605323839330681533705071632958240/166884818941132804535892580774781586387104334774784737031184369589400544303785250219152004898392301479219940857877) + (num-test (/ 63160395612932962868082774785156358041658469338654564454114468396132462549944/5671929772244157797 19541045450680948617094710246839287171374470593288265457341382295544977156173/10827756125123268218) 227961786821047895774887365257727015864174017882302289602409601101722343657899277052494444293264/36945145824164509580938949252327087600266044162541122809277442696583642758457532273140841543627) + (num-test (/ 31389399613343712511677734270541516183531975055644318154870016415582858008412/11320913214023484367 -95931706646769408081251897664360951854776052790951374912970042200868629796051/14301831604104230477) -149641969141325406602881756591195860220337618158488775091717625369334526143115090325362684257508/362011508473745439254610688691597507367516106821889963803421575701854031622412859179610532278239) + (num-test (/ -50845041077039215658764589763556935122444212169574762080162289087527164772395/482986173890811026 -51342299909113507561385579724776151277474630060658338514843664853027455595538/3864573616937705869) 196494404298439669659681446421686066898686292162412914850963937042669022612531239234324840686255/24797620991857267698917294149872672843409173617406514673128342148521539559341861421304646801988) + (num-test (/ 76283614020376921713154299810619585257752996149145061806263596894412414185408/337890011287912517039286436540240936661 70530558237421368381589233382700323659036925075366138096846582768833233488577/12121510300837787759729092713205686989) 924672613133132744522463879340347327755455994321131972145048214329608890428265966744607561005512244129921459256512/23831571118985077324412202325831974453532679575894228007993082738742295289254461850021038245882565939546151124021397) + (num-test (/ 13518475961402756750057330871273933874583566313800024119371308450919239424622/71146816100737230880567880716110051085 -11914742388051168959634071864657967837347162591767656949770878950409478930980/166466796775669753065110807850377519909) -1125188695291804746273664719520877594103080002716204716437885631737502681157239448228517736957154781558316254899699/423847992785167635691798025732868758201476408654527740579259436528169254792708107390082891890404030666159494556650) + (num-test (/ -53624051286117226406327700847140806598091981633622544805551583455315188018537/149060170957501829683988930330276188371 -49540630291338976658332195799658601133012561780540500265134312414843218811481/313014990314092319823049811442768272842) 16785131893926373429171158665038393627227592608630727377590747943991201054188961463248027101037470630205119769672154/7384534820569381535972144752572408048556227885764547207137140227958732266609348654686668662110083737942669493487451) + (num-test (/ 2634758410586745842739353561704344884865889793873131750193619887157306355755/83106075320614705363810122092414199463231740446254118542567688658288107572919 10787649314660479714744029413883607304719873485501736976813666398631455642569/2439964488756696481271244145022481444549967702052558191280867337292105066432) 2142905652761565172685487282499186838096673751132490328620490049367034561455889328384026705096013173825469773464105722689198047146574263705663366838720/298839732158850477765824602476778580028064205733214070073086531571837859351705342746223206218407306637658483098569582239416197836311325170250187389329637) + (num-test (/ -1907320079310938642409293211056905401889419041722087613680756850005726714712/10387378553621846874105702088597026076825105075730032753153301604042569998683 113647247724474559442709588703965365251731833799417671287796250968092484717057/58756890421232187224353930678527831208703723187770044891160428018937233424397) -37356065632762902117955690133395145368676268194116097031480521390942668514422835237280325034441435052929702455487858500299401976652159912902024146542888/393498994563785425899168694480259206994308562177080555315323154941891277193612821825931878224565302417504072329241812530787363937691786269618438039211977) + (num-test (/ -54987418627898620923060954379316763081930842855917193391807940070173620336071/17370345837184638879794373707261631548922174314274224219546763452439685451597 107349939397731511365417710412808670916754334908520065561311453951414109180973/7800708635318451621630266369706695626474649690647985662113853436261704078874) -428940831324519456770429889832838610542119304716244392653623661175655561457214418178921042544524225772650432309479656622489393939407340321261255371264054/1864705572939408818246392762570376592749103793151936455808919833872532407312841098160841844995663367019074328670998871082130543124576872890789577304863881) + (num-test (= -98781233389595723930250385525631360344437602649022271391716773162526352115087074898920261954897888235939429993829738630297052776667061779065100945771127020439712527398509771853491319737304616607041615012797134365574007368603232768089410097730646360760856052946465578073788924743642391638455649511108051053789425902013657106523269224045822294981391380222050223141347787674321888089837786284947870569165079491411110074602544203383038299901291952931113248943344436935596614205784436844912243069019367149526328612664067719765890897558075277707055756274228634652905751880612235340874976952880431555921814590049070979276358637989837532124647692152520447680373275200239544449293834424643702763974403094033892112967196087310232853165951285609426599617479356206218697586025251765476179158153123631158173662488102357611674821528467825910806391548770908013608889792001203039243914696463472490444573930050190716726220002151679336252008777326482398042427845860796285369622627679324605214987983884122808994422164327311297556122943400093231935477754959547620500784989043704825777186301417894825200797719289692636286337716705491307686644214213732116277102140558505945554566856673724837541141206267647285222293953181717113434757149921850120377706206012113994795124049471433490016083401216757825264766474891405185591236321448744678896448941259668731597494947127423662646933419809756274038044752395708014998820826196523041220918922611359697502638594907608648168849193813197790291360087857093790119162389573209640804111261616771827989939551840471235079945175327536638365874717775169210186608268924244639016270610098894971732892267642318266405837012482726627199088381027028630711279130575230815976484191675172279903609489448225149181063260231957171204855841611039996959582465138269247794842445177715476581512709861409446684911276158067098438009067149531119008707418601627426255891/2063950098473886055933596136103014753954685977787179797499441692283103642150668140884348149132839387663291870239435604463778573480782766958396423322880804442523056530013282118705429274303746421980903580754656364533869319744640130831962767797772323836293079599182477171562218297208495122660799328579852852969560730744211066545295945803939271680397511478811389399527913043145952054883289558914237172406636283114284363301999238526952309439259354223729114988806937903509692118585280437646676248013406270664905997291670857985754768850507766359973207600149782819306010561088246502918148146264806947375101624011387317921439210509902170092173796154464078297852707797984007992277904626058467143192149921546030028316990855470478894515952884526783686210401408859364838148201339959570732480920969000913791571631154267939054105878236201498477027265774680071188764947522112650857013491135901945605796776829525789886482760578142306057177990048751864852763036720112071475134369179525117161001517868525821398753039187062869247457336940152614866298628205010037695017885878296140891234142925514925051385440766473260338168038302226808098439763889250948602137806546736025439919604390464712793474019469457135856879584745805794574609707742445431851999335443724488636749987837445626810087003490329257105472274738811579817454656532496370562155449815456374456838912258383282154811001588175608617475540639254689723629881619252699580383612847920348111900440075645703960104081690968807839189109040568288972353424306876947127635585164905071821419089229871978994388197349499565628906992171901547121903117815637249359328193980583892566359962066242217169190169986105579733710057404319381685578470983838597020624234209884597110721892707818651210378187525863009879314177842634871978427592746452643603586344401223449546482306838947819060455178762434166799996220143825677025686435609179225302671777326568324855229172912876656233006785717920665743720753617646617017219230313226844735567400507490772935145894670445831971526014183234960075574401616682479457962912905141754252265169682318523572680657053374002911007741991220001444440319448034755483178790032581428679303588017268970 0) #f) + + ;; these come from Brad Lucier: + + (num-test (quotient 295147905149568077200 34359738366) 8589934591) + (num-test (remainder 295147905149568077200 34359738366) 21754858894) + (num-test (quotient 696898287454081973170944403677937368733396 1180591620717411303422) 590295810358705651711) + (num-test (remainder 696898287454081973170944403677937368733396 1180591620717411303422) 314390899110894278354) + + ;; (map (lambda (x) (number->string x 2)) '(696898287454081973170944403677937368733396 1180591620717411303422 295147905149568077200 34359738366)) + ;; ("1111111111111111111111111111111111111111111111111111111111111111111100100 010000101100001100110110010000011011101000100001101001011011010100" + ;; "1111111111111111111111111111111111111111111111111111111111111111111110" + ;; "11111111111111111111111111111111100100010000101100001100110110010000" + ;; "11111111111111111111111111111111110") + + (letrec ((factorial (lambda (n i) (if (positive? n) (factorial (- n 1) (* i n)) i)))) + (num-test (/ (factorial 100 1) (factorial 99 1)) 100) + (num-test (/ (factorial 1000 1) (factorial 999 1)) 1000) + (num-test (factorial 100 1) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000) + (num-test (factorial 200 1) 788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000) + + (num-test (* (factorial 3 1) (factorial 5 1) (factorial 7 1)) (factorial 10 1))) + + (num-test (modulo (+ 2 (* 3 499127 495037 490459 468803)) (* 499127 495037 490459 468803)) 2) + (num-test (let ((n 1)) (do ((i 2 (+ i 1))) ((= i 100)) (set! n (lcm n i))) n) 69720375229712477164533808935312303556800) + (num-test (log 69720375229712477164533808935312303556800) 9.40453112293573922460049312446069272415E1) + + )) + + +(let ((f= (lambda (a b) (< (magnitude (- a b)) 1.0e-15)))) + (let ((log2 0.69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641868754200148102057068573368552023575813055703267075163507596193072757082837143519030703862389167347112335011536449795523912047517268157493206515552473413952588295045300709532636664265410423915781495204374043038550080194417064167151864471283996817178454695702627163106454615025720740248163777338963855069526066834113727387372292895649354702576265209885969320196505855476470330679365443254763274495125040606943814710468994650622016772042452452961268794654619316517468139267250410380254625965686914419287160829380317271436778265487756648508567407764845146443994046142260319309673540257444607030809608504748663852313818167675143866747664789088143714198549423151997354880375165861275352916610007105355824987941472950929311389715599820565439287170007218085761025236889213244971389320378439353088774825970171559107088236836275898425891853530243634214367061189236789192372314672321720534016492568727477823445353476481149418642386776774406069562657379600867076257199184734022651462837904883062033061144630073719489002743643965002580936519443041191150608094879306786515887090060520346842973619384128965255653968602219412292420757432175748909770675268711581705113700915894266547859596489065305846025866838294002283300538207400567705304678700184162404418833232798386349001563121889560650553151272199398332030751408426091479001265168243443893572472788205486271552741877243002489794540196187233980860831664811490930667519339312890431641370681397776498176974868903887789991296503619270710889264105230924783917373501229842420499568935992206602204654941510613918788574424557751020683703086661948089641218680779020818158858000168811597305618667619918739520076671921459223672060253959543654165531129517598994005600036651356756905124592682574394648316833262490180382424082423145230614096380570070255138770268178516306902551370323405380214501901537402950994226299577964742713815736380172987394070424217997226696297993931270694) + + (log3 1.09861228866810969139524523692252570464749055782274945173469433363749429321860896687361575481373208878797002906595786574236800422593051982105280187076727741060316276918338136717937369884436095990374257031679591152114559191775067134705494016677558022220317025294689756069010652150564286813803631737329857778236699165479213181814902003010382363012224865274819822599109745249089645805346700884596508574844411901885708764749486707961308582941160216612118400140982551439194876889367984943022557315353296853452952514592138764946859325627944165569415782723103551688661021184698904399430631382552857364668828249881368228006341439107868932514564375102044516275619349739821169415857405353617589009751222337977369696877543547951357129821770175812421223514058101632724655889372495649191852429607966842346470693772372526550820320783339280558928531468730951326064583091843974968222303257654675333118230196492752575991322178513533902374829643395025460742458249346668661218814365265654295427676105054777954229339733234011737431939745798470185595484940594783539438410106029307622922281312074893063445340252777326856271480016818715472439782071878034446780216178158419042820076721243255738014364178876826161041016818724240687908909929874208152183237528942752732534071002835750695062403965462752244308462588450859786253083224774538885068003488324340490083990058080943565282122370388702036804548600776214244088697259413584365999226211739670804950952792714363154640444623089158185367119608370304853520909672629582415040355995121355450332241748474100331981487832452569334704949937301656336660991903957122822844881674312150628569993874038819012744839564791034772885972119850649422796985791669956418551265041502191554719665856929726606523573293736830027830921776605387030462007661584946700226011756797518003934791763277844935142634968360037557857160700498181519184373438290934746660457750659273670121115370582496479847930404205823964753857850960626093389914706120130243108260518262958640076003059494321166880446106134684533980)) + + (if (not (f= log3 (log 3.0))) + (begin (display "(- (log 3.0) true-log-3) = ") (display (- log3 (log 3.0))) (newline))) + (if (not (f= log2 (log 2.0))) + (begin (display "(- (log 2.0) true-log-2) = ") (display (- log2 (log 2.0))) (newline))) + (if (not (f= 3.0 (exp log3))) + (begin (display "(- 3.0 (exp log3)) = ") (display (- 3.0 (exp log3))) (newline))) + (if (not (f= 2.0 (exp log2))) + (begin (display "(- 2.0 (exp log2)) = ") (display (- 2.0 (exp log2))) (newline)))) + + (let ((sin1 8.414709848078965066525023216302989996225630607983710656727517099919104043912396689486397435430526959e-1) + (cos1 5.403023058681397174009366074429766037323104206179222276700972553811003947744717645179518560871830894e-1) + (tan1 1.557407724654902230506974807458360173087250772381520038383946605698861397151727289555099965202242984e0)) + + (if (not (f= sin1 (sin 1))) + (begin (display "(- (sin 1) true-sin-1) = ") (display (- sin1 (sin 1))) (newline))) + (if (not (f= (asin sin1) 1.0)) + (begin (display "(- (asin (sin 1)) 1) = ") (display (- (asin sin1) 1)) (newline))) + + (if (not (f= cos1 (cos 1))) + (begin (display "(- (cos 1) true-cos-1) = ") (display (- cos1 (cos 1))) (newline))) + (if (not (f= (acos cos1) 1.0)) + (begin (display "(- (acos (cos 1)) 1) = ") (display (- (acos cos1) 1)) (newline))) + + (if (not (f= tan1 (tan 1))) + (begin (display "(- (tan 1) true-tan-1) = ") (display (- tan1 (tan 1))) (newline))) + (if (not (f= (atan tan1) 1.0)) + (begin (display "(- (atan (tan 1)) 1) = ") (display (- (atan tan1) 1)) (newline))) + + (set! sin1 -.3056143888882523) + (set! cos1 -.9521553682590148) + (set! tan1 .3209711346238149) + + (if (not (f= sin1 (sin 10000))) + (begin (display "(- (sin 10000) true-sin-10000) = ") (display (- sin1 (sin 10000))) (newline))) + + (if (not (f= cos1 (cos 10000))) + (begin (display "(- (cos 10000) true-cos-10000) = ") (display (- cos1 (cos 10000))) (newline))) + + (if (not (f= tan1 (tan 10000))) + (begin (display "(- (tan 10000) true-tan-10000) = ") (display (- tan1 (tan 10000))) (newline))) + ) + + ) + +(let ((bes-i0 (lambda (x) ;I0(x) + (if (< (abs x) 3.75) + (let* ((y (expt (/ x 3.75) 2))) + (+ 1.0 + (* y (+ 3.5156229 + (* y (+ 3.0899424 + (* y (+ 1.2067492 + (* y (+ 0.2659732 + (* y (+ 0.360768e-1 + (* y 0.45813e-2))))))))))))) + (let* ((ax (abs x)) + (y (/ 3.75 ax))) + (* (/ (exp ax) (sqrt ax)) + (+ 0.39894228 + (* y (+ 0.1328592e-1 + (* y (+ 0.225319e-2 + (* y (+ -0.157565e-2 + (* y (+ 0.916281e-2 + (* y (+ -0.2057706e-1 + (* y (+ 0.2635537e-1 + (* y (+ -0.1647633e-1 + (* y 0.392377e-2)))))))))))))))))))))) + (num-test (bes-i0 1.0) 1.266065877752009) + (num-test (bes-i0 2.0) 2.279585302336067) + (num-test (bes-i0 5.0) 27.23987182360445) + (num-test (bes-i0 10.0) 2815.716628466254) + (num-test (bes-i0 50.0) 2.932553783849336E+20) ;arprec + (num-test (bes-i0 100.0) 1.073751707131074E+42)) + +(if (positive? 2147483648) ; check for int=32 bits + (begin + (num-test (< 1/123400000000 .000000000001) #f) + (num-test (> 1/123400000000 .000000000001) #t))) + +(num-test (exp (* our-pi (sqrt 163))) 262537412640768743.999999999999) +(if with-bigfloats + (begin + (num-test (exp (* our-pi (sqrt (bignum "163")))) 2.625374126407687439999999999992500725895E17) + ;; H Cohen p 383 + (test (< (abs (- (expt (- (exp (* our-pi (sqrt (bignum "163")))) 744) 1/3) 6.4031999999999999999999999999939031735E5)) 1e-32) #t) + )) + +(num-test (+ 1/2 0.5) 1.0) +(num-test (- 1/2 0.5d0) 0.0d0) +(num-test (+ 0.5 -0.5 1/2) 0.5) +(test (= 1.0+1.0i 1.0+1.0i) #t) +(test (= 0.0+0.0i 0.0+0.0i) #t) +(test (= 1.0+1i 1.0+1.0i) #t) +(test (= 0.0 0.0+0.0i) #t) +(test (= 1+1i 1+1i) #t) +(test (= 0 0) #t) +(num-test (= 3 3) #t) +(num-test (= 3 5) #f) +(num-test (= 3 3 3 3) #t) +(num-test (= 3 3 5 3) #f) +(num-test (= 3 6 5 2) #f) +(num-test (= 3 2 3) #f) +(num-test (< 3 5) #t) +(num-test (<= 3 5) #t) +(num-test (< 3 -5) #f) +(num-test (<= 3 -5) #f) +(num-test (< 3 3) #f) +(num-test (<= 3 3) #t) +(num-test (< 0 3 4 6 7) #t) +(num-test (<= 0 3 4 6 7) #t) +(num-test (< 0 3 4 4 6) #f) +(num-test (<= 0 3 4 4 6) #t) +(num-test (> 4 3) #t) +(num-test (>= 4 3) #t) +(num-test (> 4 3 2 1 0) #t) +(num-test (>= 4 3 2 1 0) #t) +(num-test (> 4 3 3 2 0) #f) +(num-test (>= 4 3 3 2 0) #t) +(num-test (> 4 3 1 2 0) #f) +(num-test (>= 4 3 1 2 0) #f) +(num-test (= 3.0 3.0+0.0i) #t) +(num-test (= 3 3.0) #t) +(num-test (= 0.0 0.0) #t) +(num-test (= 5/2 2.5) #t) +(num-test (= 2.5 5/2) #t) +(num-test (= 5/2 2.5+0.0i) #t) +(num-test (= 2.5+0.0i 5/2) #t) +(num-test (= 5/2 2.5+1.0i) #f) +(num-test (= 2.5+1.0i 5/2) #f) +(num-test (> 0.0 0.0) #f) +(num-test (= 0 0.0) #t) +(num-test (= 5/2 2.5) #t) +(num-test (< 3.0 3) #f) +(num-test (< -5 -4 -2 0 4 5) #t) +(num-test (> 8 7 6 5 4) #t) +(num-test (<= 3.0 3) #t) +(num-test (<= 3 3) #t) +(num-test (<= 1 3 3 2 5) #f) +(num-test (<= 5/2 2.5) #t) +(num-test (>= -5 -4 -2 0 4 5) #f) +(num-test (+ 1 1/2 0.5 3.0+5.5i) 5.0+5.5i) +(num-test (- 3 0 3 5 -6) 1) +(num-test (- 0+6i 1/4 0.5 7) -7.75+6.0i) +(num-test (* 7 6 5 4 3 2 1) 5040) +(num-test (* 2 2 2.0 2) 16.0) +(num-test (/ -8) -1/8) +(num-test (/ 4 2) 2) + +;; -------------------------------------------------------------------------------- +;; miscellaneous numeric tests + +(num-test (expt 0+1i 2) -1) +(num-test (acos 1.00001) 0.0+0.004472132228240686i) + +(num-test (sin (/ our-pi 12)) (* (/ (sqrt 2) 4) (- (sqrt 3) 1))) +(num-test (cos (/ our-pi 12)) (* (/ (sqrt 2) 4) (+ (sqrt 3) 1))) +(num-test (tan (/ our-pi 12)) (- 2 (sqrt 3))) +(num-test (tan (* 1/4 (atan 4))) (* 2 (+ (cos (/ (* 6 our-pi) 17)) (cos (/ (* 10 our-pi) 17))))) + +(num-test (sin (/ our-pi 6)) 1/2) +(num-test (cos (/ our-pi 6)) (/ (sqrt 3) 2)) +(num-test (tan (/ our-pi 6)) (/ (sqrt 3) 3)) + +(num-test (sin (/ our-pi 5)) (/ (sqrt (- 10 (* 2 (sqrt 5)))) 4)) +(num-test (cos (/ our-pi 5)) (/ (+ 1 (sqrt 5)) 4)) +(num-test (tan (/ our-pi 5)) (sqrt (- 5 (* 2 (sqrt 5))))) + +(num-test (* (sin (/ our-pi 7)) (sin (/ (* 2 our-pi) 7)) (sin (/ (* 3 our-pi) 7))) (/ (sqrt 7) 8)) +(num-test (* (cos (/ our-pi 7)) (cos (/ (* 2 our-pi) 7)) (cos (/ (* 3 our-pi) 7))) 1/8) + +(num-test (sin (/ our-pi 4)) (/ (sqrt 2) 2)) +(num-test (cos (/ our-pi 4)) (/ (sqrt 2) 2)) +(num-test (tan (/ our-pi 4)) 1) + +(num-test (sin (/ our-pi 3)) (/ (sqrt 3) 2)) +(num-test (cos (/ our-pi 3)) 1/2) +(num-test (tan (/ our-pi 3)) (sqrt 3)) + +(num-test (sin (/ our-pi 8)) (/ (sqrt (- 2 (sqrt 2))) 2)) +(num-test (cos (/ our-pi 8)) (/ (sqrt (+ 2 (sqrt 2))) 2)) +(num-test (tan (/ our-pi 8)) (- (sqrt 2) 1)) + +(num-test (* (sin (/ our-pi 9)) (sin (/ (* 2 our-pi) 9)) (sin (/ (* 4 our-pi) 9))) (/ (sqrt 3) 8)) +(num-test (* (cos (/ our-pi 9)) (cos (/ (* 2 our-pi) 9)) (cos (/ (* 4 our-pi) 9))) 1/8) +(num-test (* (tan (/ our-pi 9)) (tan (/ (* 2 our-pi) 9)) (tan (/ (* 4 our-pi) 9))) (sqrt 3)) + +(num-test (sin (/ our-pi 10)) (/ (- (sqrt 5) 1) 4)) +(num-test (cos (/ our-pi 10)) (/ (sqrt (+ 10 (* 2 (sqrt 5)))) 4)) +(num-test (tan (/ our-pi 10)) (/ (sqrt (- 25 (* 10 (sqrt 5)))) 5)) + +(num-test (* (sin (/ our-pi 11)) (sin (/ (* 2 our-pi) 11)) (sin (/ (* 3 our-pi) 11)) (sin (/ (* 4 our-pi) 11)) (sin (/ (* 5 our-pi) 11))) (sqrt (/ 11 1024))) +(num-test (* (cos (/ our-pi 11)) (cos (/ (* 2 our-pi) 11)) (cos (/ (* 3 our-pi) 11)) (cos (/ (* 4 our-pi) 11)) (cos (/ (* 5 our-pi) 11))) 1/32) +(num-test (* (tan (/ our-pi 11)) (tan (/ (* 2 our-pi) 11)) (tan (/ (* 3 our-pi) 11)) (tan (/ (* 4 our-pi) 11)) (tan (/ (* 5 our-pi) 11))) (sqrt 11)) + +(num-test (sin (/ our-pi 12)) (/ (- (sqrt 6) (sqrt 2)) 4)) +(num-test (cos (/ our-pi 12)) (/ (+ (sqrt 6) (sqrt 2)) 4)) +(num-test (tan (/ our-pi 12)) (- 2 (sqrt 3))) + +(num-test (sin (/ our-pi 15)) (/ (sqrt (- 7 (sqrt 5) (sqrt (- 30 (* 6 (sqrt 5)))))) 4)) +(num-test (cos (/ our-pi 15)) (/ (+ (sqrt (+ 30 (* 6 (sqrt 5)))) (sqrt 5) -1) 8)) +;(num-test (tan (/ our-pi 15)) (sqrt (- 23 (* 10 (sqrt 5)) (* 2 (sqrt (+ 255 (* 114 (sqrt 5)))))))) + +(num-test (sin (/ our-pi 16)) (/ (sqrt (- 2 (sqrt (+ 2 (sqrt 2))))) 2)) +(num-test (cos (/ our-pi 16)) (/ (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))) 2)) +(num-test (tan (/ our-pi 16)) (- (sqrt (+ 4 (* 2 (sqrt 2)))) (sqrt 2) 1)) + +(num-test (sin (/ our-pi 20)) (/ (sqrt (- 8 (* 2 (sqrt (+ 10 (* 2 (sqrt 5))))))) 4)) +(num-test (cos (/ our-pi 20)) (/ (sqrt (+ 8 (* 2 (sqrt (+ 10 (* 2 (sqrt 5))))))) 4)) +(num-test (tan (/ our-pi 20)) (+ 1 (sqrt 5) (- (sqrt (+ 5 (* 2 (sqrt 5))))))) + +(num-test (sin (/ our-pi 24)) (/ (sqrt (- 2 (sqrt (+ 2 (sqrt 3))))) 2)) +(num-test (cos (/ our-pi 24)) (/ (sqrt (+ 2 (sqrt (+ 2 (sqrt 3))))) 2)) +(num-test (tan (/ our-pi 24)) (+ -2 (sqrt 2) (- (sqrt 3)) (sqrt 6))) + +(num-test (sin (/ our-pi 30)) (/ (+ -1 (- (sqrt 5)) (sqrt (- 30 (* 6 (sqrt 5))))) 8)) +(num-test (cos (/ our-pi 30)) (/ (sqrt (+ 7 (sqrt 5) (sqrt (* 6 (+ 5 (sqrt 5)))))) 4)) +(num-test (tan (/ our-pi 30)) (sqrt (- 7 (* 2 (sqrt 5)) (* 2 (sqrt (- 15 (* 6 (sqrt 5)))))))) + +(num-test (sin (/ our-pi 32)) (/ (sqrt (- 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))))) 2)) +(num-test (cos (/ our-pi 32)) (/ (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))))) 2)) +(num-test (cos (/ our-pi 64)) (* 1/2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))))))))) +(num-test (cos (/ our-pi 128)) (* 1/2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt 2))))))))))))) + +(num-test (/ our-pi 4) (+ (* 12 (atan (/ 18))) (* 8 (atan (/ 57))) (* -5 (atan (/ 239))))) +(num-test (sin (- (/ our-pi 2) (* 0+i (log (/ (+ 1 (sqrt 5)) 2))))) (/ (sqrt 5) 2)) +(num-test (sqrt 0+i) (/ 1+i (sqrt 2))) +(num-test (expt 0+i 0+i) (exp (/ our-pi -2))) +(num-test (* (cos (/ our-pi 9)) (cos (/ (* 2 our-pi) 9)) (cos (/ (* 4 our-pi) 9))) 1/8) +(num-test (* (/ 4 (sqrt 522)) + (log (* (expt (/ (+ 5 (sqrt 29)) (sqrt 2)) 3) + (+ (* 5 (sqrt 29)) (* 11 (sqrt 6))) + (expt (+ (sqrt (/ (+ 9 (* 3 (sqrt 6))) 4)) + (sqrt (/ (+ 5 (* 3 (sqrt 6))) 4))) 6)))) ;31 digits + our-pi) +(if (or with-bignums with-64-bit-ints) (num-test (+ 2 (expt 276694819753963/226588 1/158)) our-pi)) ; 23 digits +;(num-test (expt 4297607660/144171 1/9) our-pi) ; 15 digits + +(do ((k 1 (+ k 1))) + ((= k 12)) + (num-test (+ (expt 11 k) (expt 24 k) (expt 65 k) (expt 90 k) (expt 129 k) + (expt 173 k) (expt 212 k) (expt 237 k) (expt 278 k) (expt 291 k) (expt 302 k)) + (+ (expt 3 k) (expt 5 k) (expt 30 k) (expt 57 k) (expt 104 k) (expt 116 k) + (expt 186 k) (expt 198 k) (expt 245 k) (expt 272 k) (expt 297 k) (expt 299 k)))) + +(num-test (expt (- (expt 2 1/3) 1) 1/3) (+ (expt 1/9 1/3) (- (expt 2/9 1/3)) (expt 4/9 1/3))) +(num-test (sqrt (- (expt 5 1/3) (expt 4 1/3))) (/ (+ (expt 2 1/3) (expt 20 1/3) (- (expt 25 1/3))) 3)) +(num-test (* (+ 1 3 5) (* 1 3 5)) 135) +(num-test (expt (+ (cos (/ (* 2 our-pi) 20)) (* 0+i (sin (/ (* 2 our-pi) 20)))) 20) 1.0) +(test (= (+ (expt 2421 3) (expt 19083 3)) + (+ (expt 5436 3) (expt 18948 3)) + (+ (expt 10200 3) (expt 18072 3)) + (+ (expt 13322 3) (expt 16630 3))) + #t) + +(num-test (/ our-pi 4) (- (* 4 (atan (/ 1 5))) (atan (/ 1 239)))) +(num-test (/ our-pi 4) (+ (atan 1/2) (atan 1/3))) +(num-test (/ our-pi 4) (- (* 2 (atan 1/2)) (atan 1/7))) +(num-test (/ our-pi 4) (+ (* 2 (atan 1/3)) (atan 1/7))) +(num-test (/ our-pi 4) (+ (* 5 (atan 1/7)) (* 2 (atan 3/79)))) +(num-test (/ our-pi 2) (+ (* 2 (atan (/ (sqrt 2)))) (atan (/ (sqrt 8))))) +(num-test (* 768 (sqrt (- 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 (sqrt (+ 2 1))))))))))))))))))) 3.1415904632368) + +(num-test (expt (- (expt 2 1/3) 1) 1/3) (+ (expt 1/9 1/3) (- (expt 2/9 1/3)) (expt 4/9 1/3))) +(num-test (sqrt (- (expt 5 1/3) (expt 4 1/3))) (/ (+ (expt 2 1/3) (expt 20 1/3) (- (expt 25 1/3))) 3)) +(num-test (+ (expt (+ 1/2 (/ (sqrt 69) 18)) 1/3) (/ (expt (+ 1/2 (/ (sqrt 69) 18)) -1/3) 3)) (* (/ (* 2 (sqrt 3)) 3) (cos (/ (acos (/ (* 3 (sqrt 3)) 2)) 3)))) + +(num-test (expt (/ (+ 1 (sqrt 5)) 2) 5) (/ (+ 11 (* 5 (sqrt 5))) 2)) +(num-test (/ (+ (atan (/ 239)) (atan (/ 70)) (- (atan (/ 99)))) 2) (+ (atan (/ 408)) (atan (/ 577)))) +(num-test (cos (log (+ our-pi 20))) -0.99999999924368) +(num-test (expt (+ our-pi 20) 0+i) -0.99999999924368-3.8892669402222e-05i) +(num-test (cos (* our-pi (cos (* our-pi (cos (log (+ our-pi 20))))))) -1.0) ; actually there's a 3.93216e-35 imag part +;(num-test (/ (+ (cos (/ 10)) (cosh (/ 10)) (* 2 (cos (/ (sqrt 2) 20)) (cosh (/ (sqrt 2) 20)))) 4) 1.0000000000002480) +(num-test (/ 53453 (log 53453)) 4910.0000012208) +(num-test (/ (* 2 3 4 5 6 7 8 9 10) (* 2 (expt (log 2) 11))) 102247563.00527) +(num-test (exp (* our-pi (sqrt 6))) 2197.9908695437) +(num-test (exp (* our-pi (sqrt 17))) 422150.99767568) +(num-test (exp (* our-pi (sqrt 18))) 614551.992885619) +(num-test (exp (* our-pi (sqrt 22))) 2508951.998257424) +(num-test (expt (/ (log (+ (expt 640320 3) 744)) our-pi) 2) 163.0) ; rest is 2.32167e-29 +(num-test (exp (* our-pi (sqrt 719))) 3.8426143735395488914902942778058291929999e+36) +(if (or with-bignums with-64-bit-ints) (num-test (+ (expt 415280564497/348671682660 3) (expt 676702467503/348671682660 3)) 9)) +(num-test (expt 25 6) (+ (expt 1 6) (expt 2 6) (expt 3 6) (expt 5 6) (expt 6 6) (expt 7 6) (expt 8 6) (expt 9 6) + (expt 10 6) (expt 12 6) (expt 13 6) (expt 15 6) (expt 16 6) (expt 17 6) (expt 18 6) (expt 23 6))) +(num-test (/ (- (sqrt 5) 1) 2) (/ (sin (* our-pi 1/5)) (sin (* our-pi 2/5)))) +(num-test (let* ((N 3502) + (D (* 1/2 (+ 1071 (* 184 (sqrt 34))))) + (E (* 1/2 (+ 1553 (* 266 (sqrt 34))))) + (F (+ 429 (* 304 (sqrt 2)))) + (G (* 1/2 (+ 627 (* 442 (sqrt 2))))) + (d1 (+ D (sqrt (- (* D D) 1)))) + (e1 (+ E (sqrt (- (* E E) 1)))) + (f1 (+ F (sqrt (- (* F F) 1)))) + (g1 (+ G (sqrt (- (* G G) 1)))) + (defg (* 2 d1 e1 f1 g1))) + (* (/ (sqrt N)) (- (log (expt defg -6))))) + our-pi) +(num-test (let* ((N 2737) + (D (* 1/2 (+ 621 (* 49 (sqrt 161))))) + (E (* 1/4 (+ 321 (* 25 (sqrt 161))))) + (F (* 1/4 (+ 393 (* 31 (sqrt 161))))) + (G (* 1/4 (+ 2529 (* 199 (sqrt 161))))) + (d (+ D (sqrt (- (* D D) 1)))) + (e (+ E (sqrt (- (* E E) 1)))) + (f (+ F (sqrt (- (* F F) 1)))) + (g (+ G (sqrt (- (* G G) 1)))) + (defg (* 2 d e f g))) + (* (/ (sqrt N)) (- (log (magnitude (* -1 (expt defg -6))))))) + our-pi) ; Newman and Shanks "On a Sequence Arising in Series for pi" + +(num-test (let* ((an (sqrt 2)) ; Borwein and Borwein "AGM Mean and Fast Computation" + (bn 0) + (pn (+ 2 (sqrt 2)))) + (do ((i 0 (+ i 1))) + ((= i 4) pn) + (let* ((sqa (sqrt an)) + (an1 (* 1/2 (+ sqa (/ 1.0 sqa)))) + (bn1 (* sqa (/ (+ bn 1) (+ bn an)))) + (pn1 (* pn bn1 (/ (+ an1 1) (+ bn1 1))))) + (set! pn pn1) + (set! bn bn1) + (set! an an1)))) + our-pi) + +(num-test (let ((pi2 0.0) + (ais (vector 1 -3 -2 -3 1 0))) + (do ((i 1 (+ i 1)) + (two 2 (* two 2))) + ((= i 30) (* 36 pi2)) + (set! pi2 (+ pi2 (/ (vector-ref ais (modulo (- i 1) 6)) + (* two i i)))))) + (* our-pi our-pi)) + +(num-test (let ((log2 0.0) + (ais (vector 2 -10 -7 -10 2 -1))) + (do ((i 1 (+ i 1)) + (two 2 (* two 2))) + ((= i 30) (* 2 log2)) + (set! log2 (+ log2 (/ (vector-ref ais (modulo (- i 1) 6)) + (* two i i)))))) + (* (log 2) (log 2))) + +(num-test (+ (* 2 (atan (/ (sqrt 2)))) (atan (/ (sqrt 8)))) (/ our-pi 2)) +(num-test (* 12 (/ 13591409 (expt 640320 3/2))) (/ our-pi)) +(num-test (+ (* 48 (atan (/ 49))) (* 128 (atan (/ 57))) (* -20 (atan (/ 239))) (* 48 (atan (/ 110443)))) our-pi) +(num-test (+ (* 176 (atan (/ 57))) (* 28 (atan (/ 239))) (* -48 (atan (/ 682))) (* 96 (atan (/ 12943)))) our-pi) + +(num-test (sqrt 13) (do ((i 1 (+ i 1)) (prod 1.0 (* prod (tan (/ (* i our-pi) 13))))) ((= i 7) prod))) +(num-test (let ((a (/ (* 2 our-pi) 13))) (* 8 (+ (cos a) (cos (* 5 a))) (+ (cos (* 2 a)) (cos (* 3 a))) (+ (cos (* 4 a)) (cos (* 6 a))))) -1.0) +(num-test (do ((i 1 (+ i 1)) (sum 0.0 (+ sum (cos (/ (* 2 our-pi i) 11))))) ((= i 6) sum)) -0.5) +(num-test (do ((i 1 (+ i 1)) (sum 0.0 (+ sum (expt (sin (/ (* our-pi i) (* 2 10))) 4)))) ((= i 11) sum)) 4.25) +(num-test (* 4 (+ (* 3 (atan 1/4)) (atan 1/20) (atan 1/1985))) our-pi) +(num-test (* 10 (asin (/ (- (sqrt 5) 1) 4))) our-pi) +(num-test (asin (/ (sqrt 2) 2)) (/ our-pi 4)) +(num-test (asin (/ (sqrt 3) -2)) (/ our-pi -3)) +(num-test (acos (/ (sqrt 2) 2)) (/ our-pi 4)) +(num-test (acos (/ (sqrt 3) -2)) (- our-pi (/ our-pi 6))) +(num-test (atan (sqrt 3)) (/ our-pi 3)) +(num-test (atan (/ -1 (sqrt 3))) (/ our-pi -6)) +(num-test (+ (* (sin 0.1) (sin 0.1)) (* (cos 0.1) (cos 0.1))) 1.0) +(num-test (tan (/ our-pi 3)) (sqrt 3)) +(num-test (tan (/ our-pi 4)) 1.0) +(num-test (tan (/ our-pi 6)) (/ (sqrt 3))) +(num-test (sin (/ our-pi 3)) (/ (sqrt 3) 2)) +(num-test (cos (/ our-pi 3)) 1/2) + +(let ((top 0)) + (let ((x-10 (lambda (n) (- (expt n 10) (* n n n n n n n n n n))))) + (let ((happy #t) + (lim (if with-bignums 100 + (if with-64-bit-ints 74 + 8)))) + (do ((i 1 (+ i 1))) + ((or (not happy) (= i lim))) ; stop around 63 bits + (let ((val (x-10 i))) + (if (not (= val 0)) + (begin + (set! top (- i 1)) + (set! happy #f) + (display "(expt ") (display i) (display " 10) = ") (display (expt i 10)) + (display " but (* ") (display i) (display "... 10x) = ") + (display (* i i i i i i i i i i)) (newline))))))) + (if (> top 63) + (num-test (+ (expt 1 10) (expt 2 10) (expt 4 10) (expt 5 10) (expt 6 10) (expt 8 10) (expt 12 10) + (expt 15 10) (expt 16 10) (expt 17 10) (expt 20 10) (expt 21 10) (expt 25 10) (expt 26 10) + (expt 27 10) (expt 28 10) (expt 30 10) (expt 36 10) (expt 37 10) (expt 38 10) (expt 40 10) + (expt 51 10) (expt 62 10)) + (expt 63 10)))) + +(num-test (expt 3 9) (* 3 3 3 3 3 3 3 3 3)) + +(num-test (+ (expt 510 3) (expt 580 3)) (+ (expt 300 3) (expt 670 3))) +(num-test (+ (expt 2230 4) (expt 3196 4) (expt 5620 4) (expt 6995 4)) (expt 7703 4)) +(num-test (+ (expt 2 5) (expt 298 5) (expt 351 5) (expt 474 5) (expt 500 5)) (expt 575 5)) + +;;; some of the tests in this section are thanks to Bill Gosper +(num-test (expt (- (expt 3 3/5) (expt 2 1/5)) 1/3) + (/ (+ (- (* (expt 2 1/5) (expt 3 3/5))) (* (expt 2 3/5) (expt 3 2/5)) (expt 3 1/5) (expt 2 2/5)) (expt 5 2/3))) + +(num-test (sqrt (- 2 (expt 2 1/7))) + (/ (* (expt 2 1/14) (+ (- (expt 2 6/7)) (expt 2 5/7) (expt 2 3/7) (* 2 (expt 2 1/7)) -1)) (sqrt 7))) + +(num-test (sqrt (- 127 (* 4 (sqrt 6) (expt 7 1/4)))) + (+ (/ (* (sqrt 3) (expt 7 3/4)) (sqrt 2)) (* 2 (sqrt 7)) (/ (* 3 (sqrt 3) (expt 7 1/4)) (sqrt 2)) -6)) + +(num-test (sqrt (- (expt 4 1/5) (expt 3 1/5))) + (/ (+ (* (- (expt 2 3/5)) (expt 3 4/5)) (expt 3 3/5) (* 2 (expt 2 2/5) (expt 3 2/5)) (* (- (expt 2 4/5)) (expt 3 1/5)) (expt 2 1/5)) 5)) + +(num-test (sqrt (- 161 (* 12 (expt 5 1/4)))) (+ (* 2 (expt 5 3/4)) (- (* 3 (sqrt 5))) (* 4 (sqrt (sqrt 5))) 6)) + +(num-test (* (sqrt 2) (sqrt (- 31 (* 4 (sqrt (sqrt 3)) (sqrt (sqrt 5)))))) + (+ (* (expt 3 1/4) (expt 5 3/4)) (- (* 2 (sqrt 5))) (* (expt 3 3/4) (expt 5 1/4)) (* 2 (sqrt 3)))) + +(num-test (/ (sqrt (* 7 (- 2 (expt 2 1/7)))) (expt 2 1/14)) + (+ -1 (* 2 (expt 2 1/7)) (expt 2 3/7) (expt 2 5/7) (- (expt 2 6/7)))) + +(num-test (sqrt (- (expt 4 2/3) (* (sqrt 3) (expt 5 1/6)))) + (+ (/ (expt 5 1/3) (sqrt 6)) (- (/ (expt 5 5/6) (* 3 (sqrt 2)))) (/ (* (expt 2 1/6) (sqrt 5)) 3) + (- (/ (* (expt 2 5/6) (expt 5 1/6)) 3)) (/ (expt 2 1/6) (sqrt 3)))) + +(num-test (* 2 0+i (log (/ 1-i 1+i))) our-pi) + + +;;; -------------------------------------------------------------------------------- +;;; a selection from Eric Weisstein MathWorld MachinFormulas +(let ((formulas '( + (1/4 (1 1)) + + (1/4 (1 2) (1 3)) + (1/4 (2 2) (-1 7)) + (1/4 (2 3) (1 7)) + (1/4 (4 5) (-1 239)) + + (1/4 (1 2) (1 4) (1 13)) + (1/4 (1 2) (1 5) (1 8)) + (1/4 (1 2) (2 6) (-1 117)) + (1/4 (1 3) (2 4) (-1 38)) + (1/4 (2 2) (-2 12) (1 41)) + (1/4 (2 2) (-2 14) (1 1393)) + (1/4 (2 2) (-2 17) (-1 41)) + (1/4 (2 2) (-1 5) (1 18)) + (1/4 (2 2) (-1 6) (1 43)) + (1/4 (2 2) (-1 8) (-1 57)) + (1/4 (2 2) (-1 9) (-1 32)) + (1/4 (2 2) (-1 12) (-1 17)) + (1/4 (2 3) (1 5) (-1 18)) + (1/4 (2 3) (1 6) (-1 43)) + (1/4 (2 3) (1 8) (1 57)) + (1/4 (2 3) (1 9) (1 32)) + (1/4 (2 3) (1 12) (1 17)) + (1/4 (2 3) (2 12) (-1 41)) + (1/4 (2 3) (2 14) (-1 1393)) + (1/4 (2 3) (2 17) (1 41)) + (1/4 (2 4) (1 7) (2 13)) + (1/4 (2 5) (1 7) (2 8)) + (1/4 (2 5) (3 7) (-2 57)) + (1/4 (2 5) (3 8) (1 57)) + (1/4 (2 6) (3 7) (2 68)) + (1/4 (2 7) (4 8) (1 239)) + (1/4 (3 3) (-2 11) (1 682)) + (1/4 (3 3) (-2 13) (-1 38)) + (1/4 (3 3) (-1 5) (1 57)) + (1/4 (3 3) (-1 6) (-1 68)) + (1/4 (3 3) (-1 8) (-1 18)) + (1/4 (3 4) (1 13) (-1 38)) + (1/4 (3 4) (1 20) (1 1985)) + (1/4 (3 5) (2 8) (-1 18)) + (1/4 (3 7) (2 8) (2 18)) + (1/4 (3 7) (4 11) (-2 682)) + (1/4 (3 7) (4 13) (2 38)) + (1/4 (4 3) (-4 8) (-1 239)) + (1/4 (4 4) (-1 7) (-2 38)) + (1/4 (4 4) (-4 21) (-1 239)) + (1/4 (4 5) (-2 408) (1 1393)) + (1/4 (4 5) (-2 478) (1 54608393)) + (1/4 (4 5) (-2 577) (-1 1393)) + (1/4 (4 5) (-1 41) (2 99)) + (1/4 (4 5) (-1 70) (1 99)) + (1/4 (4 5) (-1 213) (1 1958)) + (1/4 (4 5) (-1 226) (1 4155)) + (1/4 (4 5) (-1 237) (1 28322)) + (1/4 (4 5) (-1 238) (1 56883)) + (1/4 (4 5) (-1 240) (-1 57361)) + (1/4 (4 5) (-1 241) (-1 28800)) + (1/4 (4 5) (-1 252) (-1 4633)) + (1/4 (4 5) (-1 265) (-1 2436)) + (1/4 (4 5) (-1 408) (-1 577)) + (1/4 (4 5) (1 41) (-2 70)) + (1/4 (4 6) (1 7) (-2 117)) + (1/4 (4 6) (4 31) (-1 239)) + (1/4 (4 7) (4 18) (-1 239)) + (1/4 (5 5) (-3 18) (-2 57)) + (1/4 (5 6) (-1 43) (-2 117)) + (1/4 (5 6) (-1 68) (-3 117)) + + (1/4 (-29 239) (256 378) (200 829) (244 882) (-388 993) (324 2943) (-144 18543)) + (1/4 (-4 307) (394 577) (163 1393) (-12 12238) (-24 58911) (-68 1999509) (-68 11653127)) + (1/4 (7 10) (2 50) (4 100) (1 682) (4 1000) (3 1303) (-4 90109)) + (1/4 (7 10) (8 100) (1 682) (4 1000) (3 1303) (-4 90109) (-2 500150)) + (1/4 (12 18) (8 307) (46 577) (19 1393) (-8 2827807) (-16 11653127) (-8 16480443)) + (1/4 (17 23) (11 882) (24 931) (10 1143) (-2 34208) (-8 44179) (-13 485298)) + (1/4 (29 268) (198 378) (142 829) (186 882) (-301 993) (237 2943) (-115 18543)) + (1/4 (43 57) (22 746) (-2 1568) (1 4662) (28 12943) (14 32807) (11 157318)) + (1/4 (44 515) (95 538) (127 682) (176 782) (95 1068) (88 4030) (17 12943)) + (1/4 (76 682) (190 746) (271 882) (315 2917) (-132 9466) (295 12943) (-95 19703)) + (1/4 (83 107) (17 4443) (68 11343) (-5 113568) (-34 595667) (-5 23481902) (5 168925949733307)) + (1/4 (83 107) (17 4443) (68 11343) (-5 111693) (-34 595667) (5 9503057) (5 232633636378307)) + (1/4 (95 418) (171 682) (176 882) (315 2917) (-132 9466) (105 12943) (95 16693)) + (1/4 (100 437) (254 577) (127 1393) (44 2072) (24 2943) (-12 16432) (-100 28800)) + (1/4 (122 162) (22 568) (-29 1432) (83 5087) (-7 6107) (-10 27493) (-29 30027)) + (1/4 (122 183) (108 1177) (29 1393) (22 4443) (54 5087) (-64 7078) (-10 27493)) + (1/4 (122 418) (237 557) (29 1068) (144 3458) (-61 5087) (122 16452) (105 27493)) + (1/4 (127 239) (100 343) (-56 2072) (-76 2943) (100 7983) (-12 16432) (100 28322)) + (1/4 (127 239) (212 1068) (-144 2072) (188 2309) (-200 6105) (376 6807) (288 13637)) + (1/4 (127 239) (400 1068) (44 2072) (-376 2943) (-200 6105) (100 13637) (188 16432)) + (1/4 (127 682) (227 788) (227 843) (44 2072) (51 2943) (-27 12943) (88 16432)) + (1/4 (127 682) (454 818) (271 1303) (-403 2943) (-44 6118) (-254 12943) (-183 3014557)) + (1/4 (171 239) (68 788) (-56 1744) (36 2943) (44 6613) (-112 13603) (144 28322)) + (1/4 (171 239) (68 993) (-20 2943) (56 4443) (-44 13252) (-112 17088) (156 28322)) + (1/4 (171 239) (124 993) (-56 1252) (56 2855) (-76 2943) (-100 13252) (100 28322)) + (1/4 (171 682) (183 788) (227 843) (95 2943) (44 6613) (-115 12943) (88 28322)) + (1/4 (171 682) (271 882) (95 993) (315 2917) (95 2943) (-227 9466) (200 12943)) + (1/4 (171 682) (366 1068) (139 2436) (271 5357) (315 5507) (227 6962) (-71 12943)) + (1/4 (176 463) (32 682) (241 798) (241 3141) (-58 5357) (-122 12943) (-51 390112)) + (1/4 (176 557) (244 757) (90 1068) (61 1393) (22 3458) (122 11018) (44 27493)) + (1/4 (179 239) (44 5357) (80 5507) (156 12943) (8 17923) (48 32807) (-40 157318)) + (1/4 (179 239) (120 4662) (4 5357) (116 12943) (-32 17923) (88 32807) (40 390112)) + (1/4 (179 233) (120 4662) (4 5357) (-63 12943) (-32 17923) (-91 32807) (40 390112)) + (1/4 (183 239) (32 682) (-88 1143) (132 2673) (68 12943) (-132 34208) (-44 44179)) + (1/4 (183 239) (32 1023) (-68 5832) (12 111693) (-100 6826318) (-12 9503057) (-12 232633636378307)) + (1/4 (183 239) (32 1023) (-68 5832) (12 112068) (-100 6826318) (-12 13288972) (-12 49541920807)) + (1/4 (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23476958) (-12 111432033307)) + (1/4 (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23481005) (-12 612463280182)) + (1/4 (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23463218) (-12 29483238307)) + (1/4 (183 239) (32 1023) (-68 5832) (12 113568) (-100 6826318) (12 23481902) (-12 168925949733307)) + (1/4 (183 294) (44 905) (115 1292) (88 3957) (-32 12238) (68 12943) (51 114483)) + (1/4 (183 307) (32 682) (95 1143) (132 2673) (68 12943) (51 34208) (139 44179)) + (1/4 (183 378) (115 557) (29 1068) (122 2943) (144 3458) (-244 14318) (44 27493)) + (1/4 (183 378) (144 606) (86 1772) (122 2943) (-115 6118) (-71 14318) (-71 27493)) + (1/4 (183 378) (144 905) (115 1057) (151 2943) (-29 3957) (-100 14318) (-100 27493)) + (1/4 (183 378) (215 682) (44 1432) (51 2943) (-315 5257) (-71 12943) (44 13043)) + (1/4 (183 538) (215 682) (51 1068) (44 2309) (88 2673) (88 3039) (17 12943)) + (1/4 (183 568) (215 682) (278 1636) (-139 6107) (112 12943) (-234 19703) (132 32807)) + (1/4 (186 307) (41 378) (27 829) (-13 1713) (122 2943) (42 12238) (71 58911)) + (1/4 (190 577) (76 682) (176 882) (95 1393) (220 2917) (-132 9466) (200 12943)) + (1/4 (198 577) (200 606) (127 1393) (-20 2943) (112 3740) (-44 6118) (56 11018)) + (1/4 (199 233) (-60 1393) (-76 5357) (-43 12943) (-152 17923) (9 32807) (120 1049433)) + (1/4 (215 233) (-216 1568) (12 4662) (-64 6898) (113 12943) (-51 32807) (-32 534568)) + (1/4 (215 239) (-248 1568) (76 4662) (296 12943) (132 32807) (64 83270) (32 1493208)) + + (1/4 (160 200) (-1 239) (-4 515) (-8 4030) (-16 50105) (-16 62575) (-32 500150) (-80 4000300)) + (1/4 (215 682) (644 1568) (227 5767) (366 6898) (-532 12943) (227 24331) (-51 32807) (183 534568)) + (1/4 (295 4193) (3767 5507) (593 18543) (-1228 39307) (2068 55603) (-962 211050) (-708 390112) (-1587 2867938)) + (1/4 (537 1393) (1118 5357) (952 12943) (3032 17923) (-1384 32807) (-1194 157318) (-1870 1049433) (796 21638297)) + (1/4 (581 1023) (183 4443) (664 5832) (732 11343) (-171 110443) (-366 595667) (171 4841182) (83 6826318)) + (1/4 (581 1252) (764 4853) (1030 5832) (-398 58898) (-764 97232) (195 110443) (537 4841182) (266 6826318)) + (1/4 (581 1252) (764 5593) (1030 5827) (366 58898) (195 110443) (537 4841182) (-764 6826318) (-1030 1561886607)) + (1/4 (581 1252) (764 5618) (1030 5832) (366 58898) (195 110443) (764 1256859) (537 4841182) (266 6826318)) + (1/4 (581 1252) (764 5593) (1030 5832) (366 69051) (195 110443) (366 369957) (171 4841182) (266 6826318)) + (1/4 (581 1252) (764 5593) (1030 11557) (1030 11773) (366 58898) (195 110443) (537 4841182) (266 6826318)) + (1/4 (581 1252) (1030 5507) (764 5593) (366 58898) (-1030 98821) (195 110443) (537 4841182) (266 6826318)) + (1/4 (764 1068) (298 5832) (581 26307) (-183 78813) (-171 110443) (215 314982) (171 4841182) (83 6826318)) + (1/4 (808 1477) (1308 2436) (-1635 5283) (-417 5507) (593 6962) (632 390112) (-561 2733307) (266 23747457)) + (1/4 (1074 1568) (840 5357) (-779 12943) (625 17923) (-1106 32807) (657 198505) (-259 390112) (657 24185182)) + (1/4 (1074 4246) (1257 5357) (1731 6107) (295 12943) (625 19703) (-481 32807) (-1042 39307) (398 390112)) + (1/4 (1484 4693) (2097 4831) (366 18543) (1189 49457) (-227 123093) (-879 128643) (481 27872057) (-266 31895807)) + (1/4 (1738 4193) (1699 4246) (144 6687) (-1443 32318) (-266 39307) (337 235318) (-227 390112) (-481 2282363)) + (1/4 (2363 4557) (1218 5507) (1850 18543) (-266 39307) (-2658 49457) (1257 123093) (-1484 390112) (481 27872057)) + + (1/4 (-31739656 201229582) (38819595 231373438) (110380200 284862638) (122355452 312322593) (-134055653 496651953) (5301720 509435077) (63861353 543644509) (68679613 934981432) (130575087 1845907403) (-32548340 2189376182) (-71616726 2539791558) (98822066 4732978887) (119051879 7804016832) (48482068 9233371207) (-99832073 41734246913) (-99143267 66492889557) (-25601898 73276714818) (-79323772 579766497643)) + (1/4 (16106659 103224943) (48702787 196047454) (18674705 199762118) (8786524 201229582) (-16824928 244653118) (-9582339 261221282) (33092716 266981905) (50379909 270684757) (24748365 909140573) (31675677 1770638022) (1576733 2189376182) (-4742586 2701984943) (-34586991 5475957057) (10864048 14033378718) (-13079131 18986886768) (22266057 25220059245) (17791526 34840696582) (-12650410 193100304493)) + (1/4 (154370374 124845505) (-90941691 193788912) (64454803 196047454) (-82996236 201229582) (109691394 244653118) (-15562779 462333568) (6518215 553806443) (-169821027 1134156517) (-244516782 1222853176) (100563577 2154947322) (-47118309 2189376182) (-35713908 4006581229) (60656646 5475957057) (-4001125 18986886768) (-68810571 37093513413) (-20888958 100083704193) (16990004 250645741818) (-62587614 5142102426318)) + (1/4 (-119375678 193788912) (61799442 201229582) (-19991865 272525023) (20438744 321390012) (88331413 331905423) (103467976 343841922) (88464202 378026293) (138122046 600536193) (44232101 653023206) (115219328 846974497) (-81969855 1033937133) (-63521464 1454097393) (-118694678 2189376182) (117332455 2322170807) (-26482877 6884660047) (-18702052 29546599818) (7415308 250645741818) (166718050 512223806648)) + (1/4 (-85386445 101859193) (4420755 112519818) (43555859 193788912) (15003774 194195097) (108912996 201229582) (61225652 231373438) (16824928 262992072) (73421340 284862638) (123118321 1057929843) (-10593254 2189376182) (40618746 2539791558) (73863237 2616939213) (-30947737 14811180432) (58354910 41734246913) (19908612 66492889557) (5345839 73276714818) (-90280386 120563046313) (61328880 579766497643)) + (1/4 (-75143577 193788912) (17567341 201229582) (64670845 321390012) (88331413 331905423) (103467976 343841922) (68472337 372954564) (49657844 600536193) (115219328 846974497) (24240236 1012047353) (-81969855 1033937133) (24942738 1454097393) (-118694678 2189376182) (73100354 2322170807) (-88464202 4549886677) (-26482877 6884660047) (-18702052 29546599818) (7415308 250645741818) (34021747 512223806648)) + (1/4 (-9761163 108220762) (13910116 144252856) (12032992 157157432) (55358773 167207057) (6697039 168623905) (-28651627 193788912) (1825738 201229582) (67020547 215266693) (-1575761 216260702) (45238607 284862638) (10024910 934981432) (20338355 2189376182) (-450675 4832545807) (-27703534 4935283579) (-25688998 7804016832) (-58020549 18986886768) (-28330426 120563046313) (-20446387 69971515635443)) + (1/4 (-9719634 193788912) (17567341 201229582) (70452403 204415882) (12270610 244653118) (18184957 313467682) (44573394 426775692) (3945487 600536193) (33076315 892642643) (62731148 919331002) (18631836 1012047353) (58964485 1454097393) (32836016 2032914193) (-3430506 2189376182) (-19017973 5475957057) (60427493 6884660047) (-9222216 16406542707) (25467476 22827763470) (-8020348 29546599818)) + (1/4 (-7707046 100457781) (102467557 168623905) (-37989469 201229582) (-19264491 216904033) (74130709 231373438) (9117882 262992072) (61898132 284862638) (-26046661 314198789) (20721724 327012132) (-6893934 1111885489) (-40541219 1183092682) (-40255386 2189376182) (82347539 2296713307) (31354293 12988236682) (27538131 18221678207) (-68243977 41734246913) (12646329 73276714818) (-45544955 193100304493)) + (1/4 (-6829481 193788912) (49141523 227661182) (80561462 231373438) (12671730 244653118) (29897458 284862638) (-73630486 355671793) (58626712 398795108) (62468573 509435077) (24454447 543644509) (-19908612 657922943) (28905471 1057929843) (35237534 1845907403) (26678061 2189376182) (-117350972 4866438247) (-61240161 5475957057) (23212961 9075730623) (-20886351 9233371207) (-65421299 60402345333)) + (1/4 (-6249813 193788912) (56771042 201229582) (28076746 231373438) (-19468648 262992072) (30639871 266981905) (19911270 284862638) (130457979 532399876) (96830507 672554667) (-25661007 1057929843) (13459441 1111885489) (-45480502 1183092682) (5693286 1770638022) (-21577251 2170952313) (-67486342 2189376182) (2925523 2701984943) (27538131 18221678207) (-7198038 193100304493) (36293576 307026452057)) + (1/4 (-60656646 143846482) (38271221 144309885) (138138220 157565949) (35739707 193788912) (-42115413 201229582) (-49270023 231373438) (94471578 278263393) (-68287996 398795108) (87062724 462333568) (-21411533 593897943) (-13257608 1057929843) (-106971336 1206519637) (34427295 2189376182) (166256019 4006581229) (111296506 4832545807) (58999250 18986886768) (100563577 373139596292) (100694535 5142102426318)) + (1/4 (-5621437 103224943) (81294931 115811807) (23943179 193788912) (33709426 199762118) (-2077524 201229582) (-31310435 261221282) (4978864 266981905) (-15147806 282218776) (-1688365 909140573) (20050974 1047764193) (-18279356 1770638022) (-1777511 2189376182) (19200593 2701984943) (-21507860 5475957057) (30332696 34840696582) (26011854 48312162432) (7938525 193100304493) (9186926 250645741818)) + (1/4 (-5497394 101057042) (65180148 144309885) (53832596 193788912) (48554212 201229582) (52075350 447821668) (-105963621 539290393) (-8554603 2060228568) (7313117 2112819717) (-57858314 2189376182) (-3891660 2572149874) (7518287 3261365450) (-19908612 4044044333) (12568802 4866438247) (-83992146 5494891577) (-68408704 9233371207) (6071631 20336334426) (26993421 45384196187) (-20080982 71617196968)) + (1/4 (-52897653 193788912) (17567341 201229582) (88637360 214539684) (16824928 329492391) (87365276 426775692) (89084239 434859193) (64670845 478798161) (-60879340 600536193) (51820567 706366957) (25661007 1033937133) (-7721255 1119211358) (-11874055 1454097393) (-46608525 2189376182) (-7415308 2674664693) (38361126 6884660047) (-54246761 29546599818) (29095538 42354792693) (55834766 512223806648)) + (1/4 (-51730315 193788912) (50509639 201229582) (-2925523 224497457) (34338149 231373438) (56651725 266981905) (88974774 284862638) (6009207 367829623) (44851350 532399876) (77361859 672554667) (-36293576 1047764193) (19819495 1057929843) (-26011854 1695830317) (-10691678 1770638022) (-51609424 2170952313) (-31380534 2189376182) (21276728 18221678207) (9186926 250645741818) (-16384964 4125516427007)) + (1/4 (-50738726 193788912) (95363435 196047454) (69453144 225823278) (69510447 227661182) (22432893 244653118) (-32772323 266981905) (-17689880 284862638) (-25151223 657922943) (45597610 672554667) (-15126313 934981432) (76492809 1770638022) (84039104 2189376182) (-104948381 4832545807) (-85627080 5475957057) (-40656362 5684017953) (-5242611 7804016832) (-197723175 18986886768) (42533486 25220059245)) + (1/4 (-28765620 120868561) (44046442 160007778) (67427201 167207057) (37325093 191800592) (70499068 270090468) (-57543499 289008998) (17519675 361632045) (-4374603 747769833) (-52576452 2674664693) (-7666625 2971354082) (83775059 3069221943) (44136928 4549886677) (-7704241 4832545807) (109211041 4935283579) (43406332 5271470807) (-4967047 8815417307) (24253605 14033378718) (72936300 69392205693)) + (1/4 (-19504206 100457781) (24986381 107793452) (26438497 121042733) (40255386 160007778) (28377269 168623905) (23815821 314198789) (-2374068 361632045) (25057307 672554667) (-9351768 773302059) (11008080 1479406293) (574237 2296713307) (-3020779 2701984943) (17648998 4038832337) (-9422284 12139595709) (27538131 12957904393) (20007517 12988236682) (23727647 18710140581) (-4711783 120563046313)) + (1/4 (-42543389 193788912) (74917830 201229582) (28076746 231373438) (16824928 262992072) (30639871 266981905) (74351634 284862638) (21577251 640348873) (78683719 672554667) (-25661007 1057929843) (-4687347 1111885489) (-27333714 1183092682) (5693286 1770638022) (8531273 2189376182) (-76017615 2674664693) (2925523 2701984943) (-39724039 4309606382) (27538131 18221678207) (68819577 193100304493)) + (1/4 (-41665661 138884933) (61863206 168623905) (-24923249 201229582) (1860735 231373438) (152322833 244685917) (16824928 262992072) (45004160 284862638) (6816407 306903943) (-25731933 2189376182) (-2937113 2539791558) (-80514719 4100676432) (-30142453 5157407572) (88702086 17249711432) (10077565 18986886768) (-34456033 41734246913) (19908612 66492889557) (66436029 73276714818) (-10644159 579766497643)) + (1/4 (-39775463 119742462) (20197545 168623905) (93476735 201229582) (1860735 231373438) (58490589 262992072) (86669821 284862638) (-4706801 437768635) (41665661 1258140850) (-35068662 1396533757) (-56669435 1624720807) (61079955 2189376182) (69090409 2539791558) (-73253757 3712239557) (42278290 41734246913) (-46591870 52254287493) (59684075 66492889557) (-12188492 73276714818) (-15350960 579766497643)) + (1/4 (-3944315 103224943) (48706548 136899993) (18362609 186695067) (14767496 193788912) (-25501467 201229582) (-15136563 244653118) (29933522 261221282) (30079929 266981905) (117267526 480808760) (-30911261 1012047353) (40320881 1770638022) (53656250 2189376182) (20888958 2701984943) (-63283169 5475957057) (-32599626 37093513413) (-43463674 43917943025) (-64759288 193100304493) (21735578 5142102426318)) + (1/4 (-3908713 100351813) (64565359 115453918) (26685223 201229582) (-8153925 214539684) (96935488 385231007) (15853328 459637173) (-19281720 539290393) (-48760063 883337939) (62688235 909140573) (-67639108 1282794079) (-5891323 1304967682) (-10583319 2189376182) (34749426 2572149874) (-55437542 3508373380) (-90085473 4427365493) (-35842901 5494891577) (-35317011 18986886768) (-22926686 45119420807)) + (1/4 (-36515828 110175338) (5722932 193788912) (17567341 201229582) (83804410 203283777) (85603231 244653118) (79850836 273202197) (68353757 345311195) (-87424385 549758463) (-63893191 1454097393) (-111387800 1459933093) (69893108 1725455932) (-61767440 2189376182) (-19017973 5475957057) (102875038 6930719818) (47464799 16406542707) (21866697 29546599818) (-15003774 37093513413) (-46223313 5142102426318)) + (1/4 (-36293576 132095062) (57870827 168623905) (-42543389 193788912) (35193791 201229582) (-8216830 231373438) (53118504 262992072) (30639871 266981905) (128791998 284862638) (60536931 672554667) (-25661007 1057929843) (49753017 1111885489) (-45480502 1183092682) (-30600290 1770638022) (-9615515 2189376182) (-69661629 2701984943) (63831707 18221678207) (29095538 193100304493) (-36293576 5142102426318)) + (1/4 (-35775309 107793452) (-7119735 111530944) (127376638 115811807) (66649464 193788912) (-21949674 201229582) (-43413311 244653118) (-45561148 261221282) (49941099 266981905) (-9186926 396134107) (-886843 1770638022) (73138594 2189376182) (-39140796 2296713307) (61906878 2701984943) (-3565489 5458840213) (-21696619 5475957057) (-7498561 55237647473) (75356069 193100304493) (-1877124 579766497643)) + (1/4 (-35368492 144309885) (-13432309 201229582) (124560353 231373438) (-8671679 284862638) (3303573 398795108) (141414744 509435077) (203277950 543644509) (-124589816 1845907403) (-32548340 2189376182) (-53309379 2539791558) (115883211 4732978887) (68679613 9075730623) (-1890198 9233371207) (19219806 41734246913) (19908612 66492889557) (60138860 73276714818) (-53675839 102428655030) (-10644159 579766497643)) + (1/4 (-35368492 110911039) (50372266 113561432) (3303573 168623905) (-16735882 201229582) (74188087 231373438) (30000386 284862638) (106046252 509435077) (99229845 543644509) (-89221324 1845907403) (-67916832 2189376182) (-53309379 2539791558) (-15003774 3658567505) (65510945 4732978887) (-16893972 9233371207) (-19452259 41734246913) (-30463654 66492889557) (75142634 73276714818) (-10644159 579766497643)) + (1/4 (-34897469 115453918) (87164915 118708522) (27407173 168623905) (87908983 193788912) (-27111639 201229582) (25214128 284862638) (-104763374 426775692) (55687060 600536193) (-49901243 909140573) (3434531 975229968) (-44950370 1454097393) (75180138 2189376182) (27482161 3508373380) (-68146942 4866438247) (-85620582 6884660047) (15583442 9233371207) (30725109 29546599818) (2193045 1442060060693)) + (1/4 (-32461025 169937257) (42456472 193788912) (60136529 201229582) (45652872 230845763) (-11582317 231373438) (-12390325 448235443) (44415233 539290393) (59855124 595484173) (64938439 1057929843) (30600290 1500534537) (71357041 2189376182) (45920466 2616939213) (48826263 2701984943) (27854052 5494891577) (22522061 7193374037) (-21720539 11115923863) (1241486 14811180432) (-44678980 58240834569)) + (1/4 (-30911476 193788912) (17567341 201229582) (68472337 272525023) (64670845 321390012) (88331413 331905423) (15003774 343841922) (5425743 600536193) (70987227 846974497) (-37737754 1033937133) (69174839 1454097393) (-30230476 2189376182) (28868253 2322170807) (-26482877 6884660047) (-44232101 24139206772) (-18702052 29546599818) (-44232101 50443911578) (7415308 250645741818) (-10210354 512223806648)) + (1/4 (-30692741 227661182) (12504894 231373438) (-39446702 244653118) (114600079 262992072) (92590873 284862638) (113856011 314198789) (86140179 346369967) (-22467890 355671793) (-141382552 398795108) (59415160 657922943) (-7326899 1620933557) (-1037771 2189376182) (-79323772 8895085098) (-27205340 17997844652) (-10574983 41734246913) (-27904591 60402345333) (-79821190 73276714818) (16893972 102428655030)) + (1/4 (-30361861 113561432) (85628068 168623905) (20493345 231373438) (53783788 262992072) (46894358 284862638) (65430523 1172624874) (36958860 1258140850) (-16893972 1624720807) (21304492 2189376182) (-1046915 2539791558) (-16436052 3658567505) (20222978 3712239557) (18632610 9549201618) (-27859034 41734246913) (-6816407 52254287493) (50270473 66492889557) (22880170 73276714818) (-10644159 579766497643)) + (1/4 (-29735286 115453918) (-1890198 149299093) (12010178 168623905) (30661691 195053432) (7109402 201229582) (55743030 213255960) (32522426 231373438) (65751551 262992072) (35890388 284862638) (40220018 687606629) (-29216048 909140573) (-63654586 2189376182) (44099312 2539791558) (-33529628 41734246913) (-20830644 66492889557) (26660566 73276714818) (28204899 579766497643) (-48926623 1197009532318)) + + (1/2 (94283734 231373438) (147962666 262992072) (211308992 284862638) (-26800082 318942476) (-69173113 610076381) (-137945216 1111885489) (126007473 1183092682) (333203505 2189376182) (-250903561 2296713307) (248078871 2539791558) (-379960570 5458840213) (-73879914 18221678207) (132652425 30446482737) (68447160 41734246913) (-28954879 66492889557) (35907922 73276714818) (124495078 193100304493) (118351969 579766497643) (18339615 69971515635443)) + + (1/4 (-177112869 1047764193) (690072825 1057929843) (94777525 1082548618) (102841728 1770638022) (254740469 1845907403) (-7897447 2189376182) (-276135745 4866438247) (382919489 8634733487) (364832031 9233371207) (-255036003 18221678207) (-47281269 30446482737) (-14754756 31147706551) (145805470 35587716432) (-60553945 41734246913) (275062833 73276714818) (130937707 73745675437) (225667081 91140429801) (-58222931 120563046313) (217205407 250645741818) (-335335373 69971515635443)) + (1/4 (48554212 1047764193) (-8064203 1695830317) (273129107 1845907403) (256152120 2060228568) (387484239 2170952313) (522262813 2189376182) (139928940 2426435870) (35269543 6249781117) (-116987170 9233371207) (-153310392 14885462059) (243523167 16346803247) (-191276069 18221678207) (-114320902 30446482737) (430509851 31147706551) (-62448154 35587716432) (118676670 41734246913) (-206756368 73276714818) (103732367 73745675437) (887580 250645741818) (-42628659 69971515635443)) + (1/4 (59529729 1111885489) (411801489 1183092682) (-11697838 1770638022) (-10217933 2189376182) (178183864 2420845318) (481604223 2674664693) (200815307 2701984943) (18311409 4309606382) (-54066665 5684017953) (391091355 9566096322) (433050011 14033378718) (155959834 14474950443) (123563452 18221678207) (-322558047 18986886768) (-187246484 41734246913) (182267620 73276714818) (70949047 120563046313) (85657566 134237866432) (150508360 193100304493) (16824928 804006285737)) + (1/4 (79674619 1057929843) (430112898 1183092682) (103029535 1770638022) (419995354 1845907403) (161719567 2189376182) (25897285 2701984943) (-165526275 3651666474) (-450635225 4866438247) (418811986 5684017953) (520079918 9233371207) (-370946465 11079391432) (11498734 14033378718) (1575319 15548138481) (-17734177 18221678207) (310673925 18986886768) (179773324 91140429801) (10643092 193100304493) (158038974 250645741818) (-165442692 804006285737) (119720378 11484937157318)) + (1/4 (210413195 1047764193) (49034748 1057929843) (129893399 1111885489) (920835218 1222853176) (-367170458 1770638022) (-460082449 2154947322) (471386290 2189376182) (-4742586 2701984943) (-385386694 3651666474) (239038662 5684017953) (399473027 12988236682) (-298167989 14033378718) (111903950 15548138481) (-327400900 18221678207) (-789934617 18986886768) (-490722320 34352737807) (-639330225 193100304493) (-182267620 250645741818) (264670206 804006285737) (460026972 11484937157318)) + (1/4 (245117311 1057929843) (-441536832 1111885489) (694624721 1183092682) (357582197 1845907403) (993878808 2189376182) (-264511823 2296713307) (279266579 2701984943) (-1351244216 4866438247) (255211890 9233371207) (142361641 10855443178) (-647040605 11079391432) (-55648319 15548138481) (-29232911 18221678207) (533067633 35587716432) (34223580 41734246913) (165442692 73276714818) (-215957611 91140429801) (786436927 120563046313) (939525243 193100304493) (311982932 250645741818)) + (1/4 (290087814 1057929843) (129893399 1111885489) (189059832 1183092682) (312611694 1770638022) (-177755991 2189376182) (30639871 2539791558) (236310480 2701984943) (285108950 3651666474) (-530648699 5458840213) (208398791 5684017953) (381614163 14033378718) (81264079 15548138481) (-679782152 17249711432) (321741381 18221678207) (130900601 18986886768) (210413195 66492889557) (250865122 193100304493) (28145575 250645741818) (44970503 804006285737) (-460808246 11484937157318)) + (1/4 (719865552 1057929843) (-120111015 1111885489) (-210078035 1183092682) (62607280 1770638022) (322252837 2189376182) (486314894 2701984943) (254469079 3651666474) (149133453 4832545807) (-401152271 5684017953) (491057480 7804016832) (-30639871 8995467682) (-328807860 14033378718) (392548235 15548138481) (-311284156 17058320068) (-669324927 18221678207) (-180383555 18986886768) (-60419034 193100304493) (278149989 250645741818) (325614788 804006285737) (-180163961 11484937157318)) + (1/4 (764256596 1183092682) (340757269 1770638022) (82030807 2189376182) (-651971659 2296713307) (188678845 2539791558) (371182743 2701984943) (-541133952 5458840213) (282350263 5684017953) (261942239 9566096322) (414738602 14033378718) (-578034328 17249711432) (219993557 18221678207) (-126062774 18986886768) (-58097368 41734246913) (129149116 66492889557) (53118504 73276714818) (-68972608 120563046313) (210038089 193100304493) (285108950 579766497643) (16824928 804006285737)) + (1/2 (-389355483 1111885489) (-85198635 1770638022) (942772580 2189376182) (860225796 2296713307) (958295292 2439473093) (1701938869 2701984943) (570217900 3651666474) (-653171089 5684017953) (1290597651 9566096322) (632981931 14033378718) (-258298232 15548138481) (-716081542 18221678207) (-448620821 18986886768) (-1711424041 41734246913) (1131248413 73276714818) (1650144299 120563046313) (1441452520 193100304493) (766713173 250645741818) (800363029 804006285737) (-1590316151 11484937157318)) + (1/2 (-383575951 1082548618) (367447545 1695830317) (470326860 1845907403) (302791880 2060228568) (1332608020 2170952313) (1886585069 2189376182) (-562201563 2426435870) (610170129 2539791558) (-707278553 4732978887) (-215928441 6249781117) (-232950527 9233371207) (201602620 16346803247) (172870593 31147706551) (-125920121 35587716432) (696860645 41734246913) (207464734 66492889557) (-412488923 73276714818) (689924269 250645741818) (305596971 579766497643) (199162583 69971515635443)) + + (1/2 (468218462 2189376182) (1818521088 2439473093) (1312583386 2701984943) (121856072 5684017953) (-1109476277 6327662603) (570217900 8634733487) (1720710549 9566096322) (718180566 14033378718) (601927564 15548138481) (-1921221601 18221678207) (-59265338 18986886768) (1164382644 30446482737) (-936396880 41734246913) (701135515 73276714818) (1205140059 73745675437) (875117138 120563046313) (236312461 193100304493) (336600275 250645741818) (715164394 804006285737) (-815288990 11484937157318) (-860225796 69971515635443)) + ))) + (for-each + (lambda (formula) + (let ((r (/ 1 (car formula))) + (sum 0.0)) + (for-each + (lambda (arg) + (set! sum (+ sum (* (car arg) (atan (/ 1 (cadr arg))))))) + (cdr formula)) + + (if (> (magnitude (- (* r sum) our-pi)) 1e-12) + (begin (display formula) (display " = ") (display (* r sum)) (newline))))) + formulas) + + (if with-bigfloats + (let ((mxerr 0.0)) + (for-each + (lambda (formula) + (let ((r (/ (bignum "1") (car formula))) + (sum (bignum "0.0"))) + (for-each + (lambda (arg) + (set! sum (+ sum (* (car arg) (atan (/ (bignum "1") (cadr arg))))))) + (cdr formula)) + + (let ((err (magnitude (- (* r sum) (* 4 (atan (bignum "1.0") 1.0)))))) + (if (> err mxerr) + (set! mxerr err))))) + formulas) + (if (> mxerr 1e-30) + (format #t "big max error: ~A~%" mxerr))))) + + +(if with-bigfloats + (letrec ((sin-m*pi/n + (lambda (m1 n1) + + ;; this returns an expression giving the exact value of sin(m*pi/n), m and n integer + ;; if we can handle n -- currently it can be anything of the form 2^a 3^b 5^c 7^d 11^h 13^e 17^f 257^g + ;; so (sin-m*pi/n 1 60) returns an exact expression for sin(pi/60). + + (let ((m (numerator (/ m1 n1))) + (n (denominator (/ m1 n1)))) + + (set! m (modulo m (* 2 n))) + ;; now it's in lowest terms without extra factors of 2*pi + + (cond ((zero? m) 0) + + ((zero? n) (error "divide by zero (sin-m*pi/n n = 0)")) + + ((= n 1) 0) + + ((negative? n) + (let ((val (sin-m*pi/n m (- n)))) + (and val `(- ,val)))) + + ((> m n) + (let ((val (sin-m*pi/n (- m n) n))) + (and val `(- ,val)))) + + ((= n 2) (if (= m 0) 0 1)) + + ((= n 3) `(sqrt 3/4)) + + ((> m 1) + (let ((m1 (sin-m*pi/n (- m 1) n)) + (n1 (sin-m*pi/n 1 n)) + (m2 (sin-m*pi/n (- m 2) n))) + (and m1 m2 n1 + `(- (* 2 ,m1 (sqrt (- 1 (* ,n1 ,n1)))) ,m2)))) + + ((= n 5) `(/ (sqrt (- 10 (* 2 (sqrt 5)))) 4)) + + ((= n 7) `(let ((A1 (expt (+ -7/3456 (sqrt -49/442368)) 1/3)) + (A2 (expt (- -7/3456 (sqrt -49/442368)) 1/3))) + (sqrt (+ 7/12 (* -1/2 (+ A1 A2)) (* 1/2 0+i (sqrt 3) (- A1 A2)))))) + + ((= n 17) `(let* ((A1 (sqrt (- 17 (sqrt 17)))) + (A2 (sqrt (+ 17 (sqrt 17)))) + (A3 (sqrt (+ 34 (* 6 (sqrt 17)) (* (sqrt 2) (- (sqrt 17) 1) A1) (* -8 (sqrt 2) A2))))) + (* 1/8 (sqrt 2) (sqrt (- 17 (sqrt 17) (* (sqrt 2) (+ A1 A3))))))) + + + ((= n 11) `(let* ((SQRT5 (* 1/2 (- (sqrt 5) 1))) + (B5 (sqrt (+ 2 (* 1/2 (+ (sqrt 5) 1))))) + (B6 (+ SQRT5 (* 0+i B5))) + (B6_2 (* B6 B6)) + (B6_3 (* B6 B6 B6)) + (B6_4 (* B6 B6 B6 B6)) + (D1 (+ 6 (* 3/2 B6) (* 3/4 B6_2))) + (D2 (+ SQRT5 (* 0+i B5) (* 1/4 B6_2))) + (D3 (* 1/2 (- (+ 1 (* 0+i (sqrt 11)))))) + (D4 (* 1/2 (- (* 0+i (sqrt 11)) 1))) + (D6 (+ 1 (* 1/4 B6_2) (* 1/8 B6_3))) + (D7 (+ (* 1/2 B6) (* 1/16 B6_4))) + (D8 (+ 2 (* 1/2 B6))) + (D9 (+ 13 (* 21 B6) (* 67/4 B6_2) (* 21/4 B6_3) (* 2 B6_4))) + (D11 (+ 129 (* 109/2 B6) (* 59/4 B6_2) (* 9/8 B6_3) (* 9/16 B6_4))) + (D13 (+ (* 3 B6) B6_2)) + (D14 (+ (* 3 B6) (* 3/4 B6_2) (* 3/8 B6_3))) + (D15 (+ 79 (* 27 B6) (* 39/4 B6_2) (* 37/4 B6_3) (* 21/4 B6_4))) + (D16 (+ D11 (* D3 D9) (* D4 D15))) + (D17 (+ D11 (* D4 D9) (* D3 D15))) + (D30 (/ (* B6_2 (+ (* D3 D6) (* D4 D7))) (* 4 (expt D17 1/5)))) + (D32 (* 1/2 (+ 1 (* 0+i (sqrt 11))))) + (D33 (/ (* B6_3 (+ (* D4 D6) (* D3 D7))) (* 8 (expt D16 1/5)))) + (D34 (* 1/4 B6_2 (expt D16 1/5))) + (D35 (+ 2 (* 1/8 B6_4) (* 1/2 B6 D8) (* 1/8 B6_3 D2))) + (D36 (+ SQRT5 (* 0+i B5) (* 1/2 B6_2) (* 1/4 B6_3) (* 1/2 B6 D2) (* 1/4 B6_2 (+ (* 1/4 B6_3) (* 1/16 B6_4))))) + (D38 (* 1/2 (+ -1 (* 0+i (sqrt 11))))) + (D39 (* 1/8 B6_3 (expt D17 1/5))) + (D40 (+ 3 (* 3/2 B6) (* 9/4 B6_2) (* 7/8 B6_3) (* 3/16 B6_4) (* 1/2 B6 (+ 6 (* 2 B6))) + (* 1/16 B6_4 D1) (* 1/4 B6_2 D13) (* 1/8 B6_3 (+ 3 (* 3/4 B6_3) (* 3/16 B6_4))))) + (D41 (+ (* 1/4 B6_2 D1) (* 1/8 B6_3 D13) (* 1/16 B6_4 D14) (* 1/2 B6 (+ 4 (* 3/8 B6_4))))) + (D42 (+ 3 (* 3/4 B6_3) (* 3/16 B6_4) (* 1/8 B6_3 D1) (* 1/4 B6_2 D14) + (* 1/2 B6 (+ (* 3/2 B6_2) (* 3/8 B6_3) (* 3/16 B6_4))) (* 1/16 B6_4 (+ 3 (* 3/2 B6) (* 3/8 B6_4))))) + (D43 (+ (* 1/4 B6_3) (* 1/16 B6_4) (* 1/8 B6_3 D8) (* 1/4 B6_2 D2) + (* 1/2 B6 (+ (* 1/2 B6_2) (* 1/8 B6_3))) (* 1/16 B6_4 (+ 1 (* 1/8 B6_4))))) + (D44 (/ (* B6_4 (+ D42 (* D4 D40) (* D3 D41))) (* 16 (expt D16 3/5)))) + (D45 (/ (* B6 (+ D42 (* D3 D40) (* D4 D41))) (* 2 (expt D17 3/5)))) + (D48 (/ (* B6 (+ D43 (* D3 D35) (* D4 D36))) (* 2 (expt D16 2/5)))) + (D49 (/ (* B6_4 (+ D43 (* D4 D35) (* D3 D36))) (* 16 (expt D17 2/5))))) + (* -1/2 0+i + (+ (* 1/5 (- D32 D33 D34 D48 D44)) + (* 1/5 (+ D38 D30 D39 D49 D45)))))) + + ((= n 13) + `(let* ((A1 (/ (- -1 (sqrt 13)) 2)) + (A2 (/ (+ -1 (sqrt 13)) 2)) + (A3 (/ (+ -1 (* 0+i (sqrt 3))) 2)) + (A4 (+ -1 (* 0+i (sqrt 3)))) + (A5 (* 0+i (sqrt (+ 7 (sqrt 13) A2)))) + (A6 (* 0+i (sqrt (+ 7 (- (sqrt 13)) A1)))) + (A8 (* 1/2 (- A2 A6))) + (A9 (* 1/2 (+ A1 A5))) + (A11 (* 1/2 (+ A2 A6))) + (A12 (* 1/2 (- A1 A5))) + (A13 (* 3/2 A4 A8)) + (A14 (* 3/2 A4 A11)) + (A15 (* 3/4 A4 A4 A11)) + (A16 (* 3/4 A4 A4 A8)) + (A17 (+ A3 (* 1/4 A4 A4)))) + (* -1/6 0+i (+ (- A9 A12) + (* A4 (+ (/ (+ A8 (* A17 A12)) (* 2 (expt (+ 6 A13 A15 A9) 1/3))) + (/ (+ A11 (* A17 A9)) (* -2 (expt (+ 6 A16 A14 A12) 1/3))) + (* 1/4 A4 (- (expt (+ 6 A13 A15 A9) 1/3) (expt (+ 6 A16 A14 A12) 1/3))))))))) + + ((= n 257) + `(let* ((A1 (sqrt (- 514 (* 2 (sqrt 257))))) + (A2 (- 257 (* 15 (sqrt 257)))) + (A3 (+ 257 (* 15 (sqrt 257)))) + (A4 (- 257 (sqrt 257))) + (A5 (+ (sqrt 257) 257)) + (A7 (+ 257 (* 9 (sqrt 257)))) + (A8 (- 514 (* 18 (sqrt 257)))) + (AA (sqrt (* 2 A5))) + (A9 (sqrt (+ A2 (* 8 A1) (* -7 AA)))) + (A10 (sqrt (+ A2 (* -8 A1) (* 7 AA)))) + (A11 (sqrt (+ A3 (* 7 A1) (* 8 AA)))) + (A12 (sqrt (+ A3 (* -7 A1) (* -8 AA)))) + (A13 (sqrt (+ A8 (* 6 A1) (* 8 A9) (* -24 A10) (* 12 A11)))) + (A14 (* 4 (sqrt (+ A8 (* 6 A1) (* -8 A9) (* 24 A10) (* -12 A11))))) + (A15 (* 4 (sqrt (+ A8 (* -6 A1) (* -12 A12) (* 24 A9) (* 8 A10))))) + (A16 (* 4 (sqrt (* 2 (+ (- 257 (* 9 (sqrt 257))) (* -3 A1) (* 6 A12) (* -12 A9) (* -4 A10)))))) + (A17 (sqrt (* 2 (+ A7 (* -3 AA) (* -4 A12) (* 6 A9) (* 12 A11))))) + (A18 (sqrt (* 2 (+ A7 (* 3 AA) (* 12 A12) (* -6 A10) (* 4 A11))))) + (A19 (* 4 (sqrt (* 2 (+ A7 (* 3 AA) (* -12 A12) (* 6 A10) (* -4 A11)))))) + (A20 (* 4 (sqrt (* 2 (+ A7 (* -3 AA) (* 4 A12) (* -6 A9) (* -12 A11)))))) + (A22 (+ A4 (* 3 A1) (* -4 AA) (* -4 A12) (* 4 A9) (* -4 A10) (* 2 A11))) + (A23 (+ A5 (* -4 A1) (* -3 AA) (* -4 A12) (* 2 A9) (* 4 A10) (* 4 A11))) + (A24 (+ A5 (* 4 A1) (* 3 AA) (* 4 A12) (* 4 A9) (* -2 A10) (* 4 A11))) + (A26 (sqrt (+ A22 (+ (- A16) (- A19) (* 4 A17) (* -6 A13))))) + (A27 (sqrt (+ A22 (+ A16 A19 (* -4 A17) (* 6 A13))))) + (A28 (+ 257 (* 7 (sqrt 257)) (* 3 A1) (* -4 A9) (* 4 A10) (* 6 A11))) + (A29 (* 8 (sqrt (+ A24 A15 (- A20) (* -6 A18) (* -4 A13))))) + (A30 (+ A28 (* -4 A18) (* -4 A17) (* -2 A13))) + (A31 (+ (* 8 (sqrt (+ A23 A15 A14 (* 4 A18) (* -6 A17)))) (* 4 A26) A29 (* -8 A27)))) + (* 1/16 (sqrt (* 1/2 (+ A4 (- A1) (* -2 A11) (* -2 A13) (* -4 A26) + (* -4 (sqrt (* 2 (+ A30 (- A31))))) + (* -8 (sqrt (+ A4 (- A1) (* -2 A11) (* 6 A13) (* -4 A26) (* -8 A27) + (* 4 (sqrt (* 2 (+ A30 A31)))) + (* -8 (sqrt (* 2 (+ A28 (* 4 A18) (* 4 A17) (* 2 A13) (* -8 A26) (* -4 A27) + (* -8 (sqrt (+ A23 (- A15) (- A14) (* -4 A18) (* 6 A17)))) + (* -8 (sqrt (+ A24 (- A15) A20 (* 6 A18) (* 4 A13))))))))))))))))) + + ((or (= (modulo n 2) 0) (= (modulo n 3) 0) (= (modulo n 5) 0) (= (modulo n 7) 0) + (= (modulo n 17) 0) (= (modulo n 13) 0) (= (modulo n 257) 0) (= (modulo n 11) 0)) + (let ((divisor (if (= (modulo n 2) 0) 2 + (if (= (modulo n 3) 0) 3 + (if (= (modulo n 5) 0) 5 + (if (= (modulo n 7) 0) 7 + (if (= (modulo n 17) 0) 17 + (if (= (modulo n 13) 0) 13 + (if (= (modulo n 11) 0) 11 + 257))))))))) + (let ((val (sin-m*pi/n 1 (/ n divisor)))) + (and val + `(let ((ex ,val)) + (/ (- (expt (+ (sqrt (- 1 (* ex ex))) (* 0+i ex)) (/ 1 ,divisor)) + (expt (- (sqrt (- 1 (* ex ex))) (* 0+i ex)) (/ 1 ,divisor))) + 0+2i)))))) + + (else #f)))))) + + (let ((maxerr 0.0) + (max-case #f) + (cases 0)) + (do ((n 1 (+ n 1))) + ((= n 100)) + (do ((m 1 (+ m 1))) + ((= m 4)) + (letrec ((bigify (lambda (lst) + (if (pair? lst) + (cons (if (number? (car lst)) + (list 'bignum (number->string (car lst))) + (bigify (car lst))) + (bigify (cdr lst))) + lst)))) + (let ((val (sin (/ (* m our-pi) n))) + (expr (bigify (sin-m*pi/n m n)))) + (if expr + (let ((err (magnitude (- val (eval expr))))) + (set! cases (+ cases 1)) + (if (> err maxerr) + (begin + (set! max-case (/ m n)) + (set! maxerr err))))))))) + (if (> maxerr 1e-35) + (format #t "sin-m*pi/n (~A cases) max err ~A at ~A~%" cases maxerr max-case)))) + ) + + +(test (integer? (expt 2.3 54)) #f) +(test (zero? (- (expt 2.3 54) (floor (expt 2.3 54)))) #f) +(test (integer? 10000000000000000.5) #f) +(test (integer? (expt 2 54)) #t) +(num-test (+ 1 (expt 2 54)) 18014398509481985) +(num-test (- (expt 2 54) 18014398509481984) 0) +(num-test (- (expt 2 54) 18014398509481983) 1) +(num-test (+ 10000000000000000 1) 10000000000000001) +(num-test (- 10000000000000000 9999999999999999) 1) +(num-test (/ (expt 2 -53) 2) (expt 2 -54)) +(num-test (* 1/18014398509481984 1/2) (expt 2 -55)) +(num-test (/ (expt 2.3 50) (expt 2.3 49)) 2.3) +(num-test (/ 1e-10 1e10) 1e-20) +;(num-test (/ 1e-20 1e300) 1e-321) +;;; why: (- 1e-2 (expt 10 -2)) = 2.081668171172168513294235909273361692968E-19? in guile it's 0.0 +(num-test (/ (expt 10 -20) (expt 10 -20)) 1) +(num-test (/ (expt 10 -200) (expt 10 -200)) 1) +(num-test (* .000000000000123 .000000000000123) 1.5129e-26) +(num-test (sqrt (* 1.2345e-27 1.2345e-27)) 1.2345e-27) +(num-test (sqrt (* 1.2345e-127 1.2345e-127)) 1.2345e-127) + +(if with-bigfloats + (begin + + (num-test (/ (sqrt (* 1.2345e-170 1.2345e-170))) 8.100445524503847216161209708816501953798E169) + (num-test (/ (expt (* 1.2345e-170 1.2345e-170) 1/100)) 2.501325312985302606641508258507698932691E3) + (num-test (/ (+ 1.2345e-15 1 -1)) 8.1004455245038e+14) + (num-test (/ (+ 1 1.2345e-14 -1)) 81004455245038.0) + (num-test (/ (+ 1 1.2345e-10 -1)) 8100445524.5038) + (num-test (* 1.2345e-15 8.1004455245038e+14) 9.999999999999941444123044301452428384978E-1) ; the inverse is not exact + (num-test (+ 1.23456789 1.0e11 -1.0e11) 1.23456789) + (num-test (- 1.0e11 -1.23456789 1.0e11) 1.23456789) + (num-test (* 2.0e-170 3.0e-170 4.0e170 5.0e170) 120.0) + (num-test (* 4.0e170 5.0e170 2.0e-170 3.0e-170) 120.0) + (num-test (* 1000000.0 (+ 1.0 1.2345e-10 -1.0)) 1.2345e-4) + (num-test (* 1000000.0 (- 1.0 -1.2345e-10 1.0)) 1.2345e-4) + + (let ((p (lambda (x y) (+ (* 2 y y) (* 9 x x x x) (* -1 y y y y))))) + (num-test (p 408855776 708158977) 1)) + (let ((p (lambda (x y) (+ (* 2 y y) (* (- (* 3 x x) (* y y)) (+ (* 3 x x) (* y y))))))) + (num-test (p 408855776 708158977) 1)) + + )) + +(num-test (tan (/ our-pi 4)) 1.0) + +(num-test (+ (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10))) + 4197377/1049600) +(num-test (- (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10))) + -3073/1049600) +(num-test (* (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10))) + 4098/1025) +(num-test (/ (/ (expt 2 11) (+ (expt 2 10) 1)) (/ (+ (expt 2 11) 1) (expt 2 10))) + 2097152/2100225) + +(if with-64-bit-ints + (begin + (num-test (+ (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20))) + 4398049656833/1099512676352) + (num-test (- (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20))) + -3145729/1099512676352) + (num-test (* (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20))) + 4194306/1048577) + (num-test (/ (/ (expt 2 21) (+ (expt 2 20) 1)) (/ (+ (expt 2 21) 1) (expt 2 20))) + 2199023255552/2199026401281) + + (num-test (+ (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20))) + 4503601775902721/1099512676352) + (num-test (- (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20))) + -2148532225/1099512676352) + (if (not with-bignums) + (num-test (* (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20))) + 4194300.0019569) + (num-test (* (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20))) + 4398046513152/1048577)) + (num-test (/ (/ (expt 2 31) (+ (expt 2 20) 1)) (/ (+ (expt 2 31) 1) (expt 2 20))) + 2251799813685248/2251801962217473) + )) + +(if with-bignums + (begin + (num-test (+ (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40))) + 5070602400915223450095538143233/1208925819615728686333952) + (num-test (- (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40))) + -2305844108725321729/1208925819615728686333952) + (num-test (* (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40))) + 4835703278458516700921856/1099511627777) + (num-test (/ (/ (expt 2 61) (+ (expt 2 40) 1)) (/ (+ (expt 2 61) 1) (expt 2 40))) + 2535301200456458802993406410752/2535301200458764647102131732481) + )) + +(if (and (not with-bignums) (not with-64-bit-ints)) + (begin + (num-test (+ 1/98947 2/97499 3/76847) 6.9658060696377e-05) + (num-test (- 1/98947 2/97499 3/76847) -4.9445219478352e-05) + (num-test (* 1/98947 2/97499 3/76847) 8.0932236106886e-15) + (num-test (/ 1/98947 2/97499 3/76847) 12620.402257437) + ) + (begin + (num-test (+ 1/98947 2/97499 3/76847) 51641766530/741360956847391) + (num-test (- 1/98947 2/97499 3/76847) -36656755224/741360956847391) + (num-test (* 1/98947 2/97499 3/76847) 6/741360956847391) + (num-test (/ 1/98947 2/97499 3/76847) 7492505653/593682) + )) + +(if (and (not with-bignums) (not with-64-bit-ints)) + (begin + (num-test (+ 500009/500029 500057/500041) 1.99999199969608) + (num-test (- 500009/500029 500057/500041) -7.19950563497026e-5) + (num-test (* 500009/500029 500057/500041) 0.99999199841626) + (num-test (/ 500009/500029 500057/500041) 0.999928007247229)) + (begin + (num-test (+ 500009/500029 500057/500041) 500068002022/250035001189) + (num-test (- 500009/500029 500057/500041) -18001284/250035001189) + (num-test (* 500009/500029 500057/500041) 250033000513/250035001189) + (num-test (/ 500009/500029 500057/500041) 250025000369/250043001653))) + +(if (not with-bignums) + (begin + (num-test (+ 500009/500029 500057/500041 500083/500069) 3.00001999583261) + (num-test (- 500009/500029 500057/500041 500083/500069) -1.00009999119288) + (num-test (* 500009/500029 500057/500041 500083/500069) 1.00001999432878) + (num-test (/ 500009/500029 500057/500041 500083/500069) 0.999900013909921)) + (begin + (num-test (+ 500009/500029 500057/500041 500083/500069) 375106759202738205/125034753009582041) + (num-test (- 500009/500029 500057/500041 500083/500069) -125047255383687283/125034753009582041) + (num-test (* 500009/500029 500057/500041 500083/500069) 125037252995542579/125034753009582041) + (num-test (/ 500009/500029 500057/500041 500083/500069) 125029751909525461/125042254395637199))) + +(if (not with-bignums) + (begin + (num-test (+ 1/98947 2/97499 3/76847 4/61981) 0.00013419396686117) + (num-test (- 1/98947 2/97499 3/76847 4/61981) -0.00011398112564314) + (num-test (* 1/98947 2/97499 3/76847 4/61981) 5.2230351951008e-19) + (if with-64-bit-ints + (num-test (/ 1/98947 2/97499 3/76847 4/61981) 464392992878593/2374728) ;195556288.07955 -- seems to fit + (num-test (/ 1/98947 2/97499 3/76847 4/61981) 195556288.07955)) + ) + (begin + (num-test (+ 1/98947 2/97499 3/76847 4/61981) 6166252158685494/45950293466358141571) + (num-test (- 1/98947 2/97499 3/76847 4/61981) -5237466172928308/45950293466358141571) + (num-test (* 1/98947 2/97499 3/76847 4/61981) 24/45950293466358141571) + (num-test (/ 1/98947 2/97499 3/76847 4/61981) 464392992878593/2374728) + )) + +(if (not with-bignums) + (begin + (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981) 0.00021755369744252) + (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981) -0.00019734085622449) + (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981) 4.3539080668052e-23) + (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981) 2345932343059.9) + ) + (begin + (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981) 599609438061905323469/2756144552405627689570151) + (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981) -543899925850203550003/2756144552405627689570151) + (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981) 120/2756144552405627689570151) + (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981) 27854756105850886733/11873640) + )) + +(if (not with-bignums) + (begin + (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 0.00030764243484887) + (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) -0.00028742959363084) + (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 3.9223808052178e-27) + (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 2.6040239996689e+16) + ) + (begin + (num-test (+ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 56471455498794722585779775/183561983334767209753061626751) + (num-test (- 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) -52761146275983172771170709/183561983334767209753061626751) + (num-test (* 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 720/183561983334767209753061626751) + (num-test (/ 1/98947 2/97499 3/76847 4/61981 5/59981 6/66601) 1855154611405774907304533/71241840) + )) + +(if (not with-bignums) + (begin + (num-test (+ 98947 2/97499 76847 4/61981 5/59981) 175794.00016841) + (num-test (- 98947 2/97499 76847 4/61981 5/59981) 22099.999831591) + (if with-64-bit-ints + (num-test (* 98947 2/97499 76847 4/61981 5/59981) 304151204360/362470312515139) ;0.00083910652502692 + (num-test (* 98947 2/97499 76847 4/61981 5/59981) 0.00083910652502692)) + (num-test (/ 98947 2/97499 76847 4/61981 5/59981) 11667778186668.0) + ) + (begin + (num-test (+ 98947 2/97499 76847 4/61981 5/59981) 63720106179329487759/362470312515139) + (num-test (- 98947 2/97499 76847 4/61981 5/59981) 8010593845541429507/362470312515139) + (num-test (* 98947 2/97499 76847 4/61981 5/59981) 304151204360/362470312515139) + (num-test (/ 98947 2/97499 76847 4/61981 5/59981) 35865350012435458633/3073880) + )) + +(num-test (* 2 (asin 1)) our-pi) + +(num-test (+ 1e100 -1e100) 0.0) +(num-test (+ 1e200 -1e200) 0.0) +(num-test (+ 1e300 -1e300) 0.0) +(num-test (* 1e100 1e-100) 1.0) +(num-test (* 1e200 1e-200) 1.0) +(num-test (* 1e300 1e-300) 1.0) +(num-test (* 1e100 0.001) 1e97) +(test (= 1e100 1e+100) #t) +(num-test (+ 1e100 1e100) 2e100) +(num-test (let ((x 1) (y 2)) (set! x (* 0 (let () (set! y 32) 1))) y) 32) +(num-test (* 11/1234 1234/11 11/1234 1234/11 11/1234 1234/11) 1) + +(num-test (/ 1.0 (/ 1.0 our-pi)) our-pi) +(num-test (/ 1 (/ 1 1234)) 1234) +(num-test (* our-pi (+ 1.0 (atan (tan (acos (cos (asin (sin (/ 1.0 (/ 1.0 our-pi)))))))))) our-pi) +(num-test (/ 1.0 (/ 1.0 1.0+1.0i)) 1.0+1.0i) + +(let* ((angle 0.0) + (z 1.18) + (result (* z (cos angle)))) + (do ((k 0 (+ 1 k))) + ((= k 1000)) + (set! result (* z (cos result)))) + ;;result: 0.81194462369499 + ;;(let ((x 0.0)) + ;; (do ((i 0 (+ 1 i))) + ;; ((= i 10000)) + ;; (set! x (+ x (* (expt -1 i) + ;; (/ (bes-jn (+ 1 (* 2 i)) (* z (+ 1 (* 2 i)))) + ;; (+ 1 (* 2 i))))))) + ;; (* 2 x)) + ;; 0.81194498071946 + (let ((x (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos (* z (cos 0.0)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) + ;; 47? calls here so we're at around .812 (oscillating around .8119) + (test (< (abs (- x result)) .001) #t))) + +(num-test (exp (make-rectangular 0.0 our-pi)) -1.0) + +(if (positive? 2147483648) + (begin + (num-test (/ 12341234/111 123456789 12341234/111) 1/123456789) + (num-test (abs -922337203685477580) 922337203685477580))) + +(if (or with-bignums with-64-bit-ints) + (begin + (num-test (+ 123456789/3 3/123456789 -123456789/3 -3/123456789) 0) + (num-test (/ 123412341234) 1/123412341234) + (num-test (/ 1/123412341234) 123412341234))) + + +(let ((dht (lambda (data) + ; the Hartley transform of 'data' + (let* ((len (vector-length data)) + (arr (make-vector len 0.0)) + (w (/ (* 2.0 our-pi) len))) + (do ((i 0 (+ 1 i))) + ((= i len)) + (do ((j 0 (+ 1 j))) + ((= j len)) + (vector-set! arr i (+ (vector-ref arr i) + (* (vector-ref data j) + (+ (cos (* i j w)) + (sin (* i j w)))))))) + arr))) + (data (list->vector '(0.9196 0.9457 0.0268 0.0839 0.1974 0.1060 0.1463 0.3513 0.0391 0.6310 + 0.9556 0.6259 0.9580 0.8848 0.0104 0.1440 0.0542 0.3001 0.1844 0.3781 + 0.9641 0.6051 0.3319 0.6143 0.1828 0.2290 0.4026 0.5990 0.7906 0.0403 + 0.7882 0.1591))) + (saved-data (make-vector 32 0.0))) + (do ((i 0 (+ i 1))) + ((= i 32)) + (vector-set! saved-data i (vector-ref data i))) + (dht data) + (dht data) + (let ((mx 0.0)) + (do ((i 0 (+ i 1))) + ((= i 32)) + (let ((err (abs (- (vector-ref data i) (vector-ref saved-data i))))) + (if (> err mx) + (set! mx err)))) + (if (> mx 1e-6) + (begin (display "dht error: ") (display mx) (newline))))) + +(num-test (+ 3 4) 7 ) +(num-test (+ 3) '3 ) +(num-test (+) 0 ) +(num-test (* 4) 4 ) +(num-test (*) 1 ) +(num-test (- 3 4) -1 ) +(num-test (- 3) -3 ) + +;;;;From: fred@sce.carleton.ca (Fred J Kaudel) +;;; Modified by jaffer. +(let ((f3.9 (string->number "3.9")) + (f4.0 (string->number "4.0")) + (f-3.25 (string->number "-3.25")) + (f.25 (string->number ".25")) + (f4.5 (string->number "4.5")) + (f3.5 (string->number "3.5")) + (f0.0 (string->number "0.0")) + (f0.8 (string->number "0.8")) + (f1.0 (string->number "1.0")) + (f1e300 (and (string->number "1+3i") (string->number "1e300"))) + (f1e-300 (and (string->number "1+3i") (string->number "1e-300")))) + + (test (eqv? 1 f1.0) #f ) + (test (eqv? 0 f0.0) #f ) + (test (eqv? f0.0 f0.0) #t ) + (test (= f0.0 f0.0) #t ) + (test (= f0.0 (- f0.0)) #t ) + (test (= f0.0 (* -5 f0.0)) #t ) + (test (inexact? f3.9) #t ) + (test (exact->inexact 4) f4.0 ) + (test (exact->inexact 4.0) f4.0 ) + (test (inexact->exact 4) 4 ) + (test (inexact->exact 4.0) 4 ) + (num-test (round f0.0) f0.0 ) + (num-test (round f.25) f0.0 ) + (num-test (round f0.8) f1.0 ) + (num-test (round f3.5) f4.0 ) + (num-test (round f4.5) f4.0 ) + (num-test (expt f0.0 f1.0) f0.0 ) + (num-test (expt f0.0 1) f0.0 ) + (num-test (expt 0 f1.0) f0.0 ) + (num-test (expt -25 f0.0) f1.0 ) + (num-test (expt f-3.25 f0.0) f1.0 ) + (num-test (expt f-3.25 0) 1.0 ) + (num-test (atan 1 1) (atan 1))) + +(if with-bignums + (begin + (letrec ((tb (lambda (n1 n2) + (= n1 (+ (* n2 (quotient n1 n2)) + (remainder n1 n2)))))) + (let ((b3-3 (string->number "33333333333333333333")) + (b3-2 (string->number "33333333333333333332")) + (b3-0 (string->number "33333333333333333330")) + (b2-0 (string->number "2177452800"))) + + (num-test (modulo b3-3 3) 0 ) + (num-test (modulo b3-3 -3) 0 ) + (num-test (remainder b3-3 3) 0 ) + (num-test (remainder b3-3 -3) 0 ) + (num-test (modulo b3-2 3) 2 ) + (num-test (modulo b3-2 -3) -1 ) + (num-test (remainder b3-2 3) 2 ) + (num-test (remainder b3-2 -3) 2 ) + (num-test (modulo (- b3-2) 3) 1 ) + (num-test (modulo (- b3-2) -3) -2 ) + (num-test (remainder (- b3-2) 3) -2 ) + (num-test (remainder (- b3-2) -3) -2 ) + + (num-test (modulo 3 b3-3) 3 ) + (num-test (modulo -3 b3-3) b3-0 ) + (num-test (remainder 3 b3-3) 3 ) + (num-test (remainder -3 b3-3) -3 ) + (num-test (modulo -3 (- b3-3)) -3 ) + (num-test (remainder 3 (- b3-3)) 3 ) + (num-test (remainder -3 (- b3-3)) -3 ) + + (num-test (modulo (- b2-0) 86400) 0 ) + (num-test (modulo b2-0 -86400) 0 ) + (num-test (modulo b2-0 86400) 0 ) + (num-test (modulo (- b2-0) -86400) 0 ) + (num-test (modulo 0 (- b2-0)) 0 )) + + (num-test (abs -12345678901234567890) 12345678901234567890) + (num-test (abs 12345678901234567890) 12345678901234567890) + (num-test (modulo 12345678901234567890 3123) 1071) + (num-test (modulo 12345678901234567890 12345678901234567) 890) + + (test (even? 12345678901234567890) #t) + (test (even? 12345678901234567891) #f) + (test (odd? 12345678901234567891) #t) + (test (odd? 12345678901234567890) #f) + (test (positive? 12345678901234567890) #t) + (test (positive? -12345678901234567890) #f) + (test (negative? 12345678901234567890) #f) + (test (negative? -12345678901234567890) #t) + (test (zero? 12345678901234567890) #f) + (test (exact? 12345678901234567890) #t) + (test (inexact? 12345678901234567890) #f) + (test (> 12345678901234567890 12345678901234567891) #f) + (test (< 12345678901234567890 12345678901234567891) #t) + (test (>= 12345678901234567890 12345678901234567891) #f) + (test (<= 12345678901234567890 12345678901234567891) #t) + (test (= 12345678901234567890 12345678901234567891) #f) + + (num-test (max 12345678901234567890 12345678901234567891) 12345678901234567891) + (num-test (min 12345678901234567890 12345678901234567891) 12345678901234567890) + (num-test (gcd 12345678901234567890 12345) 15) + + ;; (test (not (= (sin 12345678901234567890) (cos 12345678901234567890))) #t) ; and so on + + (num-test (+ 4611686018427387904 1) 4611686018427387905) ; (expt 2 62) + 1 -- should work in both cases + (num-test (+ 4611686018427387904 -1) 4611686018427387903) + (num-test (+ 4611686018427387904 4611686018427387904) 9223372036854775808) + (num-test (+ 4611686018427387904 -4611686018427387904) 0) + (num-test (+ 8589934592 4611686018427387904) 4611686027017322496) + (num-test (+ 2147483648 4611686018427387904) 4611686020574871552) + (num-test (+ 2147483647 4611686018427387904) 4611686020574871551) + (num-test (+ 2147483649 4611686018427387904) 4611686020574871553) + (num-test (+ 8589934591 4611686018427387904) 4611686027017322495) + (num-test (+ -8589934591 4611686018427387904) 4611686009837453313) + (num-test (+ -8589934591 -4611686018427387904) -4611686027017322495) + (num-test (+ 8589934591 -4611686018427387904) -4611686009837453313) + (num-test (+ 2147483649 4611686018427387904 2147483649 4611686018427387904) 9223372041149743106) + (num-test (+ 9223372041149743106 9223372041149743106) 18446744082299486212) + (num-test (+ 9223372041149743106 -9223372041149743106) 0) + (num-test (+ 18446744082299486212 1) 18446744082299486213) + (num-test (+ 9223372036854775807 -1) 9223372036854775806) + (num-test (+ -9223372036854775807 -1) -9223372036854775808) + (num-test (+ -9223372036854775807 1) -9223372036854775806) + (num-test (+ 1073741825 1073741825) 2147483650) + (num-test (+ 2147483649 -4611686018427387904 -2147483649 4611686018427387904) 0) + (num-test (+ 1099511627775 9223372036854775807) 9223373136366403582) + (num-test (+ 576460752303423488 576460752303423488 576460752303423488 576460752303423488 + 576460752303423488 576460752303423488 576460752303423488 576460752303423488 + 576460752303423488 576460752303423488 576460752303423488 576460752303423488 + 576460752303423488 576460752303423488 576460752303423488 576460752303423488) + 9223372036854775808) + (num-test (+ -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488 + -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488 + -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488 + -576460752303423488 -576460752303423488 -576460752303423488 -576460752303423488) + -9223372036854775808) ; this fits in both cases = -(expt 2 63) + + (num-test (+ 1e400 1e399) 1.1e400) + + (test (real? 9223372036854775808) #t) + (test (integer? 9223372036854775808) #t) + (test (number? 9223372036854775808) #t) + (test (rational? 9223372036854775808) #t) + (test (complex? 9223372036854775808) #t) + (test (positive? 9223372036854775808) #t) + (test (negative? 9223372036854775808) #f) + (test (zero? 9223372036854775808) #f) + + (test (real? 9223372036854775808.1) #t) + (test (integer? 9223372036854775808.1) #f) + (test (number? 9223372036854775808.1) #t) + (test (rational? 9223372036854775808.1) #f) + (test (complex? 9223372036854775808.1) #t) + (test (positive? 9223372036854775808.1) #t) + (test (negative? 9223372036854775808.1) #f) + (test (zero? 9223372036854775808.1) #f) + + (test (real? 9223372036854775808/3) #t) + (test (integer? 9223372036854775808/3) #f) + (test (number? 9223372036854775808/3) #t) + (test (rational? 9223372036854775808/3) #t) + (test (complex? 9223372036854775808/3) #t) + (test (positive? 9223372036854775808/3) #t) + (test (negative? 9223372036854775808/3) #f) + (test (zero? 9223372036854775808/3) #f) + + (test (real? 9223372036854775808.1+1.5i) #f) + (test (integer? 9223372036854775808.1+1.5i) #f) + (test (number? 9223372036854775808.1+1.5i) #t) + (test (rational? 9223372036854775808.1+1.5i) #f) + (test (complex? 9223372036854775808.1+1.5i) #t) + (test (zero? 9223372036854775808.1+1.5i) #f) + + (num-test (+ 2147483647 1) 2147483648) + (num-test (+ 2147483648 -1) 2147483647) + (num-test (+ 2147483647 2) 2147483649) + (num-test (+ 2147483648 -2) 2147483646) + (num-test (+ 2147483648 1) 2147483649) + (num-test (+ 2147483649 -1) 2147483648) + + (num-test (+ 9223372036854775807 1) 9223372036854775808) + (num-test (+ 9223372036854775808 -1) 9223372036854775807) + (num-test (+ 9223372036854775807 2) 9223372036854775809) + (num-test (+ 9223372036854775808 -2) 9223372036854775806) + (num-test (+ 9223372036854775808 1) 9223372036854775809) + (num-test (+ 9223372036854775809 -1) 9223372036854775808) + + (test (rational? 1234567891234567890/1234567) #t) + (test (real? 1234567891234567890/1234567) #t) + (test (complex? 1234567891234567890/1234567) #t) + (test (number? 1234567891234567890/1234567) #t) + (test (integer? 1234567891234567890/1234567) #f) + + (num-test (numerator 1234567891234567890/1234567) 1234567891234567890) + (num-test (denominator 1234567891234567890/1234567) 1234567) + + (num-test (numerator 9223372036854775808/9223372036854775807) 9223372036854775808) + (num-test (denominator 9223372036854775808/9223372036854775807) 9223372036854775807) + + (num-test (+ 9223372036854775808/9223372036854775808) 1) + (test (integer? 9223372036854775808/9223372036854775808) #t) + + (test (even? 9223372036854775808) #t) + (test (odd? 9223372036854775808) #f) + (test (even? 1234567891234567891) #f) + (test (odd? 1234567891234567891) #t) + (test (even? -9223372036854775808) #t) + (test (odd? -9223372036854775808) #f) + (test (even? -1234567891234567891) #f) + (test (odd? -1231234567891234567891) #t) + (test (even? 1239223372036854775808) #t) + (test (odd? 1239223372036854775808) #f) + (test (even? 1231234567891234567891) #f) + (test (odd? 1231234567891234567891) #t) + (test (even? -1239223372036854775808) #t) + (test (odd? -1239223372036854775808) #f) + (test (even? -1231234567891234567891) #f) + (test (odd? -1231234567891234567891) #t) + (test (even? 2147483647) #f) + (test (even? 2147483648) #t) + (test (even? 2147483649) #f) + (test (odd? 2147483647) #t) + (test (odd? 2147483648) #f) + (test (odd? 2147483649) #t) + (test (even? -2147483647) #f) + (test (even? -2147483648) #t) + (test (even? -2147483649) #f) + (test (odd? -2147483647) #t) + (test (odd? -2147483648) #f) + (test (odd? -2147483649) #t) + +; (test (even? 9223372036854775808/9223372036854775807) 'error) + + (num-test (numerator (/ 2 -1)) -2) + (num-test (denominator (/ 2 -1)) 1) + (num-test (numerator (/ 9223372036854775808 -9223372036854775807)) -9223372036854775808) + (num-test (denominator (/ 9223372036854775808 -9223372036854775807)) 9223372036854775807) + + (num-test (+ 9223372036854775808 3/4) 36893488147419103235/4) + (num-test (+ 3/4 9223372036854775808) 36893488147419103235/4) + (num-test (+ 9223372036854775808/4 3) 2305843009213693955) + (num-test (+ 3 9223372036854775808/4) 2305843009213693955) + (num-test (+ 9223372036854775807/4 3) 9223372036854775819/4) + (num-test (+ 3 9223372036854775807/4) 9223372036854775819/4) + (num-test (+ 9223372036854775807/4 3/4) 4611686018427387905/2) + (num-test (+ 3/4 9223372036854775807/4) 4611686018427387905/2) + (num-test (+ 9223372036854775807/4 3/4 4611686018427387905/2) 4611686018427387905) + (num-test (+ 9223372036854775807/4 4611686018427387905/3) 46116860184273879041/12) + (num-test (+ 1/1231234567891234567891 1/4) 1231234567891234567895/4924938271564938271564) + (num-test (+ 1/65537 1/65538) 131075/4295163906) + (num-test (+ 1/65537 1/65536) 131073/4295032832) + (num-test (+ 1/65537 -1/65536) -1/4295032832) + (num-test (+ 1/65537 -1/65538) 1/4295163906) + (num-test (+ 1/2147483648 1/2147483647) 4294967295/4611686016279904256) + (num-test (+ 2147483648) 2147483648) + + (num-test (lcm 557057 23068673 167772161) 2155967190204955525121) + (num-test (lcm 132120577 33292289) 4398596432330753) + (num-test (lcm 132120577 33292289 260046847) 1143841133453061178785791) + (num-test (lcm 2353913150770005286438421033702874906038383291674012942337 9641628265553941653251772554046975615133217962696757011808257) 22695555569123220026272727097682721551725929819788097280747860983024240452040931523149698041303750665450606153441476609) + + (num-test (gcd 2155967190204955525121 12850565775361 93458656690177) 557057) + (num-test (gcd 2155967190204955525121 -12850565775361 93458656690177) 557057) + (num-test (gcd 2155967190204955525121 0) 2155967190204955525121) + (num-test (+ 132120577/12 33292289/6 260046847/4) 244711424/3) + (num-test (* 132120577/12 33292289/6 260046847/4) 1143841133453061178785791/288) + (num-test (/ 132120577/12 33292289/6 260046847/4) 264241154/8657554783862783) + (num-test (+ 1000000000 1000000000 1000000000) 3000000000) + (num-test (+ -1000000000 -1000000000 -1000000000) -3000000000) + (num-test (* 1000000000 1000000000 1000000000) 1000000000000000000000000000) + (num-test (/ 1 1000000000 1000000000 1000000000) 1/1000000000000000000000000000) + + (if with-bigfloats + (begin + (num-test (+ 9223372036854775808.0 3.4) 9.2233720368547758114E18) + (num-test (+ 9223372036854775808.0+1.5i 3.4) 9.2233720368547758114E18+1.5i) + + (num-test (+ 1.5 9223372036854775808.0) 9.2233720368547758095E18) + (num-test (+ 3/2 9223372036854775808.0) 9.2233720368547758095E18) + (num-test (+ 1 1/2 9223372036854775808.0) 9.2233720368547758095E18) + (num-test (+ 1 1/2 9223372036854775808.0 0+i) 9.2233720368547758095E18+1.0i) + (num-test (+ 1 1/2 9223372036854775808.0 0-i) 9.2233720368547758095E18-1.0i) + (num-test (+ 1 1/2 0+9223372036854775808.0i 0-i) 1.5+9.223372036854775807E18i) + + (num-test (real-part 9223372036854775808.0+1.5i) 9.223372036854775808E18) + (num-test (imag-part 9223372036854775808.0+1.5i) 1.5) + (num-test (real-part 1.5+9223372036854775808.0i) 1.5) + (num-test (imag-part 1.5+9223372036854775808.0i) 9.223372036854775808E18) + + (num-test (real-part 9223372036854775808.0) 9223372036854775808.0) + (num-test (imag-part 9223372036854775808.0) 0) + (num-test (real-part 0+9223372036854775808.0i) 0.0) + (num-test (imag-part 0+9223372036854775808.0i) 9223372036854775808.0) + (num-test (real-part 0+1e400i) 0.0) + (num-test (imag-part 0+1e400i) 1e400) + + (num-test (abs 9223372036854775808.0) 9223372036854775808.0) + (num-test (abs -9223372036854775808.0) 9223372036854775808.0) + + (test (exact? 9223372036854775808.1) #f) + (test (exact? 9223372036854775808) #t) + (test (exact? 9223372036854775808/3) #t) + (test (exact? 9223372036854775808.1+1.0i) #f) + + (test (inexact? 9223372036854775808.1) #t) + (test (inexact? 9223372036854775808) #f) + (test (inexact? 9223372036854775808/3) #f) + (test (inexact? 9223372036854775808.1+1.0i) #t) + + (num-test (magnitude 9223372036854775808.1) 9223372036854775808.1) + (num-test (magnitude 9223372036854775808) 9223372036854775808) + (num-test (magnitude 9223372036854775808/3) 9223372036854775808/3) + (num-test (magnitude 9223372036854775808.1+1.0e19i) 1.360406526484765934746566522678055771386E19) + (num-test (magnitude 1.0e19+9223372036854775808.1i) 1.360406526484765934746566522678055771386E19) + ;; maxima's sqrt(2.0) is not very accurate! use arprec: + (num-test (magnitude 14142135623730950488.0168872420969+14142135623730950488.0168872420969i) 1.9999999999999999999999999999999885751772054578776001965575456E19) + + + ;; these can be checked against arprec -- get tables of the others as well + ;; (num-test (sin 31415926535897932384626433832795028841.971693993751058209749445) 6.8290634690588564658126265428876656461078982456442870201741792E-24) + ;; this test requires 500 bits of precision + (num-test (sin 31415926535897932384626433832795028841) -8.2584214320186030736155068085595298665361290626210864656288000E-1) + (num-test (sin 1.0) 0.84147098480789650665250232163029899962256306079837106567275170999191) ; if bignum here + + ;; (num-test (cos 31415926535897932384626433832795028841.971693993751058209749445) 9.9999999999999999999999999999999999999999999997668194606778265E-1) + ;; 500 bits + (num-test (cos 1.0) 5.4030230586813971740093660744297660373231042061792222767009714E-1) + + (set! (bignum-precision) old-prec) + ))) + + (num-test (abs 9223372036854775808/3) 9223372036854775808/3) + (num-test (abs -9223372036854775808/3) 9223372036854775808/3) + + (num-test (abs 9223372036854775808) 9223372036854775808) + (num-test (abs -9223372036854775808) 9223372036854775808) + + (num-test (abs 1231234567891234567895/4924938271564938271564) 1231234567891234567895/4924938271564938271564) + (num-test (abs -1231234567891234567895/4924938271564938271564) 1231234567891234567895/4924938271564938271564) + (num-test (abs 5/4924938271564938271564) 5/4924938271564938271564) + (num-test (abs -5/4924938271564938271564) 5/4924938271564938271564) + + (num-test (abs 1231234567891234567895.4924938271564938271564) 1231234567891234567895.4924938271564938271564) + (num-test (abs -1231234567891234567895.4924938271564938271564) 1231234567891234567895.4924938271564938271564) + )) + + + + +;;; -------------------------------------------------------------------------------- +;;; string->number and number->string + +(test (string->number "+#.#") #f) +(test (string->number "-#.#") #f) +(test (string->number "#.#") #f) +(test (string->number "#i") #f) +(test (string->number "#e") #f) +(test (string->number "#") #f) + +;(let ((number-to-string-top 0)) +; (let* ((last-good 0) +; (first-bad +; (call/cc +; (lambda (return) +; (do ((i 1 (+ i 1)) +; (k 1 (* k 2))) +; ((= i 200) #f) +; (if (and (eqv? k (string->number (number->string k))) +; (eqv? (- k) (string->number (number->string (- k)))) +; (not (negative? k))) ; might hit sign bit +; (set! last-good k) +; (if (not (positive? k)) +; (return (- (* 2 last-good) 1)) +; (letrec ((search +; (lambda (lo hi) +; (if (= lo hi) +; hi +; (let ((mid (inexact->exact (floor (/ (+ hi lo) 2))))) +; (if (or (>= mid hi) +; (<= mid lo)) +; mid +; (if (and (eqv? mid (string->number (number->string mid))) +; (eqv? (- mid) (string->number (number->string (- mid))))) +; (search mid hi) +; (search lo mid)))))))) +; (return (search last-good (- (* 2 last-good) 1))))))))))) +; (set! number-to-string-top first-bad) +; (if (and (integer? first-bad) +; (or (not (defined? 'most-positive-fixnum)) +; (< first-bad most-positive-fixnum))) +; (begin +; (display "string->number ints fail around ") +; (display first-bad) +; (display " (2^") +; (display (/ (log first-bad) (log 2.0))) +; (display ")") +; (newline)))) + +;(let* ((last-good 0) +; (first-bad +; (call/cc +; (lambda (return) +; (do ((i 1 (+ i 1)) +; (k 1.0 (* k 2.0))) +; ((= i 1200) #f) +; (if (and (eqv? k (string->number (number->string k))) +; (eqv? (- k) (string->number (number->string (- k))))) +; (set! last-good k) +; (letrec ((search +; (lambda (lo hi) +; (if (= (inexact->exact (floor lo)) (inexact->exact (floor hi))) +; hi +; (let ((mid (/ (+ hi lo) 2))) +; (if (or (>= mid hi) +; (<= mid lo)) +; mid +; (if (and (eqv? mid (string->number (number->string mid))) +; (eqv? (- mid) (string->number (number->string (- mid))))) +; (search mid hi) +; (search lo mid)))))))) +; (return (search last-good (* 2 last-good)))))))))) +; (if (and (number? first-bad) +; (< first-bad (+ 1.0 first-bad))) ; else infinite I guess +; (begin +; (display "string->number floats fail around ") ; (eqv? (string->number (number->string 1e-10)) 1e-10) +; (display first-bad) +; (display " (2^") +; (display (/ (log first-bad) (log 2.0))) +; (display ")") +; (newline)))) + +;(let* ((last-good 0) +; (first-bad +; (call/cc +; (lambda (return) +; (do ((i 1 (+ i 1)) +; (k 1.0 (/ k 2.0))) +; ((= i 100) #f) +; (if (and (< (abs (- k (string->number (number->string k)))) (/ k 1e14)) ; 1e18 is ok too +; (< (abs (- (- k) (string->number (number->string (- k))))) (/ k 1e14))) +; ;; this gets confused (in eqv?) by .999.... -> 1 +; (set! last-good k) +; (letrec ((search +; (lambda (lo hi) +; (if (= (inexact->exact (floor (/ 1.0 lo))) (inexact->exact (floor (/ 1.0 hi)))) +; hi +; (let ((mid (/ (+ hi lo) 2))) +; (if (or (>= mid hi) +; (<= mid lo)) +; mid +; (if (and (eqv? mid (string->number (number->string mid))) +; (eqv? (- mid) (string->number (number->string (- mid))))) +; (search mid hi) +; (search lo mid)))))))) +; (return (search (/ last-good 2.0) last-good))))))))) +; (if (number? first-bad) +; (begin +; (display "string->number floats fail around ") +; (display first-bad) +; (display " (2^") +; (display (/ (log first-bad) (log 2.0))) +; (display ")") +; (newline)))) + +;(let* ((last-good 0) +; (first-bad +; (call/cc +; (lambda (return) +; (do ((i 1 (+ i 1)) +; (k 1/3 (* k 2))) +; ((= i 100) #f) +; (if (and (eqv? k (string->number (number->string k))) +; (eqv? (- k) (string->number (number->string (- k))))) +; (set! last-good k) +; (letrec ((search +; (lambda (lo hi) +; (if (= (inexact->exact (floor lo)) (inexact->exact (floor hi))) +; hi +; (let ((mid (/ (+ hi lo) 2))) +; (if (or (>= mid hi) +; (<= mid lo)) +; mid +; (if (and (eqv? mid (string->number (number->string mid))) +; (eqv? (- mid) (string->number (number->string (- mid))))) +; (search mid hi) +; (search lo mid)))))))) +; (return (search last-good (* 2 last-good)))))))))) +; (if (number? first-bad) +; (begin +; (display "string->number ratios fail around ") +; (display first-bad) +; (display " (2^") +; (display (/ (log first-bad) (log 2.0))) +; (display ")") +; (newline)))) + + +;(if (not (eqv? 0 (string->number (number->string 0)))) +; (begin (display "(string<->number 0) -> ") (display (number->string 0)) +; (display " -> ") (display (string->number (number->string 0))) (newline))) +;(if (not (eqv? 1 (string->number (number->string 1)))) +; (begin (display "(string<->number 1) -> ") (display (number->string 1)) +; (display " -> ") (display (string->number (number->string 1))) (newline))) +;(if (not (eqv? 2 (string->number (number->string 2)))) +; (begin (display "(string<->number 2) -> ") (display (number->string 2)) +; (display " -> ") (display (string->number (number->string 2))) (newline))) +;(if (not (eqv? 3 (string->number (number->string 3)))) +; (begin (display "(string<->number 3) -> ") (display (number->string 3)) +; (display " -> ") (display (string->number (number->string 3))) (newline))) +;(if (not (eqv? 10 (string->number (number->string 10)))) +; (begin (display "(string<->number 10) -> ") (display (number->string 10)) +; (display " -> ") (display (string->number (number->string 10))) (newline))) +;(if (not (eqv? 1234 (string->number (number->string 1234)))) +; (begin (display "(string<->number 1234) -> ") (display (number->string 1234)) +; (display " -> ") (display (string->number (number->string 1234))) (newline))) +;(if (not (eqv? 1234000000 (string->number (number->string 1234000000)))) +; (begin (display "(string<->number 1234000000) -> ") (display (number->string 1234000000)) +; (display " -> ") (display (string->number (number->string 1234000000))) (newline))) +;(if (not (eqv? 500029 (string->number (number->string 500029)))) +; (begin (display "(string<->number 500029) -> ") (display (number->string 500029)) +; (display " -> ") (display (string->number (number->string 500029))) (newline))) +;(if (not (eqv? 362880 (string->number (number->string 362880)))) +; (begin (display "(string<->number 362880) -> ") (display (number->string 362880)) +; (display " -> ") (display (string->number (number->string 362880))) (newline))) +;(if (not (eqv? 0/1 (string->number (number->string 0/1)))) +; (begin (display "(string<->number 0/1) -> ") (display (number->string 0/1)) +; (display " -> ") (display (string->number (number->string 0/1))) (newline))) +;(if (not (eqv? 0/2 (string->number (number->string 0/2)))) +; (begin (display "(string<->number 0/2) -> ") (display (number->string 0/2)) +; (display " -> ") (display (string->number (number->string 0/2))) (newline))) +;(if (not (eqv? 0/3 (string->number (number->string 0/3)))) +; (begin (display "(string<->number 0/3) -> ") (display (number->string 0/3)) +; (display " -> ") (display (string->number (number->string 0/3))) (newline))) +;(if (not (eqv? 0/10 (string->number (number->string 0/10)))) +; (begin (display "(string<->number 0/10) -> ") (display (number->string 0/10)) +; (display " -> ") (display (string->number (number->string 0/10))) (newline))) +;(if (not (eqv? 0/1234 (string->number (number->string 0/1234)))) +; (begin (display "(string<->number 0/1234) -> ") (display (number->string 0/1234)) +; (display " -> ") (display (string->number (number->string 0/1234))) (newline))) +;(if (not (eqv? 0/1234000000 (string->number (number->string 0/1234000000)))) +; (begin (display "(string<->number 0/1234000000) -> ") (display (number->string 0/1234000000)) +; (display " -> ") (display (string->number (number->string 0/1234000000))) (newline))) +;(if (not (eqv? 0/500029 (string->number (number->string 0/500029)))) +; (begin (display "(string<->number 0/500029) -> ") (display (number->string 0/500029)) +; (display " -> ") (display (string->number (number->string 0/500029))) (newline))) +;(if (not (eqv? 0/362880 (string->number (number->string 0/362880)))) +; (begin (display "(string<->number 0/362880) -> ") (display (number->string 0/362880)) +; (display " -> ") (display (string->number (number->string 0/362880))) (newline))) +;(if (not (eqv? 1/1 (string->number (number->string 1/1)))) +; (begin (display "(string<->number 1/1) -> ") (display (number->string 1/1)) +; (display " -> ") (display (string->number (number->string 1/1))) (newline))) +;(if (not (eqv? 1/2 (string->number (number->string 1/2)))) +; (begin (display "(string<->number 1/2) -> ") (display (number->string 1/2)) +; (display " -> ") (display (string->number (number->string 1/2))) (newline))) +;(if (not (eqv? 1/3 (string->number (number->string 1/3)))) +; (begin (display "(string<->number 1/3) -> ") (display (number->string 1/3)) +; (display " -> ") (display (string->number (number->string 1/3))) (newline))) +;(if (not (eqv? 1/10 (string->number (number->string 1/10)))) +; (begin (display "(string<->number 1/10) -> ") (display (number->string 1/10)) +; (display " -> ") (display (string->number (number->string 1/10))) (newline))) +;(if (not (eqv? 1/1234 (string->number (number->string 1/1234)))) +; (begin (display "(string<->number 1/1234) -> ") (display (number->string 1/1234)) +; (display " -> ") (display (string->number (number->string 1/1234))) (newline))) +;(if (not (eqv? 1/1234000000 (string->number (number->string 1/1234000000)))) +; (begin (display "(string<->number 1/1234000000) -> ") (display (number->string 1/1234000000)) +; (display " -> ") (display (string->number (number->string 1/1234000000))) (newline))) +;(if (not (eqv? 1/500029 (string->number (number->string 1/500029)))) +; (begin (display "(string<->number 1/500029) -> ") (display (number->string 1/500029)) +; (display " -> ") (display (string->number (number->string 1/500029))) (newline))) +;(if (not (eqv? 1/362880 (string->number (number->string 1/362880)))) +; (begin (display "(string<->number 1/362880) -> ") (display (number->string 1/362880)) +; (display " -> ") (display (string->number (number->string 1/362880))) (newline))) +;(if (not (eqv? 2/1 (string->number (number->string 2/1)))) +; (begin (display "(string<->number 2/1) -> ") (display (number->string 2/1)) +; (display " -> ") (display (string->number (number->string 2/1))) (newline))) +;(if (not (eqv? 2/2 (string->number (number->string 2/2)))) +; (begin (display "(string<->number 2/2) -> ") (display (number->string 2/2)) +; (display " -> ") (display (string->number (number->string 2/2))) (newline))) +;(if (not (eqv? 2/3 (string->number (number->string 2/3)))) +; (begin (display "(string<->number 2/3) -> ") (display (number->string 2/3)) +; (display " -> ") (display (string->number (number->string 2/3))) (newline))) +;(if (not (eqv? 2/10 (string->number (number->string 2/10)))) +; (begin (display "(string<->number 2/10) -> ") (display (number->string 2/10)) +; (display " -> ") (display (string->number (number->string 2/10))) (newline))) +;(if (not (eqv? 2/1234 (string->number (number->string 2/1234)))) +; (begin (display "(string<->number 2/1234) -> ") (display (number->string 2/1234)) +; (display " -> ") (display (string->number (number->string 2/1234))) (newline))) +;(if (not (eqv? 2/1234000000 (string->number (number->string 2/1234000000)))) +; (begin (display "(string<->number 2/1234000000) -> ") (display (number->string 2/1234000000)) +; (display " -> ") (display (string->number (number->string 2/1234000000))) (newline))) +;(if (not (eqv? 2/500029 (string->number (number->string 2/500029)))) +; (begin (display "(string<->number 2/500029) -> ") (display (number->string 2/500029)) +; (display " -> ") (display (string->number (number->string 2/500029))) (newline))) +;(if (not (eqv? 2/362880 (string->number (number->string 2/362880)))) +; (begin (display "(string<->number 2/362880) -> ") (display (number->string 2/362880)) +; (display " -> ") (display (string->number (number->string 2/362880))) (newline))) +;(if (not (eqv? 3/1 (string->number (number->string 3/1)))) +; (begin (display "(string<->number 3/1) -> ") (display (number->string 3/1)) +; (display " -> ") (display (string->number (number->string 3/1))) (newline))) +;(if (not (eqv? 3/2 (string->number (number->string 3/2)))) +; (begin (display "(string<->number 3/2) -> ") (display (number->string 3/2)) +; (display " -> ") (display (string->number (number->string 3/2))) (newline))) +;(if (not (eqv? 3/3 (string->number (number->string 3/3)))) +; (begin (display "(string<->number 3/3) -> ") (display (number->string 3/3)) +; (display " -> ") (display (string->number (number->string 3/3))) (newline))) +;(if (not (eqv? 3/10 (string->number (number->string 3/10)))) +; (begin (display "(string<->number 3/10) -> ") (display (number->string 3/10)) +; (display " -> ") (display (string->number (number->string 3/10))) (newline))) +;(if (not (eqv? 3/1234 (string->number (number->string 3/1234)))) +; (begin (display "(string<->number 3/1234) -> ") (display (number->string 3/1234)) +; (display " -> ") (display (string->number (number->string 3/1234))) (newline))) +;(if (not (eqv? 3/1234000000 (string->number (number->string 3/1234000000)))) +; (begin (display "(string<->number 3/1234000000) -> ") (display (number->string 3/1234000000)) +; (display " -> ") (display (string->number (number->string 3/1234000000))) (newline))) +;(if (not (eqv? 3/500029 (string->number (number->string 3/500029)))) +; (begin (display "(string<->number 3/500029) -> ") (display (number->string 3/500029)) +; (display " -> ") (display (string->number (number->string 3/500029))) (newline))) +;(if (not (eqv? 3/362880 (string->number (number->string 3/362880)))) +; (begin (display "(string<->number 3/362880) -> ") (display (number->string 3/362880)) +; (display " -> ") (display (string->number (number->string 3/362880))) (newline))) +;(if (not (eqv? 10/1 (string->number (number->string 10/1)))) +; (begin (display "(string<->number 10/1) -> ") (display (number->string 10/1)) +; (display " -> ") (display (string->number (number->string 10/1))) (newline))) +;(if (not (eqv? 10/2 (string->number (number->string 10/2)))) +; (begin (display "(string<->number 10/2) -> ") (display (number->string 10/2)) +; (display " -> ") (display (string->number (number->string 10/2))) (newline))) +;(if (not (eqv? 10/3 (string->number (number->string 10/3)))) +; (begin (display "(string<->number 10/3) -> ") (display (number->string 10/3)) +; (display " -> ") (display (string->number (number->string 10/3))) (newline))) +;(if (not (eqv? 10/10 (string->number (number->string 10/10)))) +; (begin (display "(string<->number 10/10) -> ") (display (number->string 10/10)) +; (display " -> ") (display (string->number (number->string 10/10))) (newline))) +;(if (not (eqv? 10/1234 (string->number (number->string 10/1234)))) +; (begin (display "(string<->number 10/1234) -> ") (display (number->string 10/1234)) +; (display " -> ") (display (string->number (number->string 10/1234))) (newline))) +;(if (not (eqv? 10/1234000000 (string->number (number->string 10/1234000000)))) +; (begin (display "(string<->number 10/1234000000) -> ") (display (number->string 10/1234000000)) +; (display " -> ") (display (string->number (number->string 10/1234000000))) (newline))) +;(if (not (eqv? 10/500029 (string->number (number->string 10/500029)))) +; (begin (display "(string<->number 10/500029) -> ") (display (number->string 10/500029)) +; (display " -> ") (display (string->number (number->string 10/500029))) (newline))) +;(if (not (eqv? 10/362880 (string->number (number->string 10/362880)))) +; (begin (display "(string<->number 10/362880) -> ") (display (number->string 10/362880)) +; (display " -> ") (display (string->number (number->string 10/362880))) (newline))) +;(if (not (eqv? 1234/1 (string->number (number->string 1234/1)))) +; (begin (display "(string<->number 1234/1) -> ") (display (number->string 1234/1)) +; (display " -> ") (display (string->number (number->string 1234/1))) (newline))) +;(if (not (eqv? 1234/2 (string->number (number->string 1234/2)))) +; (begin (display "(string<->number 1234/2) -> ") (display (number->string 1234/2)) +; (display " -> ") (display (string->number (number->string 1234/2))) (newline))) +;(if (not (eqv? 1234/3 (string->number (number->string 1234/3)))) +; (begin (display "(string<->number 1234/3) -> ") (display (number->string 1234/3)) +; (display " -> ") (display (string->number (number->string 1234/3))) (newline))) +;(if (not (eqv? 1234/10 (string->number (number->string 1234/10)))) +; (begin (display "(string<->number 1234/10) -> ") (display (number->string 1234/10)) +; (display " -> ") (display (string->number (number->string 1234/10))) (newline))) +;(if (not (eqv? 1234/1234 (string->number (number->string 1234/1234)))) +; (begin (display "(string<->number 1234/1234) -> ") (display (number->string 1234/1234)) +; (display " -> ") (display (string->number (number->string 1234/1234))) (newline))) +;(if (not (eqv? 1234/1234000000 (string->number (number->string 1234/1234000000)))) +; (begin (display "(string<->number 1234/1234000000) -> ") (display (number->string 1234/1234000000)) +; (display " -> ") (display (string->number (number->string 1234/1234000000))) (newline))) +;(if (not (eqv? 1234/500029 (string->number (number->string 1234/500029)))) +; (begin (display "(string<->number 1234/500029) -> ") (display (number->string 1234/500029)) +; (display " -> ") (display (string->number (number->string 1234/500029))) (newline))) +;(if (not (eqv? 1234/362880 (string->number (number->string 1234/362880)))) +; (begin (display "(string<->number 1234/362880) -> ") (display (number->string 1234/362880)) +; (display " -> ") (display (string->number (number->string 1234/362880))) (newline))) +;(if (not (eqv? 1234000000/1 (string->number (number->string 1234000000/1)))) +; (begin (display "(string<->number 1234000000/1) -> ") (display (number->string 1234000000/1)) +; (display " -> ") (display (string->number (number->string 1234000000/1))) (newline))) +;(if (not (eqv? 1234000000/2 (string->number (number->string 1234000000/2)))) +; (begin (display "(string<->number 1234000000/2) -> ") (display (number->string 1234000000/2)) +; (display " -> ") (display (string->number (number->string 1234000000/2))) (newline))) +;(if (not (eqv? 1234000000/3 (string->number (number->string 1234000000/3)))) +; (begin (display "(string<->number 1234000000/3) -> ") (display (number->string 1234000000/3)) +; (display " -> ") (display (string->number (number->string 1234000000/3))) (newline))) +;(if (not (eqv? 1234000000/10 (string->number (number->string 1234000000/10)))) +; (begin (display "(string<->number 1234000000/10) -> ") (display (number->string 1234000000/10)) +; (display " -> ") (display (string->number (number->string 1234000000/10))) (newline))) +;(if (not (eqv? 1234000000/1234 (string->number (number->string 1234000000/1234)))) +; (begin (display "(string<->number 1234000000/1234) -> ") (display (number->string 1234000000/1234)) +; (display " -> ") (display (string->number (number->string 1234000000/1234))) (newline))) +;(if (not (eqv? 1234000000/1234000000 (string->number (number->string 1234000000/1234000000)))) +; (begin (display "(string<->number 1234000000/1234000000) -> ") (display (number->string 1234000000/1234000000)) +; (display " -> ") (display (string->number (number->string 1234000000/1234000000))) (newline))) +;(if (not (eqv? 1234000000/500029 (string->number (number->string 1234000000/500029)))) +; (begin (display "(string<->number 1234000000/500029) -> ") (display (number->string 1234000000/500029)) +; (display " -> ") (display (string->number (number->string 1234000000/500029))) (newline))) +;(if (not (eqv? 1234000000/362880 (string->number (number->string 1234000000/362880)))) +; (begin (display "(string<->number 1234000000/362880) -> ") (display (number->string 1234000000/362880)) +; (display " -> ") (display (string->number (number->string 1234000000/362880))) (newline))) +;(if (not (eqv? 500029/1 (string->number (number->string 500029/1)))) +; (begin (display "(string<->number 500029/1) -> ") (display (number->string 500029/1)) +; (display " -> ") (display (string->number (number->string 500029/1))) (newline))) +;(if (not (eqv? 500029/2 (string->number (number->string 500029/2)))) +; (begin (display "(string<->number 500029/2) -> ") (display (number->string 500029/2)) +; (display " -> ") (display (string->number (number->string 500029/2))) (newline))) +;(if (not (eqv? 500029/3 (string->number (number->string 500029/3)))) +; (begin (display "(string<->number 500029/3) -> ") (display (number->string 500029/3)) +; (display " -> ") (display (string->number (number->string 500029/3))) (newline))) +;(if (not (eqv? 500029/10 (string->number (number->string 500029/10)))) +; (begin (display "(string<->number 500029/10) -> ") (display (number->string 500029/10)) +; (display " -> ") (display (string->number (number->string 500029/10))) (newline))) +;(if (not (eqv? 500029/1234 (string->number (number->string 500029/1234)))) +; (begin (display "(string<->number 500029/1234) -> ") (display (number->string 500029/1234)) +; (display " -> ") (display (string->number (number->string 500029/1234))) (newline))) +;(if (not (eqv? 500029/1234000000 (string->number (number->string 500029/1234000000)))) +; (begin (display "(string<->number 500029/1234000000) -> ") (display (number->string 500029/1234000000)) +; (display " -> ") (display (string->number (number->string 500029/1234000000))) (newline))) +;(if (not (eqv? 500029/500029 (string->number (number->string 500029/500029)))) +; (begin (display "(string<->number 500029/500029) -> ") (display (number->string 500029/500029)) +; (display " -> ") (display (string->number (number->string 500029/500029))) (newline))) +;(if (not (eqv? 500029/362880 (string->number (number->string 500029/362880)))) +; (begin (display "(string<->number 500029/362880) -> ") (display (number->string 500029/362880)) +; (display " -> ") (display (string->number (number->string 500029/362880))) (newline))) +;(if (not (eqv? 362880/1 (string->number (number->string 362880/1)))) +; (begin (display "(string<->number 362880/1) -> ") (display (number->string 362880/1)) +; (display " -> ") (display (string->number (number->string 362880/1))) (newline))) +;(if (not (eqv? 362880/2 (string->number (number->string 362880/2)))) +; (begin (display "(string<->number 362880/2) -> ") (display (number->string 362880/2)) +; (display " -> ") (display (string->number (number->string 362880/2))) (newline))) +;(if (not (eqv? 362880/3 (string->number (number->string 362880/3)))) +; (begin (display "(string<->number 362880/3) -> ") (display (number->string 362880/3)) +; (display " -> ") (display (string->number (number->string 362880/3))) (newline))) +;(if (not (eqv? 362880/10 (string->number (number->string 362880/10)))) +; (begin (display "(string<->number 362880/10) -> ") (display (number->string 362880/10)) +; (display " -> ") (display (string->number (number->string 362880/10))) (newline))) +;(if (not (eqv? 362880/1234 (string->number (number->string 362880/1234)))) +; (begin (display "(string<->number 362880/1234) -> ") (display (number->string 362880/1234)) +; (display " -> ") (display (string->number (number->string 362880/1234))) (newline))) +;(if (not (eqv? 362880/1234000000 (string->number (number->string 362880/1234000000)))) +; (begin (display "(string<->number 362880/1234000000) -> ") (display (number->string 362880/1234000000)) +; (display " -> ") (display (string->number (number->string 362880/1234000000))) (newline))) +;(if (not (eqv? 362880/500029 (string->number (number->string 362880/500029)))) +; (begin (display "(string<->number 362880/500029) -> ") (display (number->string 362880/500029)) +; (display " -> ") (display (string->number (number->string 362880/500029))) (newline))) +;(if (not (eqv? 362880/362880 (string->number (number->string 362880/362880)))) +; (begin (display "(string<->number 362880/362880) -> ") (display (number->string 362880/362880)) +; (display " -> ") (display (string->number (number->string 362880/362880))) (newline))) + +;(let ((fequal? (lambda (a b) (< (magnitude (- a b)) 1e-14)))) +; (if (not (fequal? 0.000000 (string->number (number->string 0.000000)))) +; (begin (display "(string<->number 0.000000) -> ") (display (number->string 0.000000)) +; (display " -> ") (display (string->number (number->string 0.000000))) (newline))) +; (if (not (fequal? 0.000000 (string->number (number->string 0.000000)))) +; (begin (display "(string<->number 0.000000) -> ") (display (number->string 0.000000)) +; (display " -> ") (display (string->number (number->string 0.000000))) (newline))) +; (if (not (fequal? 1.000000 (string->number (number->string 1.000000)))) +; (begin (display "(string<->number 1.000000) -> ") (display (number->string 1.000000)) +; (display " -> ") (display (string->number (number->string 1.000000))) (newline))) +; (if (not (fequal? 3.141593 (string->number (number->string 3.141593)))) +; (begin (display "(string<->number 3.141593) -> ") (display (number->string 3.141593)) +; (display " -> ") (display (string->number (number->string 3.141593))) (newline))) +; (if (not (fequal? 2.718282 (string->number (number->string 2.718282)))) +; (begin (display "(string<->number 2.718282) -> ") (display (number->string 2.718282)) +; (display " -> ") (display (string->number (number->string 2.718282))) (newline))) +; (if (not (fequal? 1234.000000 (string->number (number->string 1234.000000)))) +; (begin (display "(string<->number 1234.000000) -> ") (display (number->string 1234.000000)) +; (display " -> ") (display (string->number (number->string 1234.000000))) (newline))) +; (if (not (fequal? 1234000000.000000 (string->number (number->string 1234000000.000000)))) +; (begin (display "(string<->number 1234000000.000000) -> ") (display (number->string 1234000000.000000)) +; (display " -> ") (display (string->number (number->string 1234000000.000000))) (newline))) +; (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i)))) +; (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline))) +; (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i)))) +; (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline))) +; (if (not (fequal? 0.000000+1.000000i (string->number (number->string 0.000000+1.000000i)))) +; (begin (display "(string<->number 0.000000+1.000000i) -> ") (display (number->string 0.000000+1.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+1.000000i))) (newline))) +; (if (not (fequal? 0.000000+3.141593i (string->number (number->string 0.000000+3.141593i)))) +; (begin (display "(string<->number 0.000000+3.141593i) -> ") (display (number->string 0.000000+3.141593i)) +; (display " -> ") (display (string->number (number->string 0.000000+3.141593i))) (newline))) +; (if (not (fequal? 0.000000+2.718282i (string->number (number->string 0.000000+2.718282i)))) +; (begin (display "(string<->number 0.000000+2.718282i) -> ") (display (number->string 0.000000+2.718282i)) +; (display " -> ") (display (string->number (number->string 0.000000+2.718282i))) (newline))) +; (if (not (fequal? 0.000000+1234.000000i (string->number (number->string 0.000000+1234.000000i)))) +; (begin (display "(string<->number 0.000000+1234.000000i) -> ") (display (number->string 0.000000+1234.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+1234.000000i))) (newline))) +; (if (not (fequal? 0.000000+1234000000.000000i (string->number (number->string 0.000000+1234000000.000000i)))) +; (begin (display "(string<->number 0.000000+1234000000.000000i) -> ") (display (number->string 0.000000+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+1234000000.000000i))) (newline))) +; (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i)))) +; (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline))) +; (if (not (fequal? 0.000000+0.000000i (string->number (number->string 0.000000+0.000000i)))) +; (begin (display "(string<->number 0.000000+0.000000i) -> ") (display (number->string 0.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+0.000000i))) (newline))) +; (if (not (fequal? 0.000000+1.000000i (string->number (number->string 0.000000+1.000000i)))) +; (begin (display "(string<->number 0.000000+1.000000i) -> ") (display (number->string 0.000000+1.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+1.000000i))) (newline))) +; (if (not (fequal? 0.000000+3.141593i (string->number (number->string 0.000000+3.141593i)))) +; (begin (display "(string<->number 0.000000+3.141593i) -> ") (display (number->string 0.000000+3.141593i)) +; (display " -> ") (display (string->number (number->string 0.000000+3.141593i))) (newline))) +; (if (not (fequal? 0.000000+2.718282i (string->number (number->string 0.000000+2.718282i)))) +; (begin (display "(string<->number 0.000000+2.718282i) -> ") (display (number->string 0.000000+2.718282i)) +; (display " -> ") (display (string->number (number->string 0.000000+2.718282i))) (newline))) +; (if (not (fequal? 0.000000+1234.000000i (string->number (number->string 0.000000+1234.000000i)))) +; (begin (display "(string<->number 0.000000+1234.000000i) -> ") (display (number->string 0.000000+1234.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+1234.000000i))) (newline))) +; (if (not (fequal? 0.000000+1234000000.000000i (string->number (number->string 0.000000+1234000000.000000i)))) +; (begin (display "(string<->number 0.000000+1234000000.000000i) -> ") (display (number->string 0.000000+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 0.000000+1234000000.000000i))) (newline))) +; (if (not (fequal? 1.000000+0.000000i (string->number (number->string 1.000000+0.000000i)))) +; (begin (display "(string<->number 1.000000+0.000000i) -> ") (display (number->string 1.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 1.000000+0.000000i))) (newline))) +; (if (not (fequal? 1.000000+0.000000i (string->number (number->string 1.000000+0.000000i)))) +; (begin (display "(string<->number 1.000000+0.000000i) -> ") (display (number->string 1.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 1.000000+0.000000i))) (newline))) +; (if (not (fequal? 1.000000+1.000000i (string->number (number->string 1.000000+1.000000i)))) +; (begin (display "(string<->number 1.000000+1.000000i) -> ") (display (number->string 1.000000+1.000000i)) +; (display " -> ") (display (string->number (number->string 1.000000+1.000000i))) (newline))) +; (if (not (fequal? 1.000000+3.141593i (string->number (number->string 1.000000+3.141593i)))) +; (begin (display "(string<->number 1.000000+3.141593i) -> ") (display (number->string 1.000000+3.141593i)) +; (display " -> ") (display (string->number (number->string 1.000000+3.141593i))) (newline))) +; (if (not (fequal? 1.000000+2.718282i (string->number (number->string 1.000000+2.718282i)))) +; (begin (display "(string<->number 1.000000+2.718282i) -> ") (display (number->string 1.000000+2.718282i)) +; (display " -> ") (display (string->number (number->string 1.000000+2.718282i))) (newline))) +; (if (not (fequal? 1.000000+1234.000000i (string->number (number->string 1.000000+1234.000000i)))) +; (begin (display "(string<->number 1.000000+1234.000000i) -> ") (display (number->string 1.000000+1234.000000i)) +; (display " -> ") (display (string->number (number->string 1.000000+1234.000000i))) (newline))) +; (if (not (fequal? 1.000000+1234000000.000000i (string->number (number->string 1.000000+1234000000.000000i)))) +; (begin (display "(string<->number 1.000000+1234000000.000000i) -> ") (display (number->string 1.000000+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 1.000000+1234000000.000000i))) (newline))) +; (if (not (fequal? 3.141593+0.000000i (string->number (number->string 3.141593+0.000000i)))) +; (begin (display "(string<->number 3.141593+0.000000i) -> ") (display (number->string 3.141593+0.000000i)) +; (display " -> ") (display (string->number (number->string 3.141593+0.000000i))) (newline))) +; (if (not (fequal? 3.141593+0.000000i (string->number (number->string 3.141593+0.000000i)))) +; (begin (display "(string<->number 3.141593+0.000000i) -> ") (display (number->string 3.141593+0.000000i)) +; (display " -> ") (display (string->number (number->string 3.141593+0.000000i))) (newline))) +; (if (not (fequal? 3.141593+1.000000i (string->number (number->string 3.141593+1.000000i)))) +; (begin (display "(string<->number 3.141593+1.000000i) -> ") (display (number->string 3.141593+1.000000i)) +; (display " -> ") (display (string->number (number->string 3.141593+1.000000i))) (newline))) +; (if (not (fequal? 3.141593+3.141593i (string->number (number->string 3.141593+3.141593i)))) +; (begin (display "(string<->number 3.141593+3.141593i) -> ") (display (number->string 3.141593+3.141593i)) +; (display " -> ") (display (string->number (number->string 3.141593+3.141593i))) (newline))) +; (if (not (fequal? 3.141593+2.718282i (string->number (number->string 3.141593+2.718282i)))) +; (begin (display "(string<->number 3.141593+2.718282i) -> ") (display (number->string 3.141593+2.718282i)) +; (display " -> ") (display (string->number (number->string 3.141593+2.718282i))) (newline))) +; (if (not (fequal? 3.141593+1234.000000i (string->number (number->string 3.141593+1234.000000i)))) +; (begin (display "(string<->number 3.141593+1234.000000i) -> ") (display (number->string 3.141593+1234.000000i)) +; (display " -> ") (display (string->number (number->string 3.141593+1234.000000i))) (newline))) +; (if (not (fequal? 3.141593+1234000000.000000i (string->number (number->string 3.141593+1234000000.000000i)))) +; (begin (display "(string<->number 3.141593+1234000000.000000i) -> ") (display (number->string 3.141593+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 3.141593+1234000000.000000i))) (newline))) +; (if (not (fequal? 2.718282+0.000000i (string->number (number->string 2.718282+0.000000i)))) +; (begin (display "(string<->number 2.718282+0.000000i) -> ") (display (number->string 2.718282+0.000000i)) +; (display " -> ") (display (string->number (number->string 2.718282+0.000000i))) (newline))) +; (if (not (fequal? 2.718282+0.000000i (string->number (number->string 2.718282+0.000000i)))) +; (begin (display "(string<->number 2.718282+0.000000i) -> ") (display (number->string 2.718282+0.000000i)) +; (display " -> ") (display (string->number (number->string 2.718282+0.000000i))) (newline))) +; (if (not (fequal? 2.718282+1.000000i (string->number (number->string 2.718282+1.000000i)))) +; (begin (display "(string<->number 2.718282+1.000000i) -> ") (display (number->string 2.718282+1.000000i)) +; (display " -> ") (display (string->number (number->string 2.718282+1.000000i))) (newline))) +; (if (not (fequal? 2.718282+3.141593i (string->number (number->string 2.718282+3.141593i)))) +; (begin (display "(string<->number 2.718282+3.141593i) -> ") (display (number->string 2.718282+3.141593i)) +; (display " -> ") (display (string->number (number->string 2.718282+3.141593i))) (newline))) +; (if (not (fequal? 2.718282+2.718282i (string->number (number->string 2.718282+2.718282i)))) +; (begin (display "(string<->number 2.718282+2.718282i) -> ") (display (number->string 2.718282+2.718282i)) +; (display " -> ") (display (string->number (number->string 2.718282+2.718282i))) (newline))) +; (if (not (fequal? 2.718282+1234.000000i (string->number (number->string 2.718282+1234.000000i)))) +; (begin (display "(string<->number 2.718282+1234.000000i) -> ") (display (number->string 2.718282+1234.000000i)) +; (display " -> ") (display (string->number (number->string 2.718282+1234.000000i))) (newline))) +; (if (not (fequal? 2.718282+1234000000.000000i (string->number (number->string 2.718282+1234000000.000000i)))) +; (begin (display "(string<->number 2.718282+1234000000.000000i) -> ") (display (number->string 2.718282+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 2.718282+1234000000.000000i))) (newline))) +; (if (not (fequal? 1234.000000+0.000000i (string->number (number->string 1234.000000+0.000000i)))) +; (begin (display "(string<->number 1234.000000+0.000000i) -> ") (display (number->string 1234.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 1234.000000+0.000000i))) (newline))) +; (if (not (fequal? 1234.000000+0.000000i (string->number (number->string 1234.000000+0.000000i)))) +; (begin (display "(string<->number 1234.000000+0.000000i) -> ") (display (number->string 1234.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 1234.000000+0.000000i))) (newline))) +; (if (not (fequal? 1234.000000+1.000000i (string->number (number->string 1234.000000+1.000000i)))) +; (begin (display "(string<->number 1234.000000+1.000000i) -> ") (display (number->string 1234.000000+1.000000i)) +; (display " -> ") (display (string->number (number->string 1234.000000+1.000000i))) (newline))) +; (if (not (fequal? 1234.000000+3.141593i (string->number (number->string 1234.000000+3.141593i)))) +; (begin (display "(string<->number 1234.000000+3.141593i) -> ") (display (number->string 1234.000000+3.141593i)) +; (display " -> ") (display (string->number (number->string 1234.000000+3.141593i))) (newline))) +; (if (not (fequal? 1234.000000+2.718282i (string->number (number->string 1234.000000+2.718282i)))) +; (begin (display "(string<->number 1234.000000+2.718282i) -> ") (display (number->string 1234.000000+2.718282i)) +; (display " -> ") (display (string->number (number->string 1234.000000+2.718282i))) (newline))) +; (if (not (fequal? 1234.000000+1234.000000i (string->number (number->string 1234.000000+1234.000000i)))) +; (begin (display "(string<->number 1234.000000+1234.000000i) -> ") (display (number->string 1234.000000+1234.000000i)) +; (display " -> ") (display (string->number (number->string 1234.000000+1234.000000i))) (newline))) +; (if (not (fequal? 1234.000000+1234000000.000000i (string->number (number->string 1234.000000+1234000000.000000i)))) +; (begin (display "(string<->number 1234.000000+1234000000.000000i) -> ") (display (number->string 1234.000000+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 1234.000000+1234000000.000000i))) (newline))) +; (if (not (fequal? 1234000000.000000+0.000000i (string->number (number->string 1234000000.000000+0.000000i)))) +; (begin (display "(string<->number 1234000000.000000+0.000000i) -> ") (display (number->string 1234000000.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+0.000000i))) (newline))) +; (if (not (fequal? 1234000000.000000+0.000000i (string->number (number->string 1234000000.000000+0.000000i)))) +; (begin (display "(string<->number 1234000000.000000+0.000000i) -> ") (display (number->string 1234000000.000000+0.000000i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+0.000000i))) (newline))) +; (if (not (fequal? 1234000000.000000+1.000000i (string->number (number->string 1234000000.000000+1.000000i)))) +; (begin (display "(string<->number 1234000000.000000+1.000000i) -> ") (display (number->string 1234000000.000000+1.000000i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+1.000000i))) (newline))) +; (if (not (fequal? 1234000000.000000+3.141593i (string->number (number->string 1234000000.000000+3.141593i)))) +; (begin (display "(string<->number 1234000000.000000+3.141593i) -> ") (display (number->string 1234000000.000000+3.141593i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+3.141593i))) (newline))) +; (if (not (fequal? 1234000000.000000+2.718282i (string->number (number->string 1234000000.000000+2.718282i)))) +; (begin (display "(string<->number 1234000000.000000+2.718282i) -> ") (display (number->string 1234000000.000000+2.718282i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+2.718282i))) (newline))) +; (if (not (fequal? 1234000000.000000+1234.000000i (string->number (number->string 1234000000.000000+1234.000000i)))) +; (begin (display "(string<->number 1234000000.000000+1234.000000i) -> ") (display (number->string 1234000000.000000+1234.000000i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+1234.000000i))) (newline))) +; (if (not (fequal? 1234000000.000000+1234000000.000000i (string->number (number->string 1234000000.000000+1234000000.000000i)))) +; (begin (display "(string<->number 1234000000.000000+1234000000.000000i) -> ") (display (number->string 1234000000.000000+1234000000.000000i)) +; (display " -> ") (display (string->number (number->string 1234000000.000000+1234000000.000000i))) (newline))) +; (if (not with-bigfloats) +; (begin +; (if (not (fequal? 0.0000001 (string->number (number->string 0.0000001)))) +; (begin (display "(string<->number 0.0000001) -> ") (display (number->string 0.0000001)) +; (display " -> ") (display (string->number (number->string 0.0000001))) (newline))) +; (if (not (fequal? 0.0000001001 (string->number (number->string 0.0000001001)))) +; (begin (display "(string<->number 0.0000001001) -> ") (display (number->string 0.0000001001)) +; (display " -> ") (display (string->number (number->string 0.0000001001))) (newline))))) +; ) + +;(test (number->string 123 8) "173") +;(test (number->string 123 16) "7b") +;(test (number->string 123 2) "1111011") +;(test (number->string -123 8) "-173") +;(test (number->string -123 16) "-7b") +;(test (number->string -123 2) "-1111011") + +;(test (number->string 0 8) "0") +;(test (number->string 0 2) "0") +;(test (number->string 0 16) "0") +;(test (number->string 1 8) "1") +;(test (number->string 1 2) "1") +;(test (number->string 1 16) "1") +;(test (number->string -1 8) "-1") +;(test (number->string -1 2) "-1") +;(test (number->string -1 16) "-1") + +;(let ((happy #t)) +; (do ((i 2 (+ i 1))) +; ((or (not happy) +; (= i 17))) +; (if (not (eqv? 0 (string->number (number->string 0 i) i))) +; (begin +; (set! happy #f) +; (display "(string<->number 0 ") (display i) (display " -> ") (display (number->string 0 i)) +; (display " -> ") (display (string->number (number->string 0 i) i)) (newline))) +; (if (not (eqv? 1234 (string->number (number->string 1234 i) i))) +; (begin +; (set! happy #f) +; (display "(string<->number 1234 ") (display i) (display " -> ") (display (number->string 1234 i)) +; (display " -> ") (display (string->number (number->string 1234 i) i)) (newline))) +; (if (not (eqv? -1234 (string->number (number->string -1234 i) i))) +; (begin +; (set! happy #f) +; (display "(string<->number -1234 ") (display i) (display " -> ") (display (number->string -1234 i)) +; (display " -> ") (display (string->number (number->string -1234 i) i)) (newline))))) + +;(for-each +; (lambda (radix) +; (let* ((last-good 0) +; (first-bad +; (call/cc +; (lambda (return) +; (do ((i 1 (+ i 1)) +; (k 1 (* k 2))) +; ((= i 200) #f) +; (if (and (eqv? k (string->number (number->string k radix) radix)) +; (eqv? (- k) (string->number (number->string (- k) radix) radix)) +; (not (negative? k))) ; might hit sign bit +; (set! last-good k) +; (if (negative? k) +; (return (- (* 2 last-good) 1)) +; (letrec ((search +; (lambda (lo hi) +; (if (= lo hi) +; hi +; (let ((mid (inexact->exact (floor (/ (+ hi lo) 2))))) +; (if (and (eqv? mid (string->number (number->string mid radix) radix)) +; (eqv? (- mid) (string->number (number->string (- mid) radix) radix))) +; (search mid hi) +; (search lo mid))))))) +; (return (search last-good (- (* 2 last-good) 1))))))))))) +; (if (or (and (number? number-to-string-top) ; might have bignums +; (number? first-bad) +; (not (= first-bad number-to-string-top))) +; (and (not (number? number-to-string-top)) +; (number? first-bad))) +; (if (integer? first-bad) +; (begin +; (display "string->number ints (radix ") (display radix) (display ") fail around ") +; (display first-bad) +; (display " (2^") +; (display (/ (log first-bad) (log 2.0))) +; (display ")") +; (newline)) +; (begin +; (display "(string->number ints (radix ") (display radix) (display ") are good out to at least 2^200)") +; (newline)))))) +; (list 2 8 16 7 12))) + +;; (do ((i 0 (+ i 1)) (n 1 (* n 2))) ((= i 63)) (display n) (display " ") (display (number->string n 16)) (newline)) + +(test (number->string 3/4 2) "11/100") +(test (number->string 3/4 8) "3/4") +(test (number->string 3/4 16) "3/4") +(test (number->string -3/4 2) "-11/100") +(test (number->string -3/4 8) "-3/4") +(test (number->string -3/4 16) "-3/4") + +(test (number->string 23/34 2) "10111/100010") +(test (number->string 23/34 8) "27/42") +(test (number->string 23/34 16) "17/22") +(test (number->string -23/34 2) "-10111/100010") +(test (number->string -23/34 8) "-27/42") +(test (number->string -23/34 16) "-17/22") + +(num-test (string->number "11/100" 2) 3/4) +(num-test (string->number "10111/100010" 2) 23/34) +(num-test (string->number "27/42" 8) 23/34) +(num-test (string->number "17/22" 16) 23/34) +(num-test (string->number "1234567890123456789012345678901234567890.123456789e-30") 1234567890.1235) +(num-test (string->number "123456789012345678901234567890123456789012345678901234567890.123456789e-50") 1234567890.1235) +(num-test (- 1234567890123456789012345678901234567890123456789012345678901234567890.123456789e-60 12345678901234567890123456789012345678901234567890.123456789e-40) 0.0) + + +;(let ((happy #t)) +; (do ((i 2 (+ i 1))) +; ((or (not happy) +; (= i 17))) +; (if (not (eqv? 3/4 (string->number (number->string 3/4 i) i))) +; (begin +; (set! happy #f) +; (display "(string<->number 3/4 ") (display i) (display ") -> ") (display (number->string 3/4 i)) +; (display " -> ") (display (string->number (number->string 3/4 i) i)) (newline))) +; (if (not (eqv? 1234/11 (string->number (number->string 1234/11 i) i))) +; (begin +; (set! happy #f) +; (display "(string<->number 1234/11 ") (display i) (display ") -> ") (display (number->string 1234/11 i)) +; (display " -> ") (display (string->number (number->string 1234/11 i) i)) (newline))) +; (if (not (eqv? -1234/11 (string->number (number->string -1234/11 i) i))) +; (begin +; (set! happy #f) +; (display "(string<->number -1234/11 ") (display i) (display ") -> ") (display (number->string -1234/11 i)) +; (display " -> ") (display (string->number (number->string -1234/11 i) i)) (newline))))) + +(test (< (magnitude (- (string->number "3.1415926535897932384626433832795029") 3.1415926535897932384626433832795029)) 1e-7) #t) + +(let ((val (catch #t (lambda () (string->number "111.01" 2)) (lambda args 'error)))) + (if (number? val) + (begin + (num-test (string->number "111.01" 2) 7.25) + (num-test (string->number "-111.01" 2) -7.25) + (num-test (string->number "0.001" 2) 0.125) + (num-test (string->number "1000000.001" 2) 64.125) + + (num-test (string->number "111.01" 8) 73.015625) + (num-test (string->number "-111.01" 8) -73.015625) + (num-test (string->number "0.001" 8) 0.001953125) + (num-test (string->number "1000000.001" 8) 262144.001953125) + + (num-test (string->number "111.01" 16) 273.00390625) + (num-test (string->number "-111.01" 16) -273.00390625) + (num-test (string->number "0.001" 16) 0.000244140625) + (num-test (string->number "1000000.001" 16) 16777216.000244) + + (num-test (string->number "11.+i" 2) 3+1i) + (num-test (string->number "0+.1i" 2) 0+0.5i) + (num-test (string->number "1.+0.i" 2) 1.0) + (num-test (string->number ".01+.1i" 2) 0.25+0.5i) + (num-test (string->number "1+0.i" 2) 1.0) + (num-test (string->number "1+0i" 2) 1.0) + + (test (number->string 0.75 2) "0.11") + (test (number->string 0.125 8) "0.1") + (test (number->string 12.5 8) "14.4") + (test (number->string 12.5 16) "c.8") + (test (number->string 12.5 2) "1100.1") + (test (number->string -12.5 8) "-14.4") + (test (number->string -12.5 16) "-c.8") + (test (number->string -12.5 2) "-1100.1") + (test (number->string 12.0+0.75i 2) "1100.0+0.11i") + (test (number->string -12.5-3.75i 2) "-1100.1-11.11i") + (test (number->string 12.0+0.75i 8) "14.0+0.6i") + (test (number->string -12.5-3.75i 8) "-14.4-3.6i") + (test (number->string 12.0+0.75i 16) "c.0+0.ci") + (test (number->string -12.5-3.75i 16) "-c.8-3.ci") + + (test (string=? (substring (number->string our-pi 16) 0 14) "3.243f6a8885a3") #t) +; (test (string=? (substring (number->string our-pi 2) 0 14) "11.0010010000111111011") #t) + +; (for-each +; (lambda (expchar) +; (let ((exponent (string expchar))) +; (do ((base 2 (+ base 1))) +; ((= base 11)) +; (let ((val (string->number (string-append "1" exponent "1") base))) +; (if (and (number? val) +; (not (= val base))) +; (begin +; (display "(string->number ") (display (string-append "1" exponent "1")) (display " ") (display base) +; (display ") returned ") (display (string->number (string-append "1" exponent "1") base)) +; (display "?") (newline))))) +; +; (do ((base 2 (+ base 1))) +; ((= base 11)) +; (let ((val (string->number (string-append "1.1" exponent "1") base))) +; (if (and (number? val) +; (not (= val (+ base 1)))) +; (begin +; (display "(string->number ") (display (string-append "1.1" exponent "1")) (display " ") (display base) +; (display ") returned ") (display (string->number (string-append "1.1" exponent "1") base)) +; (display "?") (newline))))) +; +; (do ((base 2 (+ base 1))) +; ((= base 11)) +; (let ((val (string->number (string-append "1" exponent "+1") base))) +; (if (and (number? val) +; (not (= val base))) +; (begin +; (display "(string->number ") (display (string-append "1" exponent "+1")) (display " ") (display base) +; (display ") returned ") (display (string->number (string-append "1" exponent "+1") base)) +; (display "?") (newline))))) +; ; in base 16 this is still not a number because of the + (or -) +; ; but "1e+1i" is a number -- gad! +; +; (do ((base 2 (+ base 1))) +; ((= base 11)) +; (let ((val (string->number (string-append "1" exponent "-1+1i") base))) +; (if (and (number? val) +; (> (magnitude (- val (make-rectangular (/ base) 1))) 1e-6)) +; (begin +; (display "(string->number ") (display (string-append "1" exponent "-1+1i")) (display " ") (display base) +; (display ") returned ") (display (string->number (string-append "1" exponent "-1+1i") base)) +; (display "?") (newline))))))) +; +; (list #\e #\d #\f #\s #\l)) + + (test (< (abs (- (string->number "3.1415926535897932384626433832795029" 10) 3.1415926535897932384626433832795029)) 1e-7) #t) + (num-test (string->number "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427" 16) 2.4433976119657) + (num-test (string->number "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427" 11) 2.6508258818757) + +; (let ((happy #t)) +; (do ((i 2 (+ i 1))) +; ((or (not happy) +; (= i 17))) +; (let ((val (+ 1.0 i))) +; (do ((k 1 (+ k 1)) +; (incr (/ 1.0 i) (/ incr i))) +; ((< incr 1e-14)) +; (set! val (+ val incr))) +; (if (> (abs (- val (string->number "11.111111111111111111111111111111111111111111111111111111111111111111111111111111111111" i))) 1e-7) +; (begin +; (set! happy #f) +; (display "(string->number 11.111... ") (display i) (display ") -> ") +; (display (string->number "11.111111111111111111111111111111111111111111111111111111111111111111111111111111111111" i)) +; (display " but expected ") (display val) (newline)))) + + (let* ((digits "00123456789abcdef") + (str (make-string 80 (string-ref digits i)))) + (string-set! str 2 #\.) + (let ((val (exact->inexact (* i i)))) + (if (> (abs (- val (string->number str i))) 1e-7) + (begin + (set! happy #f) + (display "(string->number ") + (display (string-ref digits i)) (display (string-ref digits i)) (display ".") + (display (string-ref digits i)) (display (string-ref digits i)) (display (string-ref digits i)) (display "... ") + (display i) (display ") -> ") + (display (string->number str i)) + (display " but expected ") (display val) (newline))))) + + (let* ((radlim (list 0 0 62 39 31 26 23 22 20 19 18 17 17 16 16 15 15)) + (digits "00123456789abcdef")) + (do ((k (- (list-ref radlim i) 3) (+ k 1))) + ((= k (+ (list-ref radlim i) 4))) + (let ((str (make-string (+ k 3) (string-ref digits i)))) + (string-set! str 2 #\.) + (let ((val (exact->inexact (* i i)))) + (if (> (abs (- val (string->number str i))) 1e-7) + (begin + (set! happy #f) + (display "(string->number ") + (display str) (display " ") + (display i) (display ") -> ") + (display (string->number str i)) + (display " but expected ") (display val) (newline))))))))) + + ;(let ((happy #t)) + ; (do ((i 2 (+ i 1))) + ; ((or (not happy) + ; (= i 17))) + ; (if (> (abs (- 0.75 (string->number (number->string 0.75 i) i))) 1e-6) + ; (begin + ; (set! happy #f) + ; (display "(string<->number 0.75 ") (display i) (display ") -> ") (display (number->string 0.75 i)) + ; (display " -> ") (display (string->number (number->string 0.75 i) i)) (newline))) + ; (if (> (abs (- 1234.75 (string->number (number->string 1234.75 i) i))) 1e-6) + ; (begin + ; (set! happy #f) + ; (display "(string<->number 1234.75 ") (display i) (display ") -> ") (display (number->string 1234.75 i)) + ; (display " -> ") (display (string->number (number->string 1234.75 i) i)) (newline))) + ; (if (> (abs (- -1234.25 (string->number (number->string -1234.25 i) i))) 1e-6) + ; (begin + ; (set! happy #f) + ; (display "(string<->number -1234.25 ") (display i) (display ") -> ") (display (number->string -1234.25 i)) + ; (display " -> ") (display (string->number (number->string -1234.25 i) i)) (newline))) + + ; (let ((val (string->number (number->string 12.5+3.75i i) i))) + ; (if (or (not (number? val)) + ; (> (abs (- (real-part val) 12.5)) 1e-6) + ; (> (abs (- (imag-part val) 3.75)) 1e-6)) + ; (begin + ; (set! happy #f) + ; (display "(string<->number 12.5+3.75i ") (display i) (display ") -> ") (display (number->string 12.5+3.75i i)) + ; (display " -> ") (display (string->number (number->string 12.5+3.75i i) i)) (newline)))) + + ; (let ((happy #t)) + ; (do ((base 2 (+ base 1))) + ; ((or (not happy) + ; (= base 11))) ;;; see s7.c for an explanation of this limit + ; (do ((i 0 (+ i 1))) + ; ((= i 10)) + ; (let* ((rl (- (random 200.0) 100.0)) + ; (im (- (random 200.0) 100.0)) + ; (rlstr (number->string rl base)) + ; (imstr (number->string im base)) + ; (val (make-rectangular rl im)) + ; (str (string-append rlstr + ; (if (or (negative? im) + ; (char=? (string-ref imstr 0) #\-)) ; sigh -- -0.0 is not negative! + ; "" "+") + ; imstr + ; "i"))) + ; (let* ((sn (string->number str base)) + ; (nsn (and (number? sn) (number->string sn base))) + ; (nval (and (string? nsn) (string->number nsn base)))) + ; (if (or (not nval) + ; (> (abs (- (real-part nval) (real-part val))) 1e-3) + ; (> (abs (- (imag-part nval) (imag-part val))) 1e-3)) + ; (begin + ; (set! happy #f) + ; (display "number<->string \"") + ; (display str) + ; (display "\" ") + ; (display base) + ; (display ") -> ") + ; (display nval) + ; (display "?") + ; (display " [") (display sn) (display " ") (display nsn) (display "]") + ; (newline)))))))) + ; )) + ) + +(let ((val (number->string 1.0-1.0i))) + (if (and (not (string=? val "1-1i")) + (not (string=? val "1.0-1.0i")) + (not (string=? val "1-i")) + (not (string=? val "1.0-i"))) + (begin + (display "(number->string 1.0-1.0i) returned ") (display val) (display "?") (newline)))) + +(let ((string->number-2 (lambda (str radix) + (let ((old-str (if (string? str) (string-copy str) str))) + (let ((val (string->number str radix))) + (if (not (string=? str old-str)) + (error 'string->number-messed-up) + val))))) + (string->number-1 (lambda (str) + (let ((old-str (if (string? str) (string-copy str) str))) + (let ((val (string->number str))) + (if (not (string=? str old-str)) + (error 'string->number-messed-up) + val)))))) + + (num-test (string->number-1 "100") 100) + (num-test (string->number-2 "100" 16) 256) + (num-test (string->number-2 "100" 2) 4) + (num-test (string->number-2 "100" 8) 64) + (num-test (string->number-2 "100" 10) 100) + (num-test (string->number-2 "11" 16) 17) + (num-test (string->number-2 "-11" 16) -17) + (num-test (string->number-2 "aa" 16) 170) + (num-test (string->number-2 "-aa" 16) -170) + +; (for-each +; (lambda (str rval fval) +; (let ((happy #t)) +; (do ((radix 3 (+ radix 1))) +; ((or (not happy) +; (= radix 16))) +; (let ((val (string->number-2 str radix))) +; (if (and (number? val) +; (not (fval val (rval radix) radix))) +; (begin +; (display "(string->number \"") (display str) (display "\" ") (display radix) (display ") = ") (display val) (display "?") (newline) +; (set! happy #f))))))) +; (list "101" +; "201.02" +; "1/21" +; "2e1" +; "10.1e-1" +; ) +; (list (lambda (radix) (+ 1 (* radix radix))) +; (lambda (radix) (+ 1.0 (* 2 radix radix) (/ 2.0 (* radix radix)))) +; (lambda (radix) (/ 1 (+ 1 (* 2 radix)))) +; (lambda (radix) (if (< radix 15) (* 2 radix) (+ 1 (* 14 radix) (* 2 radix radix)))) +; (lambda (radix) (+ 1 (/ 1.0 (* radix radix)))) +; ) +; (list (lambda (a b radix) (= a b)) +; (lambda (a b radix) (< (abs (- a b)) (/ 1.0 (* radix radix)))) +; (lambda (a b radix) (= a b)) +; (lambda (a b radix) (= a b)) +; (lambda (a b radix) (< (abs (- a b)) (/ 1.0 (* radix radix radix)))) +; )) + + (num-test (string->number-2 "34" 2) #f) + (num-test (string->number-2 "19" 8) #f) + (num-test (string->number-2 "1c" 10) #f) + (num-test (string->number-2 "1c" 16) 28) + + (test (string->number-1 "") #f ) + (test (string->number-1 ".") #f ) + (test (string->number-1 "d") #f ) + (test (string->number-1 "D") #f ) + (test (string->number-1 "i") #f ) + (test (string->number-1 "I") #f ) + (test (string->number-1 "3i") #f ) + (test (string->number-1 "3I") #f ) + (test (string->number-1 "33i") #f ) + (test (string->number-1 "33I") #f ) + (test (string->number-1 "3.3i") #f ) + (test (string->number-1 "3.3I") #f ) + (test (string->number-1 "-") #f ) + (test (string->number-1 "+") #f ) + + (test (string->number-1 "#i1-1ei") #f) + (test (string->number-1 "#i-2e+i") #f) + (test (string->number-1 "#i1+i1i") #f) + (test (string->number-1 "#i1+1") #f) + (test (string->number-1 "#i2i.") #f) + + (num-test (string->number-1 "3.4e3") 3400.0) + (num-test (string->number-1 "0") 0) + (num-test (string->number-1 "#x#e-2e2") -738) + ) + +(test (let* ((str "1+0i") (x (string->number str))) (and (number? x) (string=? str "1+0i"))) #t) + +(test (= 1 #e1 1/1 #e1/1 #e1.0 #e1e0 #b1 #x1 #o1 #d1 #o001 #o+1 #o#e1 #e#x1 #e1+0i #e10e-1 #e0.1e1 #e+1-0i #e#b1) #t) +(test (= 0.3 3e-1 3d-1 0.3e0 3e-1) #t) +(test (= 0 +0 0.0 +0.0 0/1 +0/24 0+0i #e0 #b0 #x0 #o0 #e#b0) #t) + +(let ((things (vector 123 #e123 #b1111011 #e#b1111011 #b#e1111011 #o173 #e#o173 #o#e173 + #x7b #e#x7b #x#e7b (string->number "123") 246/2 #e123/1 #d123 #e#d123 #d#e123))) + (do ((i 0 (+ i 1))) + ((= i (- (vector-length things) 1))) + (do ((j (+ i 1) (+ j 1))) + ((= j (vector-length things))) + (if (not (eqv? (vector-ref things i) (vector-ref things j))) + (begin + (display "(eqv? ") (display (vector-ref things i)) (display " ") (display (vector-ref things j)) (display ") -> #f?") (newline)))))) + +(test (exact? #i1) #f) +(test (exact? #e1.0) #t) +(test (exact? #i1.0) #f) +(test (exact? #e1) #t) +(test (exact? #i#b1) #f) +(test (exact? #e#b1) #t) + +(for-each + (lambda (n) + (let ((nb + (catch #t + (lambda () + (number? n)) + (lambda args + 'error)))) + (if (not nb) + (begin + (display "(number? ") (display n) (display ") returned #f?") (newline))))) + (list 1 -1 +1 +.1 -.1 .1 .0 0. 0.0 -0 +0 -0. +0. + +1.1 -1.1 1.1 + '1.0e2 '-1.0e2 '+1.0e2 + '1.1e-2 '-1.1e-2 '+1.1e-2 + '1.1e+2 '-1.1e+2 '+1.1e+2 + '1/2 '-1/2 '+1/2 + '1.0s2 '-1.0s2 '+1.0s2 + '1.0d2 '-1.0d2 '+1.0d2 + '1.0f2 '-1.0f2 '+1.0f2 + '1.0l2 '-1.0l2 '+1.0l2 + '1.0+1.0i '1.0-1.0i '-1.0-1.0i '-1.0+1.0i + '1+i '1-i '-1-i '-1+i + '2/3+i '2/3-i '-2/3+i + '1+2/3i '1-2/3i '2/3+2/3i '2.3-2/3i '2/3-2.3i + '2e2+1e3i '2e2-2e2i '2.0e2+i '1+2.0e2i '2.0e+2-2.0e-1i '2/3-2.0e3i '2e-3-2/3i + '-2.0e-2-2.0e-2i '+2.0e+2+2.0e+2i '+2/3-2/3i '2e2-2/3i + '1e1-i '1.-i '.0+i '-.0-1e-1i '1.+.1i '0.-.1i + '.1+.0i '1.+.0i '.1+.1i '1.-.1i '.0+.00i '.10+.0i '-1.+.0i '.1-.01i '1.0+.1i + '1e1+.1i '-1.-.10i '1e01+.0i '0e11+.0i '1.e1+.0i '1.00-.0i '-1e1-.0i '1.-.1e0i + '1.+.001i '1e10-.1i '1e+0-.1i '-0e0-.1i + '-1.0e-1-1.0e-1i '-111e1-.1i '1.1-.1e11i '-1e-1-.11i '-1.1-.1e1i '-.1+.1i + )) + +(for-each + (lambda (n rl im) + (if (not (number? n)) + (begin + (display "(number? ") (display n) (display ") returned #f?") (newline)) + (begin + (if (> (abs (- (real-part n) rl)) .000001) + (begin + (display "real-part: ") (display n) (display " ") (display (real-part n)) (display " ") (display rl) (newline))) + (if (> (abs (- (imag-part n) im)) .000001) + (begin + (display "imag-part: ") (display n) (display " ") (display (imag-part n)) (display " ") (display im) (newline))) + ))) + (list 1 -1 +1 +.1 -.1 .1 .0 0. 0.0 -0 +0 -0. +0. + +1.1 -1.1 1.1 + '1.0e2 '-1.0e2 '+1.0e2 + '1.1e-2 '-1.1e-2 '+1.1e-2 + '1.1e+2 '-1.1e+2 '+1.1e+2 + '1/2 '-1/2 '+1/2 + '1.0s2 '-1.0s2 '+1.0s2 + '1.0d2 '-1.0d2 '+1.0d2 + '1.0f2 '-1.0f2 '+1.0f2 + '1.0l2 '-1.0l2 '+1.0l2 + '1.0+1.0i '1.0-1.0i '-1.0-1.0i '-1.0+1.0i + '1+i '1-i '-1-i '-1+i + '2/3+i '2/3-i '-2/3+i + '1+2/3i '1-2/3i '2/3+2/3i '2.3-2/3i '2/3-2.3i + '2e2+1e3i '2e2-2e2i '2.0e2+i '1+2.0e2i '2.0e+2-2.0e-1i '2/3-2.0e3i '2e-3-2/3i + '-2.0e-2-2.0e-2i '+2.0e+2+2.0e+2i '+2/3-2/3i '2e2-2/3i + '1e1-i '1.-i '.0+i '-.0-1e-1i '1.+.1i '0.-.1i + '.1+.0i '1.+.0i '.1+.1i '1.-.1i '.0+.00i '.10+.0i '-1.+.0i '.1-.01i '1.0+.1i + '1e1+.1i '-1.-.10i '1e01+.0i '0e11+.0i '1.e1+.0i '1.00-.0i '-1e1-.0i '1.-.1e0i + '1.+.001i '1e10-.1i '1e+0-.1i '-0e0-.1i + '-1.0e-1-1.0e-1i '-111e1-.1i '1.1-.1e11i '-1e-1-.11i '-1.1-.1e1i) + + (list 1.0 -1.0 1.0 0.1 -0.1 0.1 0.0 0.0 0.0 0.0 0.0 -0.0 0.0 1.1 -1.1 1.1 100.0 -100.0 + 100.0 0.011 -0.011 0.011 110.0 -110.0 110.0 0.5 -0.5 0.5 100.0 -100.0 100.0 100.0 + -100.0 100.0 100.0 -100.0 100.0 100.0 -100.0 100.0 1.0 1.0 -1.0 -1.0 1.0 1.0 -1.0 + -1.0 0.66666666666667 0.66666666666667 -0.66666666666667 1.0 1.0 0.66666666666667 + 2.3 0.66666666666667 200.0 200.0 200.0 1.0 200.0 0.66666666666667 0.002 -0.02 200.0 + 0.66666666666667 200.0 10.0 1.0 0.0 -0.0 1.0 0.0 0.1 1.0 0.1 1.0 0.0 0.1 -1.0 0.1 + 1.0 10.0 -1.0 10.0 0.0 10.0 1.0 -10.0 1.0 1.0 10000000000.0 1.0 -0.0 -0.1 -1110.0 + 1.1 -0.1 -1.1) + + (list 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 + 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 -1.0 + -1.0 1.0 1.0 -1.0 -1.0 1.0 1.0 -1.0 1.0 0.66666666666667 -0.66666666666667 + 0.66666666666667 -0.66666666666667 -2.3 1000.0 -200.0 1.0 200.0 -0.2 -2000.0 + -0.66666666666667 -0.02 200.0 -0.66666666666667 -0.66666666666667 -1.0 -1.0 1.0 + -0.1 0.1 -0.1 0.0 0.0 0.1 -0.1 0.0 0.0 0.0 -0.01 0.1 0.1 -0.1 0.0 0.0 0.0 0.0 + 0.0 -0.1 0.001 -0.1 -0.1 -0.1 -0.1 -0.1 -10000000000.0 -0.11 -1.0)) + + +;(for-each +; (lambda (n name) +; (if (number? n) +; (begin +; (display "(number? ") (display name) (display ") returned #t?") (newline))) +; (if (or (not (symbol? n)) +; (boolean? n)) +; (begin +; (display "(symbol? ") (display name) (display ") returned #f?") (newline))) +; (if (number? (string->number name)) +; (begin +; (display "(string->number ") (display name) (display ") returned ") (display (string->number name)) (display "?") (newline)))) +; +; (list '1e '--1 '++1 '+. '+.+ '.. '.- '1e- '+ '- '-e1 +; '1/2/3 '1/2+/2 '/2 '2/ '1+2 '1/+i '1/2e1 '1/2. +; '1..0 '1.+0 '1--1 '1+- '1.0++i '1.0-ie++2 '1+1 '1.0. '1.0e +; '1ee2 '1.0e2e2 '1es2 '1e1.0 '1.0.0 '1/2.0 '1+i2 '1+1.0i0 +; '+.i 'i 'e 'e1 '1e.1 '1+.i '1.0e.1 +; '-.1ei '-1.0+1.0 '1.0+1.0i+1.0 '1.1/2 '1/2.0 +; '1/e '1/i 'e/i '1e2/3 '2/1e2 '1e2+1e2ii '1i-1.0 '1.0-i/2 +; '1/2i '2i/3 '2+/i '2+2/i '2+2/-i '2/- '2/+ '2/+3 +; '1e1.0 '1e1e2 '1+ie2 '1ei1 '1e/2 '0-- '1+ '1- '.1. '.1+ +; '1//2 '1/-/2 '1/2/ '1// '+/1 '.0. +; '+0ei '0e++i '+0e+i '0e+-i '+0e-i '+00ei '+.0ei '0+0ei '-01ei '+.1ei +; '1-1ei '-1.ei '0+.i '0-.i '1+e0i '1+/0i '1-/0i '1+e1i '1+/1i '10+.i +; '.0+.i '-0+.i '.1+.i '0.+.i '00-.i '.1-.i '1.-.i '1e++0i '1e--1i '.1e++i +; '+10e+i '1+0e+i '+01e+i '+0e+-i '.1e+-i '1-10ei '0e++00i '1e--.1i '1.e-+1i +; '1-0.e+i '1.+1e+i '-1.e--i '1.e+-.0i '1-e+01i '1-/101i '1+/10i '1-e10i +; '-1+e+1i '.1-e-1i '1-/0e1i '1e10+.i '1/1.1+i '1/11.+i +; '1/2e1-i '-1.0e-1-1-1.0e-1i '-1.0e-1-1.0e-1-1i +; '1.0e2/3 '-1e--1.e1i '-11e--1e1i '1e--1.1e1i '1.e-1-1.ei '-1.e--1.ei +; '-1.1e1-e1i '-1.e1-e-1i '.1e1-e-11i +; '3.-3. '1'2 '+-2 '1? +; '1a '1.a '-a '+a '1.. '..1 '-..1 '1ee1 '1ef2 '1+ief2 '1.+ '1.0- '1/2+/3 +; '1'2 '1-#i '1-i. '1-ie '1... '1//1... +; ) +; (list "1e" "--1" "++1" "+." "+.+" ".." ".-" "1e-" "+" "-" "-e1" +; "1/2/3" "1/2+/2" "/2" "2/" "1+2" "1/+i" "1/2e1" "1/2." +; "1..0" "1.+0" "1--1" "1+-" "1.0++i" "1.0-ie++2" "1+1" "1.0." "1.0e" +; "1ee2" "1.0e2e2" "1es2" "1e1.0" "1.0.0" "1/2.0" "1+i2" "1+1.0i0" +; "+.i" "i" "e" "e1" "1e.1" "1+.i" "1.0e.1" +; "-.1ei" "-1.0+1.0" "1.0+1.0i+1.0" "1.1/2" "1/2.0" +; "1/e" "1/i" "e/i" "1e2/3" "2/1e2" "1e2+1e2ii" "1i-1.0" "1.0-i/2" +; "1/2i" "2i/3" "2+/i" "2+2/i" "2+2/-i" "2/-" "2/+" "2/+3" +; "1e1.0" "1e1e2" "1+ie2" "1ei1" "1e/2" "0--" "1+" "1-" ".1." ".1+" +; "1//2" "1/-/2" "1/2/" "1//" "+/1" ".0." +; "+0ei" "0e++i" "+0e+i" "0e+-i" "+0e-i" "+00ei" "+.0ei" "0+0ei" "-01ei" "+.1ei" +; "1-1ei" "-1.ei" "0+.i" "0-.i" "1+e0i" "1+/0i" "1-/0i" "1+e1i" "1+/1i" "10+.i" +; ".0+.i" "-0+.i" ".1+.i" "0.+.i" "00-.i" ".1-.i" "1.-.i" "1e++0i" "1e--1i" ".1e++i" +; "+10e+i" "1+0e+i" "+01e+i" "+0e+-i" ".1e+-i" "1-10ei" "0e++00i" "1e--.1i" "1.e-+1i" +; "1-0.e+i" "1.+1e+i" "-1.e--i" "1.e+-.0i" "1-e+01i" "1-/101i" "1+/10i" "1-e10i" +; "-1+e+1i" ".1-e-1i" "1-/0e1i" "1e10+.i" "1/1.1+i" "1/11.+i" +; "1/2e1-i" "-1.0e-1-1-1.0e-1i" "-1.0e-1-1.0e-1-1i" +; "1.0e2/3" "-1e--1.e1i" "-11e--1e1i" "1e--1.1e1i" "1.e-1-1.ei" "-1.e--1.ei" +; "-1.1e1-e1i" "-1.e1-e-1i" ".1e1-e-11i" +; "3.-3." "'1'2" "'+-2" "'1?" +; "1a" "1.a" "-a" "+a" "1.." "..1" "-..1" "1ee1" "1ef2" "1+ief2" "1.+" "1.0-" "1/2+/3" +; "'1'2" "1-#i" "1-i." "1-ie" "1..." "1/1/1/1" +; )) + +(test (number? ''1) #f) +(test (symbol? ''1) #f) +(test (string->number "''1") #f) + +(test (let ((val (catch #t (lambda () + (= 1 + 01 +1 1. + 001 +01 1/1 1.0 1e0 01. +1. + 0001 +001 1/01 .1e1 01/1 +1/1 1.00 1e00 01.0 +1.0 1e+0 1e-0 01e0 +1e0 1.e0 001. +01. 1+0i 1-0i + 11/11 00001 +0001 1/001 .1e01 01/01 +1/01 .1e+1 10e-1 0.1e1 +.1e1 .10e1 001/1 +01/1 10/10 1.000 1e000 01.00 +1.00 1e+00 1e-00 01e00 +1e00 1.e00 001.0 +01.0 01e+0 +1e+0 1.e+0 01e-0 +1e-0 1.e-0 001e0 +01e0 1.0e0 01.e0 +1.e0 0001. +001. 1+00i 1-00i 1+.0i 1-.0i 01+0i +1+0i 1.+0i 01-0i +1-0i 1.-0i 1+0.i 1-0.i + 11/011 011/11 +11/11 000001 +00001 1/0001 .1e001 01/001 +1/001 .1e+01 10e-01 0.1e01 +.1e01 .10e01 001/01 +01/01 0.1e+1 +.1e+1 .10e+1 010e-1 +10e-1 10.e-1 00.1e1 +0.1e1 0.10e1 +.10e1 .100e1 0001/1 +001/1 10/010 010/10 +10/10 1.0000 1e0000 01.000 +1.000 1e+000 1e-000 01e000 +1e000 1.e000 001.00 +01.00 01e+00 +1e+00 1.e+00 01e-00 +1e-00 1.e-00 001e00 +01e00 1.0e00 01.e00 +1.e00 0001.0 +001.0 001e+0 +01e+0 1.0e+0 01.e+0 +1.e+0 001e-0 +01e-0 1.0e-0 01.e-0 +1.e-0 0001e0 +001e0 1.00e0 01.0e0 +1.0e0 001.e0 +01.e0 00001. +0001. 1+0e1i 1-0e1i 1+0/1i 1-0/1i 1+000i 1-000i 1+.00i 1-.00i 01+00i +1+00i 1.+00i 01-00i +1-00i 1.-00i 1+0.0i 1-0.0i 01+.0i +1+.0i 1.+.0i 01-.0i +1-.0i 1.-.0i 001+0i +01+0i 1/1+0i 1.0+0i 1e0+0i 01.+0i +1.+0i 001-0i +01-0i 1/1-0i 1.0-0i 1e0-0i 01.-0i +1.-0i 1+0e0i 1-0e0i 1+00.i 1-00.i 01+0.i +1+0.i 1.+0.i 01-0.i +1-0.i 1.-0.i + 111/111 11/0011 011/011 +11/011 0011/11 +011/11 101/101 0000001 +000001 1/00001 .1e0001 01/0001 +1/0001 .1e+001 10e-001 0.1e001 +.1e001 .10e001 001/001 +01/001 0.1e+01 +.1e+01 .10e+01 010e-01 +10e-01 10.e-01 00.1e01 +0.1e01 0.10e01 +.10e01 .100e01 0001/01 +001/01 00.1e+1 +0.1e+1 0.10e+1 +.10e+1 .100e+1 0010e-1 +010e-1 10.0e-1 010.e-1 +10.e-1 000.1e1 +00.1e1 00.10e1 +0.10e1 0.100e1 +.100e1 .1000e1 00001/1 +0001/1 110/110 10/0010 010/010 +10/010 0010/10 +010/10 100/100 1.00000 1e00000 01.0000 +1.0000 1e+0000 1e-0000 01e0000 +1e0000 1.e0000 001.000 +01.000 01e+000 +1e+000 1.e+000 01e-000 +1e-000 1.e-000 001e000 +01e000 1.0e000 01.e000 +1.e000 0001.00 +001.00 001e+00 +01e+00 1.0e+00 01.e+00 +1.e+00 001e-00 +01e-00 1.0e-00 01.e-00 +1.e-00 0001e00 +001e00 1.00e00 01.0e00 +1.0e00 001.e00 +01.e00 00001.0 +0001.0 0001e+0 +001e+0 1.00e+0 01.0e+0 +1.0e+0 001.e+0 +01.e+0 0001e-0 +001e-0 1.00e-0 01.0e-0 +1.0e-0 001.e-0 +01.e-0 00001e0 +0001e0 1.000e0 01.00e0 +1.00e0 001.0e0 +01.0e0 0001.e0 +001.e0 000001. +00001. 1+0e11i 1-0e11i 1+0/11i 1-0/11i 1+0e01i 1-0e01i 1+0/01i 1-0/01i 1+0e+1i 1-0e+1i 1+0e-1i 1-0e-1i 1+00e1i 1-00e1i 1+.0e1i 1-.0e1i 01+0e1i +1+0e1i 1.+0e1i 01-0e1i +1-0e1i 1.-0e1i 1+0.e1i 1-0.e1i 1+00/1i 1-00/1i 01+0/1i +1+0/1i 1.+0/1i 01-0/1i +1-0/1i 1.-0/1i 1+0e10i 1-0e10i 1+0/10i 1-0/10i 1+0000i 1-0000i 1+.000i 1-.000i 01+000i +1+000i 1.+000i 01-000i +1-000i 1.-000i 1+0.00i 1-0.00i 01+.00i +1+.00i 1.+.00i 01-.00i +1-.00i 1.-.00i 001+00i +01+00i 1/1+00i 1.0+00i 1e0+00i 01.+00i +1.+00i 001-00i +01-00i 1/1-00i 1.0-00i 1e0-00i 01.-00i +1.-00i 1+0e00i 1-0e00i 1+00.0i 1-00.0i 01+0.0i +1+0.0i 1.+0.0i 01-0.0i +1-0.0i 1.-0.0i 001+.0i +01+.0i 1/1+.0i 1.0+.0i 1e0+.0i 01.+.0i +1.+.0i 001-.0i +01-.0i 1/1-.0i 1.0-.0i 1e0-.0i 01.-.0i +1.-.0i 0001+0i +001+0i 1/01+0i .1e1+0i 01/1+0i +1/1+0i 1.00+0i 1e00+0i 01.0+0i +1.0+0i 1e+0+0i 1e-0+0i 01e0+0i +1e0+0i 1.e0+0i 001.+0i +01.+0i 1+0e+0i 1-0e+0i 0001-0i +001-0i 1/01-0i .1e1-0i 01/1-0i +1/1-0i 1.00-0i 1e00-0i 01.0-0i +1.0-0i 1e+0-0i 1e-0-0i 01e0-0i +1e0-0i 1.e0-0i 001.-0i +01.-0i 1+0e-0i 1-0e-0i 1+00e0i 1-00e0i 1+.0e0i 1-.0e0i 01+0e0i +1+0e0i 1.+0e0i 01-0e0i +1-0e0i 1.-0e0i 1+0.e0i 1-0.e0i 1+000.i 1-000.i 01+00.i +1+00.i 1.+00.i 01-00.i +1-00.i 1.-00.i 001+0.i +01+0.i 1/1+0.i 1.0+0.i 1e0+0.i 01.+0.i +1.+0.i 001-0.i +01-0.i 1/1-0.i 1.0-0.i 1e0-0.i 01.-0.i +1.-0.i + 111/0111 0111/111 +111/111 11/00011 011/0011 +11/0011 0011/011 +011/011 00011/11 +0011/11 101/0101 0101/101 +101/101 00000001 +0000001 1/000001 .1e00001 01/00001 +1/00001 .1e+0001 10e-0001 0.1e0001 +.1e0001 .10e0001 001/0001 +01/0001 0.1e+001 +.1e+001 .10e+001 010e-001 +10e-001 10.e-001 00.1e001 +0.1e001 0.10e001 +.10e001 .100e001 0001/001 +001/001 00.1e+01 +0.1e+01 0.10e+01 +.10e+01 .100e+01 0010e-01 +010e-01 10.0e-01 010.e-01 +10.e-01 000.1e01 +00.1e01 00.10e01 +0.10e01 0.100e01 +.100e01 .1000e01 00001/01 +0001/01 000.1e+1 +00.1e+1 00.10e+1 +0.10e+1 0.100e+1 +.100e+1 .1000e+1 00010e-1 +0010e-1 10.00e-1 010.0e-1 +10.0e-1 0010.e-1 +010.e-1 0000.1e1 +000.1e1 000.10e1 +00.10e1 00.100e1 +0.100e1 0.1000e1 +.1000e1 .10000e1 000001/1 +00001/1 110/0110 0110/110 +110/110 10/00010 010/0010 +10/0010 0010/010 +010/010 00010/10 +0010/10 100/0100 0100/100 +100/100 1.000000 1e000000 01.00000 +1.00000 1e+00000 1e-00000 01e00000 +1e00000 1.e00000 001.0000 +01.0000 01e+0000 +1e+0000 1.e+0000 01e-0000 +1e-0000 1.e-0000 001e0000 +01e0000 1.0e0000 01.e0000 +1.e0000 0001.000 +001.000 001e+000 +01e+000 1.0e+000 01.e+000 +1.e+000 001e-000 +01e-000 1.0e-000 01.e-000 +1.e-000 0001e000 +001e000 1.00e000 01.0e000 +1.0e000 001.e000 +01.e000 00001.00 +0001.00 0001e+00 +001e+00 1.00e+00 01.0e+00 +1.0e+00 001.e+00 +01.e+00 0001e-00 +001e-00 1.00e-00 01.0e-00 +1.0e-00 001.e-00 +01.e-00 00001e00 +0001e00 1.000e00 01.00e00 +1.00e00 001.0e00 +01.0e00 0001.e00 +001.e00 000001.0 +00001.0 00001e+0 +0001e+0 1.000e+0 01.00e+0 +1.00e+0 001.0e+0 +01.0e+0 0001.e+0 +001.e+0 00001e-0 +0001e-0 1.000e-0 01.00e-0 +1.00e-0 001.0e-0 +01.0e-0 0001.e-0 +001.e-0 000001e0 +00001e0 1.0000e0 01.000e0 +1.000e0 001.00e0 +01.00e0 0001.0e0 +001.0e0 00001.e0 +0001.e0 0000001. +000001.)) + (lambda args 'error)))) + val) + #t) + +(for-each + (lambda (lst) + (for-each + (lambda (str) + (let ((val (catch #t (lambda () (string->number str)) (lambda args 'error)))) + (if (or (not (number? val)) + (not (= val 1))) + (begin + (display "(string->number \"") (display str) (display "\") = ") (display val) (display "?") (newline))))) + lst)) + (list + (list "1") + + (list "01" "+1" "1.") + + (list "001" "+01" "#e1" "#i1" "1/1" "#b1" "#x1" "#d1" "#o1" "1.0" "1e0" "1d0" "1l0" "1s0" "1f0" "9/9" "01." "+1." "1E0" "1D0" "1L0" "1S0" "1F0") + + (list "0001" "+001" "#e01" "#i01" "1/01" "#b01" "#x01" "#d01" "#o01" "#e+1" "#i+1" "#b+1" "#x+1" "#d+1" "#o+1" ".1e1" "01/1" "+1/1" ".1d1" ".1l1" ".1s1" ".1f1" "1.00" "1e00" "1d00" "1l00" "1s00" "1f00" "01.0" "+1.0" "1e+0" "1d+0" "1l+0" "1s+0" "1f+0" "1e-0" "1d-0" "1l-0" "1s-0" "1f-0" "01e0" "+1e0" "1.e0" "01d0" "+1d0" "1.d0" "01l0" "+1l0" "1.l0" "01s0" "+1s0" "1.s0" "01f0" "+1f0" "1.f0" "9/09" "09/9" "+9/9" "001." "+01." "#e1." "#i1." "1+0i" "1-0i" "#d1.") + + (list "11/11" "00001" "+0001" "#e001" "#i001" "1/001" "#b001" "#x001" "#d001" "#o001" "#e+01" "#i+01" "#b+01" "#x+01" "#d+01" "#o+01" ".1e01" "01/01" "+1/01" ".1d01" ".1l01" ".1s01" ".1f01" "91/91" ".1e+1" ".1d+1" ".1l+1" ".1s+1" ".1f+1" "10e-1" "10d-1" "10l-1" "10s-1" "10f-1" "0.1e1" "+.1e1" ".10e1" "#b#e1" "#x#e1" "#d#e1" "#o#e1" "#b#i1" "#x#i1" "#d#i1" "#o#i1" "001/1" "+01/1" "#e1/1" "#i1/1" "#b1/1" "#x1/1" "#d1/1" "#o1/1" "#e#b1" "#i#b1" "#e#x1" "#i#x1" "0.1d1" "+.1d1" ".10d1" "#e#d1" "#i#d1" "#e#o1" "#i#o1" "0.1l1" "+.1l1" ".10l1" "0.1s1" "+.1s1" ".10s1" "0.1f1" "+.1f1" ".10f1" "10/10" "1.000" "1e000" "1d000" "1l000" "1s000" "1f000" "01.00" "+1.00" "1e+00" "1d+00" "1l+00" "1s+00" "1f+00" "1e-00" "1d-00" "1l-00" "1s-00" "1f-00" "01e00" "+1e00" "1.e00" "01d00" "+1d00" "1.d00" "01l00" "+1l00" "1.l00" "01s00" "+1s00" "1.s00" "01f00" "+1f00" "1.f00" "90/90" "001.0" "+01.0" "#e1.0" "#i1.0" "01e+0" "+1e+0" "1.e+0" "01d+0" "+1d+0" "1.d+0" "01l+0" "+1l+0" "1.l+0" "01s+0" "+1s+0" "1.s+0" "01f+0" "+1f+0" "1.f+0" "01e-0" "+1e-0" "1.e-0" "01d-0" "+1d-0" "1.d-0" "01l-0" "+1l-0" "1.l-0" "01s-0" "+1s-0" "1.s-0" "01f-0" "+1f-0" "1.f-0" "001e0" "+01e0" "#e1e0" "#i1e0" "1.0e0" "01.e0" "+1.e0" "001d0" "+01d0" "#e1d0" "#i1d0" "1.0d0" "01.d0" "+1.d0" "001l0" "+01l0" "#e1l0" "#i1l0" "1.0l0" "01.l0" "+1.l0" "001s0" "+01s0" "#e1s0" "#i1s0" "1.0s0" "01.s0" "+1.s0" "001f0" "+01f0" "#e1f0" "#i1f0" "1.0f0" "01.f0" "+1.f0" "19/19" "9/009" "09/09" "+9/09" "99/99" "009/9" "+09/9" "#e9/9" "#i9/9" "#x9/9" "#d9/9" "0001." "+001." "#e01." "#i01." "#e+1." "#i+1." "#xe/e" "1+00i" "1-00i" "1+.0i" "1-.0i" "01+0i" "+1+0i" "1.+0i" "01-0i" "+1-0i" "1.-0i" "1+0.i" "1-0.i" "#xb/b" "#xd/d" "#xf/f" "#d1d0") + +;; remove "9": + +(list "11/011" "011/11" "+11/11" "000001" "+00001" "#e0001" "#i0001" "1/0001" "#b0001" "#x0001" "#d0001" "#o0001" "#e+001" "#i+001" "#b+001" "#x+001" "#d+001" "#o+001" ".1e001" "01/001" "+1/001" ".1d001" ".1l001" ".1s001" ".1f001" ".1e+01" ".1d+01" ".1l+01" ".1s+01" ".1f+01" "10e-01" "10d-01" "10l-01" "10s-01" "10f-01" "0.1e01" "+.1e01" ".10e01" "#b#e01" "#x#e01" "#d#e01" "#o#e01" "#b#i01" "#x#i01" "#d#i01" "#o#i01" "001/01" "+01/01" "#e1/01" "#i1/01" "#b1/01" "#x1/01" "#d1/01" "#o1/01" "#e#b01" "#i#b01" "#e#x01" "#i#x01" "0.1d01" "+.1d01" ".10d01" "#e#d01" "#i#d01" "#e#o01" "#i#o01" "0.1l01" "+.1l01" ".10l01" "0.1s01" "+.1s01" ".10s01" "0.1f01" "+.1f01" ".10f01" "0.1e+1" "+.1e+1" ".10e+1" "#b#e+1" "#x#e+1" "#d#e+1" "#o#e+1" "#b#i+1" "#x#i+1" "#d#i+1" "#o#i+1" "#e#b+1" "#i#b+1" "#e#x+1" "#i#x+1" "0.1d+1" "+.1d+1" ".10d+1" "#e#d+1" "#i#d+1" "#e#o+1" "#i#o+1" "0.1l+1" "+.1l+1" ".10l+1" "0.1s+1" "+.1s+1" ".10s+1" "0.1f+1" "+.1f+1" ".10f+1" "010e-1" "+10e-1" "10.e-1" "010d-1" "+10d-1" "10.d-1" "010l-1" "+10l-1" "10.l-1" "010s-1" "+10s-1" "10.s-1" "010f-1" "+10f-1" "10.f-1" "00.1e1" "+0.1e1" "#e.1e1" "#i.1e1" "0.10e1" "+.10e1" ".100e1" "0001/1" "+001/1" "#e01/1" "#i01/1" "#b01/1" "#x01/1" "#d01/1" "#o01/1" "#e+1/1" "#i+1/1" "#b+1/1" "#x+1/1" "#d+1/1" "#o+1/1" "00.1d1" "+0.1d1" "#e.1d1" "#i.1d1" "0.10d1" "+.10d1" ".100d1" "00.1l1" "+0.1l1" "#e.1l1" "#i.1l1" "0.10l1" "+.10l1" ".100l1" "00.1s1" "+0.1s1" "#e.1s1" "#i.1s1" "0.10s1" "+.10s1" ".100s1" "00.1f1" "+0.1f1" "#e.1f1" "#i.1f1" "0.10f1" "+.10f1" ".100f1" "10/010" "010/10" "+10/10" "1.0000" "1e0000" "1d0000" "1l0000" "1s0000" "1f0000" "01.000" "+1.000" "1e+000" "1d+000" "1l+000" "1s+000" "1f+000" "1e-000" "1d-000" "1l-000" "1s-000" "1f-000" "01e000" "+1e000" "1.e000" "01d000" "+1d000" "1.d000" "01l000" "+1l000" "1.l000" "01s000" "+1s000" "1.s000" "01f000" "+1f000" "1.f000" "001.00" "+01.00" "#e1.00" "#i1.00" "01e+00" "+1e+00" "1.e+00" "01d+00" "+1d+00" "1.d+00" "01l+00" "+1l+00" "1.l+00" "01s+00" "+1s+00" "1.s+00" "01f+00" "+1f+00" "1.f+00" "01e-00" "+1e-00" "1.e-00" "01d-00" "+1d-00" "1.d-00" "01l-00" "+1l-00" "1.l-00" "01s-00" "+1s-00" "1.s-00" "01f-00" "+1f-00" "1.f-00" "001e00" "+01e00" "#e1e00" "#i1e00" "1.0e00" "01.e00" "+1.e00" "001d00" "+01d00" "#e1d00" "#i1d00" "1.0d00" "01.d00" "+1.d00" "001l00" "+01l00" "#e1l00" "#i1l00" "1.0l00" "01.l00" "+1.l00" "001s00" "+01s00" "#e1s00" "#i1s00" "1.0s00" "01.s00" "+1.s00" "001f00" "+01f00" "#e1f00" "#i1f00" "1.0f00" "01.f00" "+1.f00" "0001.0" "+001.0" "#e01.0" "#i01.0" "#e+1.0" "#i+1.0" "001e+0" "+01e+0" "#e1e+0" "#i1e+0" "1.0e+0" "01.e+0" "+1.e+0" "001d+0" "+01d+0" "#e1d+0" "#i1d+0" "1.0d+0" "01.d+0" "+1.d+0" "001l+0" "+01l+0" "#e1l+0" "#i1l+0" "1.0l+0" "01.l+0" "+1.l+0" "001s+0" "+01s+0" "#e1s+0" "#i1s+0" "1.0s+0" "01.s+0" "+1.s+0" "001f+0" "+01f+0" "#e1f+0" "#i1f+0" "1.0f+0" "01.f+0" "+1.f+0" "001e-0" "+01e-0" "#e1e-0" "#i1e-0" "1.0e-0" "01.e-0" "+1.e-0" "001d-0" "+01d-0" "#e1d-0" "#i1d-0" "1.0d-0" "01.d-0" "+1.d-0" "001l-0" "+01l-0" "#e1l-0" "#i1l-0" "1.0l-0" "01.l-0" "+1.l-0" "001s-0" "+01s-0" "#e1s-0" "#i1s-0" "1.0s-0" "01.s-0" "+1.s-0" "001f-0" "+01f-0" "#e1f-0" "#i1f-0" "1.0f-0" "01.f-0" "+1.f-0" "0001e0" "+001e0" "#e01e0" "#i01e0" "#e+1e0" "#i+1e0" "1.00e0" "01.0e0" "+1.0e0" "001.e0" "+01.e0" "#e1.e0" "#i1.e0" "0001d0" "+001d0" "#e01d0" "#i01d0" "#e+1d0" "#i+1d0" "1.00d0" "01.0d0" "+1.0d0" "001.d0" "+01.d0" "#e1.d0" "#i1.d0" "0001l0" "+001l0" "#e01l0" "#i01l0" "#e+1l0" "#i+1l0" "1.00l0" "01.0l0" "+1.0l0" "001.l0" "+01.l0" "#e1.l0" "#i1.l0" "0001s0" "+001s0" "#e01s0" "#i01s0" "#e+1s0" "#i+1s0" "1.00s0" "01.0s0" "+1.0s0" "001.s0" "+01.s0" "#e1.s0" "#i1.s0" "0001f0" "+001f0" "#e01f0" "#i01f0" "#e+1f0" "#i+1f0" "1.00f0" "01.0f0" "+1.0f0" "001.f0" "+01.f0" "#e1.f0" "#i1.f0" "00001." "+0001." "#e001." "#i001." "#e+01." "#i+01." "#xe/0e" "#x0e/e" "#x+e/e" "1+0e1i" "1-0e1i" "1+0/1i" "1-0/1i" "1+0d1i" "1-0d1i" "1+0l1i" "1-0l1i" "1+0s1i" "1-0s1i" "1+0f1i" "1-0f1i" "1+000i" "1-000i" "1+.00i" "1-.00i" "01+00i" "+1+00i" "1.+00i" "01-00i" "+1-00i" "1.-00i" "1+0.0i" "1-0.0i" "01+.0i" "+1+.0i" "1.+.0i" "01-.0i" "+1-.0i" "1.-.0i" "001+0i" "+01+0i" "#e1+0i" "#i1+0i" "1/1+0i" "1.0+0i" "1e0+0i" "1d0+0i" "1l0+0i" "1s0+0i" "1f0+0i" "01.+0i" "+1.+0i" "001-0i" "+01-0i" "#e1-0i" "#i1-0i" "1/1-0i" "1.0-0i" "1e0-0i" "1d0-0i" "1l0-0i" "1s0-0i" "1f0-0i" "01.-0i" "+1.-0i" "1+0e0i" "1-0e0i" "1+0d0i" "1-0d0i" "1+0l0i" "1-0l0i" "1+0s0i" "1-0s0i" "1+0f0i" "1-0f0i" "1+00.i" "1-00.i" "01+0.i" "+1+0.i" "1.+0.i" "01-0.i" "+1-0.i" "1.-0.i" "#xb/0b" "#x0b/b" "#x+b/b" "#xd/0d" "#x0d/d" "#x+d/d" "#xf/0f" "#x0f/f" "#x+f/f") + +;; remove "l" and "s" and others... + +(list "111/111" "11/0011" "011/011" "+11/011" "0011/11" "+011/11" "#e11/11" "#i11/11" "#b11/11" "#x11/11" "#d11/11" "#o11/11" "101/101" "0000001" "+000001" "#e00001" "#i00001" "1/00001" "#b00001" "#x00001" "#d00001" "#o00001" "#e+0001" "#i+0001" "#b+0001" "#x+0001" "#d+0001" "#o+0001" ".1e0001" "01/0001" "+1/0001" ".1d0001" ".1f0001" ".1e+001" ".1d+001" ".1f+001" "10e-001" "10d-001" "10f-001" "0.1e001" "+.1e001" ".10e001" "#b#e001" "#x#e001" "#d#e001" "#o#e001" "#b#i001" "#x#i001" "#d#i001" "#o#i001" "001/001" "+01/001" "#e1/001" "#i1/001" "#b1/001" "#x1/001" "#d1/001" "#o1/001" "#e#b001" "#i#b001" "#e#x001" "#i#x001" "0.1d001" "+.1d001" ".10d001" "#e#d001" "#i#d001" "#e#o001" "#i#o001" "0.1f001" "+.1f001" ".10f001" "0.1e+01" "+.1e+01" ".10e+01" "#b#e+01" "#x#e+01" "#d#e+01" "#o#e+01" "#b#i+01" "#x#i+01" "#d#i+01" "#o#i+01" "#e#b+01" "#i#b+01" "#e#x+01" "#i#x+01" "0.1d+01" "+.1d+01" ".10d+01" "#e#d+01" "#i#d+01" "#e#o+01" "#i#o+01" "0.1f+01" "+.1f+01" ".10f+01" "010e-01" "+10e-01" "10.e-01" "010d-01" "+10d-01" "10.d-01" "010f-01" "+10f-01" "1.00000" "1e00000" "1d00000" "1f00000" "01.0000" "+1.0000" "1e+0000" "1d+0000" "1f+0000" "1e-0000" "1d-0000" "1f-0000" "01e0000" "+1e0000" "1.e0000" "01d0000" "+1d0000" "1.d0000" "01f0000" "+1f0000" "1.f0000" "001.000" "+01.000" "#e1.000" "#i1.000" "#d1.000" "01e+000" "+1e+000" "1.e+000" "01d+000" "+1d+000" "1.d+000" "01f+000" "+1f+000" "1.f+000" "01e-000" "+1e-000" "1.e-000" "01d-000" "+1d-000" "1.d-000" "01f-000" "+1f-000" "1.f-000" "001e000" "+01e000" "#e1e000" "#i1e000" "#d1e000" "1.0e000" "+1.e000" "001d000" "+01d000" "#e1d000" "#i1d000" "#d1d000" "1.0d000" "01.d000" "+1.d000" "001f000" "+01f000" "#e1f000" "#i1f000" "#d1f000" "1.0f000" "01.f000" "+1.f000" "0001.00" "+001.00" "#e01.00" "#i01.00" "#d01.00" "#e+1.00" "#i+1.00" "#d+1.00" "001e+00" "+01e+00" "#e1e+00" "#i1e+00" "#d1e+00" "1.0e+00" "01.e+00" "+1.e+00" "001d+00" "+01d+00" "#e1d+00" "#i1d+00" "#d1d+00" "1.0d+00" "01.d+00" "+1.d+00" "001f+00" "+01f+00" "#e1f+00" "#i1f+00" "#d1f+00" "1.0f+00" "01.f+00" "+1.f+00" "001e-00" "+01e-00" "#e1e-00" "#i1e-00" "#d1e-00" "1.0e-00" "01.e-00" "+1.e-00" "001d-00" "+01d-00" "#e1d-00" "#i1d-00" "#d1d-00" "1.0d-00" "01.d-00" "+1.d-00" "001f-00" "+01f-00" "#e1f-00" "#i1f-00" "#d1f-00" "1.0f-00" "0001.f0" "+001.f0" "#e01.f0" "#i01.f0" "#d01.f0" "#e+1.f0" "#i+1.f0" "#d+1.f0" "#xf0/f0" "000001." "+00001." "#e0001." "#i0001." "#d0001." "#e+001." "#i+001." "#d+001." "#d#e01." "#d#i01." "#e#d01." "#i#d01." "#d#e+1." "#d#i+1." "#e#d+1." "#i#d+1." "#x1e/1e" "#xe/00e" "#x0e/0e" "#x+e/0e" "#xee/ee" "#x00e/e" "#x+0e/e" "#x#ee/e" "#x#ie/e" "#e#xe/e" "#i#xe/e" "#xbe/be" "#xde/de" "#xfe/fe" "1+0e11i" "1-0e11i" "1+0/11i" "1-0/11i" "1+0d11i" "1-0d11i" "1+0f11i" "1-0f11i" "1+0e01i" "1-0e01i" "1+0/01i" "1-0/01i" "1+0d01i" "1-0d01i" "1+0f01i" "1-0f01i" "1+0e+1i" "1-0e+1i" "1+0d+1i" "1-0d+1i" "1+0f+1i" "1-0f+1i" "1+0e-1i" "1-0e-1i" "1+0d-1i" "1-0d-1i" "1+0f-1i" "1-0f-1i" "1+00e1i" "1-00e1i" "1+.0e1i" "1-.0e1i" "01+0e1i" "+1+0e1i" "1.+0e1i" "01-0e1i" "+1-0e1i" "1.-0e1i" "1+0.e1i" "1-0.e1i" "1+00/1i" "1-00/1i" "01+0/1i" "+1+0/1i" "1.+0/1i" "01-0/1i" "+1-0/1i" "1.-0/1i" "1+00d1i" "1-00d1i" "1+.0d1i" "1-.0d1i" "01+0d1i" "+1+0d1i" "1.+0d1i" "01-0d1i" "+1-0d1i" "1.-0d1i" "1+0.d1i" "1-0.d1i" "1+00f1i" "1-00f1i" "1+.0f1i" "1-.0f1i" "01+0f1i" "+1+0f1i" "1.+0f1i" "01-0f1i" "+1-0f1i" "1.-0f1i" "1+0.f1i" "1-0.f1i" "1+0e10i" "1-0e10i" "1+0/10i" "1-0/10i" "1+0d10i" "1-0d10i" "1+0f10i" "1-0f10i" "1+0000i" "1-0000i" "1+.000i" "1-.000i" "01+000i" "+1+000i" "1.+000i" "01-000i" "+1-000i" "1.-000i" "1+0.00i" "1-0.00i" "01+.00i" "+1+.00i" "1.+.00i" "01-.00i" "+1-.00i" "1.-.00i" "001+00i" "+01+00i" "#e1+00i" "#i1+00i" "1/1+00i" "#b1+00i" "#x1+00i" "#d1+00i" "#o1+00i" "1.0+00i" "1e0+00i" "1d0+00i" "1f0+00i" "01.+00i" "+1.+00i" "001-00i" "+01-00i" "#e1-00i" "#i1-00i" "1/1-00i" "#b1-00i" "#x1-00i" "#d1-00i" "#o1-00i" "1.0-00i" "1e0-00i" "1d0-00i" "1f0-00i" "01.-00i" "+1.-00i" "1+0e00i" "1-0e00i" "1+0d00i" "1-0d00i" "1+0f00i" "1-0f00i" "1+00.0i" "1-00.0i" "01+0.0i" "+1+0.0i" "1.+0.0i" "01-0.0i" "+1-0.0i" "1.-0.0i" "001+.0i" "+01+.0i" "#e1+.0i" "#i1+.0i" "1/1+.0i" "#d1+.0i" "1.0+.0i" "1e0+.0i" "1d0+.0i" "1f0+.0i" "01.+.0i" "+1.+.0i" "001-.0i" "+01-.0i" "#e1-.0i" "#i1-.0i" "1/1-.0i" "#d1-.0i" "1.0-.0i" "1e0-.0i" "1d0-.0i" "1f0-.0i" "01.-.0i" "+1.-.0i" "0001+0i" "+001+0i" "#e01+0i" "#i01+0i" "1/01+0i" "#b01+0i" "#x01+0i" "#d01+0i" "#o01+0i" "#e+1+0i" "#i+1+0i" "#b+1+0i" "#x+1+0i" "#d+1+0i" "#o+1+0i" ".1e1+0i" "01/1+0i" "+1/1+0i" ".1d1+0i" ".1f1+0i" "1.00+0i" "1e00+0i" "1d00+0i" "1f00+0i" "01.0+0i" "+1.0+0i" "1e+0+0i" "1d+0+0i" "1f+0+0i" "1e-0+0i" "1d-0+0i" "1f-0+0i" "01e0+0i" "+1e0+0i" "1.e0+0i" "01d0+0i" "+1d0+0i" "1.d0+0i" "01f0+0i" "+1f0+0i" "1.f0+0i" "001.+0i" "+01.+0i" "#e1.+0i" "#i1.+0i" "#d1.+0i" "1+0e+0i" "1-0e+0i" "1+0d+0i" "1-0d+0i" "1+0f+0i" "1-0f+0i" "0001-0i" "+001-0i" "#e01-0i" "#i01-0i" "1/01-0i" "#b01-0i" "#x01-0i" "#d01-0i" "#o01-0i" "#e+1-0i" "#i+1-0i" "#b+1-0i" "#x+1-0i" "#d+1-0i" "#o+1-0i" ".1e1-0i" "01/1-0i" "+1/1-0i" ".1d1-0i" ".1f1-0i" "1.00-0i" "1e00-0i" "1d00-0i" "1f00-0i" "01.0-0i" "+1.0-0i" "1e+0-0i" "1d+0-0i" "1f+0-0i" "1e-0-0i" "1d-0-0i" "1f-0-0i" "01e0-0i" "+1e0-0i" "1.e0-0i" "01d0-0i" "+1d0-0i" "1.d0-0i" "01f0-0i" "+1f0-0i" "1.f0-0i" "001.-0i" "+01.-0i" "#e1.-0i" "#i1.-0i" "#d1.-0i" "1+0e-0i" "1-0e-0i" "1+0d-0i" "1-0d-0i" "1+0f-0i" "1-0f-0i" "1+00e0i" "1-00e0i" "1+.0e0i" "1-.0e0i" "01+0e0i" "+1+0e0i" "1.+0e0i" "01-0e0i" "+1-0e0i" "1.-0e0i" "1+0.e0i" "1-0.e0i" "1+00d0i" "1-00d0i" "1+.0d0i" "1-.0d0i" "01+0d0i" "+1+0d0i" "1.+0d0i" "01-0d0i" "+1-0d0i" "1.-0d0i" "1+0.d0i" "1-0.d0i" "1+00f0i" "1-00f0i" "1+.0f0i" "1-.0f0i" "01+0f0i" "+1+0f0i" "1.+0f0i" "01-0f0i" "+1-0f0i" "1.-0f0i" +"1+000.i" "1-000.i" "01+00.i" "+1+00.i" "1.+00.i" "01-00.i" "+1-00.i" "1.-00.i" "001+0.i" "+01+0.i" "#e1+0.i" "#i1+0.i" "1/1+0.i" "#d1+0.i" "1.0+0.i" "1e0+0.i" "1d0+0.i" "1f0+0.i" "+1.+0.i" "001-0.i" "+01-0.i" "#e1-0.i" "#i1-0.i" "1/1-0.i" "#d1-0.i" "1.0-0.i" "1e0-0.i" "1d0-0.i" "1f0-0.i" "01.-0.i" "+1.-0.i" "#xb/00b" "#x0b/0b" "#x+b/0b" "#xeb/eb" "#x00b/b" "#x+0b/b" "#x#eb/b" "#x#ib/b" "#e#xb/b" "#i#xb/b" "#xbb/bb" "#xdb/db" "#xfb/fb" "#x1d/1d" "#xd/00d" "#x0d/0d" "#x+d/0d" "#xed/ed" ) + +;;; selected ones... + +(list "#i+11/011" "#xf11/f11" "+101/0101" "#o#e11/11" "#d+11/011" "#e1/0001" "010d-001" "#e#b+001" ".10f+001" "+10f-001" ".10d0001" "#d10d-1" "#e10e-1" + "#e.1d0001" "#d.01d002" "#i0.1f001" "#x#e1/001" "000000001" "#i+.1e+01" "#d+.1e+01" "00.10e+01" "+0.10e+01" "#e.10e+01" "#i.10e+01" "#d.10e+01" + "#e.10e+01" "#i10.0e-01" "#d+.1d+01" "#d.10f+01" "#i0.1f+01" "+010.e-01" "#e10.e-01" "#e00.1e01" "#e#d.1e01" "#i#d1e0+0e0i" + "#e#d10e-1+0e-2i" "#e#d1e0+0e-2i" "#d.1d+01+.0d01i" "#d0.001d+03+0.0d-10i" "#i#d+0.001d+03+0.0d-10i" "#i#d+1/1-0/1i" +) +)) + +(for-each + (lambda (str) + (let ((val (catch #t (lambda () (string->number str)) (lambda args 'error)))) + (if (or (not (number? val)) + (= val 1)) + (begin + (display "(string->number \"") (display str) (display "\") = ") (display val) (display "?") (newline))))) + (list "#e1+i" "#e1-i" "#e01+i" "#e+1+i" "#e1.+i" "#e01-i" "#e+1-i" "#e1.-i" "#e1+1i" "#e1-1i" "011e0" "11e-00" + "00.e01-i" "+10e10+i" "+1.110+i" "10011-0i" "-000.111" "0.100111" "-11.1111" "10.00011" "110e00+i" + "1e-011+i" "101001+i" "+11e-0-0i" "11+00e+0i" "-11101.-i" "1110e-0-i" + )) + + +(for-each + (lambda (str) + (let ((val (catch #t (lambda () (string->number str)) (lambda args 'error)))) + (if (number? val) + (begin + (display "(string->number \"") (display str) (display "\") = ") (display val) (display "?") (newline))))) + (list "#b#e#e1" "#x#e#e1" "#d#e#e1" "#o#e#e1" "#b#i#e1" "#x#i#e1" "#d#i#e1" "#o#i#e1" "#e#b#e1" "#i#b#e1" "#e#x#e1" "#i#x#e1" + "#e#d#e1" "#i#d#e1" "#e#o#e1" "#i#o#e1" "#e#b#i1" "#e#x#i1" "#e#d#i1" "#e#o#i1" "#b#e#b1" "#x#e#b1" "#d#e#b1" "#o#e#b1" + "#b#i#b1" "#x#i#b1" "#d#i#b1" "#o#i#b1" "#b#e#x1" "#x#e#x1" "#d#e#x1" "#o#e#x1" "#b#i#x1" "#x#i#x1" "#d#i#x1" "#o#i#x1" + "#b#e#d1" "#x#e#d1" "#d#e#d1" "#o#e#d1" "#b#i#d1" "#x#i#d1" "#d#i#d1" "#o#i#d1" "#b#e#o1" "#x#e#o1" "#d#e#o1" "#o#e#o1" + "#b#i#o1" "#x#i#o1" "#d#i#o1" "#o#i#o1" + + "+1ei" "-1ei" "+0ei" "-0ei" "+1di" "-1di" "+0di" "-0di" "+1fi" "-1fi" "+0fi" "-0fi" "0e-+i" "1d-+i" + "0d-+i" "1f-+i" "0f-+i" "1e++i" "0e++i" "1d++i" ".10-10." "-1.e++i" "0e--01i" "1-00." "0-00." "#xf+b" + "#x1+d" "0f++1i" "1+0d-i" ".0f--i" "1-0d-i" "#xe-ff" "0-" "0-e0" + +)) + +(num-test (string->number "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427") 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427) + + +;;; every scheme disagrees about stuff like #b.1 or #b+i etc -- I'll just omit them + +(for-each + (lambda (p) + (let ((sym (car p)) + (num (cdr p))) + (let ((tag (catch #t (lambda () (string->number sym)) (lambda args 'error)))) + (if (not (equal? num tag)) + (begin (display "(string->number \"") (display sym) (display "\") = ") + (display tag) (display " [") (display num) (display "])") (newline)))))) + '(("#xe/d" . 14/13) ("#xb/d" . 11/13) ("#xf/d" . 15/13) ("#x1/f" . 1/15) ("#xd/f" . 13/15) ("#xe/f" . 14/15) ("#d.1" . .1) ("#d01" . 1) + ("#d+1" . 1) ("#d+0" . 0) ("#d0+i" . 0+i) ("#xe+i" . 14.0+1.0i) ("#xf+i" . 15.0+1.0i) ("#d1-i" . 1.0-1.0i) ("#e1+i" . 1+i) + )) + +(test (equal? #e1.5 3/2) #t) +(test (equal? #e1.0 1) #t) +(test (equal? #e-.1 -1/10) #t) +(test (equal? #e1 1) #t) +(test (equal? #e3/2 3/2) #t) +(test (< (abs (- #i3/2 1.5)) 1e-12) #t) +(test (< (abs (- #i1 1.0)) 1e-12) #t) +(test (< (abs (- #i-1/10 -0.1)) 1e-12) #t) +(test (< (abs (- #i1.5 1.5)) 1e-12) #t) +(num-test (= 0e-1 0.0) #t) +;;; (/ (/ 0))?? + +;;; here's code to generate all (im)possible numbers (using just a few digits) of a given length [leaving aside @ and # and so on] +;(define file (open-output-file "ntest.scm")) +;(define chars (list #\1 #\0 #\9 #\@ #\# #\. #\+ #\- #\e #\i #\/ #\b #\x #\d #\o #\l #\s #\f)) +; +;(define (all-syms f len with-file) +; (let ((sym (make-string len)) +; (num-chars (length chars)) +; (ctrs (make-vector len 0))) +; (do ((i 0 (+ i 1))) +; ((= i (expt num-chars len))) +; (let ((carry #t)) +; (do ((k 0 (+ k 1))) +; ((or (= k len) +; (not carry))) +; (vector-set! ctrs k (+ 1 (vector-ref ctrs k))) +; (if (= (vector-ref ctrs k) num-chars) +; (vector-set! ctrs k 0) +; (set! carry #f))) +; (do ((k 0 (+ k 1))) +; ((= k len)) +; (string-set! sym k (list-ref chars (vector-ref ctrs k))))) +; +; ;(display (format #f "~S " sym)) +; +; (let ((tag (catch #t (lambda () (string->number sym)) (lambda args (car args))))) +; (if (not with-file) +; (if (and (number? tag) +; (= tag 1)) +; (display (format #f "~S " sym))) +; (begin +; (if (number? tag) +; (display (format file "(if (not (number? (string->number ~S))) (begin (display ~S) (display #\space)))")) +; (display (format file "(if (number? (string->number ~S)) (begin (display ~S) (display #\space)))"))) +; (newline file))))))) +; +;(do ((len 1 (+ len 1))) +; ((= len 12)) +; (all-syms file len #f) +; (newline)) +; +;(close-output-port file) + +(for-each + (lambda (n name) + (if (number? n) + (begin + (display "(number? ") (display name) (display ") returned #t?") (newline)))) +(list +'a9 'aa 'aA 'a! 'a$ 'a% 'a& 'a* 'a+ 'a- 'a. 'a/ 'a: 'a< 'a= 'a> 'a? 'a@ 'a^ 'a_ 'a~ 'A9 'Aa 'AA 'A! 'A$ 'A% 'A& 'A* 'A+ 'A- 'A. 'A/ 'A: 'A< 'A= 'A> 'A? 'A@ 'A^ 'A_ 'A~ '!9 '!a '!A '!! '!$ '!% '!& '!* '!+ '!- '!. '!/ '!: '!< '!= '!> '!? '!@ '!^ '!_ '!~ '$9 '$a '$A '$! '$$ '$% '$& '$* '$+ '$- '$. '$/ '$: '$< '$= '$> '$? '$@ '$^ '$_ '$~ '%9 '%a '%A '%! '%$ '%% '%& '%* '%+ '%- '%. '%/ '%: '%< '%= '%> '%? '%@ '%^ '%_ '%~ '&9 '&a '&A '&! '&$ '&% '&& '&* '&+ '&- '&. '&/ '&: '&< '&= '&> '&? '&@ '&^ '&_ '&~ '*9 '*a '*A '*! '*$ '*% '*& '** '*+ '*- '*. '*/ '*: '*< '*= '*> '*? '*@ '*^ '*_ '*~ '/9 '/a '/A '/! '/$ '/% '/& '/* '/+ '/- '/. '// '/: '/< '/= '/> '/? '/@ '/^ '/_ '/~ ':9 ':a ':A ':! ':$ ':% ':& ':* ':+ ':- ':. ':/ ':: ':< ':= ':> ':? ':@ ':^ ':_ ':~ '<9 ' '=? '=@ '=^ '=_ '=~ '>9 '>a '>A '>! '>$ '>% '>& '>* '>+ '>- '>. '>/ '>: '>< '>= '>> '>? '>@ '>^ '>_ '>~ '?9 '?a '?A '?! '?$ '?% '?& '?* '?+ '?- '?. '?/ '?: '?< '?= '?> '?? '?@ '?^ '?_ '?~ '^9 '^a '^A '^! '^$ '^% '^& '^* '^+ '^- '^. '^/ '^: '^< '^= '^> '^? '^@ '^^ '^_ '^~ '_9 '_a '_A '_! '_$ '_% '_& '_* '_+ '_- '_. '_/ '_: '_< '_= '_> '_? '_@ '_^ '__ '_~ '~9 '~a '~A '~! '~$ '~% '~& '~* '~+ '~- '~. '~/ '~: '~< '~= '~> '~? '~@ '~^ '~_ '~~) + +(list +"'a9" "'aa" "'aA" "'a!" "'a$" "'a%" "'a&" "'a*" "'a+" "'a-" "'a." "'a/" "'a:" "'a<" "'a=" "'a>" "'a?" "'a@" "'a^" "'a_" "'a~" "'A9" "'Aa" "'AA" "'A!" "'A$" "'A%" "'A&" "'A*" "'A+" "'A-" "'A." "'A/" "'A:" "'A<" "'A=" "'A>" "'A?" "'A@" "'A^" "'A_" "'A~" "'!9" "'!a" "'!A" "'!!" "'!$" "'!%" "'!&" "'!*" "'!+" "'!-" "'!." "'!/" "'!:" "'!<" "'!=" "'!>" "'!?" "'!@" "'!^" "'!_" "'!~" "'$9" "'$a" "'$A" "'$!" "'$$" "'$%" "'$&" "'$*" "'$+" "'$-" "'$." "'$/" "'$:" "'$<" "'$=" "'$>" "'$?" "'$@" "'$^" "'$_" "'$~" "'%9" "'%a" "'%A" "'%!" "'%$" "'%%" "'%&" "'%*" "'%+" "'%-" "'%." "'%/" "'%:" "'%<" "'%=" "'%>" "'%?" "'%@" "'%^" "'%_" "'%~" "'&9" "'&a" "'&A" "'&!" "'&$" "'&%" "'&&" "'&*" "'&+" "'&-" "'&." "'&/" "'&:" "'&<" "'&=" "'&>" "'&?" "'&@" "'&^" "'&_" "'&~" "'*9" "'*a" "'*A" "'*!" "'*$" "'*%" "'*&" "'**" "'*+" "'*-" "'*." "'*/" "'*:" "'*<" "'*=" "'*>" "'*?" "'*@" "'*^" "'*_" "'*~" "'/9" "'/a" "'/A" "'/!" "'/$" "'/%" "'/&" "'/*" "'/+" "'/-" "'/." "'//" "'/:" "'/<" "'/=" "'/>" "'/?" "'/@" "'/^" "'/_" "'/~" "':9" "':a" "':A" "':!" "':$" "':%" "':&" "':*" "':+" "':-" "':." "':/" "'::" "':<" "':=" "':>" "':?" "':@" "':^" "':_" "':~" "'<9" "'" "'" "'=?" "'=@" "'=^" "'=_" "'=~" "'>9" "'>a" "'>A" "'>!" "'>$" "'>%" "'>&" "'>*" "'>+" "'>-" "'>." "'>/" "'>:" "'><" "'>=" "'>>" "'>?" "'>@" "'>^" "'>_" "'>~" "'?9" "'?a" "'?A" "'?!" "'?$" "'?%" "'?&" "'?*" "'?+" "'?-" "'?." "'?/" "'?:" "'?<" "'?=" "'?>" "'??" "'?@" "'?^" "'?_" "'?~" "'^9" "'^a" "'^A" "'^!" "'^$" "'^%" "'^&" "'^*" "'^+" "'^-" "'^." "'^/" "'^:" "'^<" "'^=" "'^>" "'^?" "'^@" "'^^" "'^_" "'^~" "'_9" "'_a" "'_A" "'_!" "'_$" "'_%" "'_&" "'_*" "'_+" "'_-" "'_." "'_/" "'_:" "'_<" "'_=" "'_>" "'_?" "'_@" "'_^" "'__" "'_~" "'~9" "'~a" "'~A" "'~!" "'~$" "'~%" "'~&" "'~*" "'~+" "'~-" "'~." "'~/" "'~:" "'~<" "'~=" "'~>" "'~?" "'~@" "'~^" "'~_" "'~~")) + +;(let ((initial-chars "aA!$%&*/:<=>?^_~") +; (subsequent-chars "9aA!$%&*+-./:<=>?@^_~")) +; (do ((i 0 (+ i 1))) +; ((= i (string-length initial-chars))) +; (do ((k 0 (+ k 1))) +; ((= k (string-length subsequent-chars))) +; (display (format #f "'~A " (string (string-ref initial-chars i) (string-ref subsequent-chars k))))))) + + +(for-each + (lambda (z) + (if (not (zero? z)) + (begin (display z) (display " is not zero?") (newline))) + (if (and (real? z) (positive? z)) + (begin (display z) (display " is positive?") (newline))) + (if (and (real? z) (negative? z)) + (begin (display z) (display " is negative?") (newline)))) + '(0 -0 +0 0.0 -0.0 +0.0 0/1 -0/1 +0/24 0+0i 0-0i -0-0i +0-0i 0.0-0.0i -0.0+0i #b0 #o-0 #x000 #e0 #e0.0 #e#b0 #b#e0 #e0/1 #b+0)) + + +;;; these 2 are (mostly) from guile +(for-each + (lambda (x) + (if (string->number x) + (begin + (display "(string->number ") (display x) (display ") returned ") (display (string->number x)) (newline)))) + '("" "q" "1q" "6+7iq" "8+9q" "10+11" "13+" "18@19q" "20@q" "23@" + "+25iq" "26i" "-q" "-iq" "i" "5#.0" "8/" "10#11" ".#" "." + "3.4q" "15.16e17q" "18.19e+q" ".q" ".17#18" "10q" "#b2" "#b12" "#b-12" + "#b3" "#b4" "#b5" "#b6" "#b7" "#b8" "#b9" "#ba" "#bb" "#bc" + "#bd" "#be" "#bf" "#q" "#b#b1" "#o#o1" "#d#d1" "#x#x1" "#e#e1" "#xag" "#x1x" + "#o8" "#o9" "1/#e1" "#o#" "#e#i1" "#d--2" "#b#x1" "#i#x#b1" "#e#e#b1" "#e#b#b1" + "-#b1" "+#b1" "#b1/#b2" "#b1+#b1i" "1+#bi" "1+#b1i" "1#be1" "#b" "#o" "#" "#ea" "#e1a" "1+ie1" "1+i1" "1e+1i" + "#e#b" "#b#b" "#b#b1" "1e3e4" "1.0e-3e+4" "1e3s" "1e3s3" "#o#x1" "#i#i1" "1e-i" "#be1" "1/i" "1/e1" "1+e1" + "1e+" "1e1+" "1e1e1" "1e-+1" "1e0x1" "1e-" + "#i#i1" "12@12+0i")) + +(for-each + (lambda (couple) + (apply + (lambda (x y) + (let ((xx (string->number x))) + (if (or (eq? xx #f) + (and (exact? y) + (not (eqv? xx y))) + (> (abs (- xx y)) 1e-12)) + (begin + (display "(string->number ") (display x) (display ") returned ") (display (string->number x)) (display " but expected ") (display y) (newline))))) + couple)) + `(;; Radix: + ("#b0" 0) ("#b1" 1) ("#o0" 0) ("#b-1" -1) ("#b+1" 1) + ("#o1" 1) ("#o2" 2) ("#o3" 3) ("#o-1" -1) + ("#o4" 4) ("#o5" 5) ("#o6" 6) + ("#o7" 7) ("#d0" 0) ("#d1" 1) + ("#d2" 2) ("#d3" 3) ("#d4" 4) + ("#d5" 5) ("#d6" 6) ("#d7" 7) ("#d-123" -123) ("#d+123" 123) + ("#d8" 8) ("#d9" 9) + ("#xa" 10) ("#xb" 11) ("#x-1" -1) ("#x-a" -10) + ("#xc" 12) ("#xd" 13) + ("#xe" 14) ("#xf" 15) ("#x-abc" -2748) + ("#b1010" 10) + ("#o12345670" 2739128) + ("#d1234567890" 1234567890) + ("#x1234567890abcdef" 1311768467294899695) + ;; Exactness: + ("#e1" 1) ("#e1.2" 12/10) + ("#i1.1" 1.1) ("#i1" 1.0) + ;; Integers: + ("1" ,(+ 1 0)) ("23" ,(+ 9 9 5)) ("-1" ,(- 0 1)) + ("-45" ,(- 0 45)) ;("2#" 20.0) ("2##" 200.0) ("12##" 1200.0) ; this # = 0 is about the stupidest thing I've ever seen + ("#b#i100" 4.0) ("#b#e100" 4) ("#i#b100" 4.0) ("#e#b100" 4) + ("#b#i-100" -4.0) ("#b#e+100" 4) ("#i#b-100" -4.0) ("#e#b+100" 4) + ("#o#i100" 64.0) ("#o#e100" 64) ("#i#o100" 64.0) ("#e#o100" 64) + ("#d#i100" 100.0) ("#d#e100" 100) ("#i#d100" 100.0) ("#e#d100" 100) + ("#x#i100" 256.0) ("#x#e100" 256) ("#i#x100" 256.0) ("#e#x100" 256) + ("#e#xee" 238) ("#e#x1e1" 481) + + ;; Fractions: + ("1/1" 1) ("1/2" 1/2) ("-1/2" -1/2) ;("1#/1" 10.0) + ;("10/1#" 1.0) ("1#/1#" 1.0) ("#e9/10" 9/10) ("#e10/1#" 1) + ;("#i6/8" 0.75) ("#i1/1" 1.0) + ;; Decimal numbers: + ;; * + ("1e2" 100.0) ("1s2" 100.0) + ("1f2" 100.0) ("1d2" 100.0) + ;("1l2" 100.0) + ("1e+2" 100.0) ("1e-2" 0.01) + ;; * . + #* + (".1" .1) (".0123456789" 123456789e-10) ;(".16#" 0.16) + (".0123456789e10" 123456789.0) ;(".16#e3" 160.0) ("#d.3" 0.3) + ;; * + . * #* + ("3." ,(exact->inexact 3)) ("3.e0" ,(exact->inexact 3)) + ("3.1" ,(exact->inexact 31/10)) ("3.1e0" 3.1) ;("3.1#" 3.1) + ;("3.1#e0" 3.1) + ;; * + #+ . #* + ;("3#." 30.0) ("3#.e0" 30.0) ("3#.#" 30.0) ("3#.#e0" 30.0) + ;; Complex: + ;; ("1@0" 1.0) ("1@+0" 1.0) ("1@-0" 1.0) ; whose dumb idea was this? + ("2+3i" ,(+ 2 (* 3 0+i))) ("4-5i" ,(- 4 (* 5 0+i))) + ("1+i" 1+1i) ("1-i" 1-1i) + ;; ("+1i" 0+1i) ("-1i" 0-1i) ("+i" +1i) ("-i" -1i) ; I don't like these + ("#e1e1" 10) ("#i1e1+i" 10.0+1.0i) + )) + +;;; -------------------------------------------------------------------------------- + +(if with-error-checks + (begin + + (test (eq?) 'error) + (test (eq? #t) 'error) + (test (eqv?) 'error) + (test (eqv? #t) 'error) + (test (equal?) 'error) + (test (equal? #t) 'error) + (test (boolean?) 'error) + (test (not) 'error) + (test (symbol?) 'error) + (test (procedure?) 'error) + (test (char?) 'error) + ;(test (char? '#\xxx) 'error) ; or possibly #f?? + (test (char-upper-case? 1) 'error) + (test (char-upper-case?) 'error) + (test (char-upper-case? 1) 'error) + (test (char-upper-case?) 'error) + (test (char-upcase) 'error) + (test (char-downcase) 'error) + (test (char-numeric?) 'error) + (test (char-whitespace?) 'error) + (test (char-alphabetic?) 'error) + + (for-each + (lambda (op) + (for-each + (lambda (arg) + (test (op arg) 'error)) + (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1))))) + (list char-upper-case? char-lower-case? char-upcase char-downcase char-numeric? char-whitespace? char-alphabetic?)) + + (for-each + (lambda (op) + (for-each + (lambda (arg) + (test (op #\a arg) 'error)) + (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1))))) + (list char=? char? char>? char-ci=? char-ci? char-ci>=?)) + + (for-each + (lambda (op) + (for-each + (lambda (arg) + (test (op arg #\a) 'error)) + (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1))))) + (list char=? char? char>? char-ci=? char-ci? char-ci>=?)) + + (test (char=? #\a) 'error) + (test (char=?) 'error) + (test (char?) 'error) + (test (char>=?) 'error) + (test (char-ci=?) 'error) + (test (char->integer 33) 'error) + (test (char->integer) 'error) + (test (integer->char) 'error) + + (for-each + (lambda (arg) + (test (char->integer arg) 'error)) + (list -1 1 0 123456789 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (integer->char arg) 'error)) + (list -1 123456789 -123456789 #\a "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + + ;(test (string? "das ist die eine haelfte" "und das die andere") 'error) + (test (string?) 'error) + + (for-each + (lambda (arg) + (test (string=? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string<=? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string>=? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-ci=? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + + (for-each + (lambda (arg) + (test (string-ci? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-ci<=? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-ci>=? "hi" arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-length arg) 'error)) + (list #\a '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string #\a arg) 'error)) + (list '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (test (make-string -1) 'error) + + (for-each + (lambda (arg) + (test (make-string 3 arg) 'error)) + (list "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (make-string arg #\a) 'error)) + (list #\a "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (make-string arg) 'error)) + (list #\a "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (test (string-ref "abcdef-dg1ndh" 20) 'error) + (test (string-ref "abcdef-dg1ndh") 'error) + (test (string-ref "abcdef-dg1ndh" -3) 'error) + (test (string-ref) 'error) + (test (string-ref 2) 'error) + (test (string-ref "\"\\\"" 3) 'error) + (test (string-ref "" 0) 'error) ; guile returns #\nul here? + (test (string-ref "" 1) 'error) + + (for-each + (lambda (arg) + (test (string-ref arg 0) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-ref "hiho" arg) 'error)) + (list #\a -1 123 4 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (test (let ((hi (string-copy "hi"))) (string-set! hi 2 #\H) hi) 'error) + (test (let ((hi (string-copy "hi"))) (string-set! hi -1 #\H) hi) 'error) + (test (let ((g (lambda () "***"))) (string-set! (g) 0 #\?)) 'error) ; guile is happy here and below + (test (string-set! "" 0 #\a) 'error) + (test (string-set! "" 1 #\a) 'error) + (test (string-set! (string) 0 #\a) 'error) + (test (string-set! (symbol->string 'lambda) 0 #\a) 'error) + + (for-each + (lambda (arg) + (test (string-set! arg 0 #\a) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-set! "hiho" arg #\a) 'error)) + (list #\a -1 123 4 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-set! "hiho" 0 arg) 'error)) + (list 1 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + + (test (substring "ab" 0 3) 'error) + (test (substring "ab" 3 3) 'error) + (test (substring "ab" 2 3) 'error) + (test (substring "" 0 1) 'error) + (test (substring "" -1 0) 'error) + (test (substring "abc" -1 0) 'error) + + (for-each + (lambda (arg) + (test (substring "hiho" arg 0) 'error)) + (list "hi" #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (substring "hiho" 1 arg) 'error)) + (list "hi" #\a 0 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (substring arg 1 2) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-append "hiho" arg) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (let ((hiho "hiho")) (string-fill! hiho arg) hiho) 'error)) + (list 1 "hi" '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-fill! arg #\a) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string-copy arg) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string->list arg) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (test (let ((x (cons #\a #\b))) (set-cdr! x x) (list->string x)) 'error) + + (for-each + (lambda (arg) + (test (list->string arg) 'error)) + (list "hi" #\a 1 ''foo '(1 . 2) (cons #\a #\b) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (symbol->string arg) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (string->symbol arg) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + + + (for-each + (lambda (op) + (for-each + (lambda (arg) + (let ((result (catch #t (lambda () (op arg)) (lambda args 'error)))) + (if (not (eq? result 'error)) + (begin + (display "(") (display op) (display " ") (display arg) (display ") returned ") (display result) (display "?") (newline))))) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1))))) + + (list reverse cons car cdr set-car! set-cdr! caar cadr cdar cddr caaar caadr cadar cdaar caddr cdddr cdadr cddar + caaaar caaadr caadar cadaar caaddr cadddr cadadr caddar cdaaar cdaadr cdadar cddaar cdaddr cddddr cddadr cdddar + length assq assv assoc memq memv member list-ref list-tail)) + + (test (cons 1 . 2) 'error) + (test (car (list)) 'error) + (test (car '()) 'error) + (test (cdr (list)) 'error) + (test (cdr '()) 'error) + (test (caddar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 'error) + (test (cdddar '(((((1 2 3) 4) 5) (6 7)) (((u v w) x) y) ((q w e) r) (a b c) e f g)) 'error) + (test (caar '(a b c d e f g)) 'error) + (test (cdar '(a b c d e f g)) 'error) + (test (caaar '(a b c d e f g)) 'error) + (test (caadr '(a b c d e f g)) 'error) + (test (cadar '(a b c d e f g)) 'error) + (test (cdaar '(a b c d e f g)) 'error) + (test (cdadr '(a b c d e f g)) 'error) + (test (cddar '(a b c d e f g)) 'error) + (test (caaaar '(a b c d e f g)) 'error) + (test (caaadr '(a b c d e f g)) 'error) + (test (caadar '(a b c d e f g)) 'error) + (test (caaddr '(a b c d e f g)) 'error) + (test (cadaar '(a b c d e f g)) 'error) + (test (cadadr '(a b c d e f g)) 'error) + (test (caddar '(a b c d e f g)) 'error) + (test (cdaaar '(a b c d e f g)) 'error) + (test (cdaadr '(a b c d e f g)) 'error) + (test (cdadar '(a b c d e f g)) 'error) + (test (cdaddr '(a b c d e f g)) 'error) + (test (cddaar '(a b c d e f g)) 'error) + (test (cddadr '(a b c d e f g)) 'error) + (test (cdddar '(a b c d e f g)) 'error) + (test (caar 'a) 'error) + (test (caar '(a)) 'error) + (test (cadr 'a) 'error) + (test (cadr '(a . b)) 'error) + (test (cdar 'a) 'error) + (test (cdar '(a . b)) 'error) + (test (cddr 'a) 'error) + (test (cddr '(a . b)) 'error) + (test (caaar 'a) 'error) + (test (caaar '(a)) 'error) + (test (caaar '((a))) 'error) + (test (caadr 'a) 'error) + (test (caadr '(a . b)) 'error) + (test (caadr '(a b)) 'error) + (test (cadar 'a) 'error) + (test (cadar '(a . b)) 'error) + (test (cadar '((a . c) . b)) 'error) + (test (caddr 'a) 'error) + (test (caddr '(a . b)) 'error) + (test (caddr '(a c . b)) 'error) + (test (cdaar 'a) 'error) + (test (cdaar '(a)) 'error) + (test (cdaar '((a . b))) 'error) + (test (cdadr 'a) 'error) + (test (cdadr '(a . b)) 'error) + (test (cdadr '(a b . c)) 'error) + (test (cddar 'a) 'error) + (test (cddar '(a . b)) 'error) + (test (cddar '((a . b) . b)) 'error) + (test (cdddr 'a) 'error) + (test (cdddr '(a . b)) 'error) + (test (cdddr '(a c . b)) 'error) + (test (caaaar 'a) 'error) + (test (caaaar '(a)) 'error) + (test (caaaar '((a))) 'error) + (test (caaaar '(((a)))) 'error) + (test (caaadr 'a) 'error) + (test (caaadr '(a . b)) 'error) + (test (caaadr '(a b)) 'error) + (test (caaadr '(a (b))) 'error) + (test (caadar 'a) 'error) + (test (caadar '(a . b)) 'error) + (test (caadar '((a . c) . b)) 'error) + (test (caadar '((a c) . b)) 'error) + (test (caaddr 'a) 'error) + (test (caaddr '(a . b)) 'error) + (test (caaddr '(a c . b)) 'error) + (test (caaddr '(a c b)) 'error) + (test (cadaar 'a) 'error) + (test (cadaar '(a)) 'error) + (test (cadaar '((a . b))) 'error) + (test (cadaar '((a b))) 'error) + (test (cadadr 'a) 'error) + (test (cadadr '(a . b)) 'error) + (test (cadadr '(a b . c)) 'error) + (test (cadadr '(a (b . e) . c)) 'error) + (test (caddar 'a) 'error) + (test (caddar '(a . b)) 'error) + (test (caddar '((a . b) . b)) 'error) + (test (caddar '((a b . c) . b)) 'error) + (test (cadddr 'a) 'error) + (test (cadddr '(a . b)) 'error) + (test (cadddr '(a c . b)) 'error) + (test (cadddr '(a c e . b)) 'error) + (test (cdaaar 'a) 'error) + (test (cdaaar '(a)) 'error) + (test (cdaaar '((a))) 'error) + (test (cdaaar '(((a . b)))) 'error) + (test (cdaadr 'a) 'error) + (test (cdaadr '(a . b)) 'error) + (test (cdaadr '(a b)) 'error) + (test (cdaadr '(a (b . c))) 'error) + (test (cdadar 'a) 'error) + (test (cdadar '(a . b)) 'error) + (test (cdadar '((a . c) . b)) 'error) + (test (cdadar '((a c . d) . b)) 'error) + (test (cdaddr 'a) 'error) + (test (cdaddr '(a . b)) 'error) + (test (cdaddr '(a c . b)) 'error) + (test (cdaddr '(a c b . d)) 'error) + (test (cddaar 'a) 'error) + (test (cddaar '(a)) 'error) + (test (cddaar '((a . b))) 'error) + (test (cddaar '((a b))) 'error) + (test (cddadr 'a) 'error) + (test (cddadr '(a . b)) 'error) + (test (cddadr '(a b . c)) 'error) + (test (cddadr '(a (b . e) . c)) 'error) + (test (cdddar 'a) 'error) + (test (cdddar '(a . b)) 'error) + (test (cdddar '((a . b) . b)) 'error) + (test (cdddar '((a b . c) . b)) 'error) + (test (cddddr 'a) 'error) + (test (cddddr '(a . b)) 'error) + (test (cddddr '(a c . b)) 'error) + (test (cddddr '(a c e . b)) 'error) + + (test (length 'x) 'error) + (test (length (cons 1 2)) 'error) + (let ((x (list 1 2))) + (set-cdr! x x) + (test (length x) 'error)) + (test (length '(1 2 . 3)) 'error) + + (test (reverse (cons 1 2)) 'error) + (test (reverse '(1 . 2)) 'error) + (test (reverse '(1 2 . 3)) 'error) + + (test (set-car! '() 32) 'error) + (test (set-car! 'x 32) 'error) + (test (set-car! #f 32) 'error) + (test (set-cdr! '() 32) 'error) + (test (set-cdr! 'x 32) 'error) + (test (set-cdr! #f 32) 'error) + + (test (list-ref '() 0) 'error) + (test (list-ref (list 1 2) 2) 'error) + (test (list-ref (list 1 2) -1) 'error) + (test (list-ref (list 1 2) 1.3) 'error) + (test (list-ref (list 1 2) 1/3) 'error) + (test (list-ref (list 1 2) 1+2.0i) 'error) + (test (list-ref (cons 1 2) 1) 'error) + (test (list-ref (cons 1 2) 2) 'error) + + (for-each + (lambda (arg) + (test (list-ref (list 1 2) arg) 'error)) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + (test (list-set! '() 0 1) 'error) + (test (list-set! '(1) 1 2) 'error) + (test (list-set! '(1 2 3) -1 2) 'error) + (test (list-set! '(1) 1.5 2) 'error) + (test (list-set! '(1) 3/2 2) 'error) + (test (list-set! '(1) 1+3i 2) 'error) + (test (let ((x (cons 1 2))) (list-set! x 1 3) x) 'error) + + (for-each + (lambda (arg) + (test (list-set! (list 1 2) arg arg) 'error)) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + (test (list 1 2 . 3) 'error) + (test (list 1 2 , 3) 'error) + (test (list 1 2 ,@ 3) 'error) + + (test (list-tail (list 1 2) 3) 'error) + (test (list-tail (list 1 2) -1) 'error) + (test (list-tail (list 1 2) 1.3) 'error) + (test (list-tail (list 1 2) 1/3) 'error) + (test (list-tail (list 1 2) 1+2.0i) 'error) + (test (list-tail (cons 1 2) 2) 'error) + (test (list-tail '(1 2 . 3)) 'error) + + (for-each + (lambda (arg) + (test (list-tail (list 1 2) arg) 'error)) + (list "hi" (integer->char 65) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #\f #t (lambda (a) (+ a 1)))) + + + (test (assq #f '(#f 2 . 3)) 'error) + (test (assq #f '((#f 2) . 3)) 'error) ; an a-list is a proper list sez kd + (test (assv 1 '(1 2 . 3)) 'error) + (test (assv 1 '((1 2) . 3)) 'error) ; an a-list is a proper list sez kd + + (test (assoc '() 1) 'error) + (test (assoc (cons 1 2) 1) 'error) + (test (assoc (let ((x (cons 1 2))) (set-cdr! x x)) 1) 'error) + (test (assoc '((1 2) .3) 1) 'error) + (test (assoc ''foo quote) 'error) + (test (assoc 1 '(1 2 . 3)) 'error) + (test (assoc 1 '((1 2) . 3)) 'error) ; an a-list is a proper list sez kd + + ;(test (let ((lst '((1 2)))) (assq #t (reverse! lst lst))) #f) ; this will hang Guile + + + (test (append 'a 'b) 'error) + (test (append 'a '()) 'error) + (test (append (cons 1 2) '()) 'error) + (test (append '(1) 2 '(3)) 'error) + (test (append '(1) 2 3) 'error) + + ;(test (memq 'a (cons a b)) 'error) ; there is disagreement about this + (test (memq 'a (list a b . c)) 'error) + ;(test (memv 1 (cons 1 2)) 'error) ; there is disagreement about this + (test (memv 'a (list a b . c)) 'error) + ;(test (member 1 (cons 1 2)) 'error) ; there is disagreement about this + (test (member 'a (list a b . c)) 'error) + (test (member 1 '(1 2 . 3)) 'error) + + (test (make-vector) 'error) + + (for-each + (lambda (arg) + (test (make-vector arg) 'error)) + (list #\a '() -1 #f "hi" 'a-symbol abs 3.14 3/4 1.0+1.0i #t (vector 1 2 3) (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (vector->list arg) 'error)) + (list #\a 1 '() (list 1) '(1 . 2) #f 'a-symbol "hi" abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (test (let ((x (cons #\a #\b))) (set-cdr! x x) (list->vector x)) 'error) + (test (list->vector (cons 1 2)) 'error) + (test (list->vector '(1 2 . 3)) 'error) + + (for-each + (lambda (arg) + (test (list->vector arg) 'error)) + (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (for-each + (lambda (arg) + (test (vector-length arg) 'error)) + (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (test (let ((v (make-vector 1 0))) (vector-ref v 1)) 'error) + (test (let ((v (make-vector 1 0))) (vector-ref v -1)) 'error) + (test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref (vector-ref v 2) 3)) 'error) + (test (let ((v (vector 1 (list 2) (make-vector 3 #\a)))) (vector-ref (vector-ref v 3) 0)) 'error) + (test (vector-ref (vector) 0) 'error) + (test (vector-ref '#() 0) 'error) + (test (vector-ref '#() -1) 'error) + (test (vector-ref '#() 1) 'error) + + ;(test (vector-set! '#(0 1 2) 1 "doe") 'error) + (test (let ((v (vector 1 2 3))) (vector-set! v -1 0)) 'error) + (test (let ((v (vector 1 2 3))) (vector-set! v 3 0)) 'error) + + (let ((v (vector 1 2 3))) + (for-each + (lambda (arg) + (test (vector-set! v arg 0) 'error)) + (list "hi" #\a -1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (make-vector 3) (lambda (a) (+ a 1))))) + + (for-each + (lambda (arg) + (test (vector-set! arg 0 0) 'error)) + (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + (let ((v (vector))) + (test (vector-set! v 0 0) 'error) + (test (vector-set! v 1 0) 'error) + (test (vector-set! v -1 0) 'error)) + + (for-each + (lambda (arg) + (test (vector-fill! arg 0) 'error)) + (list "hi" #\a 1 '(1 . 2) (cons #\a #\b) #f 'a-symbol abs 3.14 3/4 1.0+1.0i #t (lambda (a) (+ a 1)))) + + + + (for-each + (lambda (arg) + (test (string->number arg) 'error)) + (list -1 #\a 1 '#(1 2 3) 3.14 3/4 1.0+1.0i '() 'hi abs '#(()) (list 1 2 3) '(1 . 2) (lambda () 1))) + + (for-each + (lambda (arg) + (test (string->number "123" arg) 'error) + (test (string->number "1" arg) 'error)) + (list -1 0 1 #\a '#(1 2 3) 3.14 3/4 1.5+0.3i 1+i '() 'hi abs '#(()) (list 1 2 3) '(1 . 2) (lambda () 1))) + + ;; (string->number "0" 1) ?? why not? + + (for-each + (lambda (arg) + (test (number->string arg) 'error)) + (list #\a '#(1 2 3) '() 'hi abs "hi" '#(()) (list 1 2 3) '(1 . 2) (lambda () 1))) + + (for-each + (lambda (arg) + (test (number->string 123 arg) 'error)) + (list -1 0 1 512 #\a '#(1 2 3) 3.14 2/3 1.5+0.3i 1+i '() 'hi abs "hi" '#(()) (list 1 2 3) '(1 . 2) (lambda () 1))) + + (test (exact?) 'error) + (test (exact? "hi") 'error) + (test (exact? 1.0+23.0i 1.0+23.0i) 'error) + (test (inexact?) 'error) + (test (inexact? "hi") 'error) + (test (inexact? 1.0+23.0i 1.0+23.0i) 'error) + (test (/) 'error) + (test (/ "hi") 'error) + (test (zero?) 'error) + (test (zero? "hi") 'error) + (test (zero? 1.0+23.0i 1.0+23.0i) 'error) + (test (positive?) 'error) + (test (positive? 1.23+1.0i) 'error) + (test (positive? 1.23 1.23) 'error) + (test (negative?) 'error) + (test (negative? 1.23+1.0i) 'error) + (test (negative? 1.23 1.23) 'error) + (test (even?) 'error) + (test (even? 1.23) 'error) + (test (even? 123 123) 'error) + (test (odd?) 'error) + (test (odd? 1.23) 'error) + (test (odd? 123 123) 'error) + (test (quotient) 'error) + (test (quotient 123) 'error) + (if (not with-generic-modulo) + (test (quotient 1.23 1.23) 'error)) + (test (quotient 123 123 123) 'error) + (test (remainder) 'error) + (test (remainder 123) 'error) + (if (not with-generic-modulo) + (test (remainder 1.23 1.23) 'error)) + (test (remainder 123 123 123) 'error) + (test (modulo) 'error) + (test (modulo 123) 'error) + (if (not with-generic-modulo) + (test (modulo 1.23 1.23) 'error)) + (test (modulo 123 123 123) 'error) + (test (truncate) 'error) + (test (truncate 1.23+1.0i) 'error) + (if (not with-generic-modulo) + (test (truncate 1.23 1.23) 'error)) + (test (floor) 'error) + (test (floor 1.23+1.0i) 'error) + (test (floor 1.23 1.23) 'error) + (test (ceiling) 'error) + (test (ceiling 1.23+1.0i) 'error) + (test (ceiling 1.23 1.23) 'error) + (test (round) 'error) + (test (round 1.23+1.0i) 'error) + (test (round 1.23 1.23) 'error) + (test (abs) 'error) + (test (abs 1.23+1.0i) 'error) + (test (abs 1.23 1.23) 'error) + (test (max) 'error) + (test (max 1.23+1.0i) 'error) + (test (min) 'error) + (test (min 1.23+1.0i) 'error) + (test (expt) 'error) + (test (expt 1.0+23.0i) 'error) + (test (expt "hi" "hi") 'error) + ;(test (expt 1.0+23.0i 1.0+23.0i 1.0+23.0i) 'error) ; this is ok in s7 + (test (exact->inexact) 'error) + (test (exact->inexact "hi") 'error) + (test (exact->inexact 1.0+23.0i 1.0+23.0i) 'error) + (test (inexact->exact) 'error) + (test (inexact->exact "hi") 'error) + (test (inexact->exact 1.0+23.0i 1.0+23.0i) 'error) + (if with-rationalize (begin + (test (rationalize) 'error) +; (test (rationalize 1.23) 'error) + (test (rationalize 1.23+1.0i 1.23+1.0i) 'error) + (test (rationalize 1.23 1.23 1.23) 'error))) + (test (numerator) 'error) + (test (numerator 1.23+1.0i) 'error) + (test (numerator 1.23 1.23) 'error) + (test (denominator) 'error) + (test (denominator 1.23+1.0i) 'error) + (test (denominator 1.23 1.23) 'error) + (test (imag-part) 'error) + (test (imag-part "hi") 'error) + (test (imag-part 1.0+23.0i 1.0+23.0i) 'error) + (test (real-part) 'error) + (test (real-part "hi") 'error) + (test (real-part 1.0+23.0i 1.0+23.0i) 'error) + (test (magnitude) 'error) + (test (magnitude "hi") 'error) + (test (magnitude 1.0+23.0i 1.0+23.0i) 'error) + (test (angle) 'error) + (test (angle "hi") 'error) + (test (angle 1.0+23.0i 1.0+23.0i) 'error) + (test (make-polar) 'error) + (test (make-polar 1.23) 'error) + (test (make-polar 1.23+1.0i 1.23+1.0i) 'error) + (test (make-polar 1.23 1.23 1.23) 'error) + (test (make-rectangular) 'error) + (test (make-rectangular 1.23) 'error) + (test (make-rectangular 1.23+1.0i 1.23+1.0i) 'error) + (test (make-rectangular 1.23 1.23 1.23) 'error) + (test (sqrt) 'error) + (test (sqrt "hi") 'error) + (test (sqrt 1.0+23.0i 1.0+23.0i) 'error) + (test (exp) 'error) + (test (exp "hi") 'error) + (test (exp 1.0+23.0i 1.0+23.0i) 'error) + (test (log) 'error) + (test (log "hi") 'error) + (test (log 1.0+23.0i 1.0+23.0i 1.0+23.0i) 'error) + (test (sin) 'error) + (test (sin "hi") 'error) + (test (sin 1.0+23.0i 1.0+23.0i) 'error) + (test (cos) 'error) + (test (cos "hi") 'error) + (test (cos 1.0+23.0i 1.0+23.0i) 'error) + (test (tan) 'error) + (test (tan "hi") 'error) + (test (tan 1.0+23.0i 1.0+23.0i) 'error) + (test (asin) 'error) + (test (asin "hi") 'error) + (test (asin 1.0+23.0i 1.0+23.0i) 'error) + (test (acos) 'error) + (test (acos "hi") 'error) + (test (acos 1.0+23.0i 1.0+23.0i) 'error) + (test (atan) 'error) + (test (atan "hi") 'error) + (test (atan 1.0+23.0i 1.0+23.0i) 'error) + + (for-each + (lambda (op) + (for-each + (lambda (arg) + (let ((val (catch #t (lambda () (op arg)) (lambda args 'error)))) + (if (not (eq? val 'error)) + (begin + (display "(") (display op) (display " ") (display arg) (display ") returned ") + (display val) (display " but expected 'error") (newline))))) + (list "hi" '() #\a (list 1) '(1 . 2) #f 'a-symbol (make-vector 3) abs #t (lambda (a) (+ a 1))))) + (list exact? inexact? zero? positive? negative? even? odd? quotient remainder modulo truncate floor ceiling round + abs max min gcd lcm expt exact->inexact inexact->exact rationalize numerator denominator imag-part real-part + magnitude angle make-polar make-rectangular sqrt exp log sin cos tan asin acos atan number->string)) + + (test (string->number) 'error) + (test (string->number 'symbol) 'error) + (test (string->number "1.0" "1.0") 'error) + (test (number->string) 'error) + (test (number->string "hi") 'error) + (test (number->string 1.0+23.0i 1.0+23.0i 1.0+23.0i) 'error) + (test (+ 1 2 . 3) 'error) + + + + (num-test (gcd 1.4 2.3) 'error) + (num-test (lcm 1.4 2.3) 'error) + ;(num-test (gcd 2/3 1) 'error) ; these are ok in s7 + ;(num-test (lcm 2/3 1) 'error) + (num-test (gcd 2 1.0+0.5i) 'error) + (num-test (lcm 2 1.0+0.5i) 'error) + (test (gcd 1 "hi") 'error) + (test (lcm 0 "hi") 'error) + (num-test (numerator 2.3+0.5i) 'error) + (num-test (denominator 2.3+0.5i) 'error) + + (if (not with-generic-modulo) (begin + (num-test (modulo 3 2.3) 'error) + (num-test (modulo 2.3 3) 'error) + (num-test (modulo 1/3 2.3) 'error))) + (num-test (modulo 2.3 1.0+0.1i) 'error) + (num-test (modulo 3.0+2.3i 3) 'error) + (if (not with-generic-modulo) (begin + (num-test (remainder 3 2.3) 'error) + (num-test (remainder 2.3 3) 'error) + (num-test (remainder 1/3 2.3) 'error))) + + (num-test (mod 2 0) 'error) + + (num-test (remainder 2.3 1.0+0.1i) 'error) + (num-test (remainder 3.0+2.3i 3) 'error) + (num-test (abs 1.0+0.1i) 'error) + (num-test (make-polar 1.0 1.0+0.1i) 'error) + (num-test (make-polar 1.0+0.1i 0.0) 'error) + (num-test (make-rectangular 1.0 1.0+0.1i) 'error) + (num-test (make-rectangular 1.0+0.1i 1.0) 'error) + (test (>=- 1 2) 'error) + (test (>= - 1 2) 'error) + + (if with-relational-ops-that-require-at-least-2-args (begin + (num-test (< 0) 'error) + (num-test (<= 0) 'error) + (num-test (= 0) 'error) + (num-test (> 0) 'error) + (num-test (>= 0) 'error) + (num-test (< 2) 'error) + (num-test (<= 2) 'error) + (num-test (= 2) 'error) + (num-test (> 2) 'error) + (num-test (>= 2) 'error) + (num-test (< 0/1) 'error) + (num-test (<= 0/1) 'error) + (num-test (= 0/1) 'error) + (num-test (> 0/1) 'error) + (num-test (>= 0/1) 'error) + (num-test (< 10/3) 'error) + (num-test (<= 10/3) 'error) + (num-test (= 10/3) 'error) + (num-test (> 10/3) 'error) + (num-test (>= 10/3) 'error) + (num-test (< 0.0) 'error) + (num-test (<= 0.0) 'error) + (num-test (= 0.0) 'error) + (num-test (> 0.0) 'error) + (num-test (>= 0.0) 'error) + (num-test (< 1.0) 'error) + (num-test (<= 1.0) 'error) + (num-test (= 1.0) 'error) + (num-test (> 1.0) 'error) + (num-test (>= 1.0) 'error) + )) + + + (num-test (min 0.0+0.00000001i) 'error) + (num-test (max 0.0+0.00000001i) 'error) + (num-test (< 0.0+0.00000001i) 'error) + (num-test (<= 0.0+0.00000001i) 'error) + (num-test (= 0.0+0.00000001i) 'error) + (num-test (> 0.0+0.00000001i) 'error) + (num-test (>= 0.0+0.00000001i) 'error) + (num-test (min -0.0+0.00000001i) 'error) + (num-test (max -0.0+0.00000001i) 'error) + (num-test (min 1.0+1.0i) 'error) + (num-test (max 1.0+1.0i) 'error) + (num-test (< 1.0+1.0i) 'error) + (num-test (<= 1.0+1.0i) 'error) + (num-test (= 1.0+1.0i) 'error) + (num-test (> 1.0+1.0i) 'error) + (num-test (>= 1.0+1.0i) 'error) + (num-test (min -1.0+1.0i) 'error) + (num-test (max -1.0+1.0i) 'error) + (num-test (min 2.71828182845905+3.14159265358979i) 'error) + (num-test (max 2.71828182845905+3.14159265358979i) 'error) + (num-test (< 2.71828182845905+3.14159265358979i) 'error) + (num-test (<= 2.71828182845905+3.14159265358979i) 'error) + (num-test (= 2.71828182845905+3.14159265358979i) 'error) + (num-test (> 2.71828182845905+3.14159265358979i) 'error) + (num-test (>= 2.71828182845905+3.14159265358979i) 'error) + (num-test (min -2.71828182845905+3.14159265358979i) 'error) + (num-test (max -2.71828182845905+3.14159265358979i) 'error) + (num-test (min 1234000000.0+2.71828182845905i) 'error) + (num-test (max 1234000000.0+2.71828182845905i) 'error) + (num-test (< 1234000000.0+2.71828182845905i) 'error) + (num-test (<= 1234000000.0+2.71828182845905i) 'error) + (num-test (= 1234000000.0+2.71828182845905i) 'error) + (num-test (> 1234000000.0+2.71828182845905i) 'error) + (num-test (>= 1234000000.0+2.71828182845905i) 'error) + (num-test (min -1234000000.0+2.71828182845905i) 'error) + (num-test (max -1234000000.0+2.71828182845905i) 'error) + (num-test (< 2 1 1.0+1.0i) 'error) + (num-test (<= 2 1 1.0+1.0i) 'error) + (num-test (> 1 2 1.0+1.0i) 'error) + (num-test (>= 1 2 1.0+1.0i) 'error) + + (num-test (< 2 1 #\a) 'error) + (num-test (<= 2 1 #\a) 'error) + (num-test (> 1 2 #\a) 'error) + (num-test (>= 1 2 #\a) 'error) + + (num-test (= 0 1 "hi") 'error) + (num-test (= 0.0 1.0 "hi") 'error) + (num-test (* 0 1 "hi") 'error) + (num-test (* 0.0 "hi") 'error) + (num-test (* 0.0+0.0i "hi") 'error) + (num-test (* 0/1 "hi") 'error) + (num-test (/ 0 1 "hi") 'error) + (num-test (gcd 0 "hi") 'error) + (num-test (lcm 0 "hi") 'error) + (num-test (* 1 0.0 #\a) 'error) + + ;(num-test (< 3 3.0 3 3.0+1.0i) 'error) + ;(num-test (> 3 3.0 3 3.0+1.0i) 'error) + (num-test (log 3 0) 'error) + + (for-each + (lambda (arg) + (test (log 10.0 arg) 'error)) + (list "hi" #\a 0 '#(1 2 3) #t #f '() abs 'hi (list 1 2 3) '(1 . 2))) + + (test (quotient 3 0) 'error) + (test (remainder 3 0) 'error) + (test (+ 1 + 2) 'error) + (test (+ 1 - 2) 'error) + + (test (+ 1 #t) 'error) + (test (+ 1 #f) 'error) + + ;(test (/ 0) 'error) + + (for-each + (lambda (arg) + (test (char-ready? arg) 'error)) + (list "hi" -1 #\a 1 'a-symbol (make-vector 3) abs 3.14 3/4 1.0+1.0i #f #t (lambda (a) (+ a 1)))) + + (test (if #f) 'error) + (test (if (< 2 3)) 'error) + (test (if #f 1 2 3) 'error) + (test (if 1 2 3 4) 'error) + (test (if #f 1 else 2) 'error) + (test (if) 'error) + (test ('+ '1 '2) 'error) + + (test (for-each (lambda (x) (display "for-each should not have called this"))) 'error) + (test (for-each (lambda () 1) '()) 'error) + (test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(1) '(3) '()) ctr) 'error) + (test (let ((ctr 0)) (for-each (lambda (x y z) (set! ctr (+ ctr x y z))) '(0 1) '(2 3) '(4 5 6)) ctr) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1) (list)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1) (list 1 2)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1 2 3)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list 1 2)) 'error) + (test (for-each (lambda (a b) (+ a b)) (list 1 2) (cons 1 2)) 'error) + (test (for-each (lambda (a b) (+ a b)) (cons 1 2) (list 1 2)) 'error) + (test (for-each (lambda (a) (+ a 1)) (list 1) (list 2)) 'error) + (test (for-each (lambda (a) (+ a 1)) #\a) 'error) + (test (for-each (lambda (a) (+ a 1)) (cons 1 2)) 'error) + (test (let ((sum 0)) (for-each (lambda (a b . args) (set! sum (+ sum a b (apply + args)))) '(0 1 2)) sum) 'error) + (test (for-each (lambda (a) a) '(1 2 . 3)) 'error) + (for-each + (lambda (arg) + (test (for-each arg (list 1)) 'error)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + + (for-each + (lambda (arg) + (test (for-each (lambda (a) a) arg) 'error)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t '(1 . 2))) + + + (test (map (lambda (x) (display "map should not have called this"))) 'error) + (test (map (lambda () 1) '()) 'error) + (test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(1) '(3) '())) 'error) + (test (let ((ctr 0)) (map (lambda (x y z) (set! ctr (+ ctr x y z)) ctr) '(0 1) '(2 3) '(4 5 6))) 'error) + + (test (map (lambda (a b) (+ a b)) (list 1)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1) (list)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1) (list 2)) (list 3)) + (test (map (lambda (a b) (+ a b)) (list 1) (list 1 2)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2 3)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1 2) (list 1 2) (list 1 2)) 'error) + (test (map (lambda (a b) (+ a b)) (list 1 2) (cons 1 2)) 'error) + + (test (map (lambda (a) (+ a 1)) (list 1) (list 2)) 'error) + (test (map (lambda (a) (+ a 1)) #\a) 'error) + (test (map (lambda (a) (+ a 1)) (cons 1 2)) 'error) + (test (map (lambda (a b . args) (+ a b (apply + args))) '(0 1 2)) 'error) + (test (map (lambda (a) a) '(1 2 . 3)) 'error) + (for-each + (lambda (arg) + (test (map arg (list 1)) 'error)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t (list 1 2 3) '(1 . 2))) + + (for-each + (lambda (arg) + (test (map (lambda (a) a) arg) 'error)) + (list "hi" -1 #\a 1 'a-symbol '#(1 2 3) 3.14 3/4 1.0+1.0i #f #t '(1 . 2))) + + ;(test (do '() ('() '())) 'error) ; ?? -- isn't this the same as before? + (test (do '() (#t 1)) 'error) + (test (do ((i i i)) (i i)) 'error) + (test (do ((i 0 i (+ i 1))) (i i)) 'error) + ;(test (do ((i)) (#t i)) 'error) ; there's some disagreement about this? + (test (do ((i 0 (+ i 1))) #t) 'error) + (test (do 123 (#t 1)) 'error) + (test (do ((i 1)) (#t . 1) 1) 'error) + (test (do ((i 1) . 1) (#t 1) 1) 'error) + ;(test (do ((i 0 j) (i 0 j) (j 1 (+ j 1))) ((= j 3) i)) 'error) ; ?? + (test (do ((i 1) ()) (= i 1)) 'error) + + + (test (let ((a 1)) (set! a)) 'error) + (test (let ((a 1)) (set! a 2 3)) 'error) + (test (set! "hi" 1) 'error) + (test (set! 'a 1) 'error) + (test (set! 1 1) 'error) + (test (set! (list 1 2) 1) 'error) + (test (set! (let () 'a) 1) 'error) + (test (set!) 'error) + (test (set! #t #f) 'error) + + (test (let ((a (lambda (x) (set! a 3) x))) (list (a 1) a)) 'error) + (test (let ((a (let ((b 1)) (set! a 3) b))) a) 'error) + (test (let ((a (lambda () "hi"))) (set! (a) "ho")) 'error) + (test (let ((a (let ((b 1)) (set! a 3) b))) a) 'error) + + (test (cond) 'error) + ;(test (cond ((= 1 2) 3) (else 4) (4 5)) 'error) + (test (cond ((+ 1 2) => (lambda (a b) (+ a b)))) 'error) + ;(test (cond (else)) 'error) ; value of else might be #t -- perhaps (equal? (cond (else)) else) + (test (cond (#t => 'ok)) 'error) + (test (cond (else =>)) 'error) +; (test (cond ((values -1) => => abs)) 'error) +; (test (cond ((values -1) =>)) 'error) + (test (cond (cond (#t 1))) 'error) + (test (cond 1) 'error) + (test (cond (1 . 2) (else 3)) 'error) + (test (cond (#f 2) (else . 4)) 'error) +; (test (cond ((values 1 2) => (lambda (x y) #t))) 'error) + (test (cond #t) 'error) + (test (cond 1 2) 'error) + (test (cond 1 2 3) 'error) + (test (cond 1 2 3 4) 'error) + (test (cond (1 => (lambda (x y) #t))) 'error) + + + (test (case 1) 'error) + (test (case 1 . "hi") 'error) + (test (case 1 ("hi")) 'error) + (test (case 1 ("a" "b")) 'error) + (test (case 1 (else #f) ((1) #t)) 'error) + (test (case "hi" (("hi" "ho") 123) ("ha" 321)) 'error) + (test (case) 'error) + (test (case 1 (#t #f) ((1) #t)) 'error) + (test (case 1 (#t #f)) 'error) + (test (case -1 ((-1) => abs)) 'error) + (test ((lambda () => abs)) 'error) + (test ((lambda () => => 3)) 'error) + ;; actually, both Guile and Gauche accept + ;; ((lambda () + 3)) and (begin + 3) + ;; but surely => is an undefined variable in this context? + + (test (lambda) 'error) + (test (lambda (a) ) 'error) + ;; should this be an error: (lambda (a) (define x 1)) ? + (test (lambda . 1) 'error) + (test (lambda 1) 'error) + (test (lambda (x 1) x) 'error) + (test (lambda "hi" 1) 'error) + ;(test (lambda (x x) x) 'error) + ;(test ((lambda (x x) x) 1 2) 'error) + (test (lambda (x "a")) 'error) + (test ((lambda (x y) (+ x y a)) 1 2) 'error) + ;(test ((lambda ())) 'error) + (test (lambda (x (y)) x) 'error) + (test ((lambda (x) x . 5) 2) 'error) + (test (lambda (1) #f) 'error) + ;(test (lambda (x . y z) x) 'error) ; this is apparently uncatchable in Guile + (test ((lambda () 1) 1) 'error) + (test ((lambda (()) 1) 1) 'error) + (test ((lambda (x) x) 1 2) 'error) + (test ((lambda (x) x)) 'error) + (test ((lambda ("x") x)) 'error) + (test ((lambda "x" x)) 'error) + (test ((lambda (x . "hi") x)) 'error) + + ;(test (begin . 1) 'error) + ;(test (let () (begin . 1)) 'error) + + ;(test (let ((x 0)) (set! x (+ x 1)) (begin (define y 1)) (+ x y)) 'error) ; is this correct? + + + (test (apply + #f) 'error) + (test (apply #f '(2 3)) 'error) + (test (apply make-vector '(1 2 3)) 'error) + (test (apply + 1) 'error) + (test (apply) 'error) + (test (apply 1) 'error) + (test (apply . 1) 'error) + (test (apply car ''foo) 'error) + (test (apply + '(1 . 2)) 'error) + + (for-each + (lambda (arg) + (test (apply arg '(1)) 'error)) + (list "hi" -1 #\a 1 'a-symbol 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + + (test (let ((x (list 1 2))) (set-cdr! x x) (apply + x)) 'error) + (test (apply + '(1 2 . 3)) 'error) + (test (apply + '(1 2) (list 3 4)) 'error) + + (test (define) 'error) + (test (define x) 'error) + (test (define . x) 'error) + (test (define x 1 2) 'error) + (test (define (x 1)) 'error) + (test (define 1 2) 'error) + (test (define "hi" 2) 'error) + ;(test (define 'hi 1) 'error) ; this redefines quote, which maybe isn't an error + (test (let () (define . 1) 1) 'error) + (test (let ((hi (lambda (a 0.0) (b 0.0) (+ a b)))) (hi)) 'error) + + +; (test (call-with-values (lambda (x) (+ x 1)) (lambda (y) y)) 'error) +; (test (+ (values . 1)) 'error) +; (for-each +; (lambda (arg) +; (test (call-with-values arg arg) 'error)) +; (list "hi" -1 #\a 1 'a-symbol 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + + + (test (let 1) 'error) + (test (let . 1) 'error) + (test (let* (x)) 'error) + (test (let (x) 1) 'error) + (test (let ((x)) 3) 'error) + (test (let ((x 1) y) x) 'error) + (test (let* x ()) 'error) + (test (let* ((1 2)) 3) 'error) + (test (let () ) 'error) + (test (let '() 3) 'error) + (test (let* ((x 1))) 'error) + (test (let ((x 1)) (letrec ((x 32) (y x)) (+ 1 y))) 'error) ; # seems reasonable if not the 1+ + (test (let ((x 1)) (letrec ((y x) (x 32)) (+ 1 y))) 'error) + ;(test (let ((x 1)) (letrec ((y x) (x 32)) 1)) 'error) ; Guile is perverse... s7 returns 1 here + (test (let ((x 1)) (letrec ((y (let () (+ x 1))) (x 32)) (+ 1 y))) 'error) + (test (let ((x 1)) (letrec ((y (let ((xx (+ x 1))) xx)) (x 32)) (+ 1 y))) 'error) + ;(test (let ((x 32)) (letrec ((y (apply list `(* ,x 2))) (x 1)) y)) 'error) + (test (letrec) 'error) + (test (let ((x . 1)) x) 'error) + ;(test (let ((x 1) (x 2)) x) 'error) + (test (let (((x 1)) 2) 3) 'error) + (test (let ((#f 1)) #f) 'error) + (test (let (()) #f) 'error) + (test (let (lambda () ) #f) 'error) + + +; (test (call/cc (lambda () 0)) 'error) +; (test (call/cc (lambda (a) 0) 123) 'error) +; (test (call/cc) 'error) +; (test (call/cc abs) 'error) +; (for-each +; (lambda (arg) +; (test (call/cc arg) 'error)) +; (list "hi" -1 #\a 1 'a-symbol 3.14 3/4 1.0+1.0i #t (list 1 2 3) '(1 . 2))) + +; (test (call/cc . 1) 'error) + + + (test (dynamic-wind) 'error) + (test (dynamic-wind (lambda () #f)) 'error) + (test (dynamic-wind (lambda () #f) (lambda () #f)) 'error) + (test (dynamic-wind (lambda (a) #f) (lambda () #f) (lambda () #f)) 'error) + (test (dynamic-wind (lambda () #f) (lambda (a b) #f) (lambda () #f)) 'error) + (test (dynamic-wind (lambda () #f) (lambda () #f) (lambda (a) #f)) 'error) + (test (dynamic-wind (lambda () 1) #f (lambda () 2)) 'error) + (test (dynamic-wind . 1) 'error) + + + (if with-delay + (begin + (test (force) 'error) + (test (delay) 'error) + (test (delay 1 2) 'error) + )) + + (let ((d 3.14) + (i 32) + (r 2/3) + (c 1.5+0.3i)) + (let ((check-vals (lambda (name) + (if (or (not (= d 3.14)) + (not (= i 32)) + (not (= r 2/3)) + (not (= c 1.5+0.3i))) + (begin + (display name) (display " changed ") + (if (not (= i 32)) + (begin (display "stored integer to: ") (display i)) + (if (not (= r 2/3)) + (begin (display "stored ratio to: ") (display r)) + (if (not (= d 3.14)) + (begin (display "stored real to: ") (display d)) + (begin (display "stored complex to: ") (display c))))) + (display "?") (newline)))))) + (for-each + (lambda (op) + (let ((x (catch #t (lambda () (op i)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op r)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op d)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op c)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op i d)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op r d)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op d d)) (lambda args 'error)))) + (check-vals op)) + (let ((x (catch #t (lambda () (op c d)) (lambda args 'error)))) + (check-vals op))) + (list + number->string string->number make-rectangular magnitude abs exp make-polar angle + ;sin cos tan sinh cosh tanh atan sqrt log asinh acosh atanh acos asin + sin cos tan atan sqrt log acos asin + number? integer? real? complex? rational? even? odd? zero? positive? negative? real-part imag-part + numerator denominator rationalize exact? inexact? exact->inexact inexact->exact floor ceiling truncate round + + - * / quotient remainder + expt = max min modulo < > <= >= lcm gcd + )))) + + )) + + +;;; ---------------- +;;; Guile's reader can't handle these + +(test (char? '1e311) #f) +(for-each + (lambda (n) + (let ((nb (catch #t (lambda () (number? n)) (lambda args 'error)))) + (if (not nb) (begin (display "(number? ") (display n) (display ") returned #f?") (newline))))) + (list '1e311 '1e-311 '0e311 '2.1e40000)) +;;; also (string->number "#e+i") throws an error in Guile, also "1e1111." + + + +;;; ---------------- +;;; these might be "reader errors", so put them all here for convenience +;;; ideally they'd report the bad input, but allow us to continue, signalling +;;; a catchable error only if the bad stuff is accessed by the evaluator. +;;; The ones s7 can't handle gracefully are currently commented out with "";#;" + +;;; (catch #t (lambda () (car '( . 1))) (lambda arg 'error)) + +;;; Guile treats dot as a quasiquote subsidiary, I guess: +;;; guile> (. 1) +;;; 1 +;;; guile> '(. 1) +;;; 1 +;;; guile> ( . 1) +;;; 1 +;;; guile> . +;;; ERROR: Unbound variable: #{.}# +;;; ABORT: (unbound-variable) +;;; guile> (symbol? '.) +;;; #t +;;; guile> '(. (cons 1 2)) +;;; 2 +;;; guile> '(. (list 1 2 3)) +;;; 2 +;;; +;;; gosh> (. 1) +;;; *** READ-ERROR: Read error at "(stdin)":line 2: bad dot syntax + + +;(test (list #b) 'error) + +;;; what # stuff is supported seems completely random: +;;; guile> #+ +;;; ERROR: In procedure scm_lreadr: +;;; ERROR: standard input:1:3: Unknown # object: #\+ +;;; ABORT: (read-error) +;;; guile> #* +;;; #* +;;; +;;; gosh> #* +;;; *** READ-ERROR: Read error at "(stdin)":line 2: unsupported #*-syntax: #* + + +; (test (char? #\spaces) 'error) +; (test (car '( . 1)) 'error) +; (test (car '(. )) 'error) +; (test (car '( . )) 'error) +; (test (car '(. . . )) 'error) +; (test '#( . 1) 'error) +; (test '(1 2 . ) 'error) +; (test '#(1 2 . ) 'error) +; (test (+ 1 . . ) 'error) +; (test (car '(1 . )) 'error) +; (test (car '(1 . . 2)) 'error) +; (test '#( . ) 'error) +; (test '#(1 . ) 'error) +; (test '#(. . . ) 'error) +; (test '#(1 . . 2) 'error) +; (test '(. 1) 'error) +; (test '#(. 1) 'error) +; (test '(. ) 'error) +; (test '#(. ) 'error) +; (test (list 1 . 2) 'error) +; (test (+ 1 . 2) 'error) +; (test (car '@#`') 'error) +; (test (list . ) 'error) +; (test '#( .) 'error) +; (test (car '( .)) 'error) +; (test '#(1 . 2) 'error) + + +;;; ---------------- + +;;; due primarily to stupidities on my part, the "expected" values are sometimes not more +;;; accurate than say 1e-7 or so + +(if (and (not (null? error-data)) + with-error-data) + (begin + (for-each + (lambda (op) + (begin + (display op) (newline))) + error-data) + + (let ((data '((3.0 0.14159265358979323846 0.1411200080598672) + (31.0 0.41592653589793238462 0.404037645323065) + (314.0 0.15926535897932384626 0.1585929060285728) + (3141.0 0.59265358979323846264 0.5585640372121817) + (31415.0 0.92653589793238462643 0.7995441773754675) + (314159.0 0.26535897932384626433 0.262255699519879) + (3141592.0 0.65358979323846264338 0.6080402764374114) + (31415926.0 0.53589793238462643383 0.5106132968486387) + (314159265.0 0.35897932384626433832 0.3513188023745885) + (3141592653.0 0.58979323846264338327 0.5561892044494355) + (31415926535.0 0.89793238462643383279 0.7820399858427447) + (314159265358.0 0.97932384626433832795 0.8301205477998297) + (3141592653589.0 0.79323846264338327950 0.7126289202333107) + (31415926535897.0 0.93238462643383279502 0.8030432710678118) + (314159265358979.0 0.32384626433832795028 0.3182152351447919) + (3141592653589793.0 0.23846264338327950288 0.2362090532517409) + (31415926535897932.0 0.38462643383279502884 0.3752128900123344) + (314159265358979323.0 0.84626433832795028841 0.7488096950162713) + (3141592653589793238.0 0.46264338327950288419 0.4463151633593201) + (31415926535897932384.0 0.62643383279502884197 0.5862594566145847) + (314159265358979323846.0 0.26433832795028841971 0.2612706361296674) + (3141592653589793238462.0 0.64338327950288419716 0.5999057324027754) + (31415926535897932384626.0 0.43383279502884197169 0.4203516113275538) + (314159265358979323846264.0 0.33832795028841971693 0.3319102940355321) + (3141592653589793238462643.0 0.38327950288419716939 .3739640276557301))) + (vals '()) + (mx-sin-err 0.0)) + + (for-each + (lambda (p) + (let ((arg1 (car p)) + (arg2 (cadr p)) + (mxerr 0.0)) + (do ((i 0 (+ i 1)) + (x 0.0 (+ x .1))) + ((= i 10)) + (let ((err (abs (- (abs (sin (- arg1 x))) (abs (sin (+ arg2 x))))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! vals (cons mxerr vals)) + (set! mx-sin-err (max mx-sin-err (abs (- (sin arg2) (caddr p))))))) + data) + + (if (> mx-sin-err 1e-8) + (begin + (display "base sine seems inaccurate! error: ") + (display mx-sin-err) + (newline))) + + (set! vals (reverse vals)) + + (let ((stop #f)) + (do ((i 0 (+ i 1))) + ((or (number? stop) + (= i (length vals)))) + (if (> (list-ref vals i) 1e-6) + (set! stop i))) + (if (number? stop) + (begin + (display "sin error > 1e-6 after 2^") + (display (/ (log (car (list-ref data stop))) (log 2.0))) + (display " or thereabouts") + (newline))))) + + (let ((data (list + 2.71828182845904523536028747135266249775724709369995957 + 27.1828182845904523536028747135266249775724709369995957 + 271.828182845904523536028747135266249775724709369995957 + 2718.28182845904523536028747135266249775724709369995957 + 27182.8182845904523536028747135266249775724709369995957 + 271828.182845904523536028747135266249775724709369995957 + 2718281.82845904523536028747135266249775724709369995957 + 27182818.2845904523536028747135266249775724709369995957 + 271828182.845904523536028747135266249775724709369995957 + 2718281828.45904523536028747135266249775724709369995957 + 27182818284.5904523536028747135266249775724709369995957 + 271828182845.904523536028747135266249775724709369995957 + 2718281828459.04523536028747135266249775724709369995957 + 27182818284590.4523536028747135266249775724709369995957 + 271828182845904.523536028747135266249775724709369995957 + 2718281828459045.23536028747135266249775724709369995957 + 27182818284590452.3536028747135266249775724709369995957 + 271828182845904523.536028747135266249775724709369995957 + 2718281828459045235.36028747135266249775724709369995957 + 27182818284590452353.6028747135266249775724709369995957 + 271828182845904523536.028747135266249775724709369995957 + 2718281828459045235360.28747135266249775724709369995957 + 27182818284590452353602.8747135266249775724709369995957 + 271828182845904523536028.747135266249775724709369995957 + 2718281828459045235360287.47135266249775724709369995957 + 27182818284590452353602874.7135266249775724709369995957 + 271828182845904523536028747.135266249775724709369995957 + 2718281828459045235360287471.35266249775724709369995957 + 27182818284590452353602874713.5266249775724709369995957))) + (let ((happy #t)) + (do ((i 0 (+ i 1)) + (dec 1.0 (* dec 10.0))) + ((or (not happy) + (= i (length data)))) + (let ((val (exp (+ 1.0 (log dec))))) + (let ((err (abs (- (list-ref data i) val)))) + (if (> err 1e-6) + (begin + (set! happy #f) + (display "exp+log error > 1e-6 around 2^") (display (/ (log val) (log 2))) (newline)))))))) + + (let ((data (list ; table[Tan[10^k], {k, 0, 30}] + 1.55740772465490223050697480745836017308725077238152003838394660569886 + 0.64836082745908667125912493300980867681687434298372497563362796739585 + -0.58721391515692907667780963564458789425876598687291954412663968360989 + 1.47032415570271844598020880490391856915748389146711182025455665358979 + 0.32097113462381472460896162480876337966088525010731594977977206336933 + -0.03577166295289877341133054456893096203777589491986804979647879769616 + -0.37362445398759902917349708857538141978530379801059302641978134928241 + -0.46353082785018908581469758918080168755473695345937070670149218665289 + -2.56377890672837725789840319603083470729708859667680805828679070820622 + 0.65145220214514128858645272422054798185112543058289784681820964602226 + -0.55834963781124184656189340731863681858164809933060716499623295934358 + 2.50424481449822111118237373761381771825510968075886393173926375110559 + -0.77230596813187614161063494471423746038444882506077057787558499031077 + -0.30175082856983471199636858701688775346296430492149675721730025846251 + 0.21415652428250396225222102422385566728114779011753338339645623774420 + -1.67241478212758304295552142696079055033040910554091189243737002950172 + -1.24517343571840642168009129451609763781317676741030141327973693611564 + 0.52456243090255001593041672482494038697466467439258592602675334853162 + -8.38854968059368800013526842602194492647448392917034135131083409265520 + 2.47279376584652736033818679563656602249667799226358809957010483326311 + -0.84460246301988425418409323400055358116535547279258431245425813826798 + -0.89552329255426546888442598272446987755918451773757800611680045521648 + -1.62877822560689887854937593693954851354515116817021717086346127966844 + -0.98333523138083649717001389546802280189805226009031609173028377317771 + -11.87362630545544227571094967408372098364257316309876130680769667747893 + 1.11612596981774655887307362253927728556627435787456734029790793087502 + -1.63758698713112186463163321344320618241852069893975176926240178134592 + -1.03173363516910726343237554775898936974208941138122693037794681869065 + 6.35083773135836351463817396716338533781524290151157250457191403689220 + -110.81342510911236031336859049236316125148742351166700266651506403034426 + 0.09048506806330217256622313805004127372738954023205417991033965089185))) + (let ((happy #t)) + (do ((i 0 (+ i 1)) + (dec 1.0 (* dec 10.0))) + ((or (not happy) + (= i (length data)))) + (let ((val (tan dec))) + (let ((err (abs (- (list-ref data i) val))) + (err1 (- (tan (+ 0.1 (* our-pi dec))) (tan 0.1))) + (err2 (- (tan (+ 1.0 (* our-pi dec))) (tan 1.0)))) + (if (or (> err 1e-6) + (> err1 1e-6) + (> err2 1e-6)) + (begin + (set! happy #f) + (display "tan error > 1e-6 around 2^") (display (/ (log dec) (log 2))) (newline)))))))) + + ;; table[(1/10^k)/(((1/10^k)^(1/10^k)) - 1), {k, 1, 30}] + ;; the test came from calc_errors.txt from the web by "dave" + (let ((expts (list + -0.48621160938616180680870317336747983548142173621715706851490974881717 + -0.22218561601345857583044966876729715619642038672598556073380084629504 + -0.14526540294689938889864991134840220307566223888497162784858064408875 + -0.10862362815109649171007844591526444220973735508130191198062253212652 + -0.08686389647659141105044978528770239308857034812798554177686261943193 + -0.07238291365169326382168151357331039782973682143307349669152489742891 + -0.06204211884333512141082278643490234288550259196615819050849846987015 + -0.05428681523790663196206398113420109019962541643547760927657854324749 + -0.04825494293369464924373092184737925979664303236414611590980578553450 + -0.04342944824032518278430110099994422226122739720915846151097610557365 + -0.03948131654165925705940460838351885560840418164027583205682137097699 + -0.03619120682577098563759637916147675090355043511246085981138602579761 + -0.03340726783876167905008686486133377017608955166698061593202699553920 + -0.03102103442166584483222349447696386196557178259759899539894506586562 + -0.02895296546021728851007526126398523685253569082526692705926181546848 + -0.02714340511895328922819555743231851877797306680518273360154914602559 + -0.02554673422960305368536052464215356633451937057629542604571806752914 + -0.02412747121684732425839605105092250802578858425793889081112350331353 + -0.02285760431069746466321731152192658331511007129540571803806313398860 + -0.02171472409516259138755644594583025411510361447234900258639235440074 + -0.02068068961444056322198232947221928963307055360980162368063530687389 + -0.01974065826832962852964676904166386737701808793240851850210059107980 + -0.01888236877840225337614103995289587314323465286757518193028428290776 + -0.01809560341263549281879753828819187842893320857975794377409033233328 + -0.01737177927613007310604520675666420329177588023219463316734886061171 + -0.01670363391935583952504342495833096470363065406937228989783888395986 + -0.01608498081123154917226403453394833638127396317791358170357400676126 + -0.01551051721083042241611174715416446722479989306441666312924319204483 + -0.01497567178976730440176306617453810628601368985529884710795141610434 + -0.01447648273010839425503763063105350274314656686012221887048754923492))) + (let ((happy #t)) + (do ((i 1 (+ i 1))) + ((or (= i (length expts)) + (not happy))) + (catch #t + (lambda () + (let ((val (/ (expt .1 i) + (- (expt (expt .1 i) (expt .1 i)) 1)))) + (if (> (abs (- val (list-ref expts (- i 1)))) 1e-6) + (begin + (set! happy #f) + (display "expt error > 1e-6 around 2^") (display (/ (log (expt .1 i)) (log 2))) (newline))))) + (lambda args + (display "expt no accurate below around 2^") (display (/ (log (expt .1 i)) (log 2))) (newline)))))) + + (let ((sin-err 0.0) + (cos-err 0.0) + (log-err 0.0) + (asin-err 0.0) + (atan-err 0.0) + (sqrt-err 0.0)) + ;; data generated by mathtool in the arprec package + + ;; another baddy: (tan 314159265358979323) should be -1.129792652308908544253650171110 + + (let ((sins (list + 0.00000000000000000000000000000000000000000000000000000000000000000000 + 0.09983341664682815230681419841062202698991538801798225999276686156165 + 0.19866933079506121545941262711838975037020672954020540398639599139797 + 0.29552020666133957510532074568502737367783211174261844850153103617326 + 0.38941834230865049166631175679570526459306018344395889511584896585734 + 0.47942553860420300027328793521557138808180336794060067518861661312553 + 0.56464247339503535720094544565865790710988808499415177102426589426735 + 0.64421768723769105367261435139872018306581384457368964474396308809382 + 0.71735609089952276162717461058138536619278523779142282098968252068287 + 0.78332690962748338846138231571354862314014792572030960356048515256195 + 0.84147098480789650665250232163029899962256306079837106567275170999191 + 0.89120736006143533995180257787170353831890931945282652766035329176720 + 0.93203908596722634967013443549482599541507058820873073536659789445024 + 0.96355818541719296470134863003955481534204849131773911795564922309212 + 0.98544972998846018065947457880609751735626167234736563194021894560084 + 0.99749498660405443094172337114148732270665142592211582194997482405934 + 0.99957360304150516434211382554623417197949791475491995534260751586102 + 0.99166481045246861534613339864787565240681957116712372532710249102330 + 0.97384763087819518653237317884335760670293947136523395566725825917196 + 0.94630008768741448848970961163495776211399866559491176443047155279581 + 0.90929742682568169539601986591174484270225497144789026837897301153096 + 0.86320936664887377068075931326902458492047242489508107697183045949721 + 0.80849640381959018430403691041611906515855960597557707903336060873485 + 0.74570521217672017738540621164349953894264877802047425750762828050000 + 0.67546318055115092656577152534128337425336495789352584226890212866520 + 0.59847214410395649405185470218616227170359717157722357330262703263874 + 0.51550137182146423525772693520936824389387858775426312126259173008382 + 0.42737988023382993455605308585788064749647642266670256499017776070511 + 0.33498815015590491954385375271242210603030652888358671068410107309479 + 0.23924932921398232818425691873957537221555293029961877411621026588071 + 0.14112000805986722210074480280811027984693326425226558415188264123242 + 0.04158066243329057919469827159667310055461342296380675064800900076588 + -0.05837414342757990913721741461909518512512509908292656970935025422273))) + (let ((mxerr 0.0)) + (do ((i 0 (+ i 1)) + (x 0.0 (+ x 0.1))) + ((= i 32)) + (let ((err (abs (- (sin x) (list-ref sins i))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! sin-err mxerr))) + + (let ((coss (list + 1.00000000000000000000000000000000000000000000000000000000000000000000 + 0.99500416527802576609556198780387029483857622541508403595935274468526 + 0.98006657784124163112419651674816887739352436080656799405254829012618 + 0.95533648912560601964231022756804989824421408263203767451761361222758 + 0.92106099400288508279852673205180161402585956931985044561508926713514 + 0.87758256189037271611628158260382965199164519710974405299761086831595 + 0.82533561490967829724095249895537603887809103918847038136974977367156 + 0.76484218728448842625585999019186490926821055037370335607293245825206 + 0.69670670934716542092074998164232492610178601370806078363714489414924 + 0.62160996827066445648471615140713350872176136659123900757638348453897 + 0.54030230586813971740093660744297660373231042061792222767009725538110 + 0.45359612142557738777137005178471612212146729566259504745593805541880 + 0.36235775447667357763837335562307602033994778557664862648774972093613 + 0.26749882862458740699798410929287135927592992167912966191725336742182 + 0.16996714290024093861674803520364980292818392102853430898236521149464 + 0.07073720166770291008818985143426870908509102756334686942264541719092 + -0.02919952230128872620577046294649852444486472109384694500313007908245 + -0.12884449429552468408764285733487351410164007964520297633178213994289 + -0.22720209469308705531667430653058073247695158653826107158496911100681 + -0.32328956686350342227883369508031017459419076544223959990115436505106 + -0.41614683654714238699756822950076218976600077107554489075514997378196 + -0.50484610459985745162093852371916747040702337674136205964819622353659 + -0.58850111725534570852414261265492841629376036669872798974753517400616 + -0.66627602127982419331788057116601723016327537100376988865266957182167 + -0.73739371554124549960882222733478290843301289199228479878436568873073 + -0.80114361554693371483350279046735166442856784876782013507459799166202 + -0.85688875336894723379770215164520111235392263823324404910501242714241 + -0.90407214201706114798252728194333012633184973516362471104126694868604 + -0.94222234066865815258678811736615401246341423446824662018098201995710 + -0.97095816514959052178110666934553217911761475942423954213867099245327 + -0.98999249660044545727157279473126130239367909661558832881408593292832 + -0.99913515027327946449237605454146626283664166994794274354471598254947 + -0.99829477579475308466166072228358269144701258595166016759508002045139))) + (let ((mxerr 0.0)) + (do ((i 0 (+ i 1)) + (x 0.0 (+ x 0.1))) + ((= i 32)) + (let ((err (abs (- (cos x) (list-ref coss i))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! cos-err mxerr))) + + (let ((logs-1 (list + -4.60517018598809136803598290936872841520220297725754595206665580193514 + -3.91202300542814605861875078791055184712670284289729069794597579244175 + -3.50655789731998167664073767244620271055471241943479650033196146829765 + -3.21887582486820074920151866645237527905120270853703544382529578294835 + -2.99573227355399099343522357614254077567660162298902823015400791046096 + -2.81341071676003636722350555098802614247921228507454124621128145880425 + -2.65926003693277806293063016592554868556511824767568476360726565199756 + -2.52572864430825543978428654499419871097570257417678018970461577345496 + -2.40794560865187198524549243552367700590722186161204704859726713466015 + -2.30258509299404568401799145468436420760110148862877297603332790096757 + -2.20727491318972082397403933140359911538049612332012877684808809280457 + -2.12026353620009105780627342952984957440371215071428599209060144931086 + -2.04022082852655463198249546780340981039693503249733883564761029127168 + -1.96611285637283275351339804446737211748961811331542950948658564250417 + -1.89711998488588130203997833922001507102911106516627877841931357682347 + -1.83258146374831013036705442353602214290020243981652493558393576396157 + -1.77195684193187528778644829149560187961399996467180116476941806405285 + -1.71479842809192667582826031406550043783172172725179179447658712516676 + -1.66073120682165090802695547748087487796482371595841713352869556552585 + -1.60943791243410037460075933322618763952560135426851772191264789147417)) + (logs-2 (list + 2.30258509299404568401799145468436420760110148862877297603332790096757 + 2.99573227355399099343522357614254077567660162298902823015400791046096 + 3.40119738166215537541323669160688991224859204645152242776802223460506 + 3.68887945411393630285245569760071734375210175734928348427468791995435 + 3.91202300542814605861875078791055184712670284289729069794597579244175 + 4.09434456222210068483046881306506648032409218081177768188870224409846 + 4.24849524204935898912334419812754393723818621821063416449271805090515 + 4.38202663467388161226968781905889391182760189170953873839536792944775 + 4.49980967033026506680848192852941561689608260427427187950271656824256 + 4.60517018598809136803598290936872841520220297725754595206665580193514 + 4.70048036579241622807993503264949350742280834256619015125189561009814 + 4.78749174278204599424770093452324304839959231517203293600938225359185 + 4.86753445045558242007147889624968281240636943338898009245237341163103 + 4.94164242260930429854057631958572050531368635257088941861339806039854 + 5.01063529409625575001399602483307755177419340072004014968067012607924 + 5.07517381523382692168691994051707047990310202606979399251604793894114 + 5.13579843705026176426752607255749074318930450121451776333056563884986 + 5.19295685089021037622571404998759218497158273863452713362339657773595 + 5.24702407216048614402701888657221774483848074992790179457128813737686 + 5.29831736654803667745321503082690498327770311161780120618733581142853))) + (let ((mxerr 0.0)) + (do ((i 0 (+ i 1)) + (x 0.01 (+ x 0.01)) + (y 10.0 (+ y 10.0))) + ((= i 20)) + (let ((err (max (abs (- (log x) (list-ref logs-1 i))) + (abs (- (log y) (list-ref logs-2 i)))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! log-err mxerr))) + + (let ((asins (list + 0.00000000000000000000000000000000000000000000000000000000000000000000 + 0.02500260489936113599406838915349107150195748368840710160729904233944 + 0.05002085680577001466274438682046411497780608049468789272874398055703 + 0.07507049107671654265775143572317089898194705496817785120910161299955 + 0.10016742116155979634552317945269331856867597222962954139102385503640 + 0.12532783116806539687456698635708471804814772683867237523396403098649 + 0.15056827277668602642326030146739539047425784470580485344319902595849 + 0.17590576816371628737774199743846051972730948209298253171964068749984 + 0.20135792079033079145512555221762341024003808140222838625725124345560 + 0.22694303617851994909359260763689579636930963064761339672521677581090 + 0.25268025514207865348565743699371097225219373309683819363392377874057 + 0.27858970239165058217050815183568882129133935843106227203280647300877 + 0.30469265401539750797200296122752916695456003170677638739297794874647 + 0.33101172808929452771961639961139035858195303667932389628972377319123 + 0.35757110364551028671483849232064256784674132498948776325141270863037 + 0.38439677449563908303819487296704697375277948430656504155058375479079 + 0.41151684606748801938473789761733560485570113512702585178394678070009 + 0.43896188560976067483321619602147236009843505358239561712817387552271 + 0.46676533904729636185033976030413712126156503909241369925276357159851 + 0.49496403171689461363027991615293072605447706550005723007748628111125 + 0.52359877559829887307710723054658381403286156656251763682915743205130 + 0.55271511309678317285035596261806027710654731438452549350875265730232 + 0.58236423786874344183204729090997636797897358751436418853659347126034 + 0.61260414804862246566851988030718610964520075565860642564808142300476 + 0.64350110879328438680280922871732263804151059111531238286560611871351 + 0.67513153293703164720905626529438801420418535124967921737841984904557 + 0.70758443672535557545286474430459468476197717933193633785448106190261 + 0.74096470220302000164595109317351452207440076171206748884906746063949 + 0.77539749661075306374035335271498711355578873864116199359771996373272 + 0.81103439428758154765966499519016990220446846078107874166646027112837 + 0.84806207898148100805294433899841808007336621326311264286071816357020 + 0.88671509499956738294114522105877020358977872696702934222169938478807 + 0.92729521800161223242851246292242880405707410857224052762186617744039 + 0.97020219992884564627294507144637975649395034794671876838355202607208 + 1.01598529381482513116231792163105149400316379682053508778250056579494 + 1.06543581651073931226000681765232949759419723349387652321962473867275 + 1.11976951499863418668667705584539961589516218640330288237568186391443 + 1.18103559399742179696187441797151603545275866323114802494551011137296 + 1.25323589750337525873710391866600599574114067342736145636046515573871 + 1.34672104149307735953151290762049740983950868154764854526693662237423 + 1.57079632679489661923132169163975144209858469968755291048747229615390))) + (let ((mxerr 0.0)) + (do ((i 0 (+ i 1)) + (x 0.0 (+ x (/ 1.0 40.0)))) + ((= i 40)) + (let ((err (abs (- (asin x) (list-ref asins i))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! asin-err mxerr))) + + (let ((atans (list + 0.00000000000000000000000000000000000000000000000000000000000000000000 + 0.04995839572194276141000628703484488149127708042350717441085345482998 + 0.09966865249116202737844611987802059024327832250431464801550877681002 + 0.14888994760949725058653039165586728099052584656913639751654183508627 + 0.19739555984988075837004976519479029344758510378785210151768894024103 + 0.24497866312686415417208248121127581091414409838118406712737591466735 + 0.29145679447786709199560462143289119350316759901206541927220608308729 + 0.33667481938672718139669863134176645842796861176681965716976593102220 + 0.38050637711236488630358791681043310449740571365810083757630562232420 + 0.42285392613294071296648279098114197360332058559089653470801277782477 + 0.46364760900080611621425623146121440202853705428612026381093308872019 + 0.50284321092786082733088202924527755577645581499776483101147435179592 + 0.54041950027058415544357836460859991013514825146259238811636023340959 + 0.57637522059118368022757047839377004593402018294846332167674413471879 + 0.61072596438920861654375887649023609381850306612882761584286773000023 + 0.64350110879328438680280922871732263804151059111531238286560611871351 + 0.67474094222355266305652097360981361507400625484071242312092170496930 + 0.70449406424221771665748034078199625698360683805607748632242138272858 + 0.73281510178650659164079207273428025198575567935825608631050693192821 + 0.75976275487577082892296119539998182400552294838843900175686400378812 + 0.78539816339744830961566084581987572104929234984377645524373614807695 + 0.80978357257016684662414585801888523310377327237135123533486105150550 + 0.83298126667443170541769356183636123851585134443710842085342312250327 + 0.85505273712601651097815432807058769283799489703232752323972864020297 + 0.87605805059819342311404752112834133907534524616033200346065614838499 + 0.89605538457134395617480071802993782702457844484684048736655059118459 + 0.91510070055336041656680197245527296654755880944161873770852665151657 + 0.93324752865620386989366255071265925262560793377140310475404520234906 + 0.95054684081207514789478913546381917504767901030880427426177057808809 + 0.96704699339746024466331914650201513140746494542545306371969751473184 + 0.98279372324732906798571061101466601449687745363162855676142508831798 + 0.99783018390619045494496187944270463542510496590550026609871776901127 + 1.01219701145133418325981347523809017175213711715353810435383625801215 + 1.02593241134335292660599590143869494280346122674543977431139573494988 + 1.03907225953609102762125033790727884531233378855364699989530509706554 + 1.05165021254837366745986731208629982963024430034204461753698029655611 + 1.06369782240255966094389111605254547856256296541932752568273985366635 + 1.07524465330906808242086208732184320752064516718532174460312177009311 + 1.08631839775787341806397958192567762897580047046812780208748680606431 + 1.09694499030013626798639002132512259906130967805041989207206852796014 + 1.10714871779409050301706546017853704007004764540143264667653920743371))) + (let ((mxerr 0.0)) + (do ((i 0 (+ i 1)) + (x 0.0 (+ x 0.05))) + ((= i 40)) + (let ((err (abs (- (atan x) (list-ref atans i))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! atan-err mxerr))) + + (let ((sqrts (list + 1.00000000000000000000000000000000000000000000000000000000000000000000 + 1.41421356237309504880168872420969807856967187537694807317667973799073 + 1.73205080756887729352744634150587236694280525381038062805580697945193 + 2.00000000000000000000000000000000000000000000000000000000000000000000 + 2.23606797749978969640917366873127623544061835961152572427089724541052 + 2.44948974278317809819728407470589139196594748065667012843269256725096 + 2.64575131106459059050161575363926042571025918308245018036833445920106 + 2.82842712474619009760337744841939615713934375075389614635335947598146 + 3.00000000000000000000000000000000000000000000000000000000000000000000 + 3.16227766016837933199889354443271853371955513932521682685750485279259 + 3.31662479035539984911493273667068668392708854558935359705868214611648 + 3.46410161513775458705489268301174473388561050762076125611161395890386 + 3.60555127546398929311922126747049594625129657384524621271045305622716 + 3.74165738677394138558374873231654930175601980777872694630374546732003 + 3.87298334620741688517926539978239961083292170529159082658757376611348 + 4.00000000000000000000000000000000000000000000000000000000000000000000 + 4.12310562561766054982140985597407702514719922537362043439863357309495 + 4.24264068711928514640506617262909423570901562613084421953003921397219 + 4.35889894354067355223698198385961565913700392523244493689034413815955 + 4.47213595499957939281834733746255247088123671922305144854179449082104 + 4.58257569495584000658804719372800848898445657676797190260724212390686 + 4.69041575982342955456563011354446628058822835341173715360570189101702 + 4.79583152331271954159743806416269391999670704190412934648530911444825 + 4.89897948556635619639456814941178278393189496131334025686538513450192 + 5.00000000000000000000000000000000000000000000000000000000000000000000 + 5.09901951359278483002822410902278198956377094609959640758497080442593 + 5.19615242270663188058233902451761710082841576143114188416742093835579 + 5.29150262212918118100323150727852085142051836616490036073666891840213 + 5.38516480713450403125071049154032955629512016164478883768038867001664 + 5.47722557505166113456969782800802133952744694997983254226894449732493 + 5.56776436283002192211947129891854952047639337757041430396843258560358 + 5.65685424949238019520675489683879231427868750150779229270671895196292 + 5.74456264653802865985061146821892931822026445798279236769987747056590 + 5.83095189484530047087415287754558307652139833488597195445000674486781 + 5.91607978309961604256732829156161704841550123079434032287971966914282 + 6.00000000000000000000000000000000000000000000000000000000000000000000 + 6.08276253029821968899968424520206706208497009478641118641915304648633 + 6.16441400296897645025019238145424422523562402344457454487457207245839 + 6.24499799839839820584689312093979446107295997799165630845297193060961 + 6.32455532033675866399778708886543706743911027865043365371500970558518))) + (let ((mxerr 0.0)) + (do ((i 1 (+ i 1))) + ((> i 40)) + (let ((err (abs (- (sqrt i) (list-ref sqrts (- i 1)))))) + (if (> err mxerr) + (set! mxerr err)))) + (set! sqrt-err mxerr))) + + (if (> sin-err 1e-12) (begin (display "sin err: ") (display sin-err) (newline))) + (if (> cos-err 1e-12) (begin (display "cos err: ") (display cos-err) (newline))) + (if (> log-err 1e-12) (begin (display "log err: ") (display log-err) (newline))) + (if (> asin-err 1e-12) (begin (display "asin err: ") (display asin-err) (newline))) + (if (> atan-err 1e-12) (begin (display "atan err: ") (display atan-err) (newline))) + (if (> sqrt-err 1e-12) (begin (display "sqrt err: ") (display sqrt-err) (newline))) + ) + + )) + +;'( +;;;; this is the current s7 output from loading this file: +; +; " " +; (let ((funcs (make-vector 3 #f))) (do ((i 0 (+ i 1))) ((= i 3)) (vector-set! funcs i (lambda () (+ i 1)))) (+ ((vector-ref funcs 0)) ((vector-ref funcs 1)) ((vector-ref funcs 2)))) got 12 but expected 6 +; +;(let* ((x (quote (1 2 3))) (y (apply list x))) (not (eq? x y))) got #f but expected #t +; +;(let () (define q (let ((count 5)) (define (get-count) count) (define p (make-promise (if (<= count 0) count (begin (set! count (- count 1)) (force p) (set! count (+ count 2)) count)))) (list get-count p))) (let* ((get-count (car q)) (p (cadr q)) (a (get-count)) (b (force p)) (c (get-count))) (list a b c))) got (5 10 10) but expected (5 0 10) +; +;format #t 1 output-port: 2! (this is testing output ports) +; +;op error test result expected +;bes-i0: 4.728274528735e-07 (bes-i0 100.0) 1.0737511994318e+42 1.0737517071311e+42 +;*: 1.4453905801655e-16 (* 1234/11 1234/11 1+1i) 12584.760330579+12584.760330579i 12584.760330579+12584.760330579i +;+: 1.2356560980092e-17 (+ 1.234+1.234i -1+1i) 0.234+2.234i 0.234+2.234i +;-: 7.065416064077e-15 (- 1234/11 1234/11 -1+1i) 1-1i 1-1i +;/: 6.7706212385519e-12 (/ 1+1i 123.4 123.4) 6.5670402874788e-05+6.5670402874788e-05i 6.567040287e-05+6.567040287e-05i +;magnitude: 4.3762690498963e-15 (magnitude 1e-08+1e-08i) 1.4142135623731e-08 1.414214e-08 +;angle: 5.2180482157382e-15 (angle 3.1415926535898+1i) 0.30816907111599 0.30816907111598 +;make-polar: 5.1075947370453e-12 (make-polar 1e-08 1234.0) -7.9855062358758e-09+6.019276547625e-09i -7.98551e-09+6.01928e-09i +;remainder: 1.1102230246252e-16 (remainder -3.1 2.5) -0.6 -0.6 +;modulo: 1.1102230246252e-16 (modulo -3.1 2.0) 0.9 0.9 +;expt: 5.3037918931232e-12 (expt -1234-2.718281828459i -1-1e-08i) -0.00081036881365486+1.7851555921329e-06i -0.00081036881365+1.78515559e-06i +;log: 1.9801079834368e-14 (log 8.0 1+1i) 0.97790391649038-2.2161063668189i 0.97790391649038-2.2161063668189i +;exp: 6.2082941131998e-11 (exp 2.718281828459+1234000000i) 2.4081506430049-14.961700256459i 2.4081506420759-14.961700256608i +;sqrt: 4.9628289840723e-12 (sqrt 1e-08+1e-08i) 0.00010986841134678+4.5508986056223e-05i 0.00010986841135+4.550898606e-05i +;atanh: 3.3019134302818e-14 (atanh 1e-08+1e-08i) 9.9999999669809e-09+1e-08i 1e-08+1e-08i +;acosh: 3.0063814632876e-11 (acosh 0-1234i) 7.8111635492012-1.5707963267949i 7.8111635489617-1.5707963267949i +;asinh: 1.8798350372034e-07 (asinh -181440) -12.801827480089 -12.801829886622 +;tanh: 3.9570983863574e-10 (tanh 1e-08+1234000000i) 3.9600648213873e-07-6.2129419934418i 3.9600648244422e-07-6.2129419959003i +;cosh: 3.8571780349279e-10 (cosh 1e-08+1234000000i) 0.15890913095152-9.8729321283003e-09i 0.15890913089022-9.8729321283989e-09i +;sinh: 6.1863103554352e-11 (sinh 3.1415926535898+1234000000i) 1.8352001348474-11.444656792365i 1.8352001341396-11.44465679248i +;atan: 1.6781042865365e-14 (atan 0+1e-08i) 0+1.0000000016781e-08i 0+1e-08i +;acos: 1.8259451651704e-08 (acos 181440) -0+12.801827480074i 0+12.80182724632i +;asin: 6.2060307610322e-09 (asin 1e-08+1234000000i) 8.1037277147488e-18+21.62667394299i 8.1037250521496e-18+21.626673808774i +;tan: 4.2096697956986e-07 (tan 1234000000/3) -18.780955178921 -18.780947272762 +;cos: 2.2319583216357e-08 (cos 1234000000/3) -0.053170110875237 -0.05317013319482 +;sin: 1.1884160322495e-09 (sin 1234000000/3) 0.99858546920607 0.99858546801766 +;string->number: 3.514766724748e-14 (string->number "1234567890123456789012345678901234567890.123456789e-30") 1234567890.1235 1234567890.1235 +;sin error > 1e-6 after 2^38.192705173229 or thereabouts +;exp+log error > 1e-6 around 2^31.340047894875 +;tan error > 1e-6 around 2^46.506993328423 +;expt error > 1e-6 around 2^-46.506993328423 +;) + + +(newline) (display ";all done!") (newline)