Arithmetic derivative: Difference between revisions

← Older edit

Arithmetic derivative (view source)

Revision as of 09:16, 28 January 2024

58,728 bytes added , 4 months ago

Added Easylang

Chkas

2,063

edits

Revision as of 08:04, 3 July 2022 (view source) Rdm (talk \| contribs) (→‎{{header\|J}}: more direct (non-recursive) implementation) ← Older edit		Latest revision as of 09:16, 28 January 2024 (view source) Chkas (talk \| contribs) (Added Easylang)
(45 intermediate revisions by 18 users not shown)
Line 1: {{~~draft~~ task}} The '''arithmetic derivative''' of an integer (more specifically, the Line 36: ;[[wp:Arithmetic_derivative\|Wikipedia: Arithmetic Derivative]] =={{header\|ALGOL 68}}== <syntaxhighlight lang="algol68"> BEGIN PROC lagarias = (LONG INT n) LONG INT: # Lagarias arithmetic derivative # IF n < 0 THEN -lagarias (-n) ELIF n = 0 OR n = 1 THEN 0 ELIF PROC small pf = (LONG INT j, k) LONG INT: # Smallest prime factor # (j % k = 0 \| k \| small pf (j, k + 1)); LONG INT f = small pf (n, 2); LONG INT q = n % f; q = 1 THEN 1 ELSE q * lagarias (f) + f * lagarias (q) FI; FOR n FROM -99 TO 100 DO print (("D(", whole (n, 0), ") = ", whole (lagarias (n), 0), new line)) OD; new line (standout); FOR n TO 20 DO LONG INT m = LONG 10 ^ n; print (("D(", whole (m, 0), ") / 7 = ", whole (lagarias (m) % 7, 0), new line)) OD END </syntaxhighlight> {{out}} <pre> D(-99) = -75 D(-98) = -77 D(-97) = -1 D(-96) = -272 ... D(96) = 272 D(97) = 1 D(98) = 77 D(99) = 75 D(100) = 140 D(10) / 7 = 1 D(100) / 7 = 20 D(1000) / 7 = 300 ... D(1000000000000000000) / 7 = 1800000000000000000 D(10000000000000000000) / 7 = 19000000000000000000 D(100000000000000000000) / 7 = 200000000000000000000 </pre> =={{header\|ALGOL W}}== {{Trans\|ALGOL 68\|using compressed output and basic task only as Algol W integers are limited to 32 bits}} <syntaxhighlight lang="algolw"> begin integer procedure lagarias ( integer value n ) ; % Lagarias arithmetic derivative % if n < 0 then -lagarias (-n) else if n = 0 or n = 1 then 0 else begin integer f, q; integer procedure smallPf ( integer value j, k ) ; % Smallest prime factor % if j rem k = 0 then k else smallPf (j, k + 1); f := smallPf (n, 2); q := n div f; if q = 1 then 1 else q * lagarias (f) + f * lagarias (q) end lagarias ; for n := -99 until 100 do begin writeon( i_w := 6, s_w := 0, " ", lagarias (n) ); if n rem 10 = 0 then write() end for_n end. </syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 </pre> =={{header\|C}}== {{trans\|Go}} <syntaxhighlight lang="c">#include <stdio.h> #include <stdint.h> typedef uint64_t u64; void primeFactors(u64 n, u64 factors, int length) { if (n < 2) return; int count = 0; int inc[8] = {4, 2, 4, 2, 4, 6, 2, 6}; while (!(n%2)) { factors[count++] = 2; n /= 2; } while (!(n%3)) { factors[count++] = 3; n /= 3; } while (!(n%5)) { factors[count++] = 5; n /= 5; } for (u64 k = 7, i = 0; kk <= n; ) { if (!(n%k)) { factors[count++] = k; n /= k; } else { k += inc[i]; i = (i + 1) % 8; } } if (n > 1) { factors[count++] = n; } length = count; } double D(double n) { if (n < 0) return -D(-n); if (n < 2) return 0; int i, length; double d; u64 f[80], g; if (n < 1e19) { primeFactors((u64)n, f, &length); } else { g = (u64)(n / 100); primeFactors(g, f, &length); f[length+1] = f[length] = 2; f[length+3] = f[length+2] = 5; length += 4; } if (length == 1) return 1; if (length == 2) return (double)(f[0] + f[1]); d = n / (double)f[0]; return D(d) * (double)f[0] + d; } int main() { u64 ad[200]; int n, m; double pow; for (n = -99; n < 101; ++n) { ad[n+99] = (int)D((double)n); } for (n = 0; n < 200; ++n) { printf("%4ld ", ad[n]); if (!((n+1)%10)) printf("\n"); } printf("\n"); pow = 1; for (m = 1; m < 21; ++m) { pow = 10; printf("D(10^%-2d) / 7 = %.0f\n", m, D(pow)/7); } return 0; }</syntaxhighlight> {{out}} <pre> As Go example </pre> =={{header\|C++}}== {{libheader\|Boost}} <syntaxhighlight lang="cpp">#include <iomanip> #include <iostream> #include <boost/multiprecision/cpp_int.hpp> template <typename IntegerType> IntegerType arithmetic_derivative(IntegerType n) { bool negative = n < 0; if (negative) n = -n; if (n < 2) return 0; IntegerType sum = 0, count = 0, m = n; while ((m & 1) == 0) { m >>= 1; count += n; } if (count > 0) sum += count / 2; for (IntegerType p = 3, sq = 9; sq <= m; p += 2) { count = 0; while (m % p == 0) { m /= p; count += n; } if (count > 0) sum += count / p; sq += (p + 1) << 2; } if (m > 1) sum += n / m; if (negative) sum = -sum; return sum; } int main() { using boost::multiprecision::int128_t; for (int n = -99, i = 0; n <= 100; ++n, ++i) { std::cout << std::setw(4) << arithmetic_derivative(n) << ((i + 1) % 10 == 0 ? '\n' : ' '); } int128_t p = 10; std::cout << '\n'; for (int i = 0; i < 20; ++i, p = 10) { std::cout << "D(10^" << std::setw(2) << i + 1 << ") / 7 = " << arithmetic_derivative(p) / 7 << '\n'; } }</syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^ 1) / 7 = 1 D(10^ 2) / 7 = 20 D(10^ 3) / 7 = 300 D(10^ 4) / 7 = 4000 D(10^ 5) / 7 = 50000 D(10^ 6) / 7 = 600000 D(10^ 7) / 7 = 7000000 D(10^ 8) / 7 = 80000000 D(10^ 9) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|EasyLang}}== {{trans\|Lua}} <syntaxhighlight> func lagarias n . if n < 0 return -lagarias -n . if n = 0 or n = 1 return 0 . f = 2 while n mod f <> 0 f += 1 . q = n / f if q = 1 return 1 . return q * lagarias f + f * lagarias q . for n = -99 to 100 write lagarias n & " " . </syntaxhighlight> =={{header\|Factor}}== {{works with\|Factor\|0.99 2022-04-03}} <syntaxhighlight lang=factor>USING: combinators formatting grouping io kernel math math.primes.factors prettyprint ranges sequences ; : n' ( m -- n ) { { [ dup neg? ] [ neg n' neg ] } { [ dup 2 < ] [ drop 0 ] } { [ factors dup length 1 = ] [ drop 1 ] } [ unclip-slice swap product 2dup n' * spin n' * + ] } cond ; -99 100 [a..b] [ n' ] map 10 group [ [ "%5d" printf ] each nl ] each</syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 </pre> =={{header\|Go}}== {{libheader\|Go-rcu}} Using ''float64'' (finessed a little) to avoid the unpleasantness of ''math/big'' for the stretch goal. Assumes that ''int'' type is 64 bit. <syntaxhighlight lang="go">package main import ( "fmt" "rcu" ) func D(n float64) float64 { if n < 0 { return -D(-n) } if n < 2 { return 0 } var f []int if n < 1e19 { f = rcu.PrimeFactors(int(n)) } else { g := int(n / 100) f = rcu.PrimeFactors(g) f = append(f, []int{2, 2, 5, 5}...) } c := len(f) if c == 1 { return 1 } if c == 2 { return float64(f[0] + f[1]) } d := n / float64(f[0]) return D(d)float64(f[0]) + d } func main() { ad := make([]int, 200) for n := -99; n < 101; n++ { ad[n+99] = int(D(float64(n))) } rcu.PrintTable(ad, 10, 4, false) fmt.Println() pow := 1.0 for m := 1; m < 21; m++ { pow = 10 fmt.Printf("D(10^%-2d) / 7 = %.0f\n", m, D(pow)/7) } }</syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1 ) / 7 = 1 D(10^2 ) / 7 = 20 D(10^3 ) / 7 = 300 D(10^4 ) / 7 = 4000 D(10^5 ) / 7 = 50000 D(10^6 ) / 7 = 600000 D(10^7 ) / 7 = 7000000 D(10^8 ) / 7 = 80000000 D(10^9 ) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|Haskell}}== <syntaxhighlight lang="haskell">import Control.Monad (forM_) import Data.List (intercalate) import Data.List.Split (chunksOf) import Math.NumberTheory.Primes (factorise, unPrime) import Text.Printf (printf) -- The arithmetic derivative of a number, which is assumed to be non-negative. arithderiv_ :: Integer -> Integer arithderiv_ 0 = 0 arithderiv_ n = foldr step 0 $ factorise n where step (p, v) s = s + n `quot` unPrime p * fromIntegral v -- The arithmetic derivative of any integer. arithderiv :: Integer -> Integer arithderiv n \| n < 0 = negate $ arithderiv_ (negate n) \| otherwise = arithderiv_ n printTable :: [Integer] -> IO () printTable = putStrLn . intercalate "\n" . map unwords . chunksOf 10 . map (printf "%5d") main :: IO () main = do printTable [arithderiv n \| n <- [-99..100]] putStrLn "" forM_ [1..20 :: Integer] $ \i -> let q = 7 n = arithderiv (10^i) `quot` q in printf "D(10^%-2d) / %d = %d\n" i q n</syntaxhighlight> {{out}} <pre> $ arithderiv -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1 ) / 7 = 1 D(10^2 ) / 7 = 20 D(10^3 ) / 7 = 300 D(10^4 ) / 7 = 4000 D(10^5 ) / 7 = 50000 D(10^6 ) / 7 = 600000 D(10^7 ) / 7 = 7000000 D(10^8 ) / 7 = 80000000 D(10^9 ) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|J}}== Implementation: <syntaxhighlight lang J="j">D=: {{ (y)+/~~1/\.~~y%q:1>.\|y }}"0</~~lang~~syntaxhighlight> In other words: find the ~~prime factors~~sum of the ~~absolute~~argument ~~value~~divided ofby yeach asof athe sequence, ~~find~~of ~~and~~prime ~~sum each~~factors of ~~the~~its ~~products~~absolute value (with ~~exactly~~a ~~one~~special ~~value~~case ~~removed~~for ~~from~~zero ~~this~~-- ~~sequence~~we ~~and multiply by~~use the ~~sign~~maximum of y.either ~~(And~~1 ~~since~~or 0that ~~has~~absolute anvalue ~~infinite~~when ~~list of prime factors which makes treating it nonsensical, use~~finding the ~~empty list~~sequence of prime factors ~~of 1 for that case~~).) Task example: <~~lang~~syntaxhighlight Jlang="j"> D _99+i.20 10 _75 _77 _1 _272 _24 _49 _34 _96 _20 _123 _1 _140 _32 _45 _22 _124 _1 _43 _108 _176 Line 65 ⟶ 581: 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140</~~lang~~syntaxhighlight> Also, it seems like it's worth verifying that order of evaluation does not create an ambiguity for the value of D (order shouldn't matter, since summation of integers is order independent): <~~lang~~syntaxhighlight Jlang="j"> 15 10 6 + 2 3 5 D 15 10 6 31 31 31</~~lang~~syntaxhighlight> Stretch task: <~~lang~~syntaxhighlight lang="j"> (D 10x^1+i.4 5)%7 1 20 300 4000 50000 600000 7000000 80000000 900000000 10000000000 110000000000 1200000000000 13000000000000 140000000000000 1500000000000000 16000000000000000 170000000000000000 1800000000000000000 19000000000000000000 200000000000000000000</~~lang~~syntaxhighlight> =={{header\|Java}}== <syntaxhighlight lang="java"> import java.math.BigInteger; public final class ArithmeticDerivative { public static void main(String[] aArgs) { System.out.println("Arithmetic derivatives for -99 to 100 inclusive:"); for ( int n = -99, column = 0; n <= 100; n++ ) { System.out.print(String.format("%4d%s", derivative(BigInteger.valueOf(n)), ( ++column % 10 == 0 ) ? "\n" : " ")); } System.out.println(); final BigInteger seven = BigInteger.valueOf(7); for ( int power = 1; power <= 20; power++ ) { System.out.println(String.format("%s%2d%s%d", "D(10^", power, ") / 7 = ", derivative(BigInteger.TEN.pow(power)).divide(seven))); } } private static BigInteger derivative(BigInteger aNumber) { if ( aNumber.signum() == -1 ) { return derivative(aNumber.negate()).negate(); } if ( aNumber == BigInteger.ZERO \|\| aNumber == BigInteger.ONE ) { return BigInteger.ZERO; } BigInteger divisor = BigInteger.TWO; while ( divisor.multiply(divisor).compareTo(aNumber) <= 0 ) { if ( aNumber.mod(divisor).signum() == 0 ) { final BigInteger quotient = aNumber.divide(divisor); return quotient.multiply(derivative(divisor)).add(divisor.multiply(derivative(quotient))); } divisor = divisor.add(BigInteger.ONE); } return BigInteger.ONE; } } </syntaxhighlight> {{ out }} <pre> Arithmetic derivatives for -99 to 100 inclusive: -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 -1 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^ 1) / 7 = 1 D(10^ 2) / 7 = 20 D(10^ 3) / 7 = 300 D(10^ 4) / 7 = 4000 D(10^ 5) / 7 = 50000 D(10^ 6) / 7 = 600000 D(10^ 7) / 7 = 7000000 D(10^ 8) / 7 = 80000000 D(10^ 9) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|jq}}== For this task, gojq (the Go implementation of jq) is used for numerical accuracy, though the C implementation has sufficient accuracy at least for D(10^16). See [[Prime_decomposition#jq]] for the def of factors/0 used here. <syntaxhighlight lang="jq"> To take advantage of gojq's arbitrary-precision integer arithmetic: def power($b): . as $in \| reduce range(0;$b) as $i (1; . * $in); # In case gojq is used: def _nwise($n): def nw: if length <= $n then . else .[0:$n] , (.[$n:] \| nw) end; nw; def lpad($len): tostring \| ($len - length) as $l \| (" " * $l)[:$l] + .; def D($n): if $n < 0 then -D(- $n) elif $n < 2 then 0 else [$n \| factors] as $f \| ($f\|length) as $c \| if $c <= 1 then 1 elif $c == 2 then $f[0] + $f[1] else ($n / $f[0]) as $d \| D($d) * $f[0] + $d end end ; def task: def task1: reduce range(-99; 101) as $n ([]; .[$n+99] = D($n)) \| _nwise(10) \| map(lpad(4)) \| join(" "); def task2: range(1; 21) as $i \| "D(10^\($i)) / 7 = \( D(10\|power($i))/7 )" ; task1, "", task2 ; task </syntaxhighlight> {{Output}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1) / 7 = 1 D(10^2) / 7 = 20 D(10^3) / 7 = 300 D(10^4) / 7 = 4000 D(10^5) / 7 = 50000 D(10^6) / 7 = 600000 D(10^7) / 7 = 7000000 D(10^8) / 7 = 80000000 D(10^9) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|Julia}}== <~~lang~~syntaxhighlight ~~ruby~~lang="julia">using Primes D(n) = n < 0 ? -D(-n) : n < 2 ? zero(n) : isprime(n) ? one(n) : typeof(n)(sum(e * n ÷ p for (p, e) in eachfactor(n))) Line 91 ⟶ 782: println("D for 10^", rpad(m, 3), "divided by 7 is ", D(Int128(10)^m) ÷ 7) end </~~lang~~syntaxhighlight>{{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 Line 134 ⟶ 825: D for 10^19 divided by 7 is 19000000000000000000 D for 10^20 divided by 7 is 200000000000000000000 </pre> =={{header\|Lua}}== {{Trans\|ALGOL 68\|with condensed output and only showing D values up to 10^17 as 10^18 onwards overflows}} Tested with Lua 5.1 (LuaJIT and OpenResty), 5.3.6 and 5.4.6.<br/> Lua 5.2.4 didn't like the string.format. Also the format of the larger D values appears to be sensitive to the Lua version. <syntaxhighlight lang="lua"> do local function lagarias (n) -- Lagarias arithmetic derivative if n < 0 then return -lagarias (-n) elseif n == 0 or n == 1 then return 0 else local function smallPf (j, k) -- Smallest prime factor if j % k == 0 then return k else return smallPf (j, k + 1) end end local f = smallPf (n, 2) local q = math.floor (n / f) if q == 1 then return 1 else return q * lagarias (f) + f * lagarias (q) end end end for n = -99,100 do io.write (string.format("%6d", lagarias (n))) if n % 10 == 0 then io.write ("\n") end end io.write ("\n") for n = 1,17 -- 18, 19 and 20 would overflow do local m = 10 ^ n io.write ("D(", string.format ("%d", m), ") / 7 = ", math.floor (lagarias (m) / 7), "\n") end end </syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10) / 7 = 1 D(100) / 7 = 20 D(1000) / 7 = 300 D(10000) / 7 = 4000 D(100000) / 7 = 50000 D(1000000) / 7 = 600000 D(10000000) / 7 = 7000000 D(100000000) / 7 = 80000000 D(1000000000) / 7 = 900000000 D(10000000000) / 7 = 10000000000 D(100000000000) / 7 = 110000000000 D(1000000000000) / 7 = 1200000000000 D(10000000000000) / 7 = 13000000000000 D(100000000000000) / 7 = 140000000000000 D(1000000000000000) / 7 = 1500000000000000 D(10000000000000000) / 7 = 16000000000000000 D(100000000000000000) / 7 = 170000000000000000 </pre> =={{header\|MiniScript}}== {{Trans\|ALGOL 68\|via Lua}} <syntaxhighlight lang="miniscript"> lagarias = function (n) // Lagarias arithmetic derivative if n < 0 then return -lagarias (-n) else if n == 0 or n == 1 then return 0 else smallPf = function (j, k) // Smallest prime factor if j % k == 0 then return k else return smallPf (j, k + 1) end if end function f = smallPf (n, 2) q = floor (n / f) if q == 1 then return 1 else return q * lagarias (f) + f * lagarias (q) end if end if end function fmt6 = function (n) // return a 6 character string representation of n s = str( n ) if s.len > 5 then return s else return ( " " * ( 6 - s.len ) ) + s end if end function ad = "" for n in range( -99, 100 ) ad = ad + " " + fmt6( lagarias (n) ) if n % 10 == 0 then print( ad ) ad = "" end if end for print() for n in range( 1, 17 ) // 18, 19 and 20 would overflow ????? TODO: check m = 10 ^ n print( "D(" + str(m) + ") / 7 = " + str( floor (lagarias (m) / 7) ) ) end for </syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10) / 7 = 1 D(100) / 7 = 20 D(1000) / 7 = 300 D(10000) / 7 = 4000 D(100000) / 7 = 50000 D(1000000) / 7 = 600000 D(10000000) / 7 = 7000000 D(100000000) / 7 = 80000000 D(1000000000) / 7 = 900000000 D(10000000000) / 7 = 10000000000 D(100000000000) / 7 = 110000000000 D(1000000000000) / 7 = 1200000000000 D(10000000000000) / 7 = 13000000000000 D(100000000000000) / 7 = 140000000000000 D(1000000000000000) / 7 = 1500000000000000 D(10000000000000000) / 7 = 16000000000000000 D(100000000000000000) / 7 = 170000000000000000 D(1000000000000000000) / 7 = 1800000000000000000 D(10000000000000000000) / 7 = 19000000000000000000 D(100000000000000000000) / 7 = 200000000000000000000 </pre> =={{header\|Nim}}== {{libheader\|Nim-Integers}} <syntaxhighlight lang="Nim">import std/[strformat, strutils] import integers func aDerivative(n: int \| Integer): typeof(n) = ## Recursively compute the arithmetic derivative. ## The function works with normal integers or big integers. ## Using a cache to store the derivatives would improve the ## performance, but this is not needed for these tasks. if n < 0: return -aDerivative(-n) if n == 0 or n == 1: return 0 if n == 2: return 1 var d = 2 result = 1 while d * d <= n: if n mod d == 0: let q = n div d result = q * aDerivative(d) + d * aDerivative(q) break inc d ### Task ### echo "Arithmetic derivatives for -99 through 100:" # We can use an "int" variable here. var col = 0 for n in -99..100: inc col stdout.write &"{aDerivative(n):>4}" stdout.write if col == 10: '\n' else: ' ' if col == 10: col = 0 ### Stretch task ### echo() # To avoid overflow, we have to use an "Integer" variable. var n = Integer(1) for m in 1..20: n = 10 let a = aDerivative(n) let left = &"D(10^{m}) / 7" echo &"{left:>12} = {a div 7}" </syntaxhighlight> {{out}} <pre>Arithmetic derivatives for -99 through 100: -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1) / 7 = 1 D(10^2) / 7 = 20 D(10^3) / 7 = 300 D(10^4) / 7 = 4000 D(10^5) / 7 = 50000 D(10^6) / 7 = 600000 D(10^7) / 7 = 7000000 D(10^8) / 7 = 80000000 D(10^9) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|Perl}}== {{trans\|J}} {{libheader\|ntheory}} <syntaxhighlight lang="perl">use v5.36; use bigint; no warnings 'uninitialized'; use List::Util 'max'; use ntheory 'factor'; sub table ($c, @V) { my $t = $c (my $w = 2 + length max @V); ( sprintf( ('%'.$w.'d')x@V, @V) ) =~ s/.{1,$t}\K/\n/gr } sub D ($n) { my(%f, $s); $f{$_}++ for factor max 1, my $nabs = abs $n; map { $s += $nabs * $f{$_} / $_ } keys %f; $n > 0 ? $s : -$s; } say table 10, map { D $_ } -99 .. 100; say join "\n", map { sprintf('D(10%-2d) / 7 == ', $_) . D(10$_) / 7 } 1 .. 20; </syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(101 ) / 7 == 1 D(102 ) / 7 == 20 D(103 ) / 7 == 300 D(104 ) / 7 == 4000 D(105 ) / 7 == 50000 D(106 ) / 7 == 600000 D(107 ) / 7 == 7000000 D(108 ) / 7 == 80000000 D(109 ) / 7 == 900000000 D(1010) / 7 == 10000000000 D(1011) / 7 == 110000000000 D(1012) / 7 == 1200000000000 D(1013) / 7 == 13000000000000 D(1014) / 7 == 140000000000000 D(1015) / 7 == 1500000000000000 D(1016) / 7 == 16000000000000000 D(1017) / 7 == 170000000000000000 D(1018) / 7 == 1800000000000000000 D(1019) / 7 == 19000000000000000000 D(1020) / 7 == 200000000000000000000</pre> =={{header\|Phix}}== <!--<syntaxhighlight lang="phix">(phixonline)--> <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> <span style="color: #008080;">procedure</span> <span style="color: #000000;">D</span><span style="color: #0000FF;">(</span><span style="color: #004080;">mpz</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_cmp_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">if</span> <span style="color: #000000;">s</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">mpz_neg</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> <span style="color: #008080;">if</span> <span style="color: #7060A8;">mpz_cmp_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">else</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">vslice</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)),</span> <span style="color: #000000;">f1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">if</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">elsif</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f1</span> <span style="color: #0000FF;">+</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">?</span><span style="color: #000000;">f1</span><span style="color: #0000FF;">:</span><span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">][</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]))</span> <span style="color: #008080;">else</span> <span style="color: #7060A8;">assert</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_fdiv_q_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f1</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #004080;">mpz</span> <span style="color: #000000;">d</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init_set</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #000000;">D</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #7060A8;">mpz_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">f1</span><span style="color: #0000FF;">)</span> <span style="color: #7060A8;">mpz_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">d</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> <span style="color: #008080;">if</span> <span style="color: #000000;">s</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #7060A8;">mpz_neg</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span> <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">200</span><span style="color: #0000FF;">)</span> <span style="color: #004080;">mpz</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">()</span> <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">99</span> <span style="color: #008080;">to</span> <span style="color: #000000;">100</span> <span style="color: #008080;">do</span> <span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span> <span style="color: #000000;">D</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">+</span><span style="color: #000000;">100</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">:=</span><span style="color: #008000;">"%4s"</span><span style="color: #0000FF;">)})</span> <span style="color: #008080;">for</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20</span> <span style="color: #008080;">do</span> <span style="color: #7060A8;">mpz_ui_pow_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)</span> <span style="color: #000000;">D</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span> <span style="color: #7060A8;">assert</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_fdiv_q_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span> <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"D(10^%d)/7 = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)})</span> <span style="color: #008080;">end</span> <span style="color: #008080;">for</span> <!--</syntaxhighlight>--> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1)/7 = 1 D(10^2)/7 = 20 D(10^3)/7 = 300 D(10^4)/7 = 4000 D(10^5)/7 = 50000 D(10^6)/7 = 600000 D(10^7)/7 = 7000000 D(10^8)/7 = 80000000 D(10^9)/7 = 900000000 D(10^10)/7 = 10000000000 D(10^11)/7 = 110000000000 D(10^12)/7 = 1200000000000 D(10^13)/7 = 13000000000000 D(10^14)/7 = 140000000000000 D(10^15)/7 = 1500000000000000 D(10^16)/7 = 16000000000000000 D(10^17)/7 = 170000000000000000 D(10^18)/7 = 1800000000000000000 D(10^19)/7 = 19000000000000000000 D(10^20)/7 = 200000000000000000000 </pre> =={{header\|Python}}== <~~lang~~syntaxhighlight lang="python">from sympy.ntheory import factorint def D(n): Line 157 ⟶ 1,260: print('(D for 10{}) divided by 7 is {}'.format(m, D(10 m) // 7)) </~~lang~~syntaxhighlight>{{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 Line 200 ⟶ 1,303: (D for 1019) divided by 7 is 19000000000000000000 (D for 1020) divided by 7 is 200000000000000000000 </pre> =={{header\|Quackery}}== <code>primefactors</code> is defined at [[ Prime decomposition#Quackery]]. <syntaxhighlight lang="Quackery"> [ dup 0 < iff [ negate ' negate ] else [] swap 0 over primefactors witheach [ dip over / + ] nip swap do ] is d ( n --> n ) 200 times [ i^ 99 - d echo sp ] cr cr 20 times [ 10 i^ 1+ d 7 / echo cr ]</syntaxhighlight> {{out}} <pre>-75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 1 20 300 4000 50000 600000 7000000 80000000 900000000 10000000000 110000000000 1200000000000 13000000000000 140000000000000 1500000000000000 16000000000000000 170000000000000000 1800000000000000000 19000000000000000000 200000000000000000000 </pre> =={{header\|Raku}}== <syntaxhighlight lang="raku" ~~perl6~~line>use Prime::Factor; multi D (0) { 0 } Line 216 ⟶ 1,363: put ''; put join "\n", (1..20).map: { sprintf "D(10%-2d) / 7 == %d", $_, D(10$_) / 7 }</~~lang~~syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 Line 259 ⟶ 1,406: D(1019) / 7 == 19000000000000000000 D(10*20) / 7 == 200000000000000000000</pre> =={{header\|RPL}}== {{works with\|HP\|49}} ≪ '''CASE''' DUP 0 < '''THEN''' NEG <span style="color:blue">ADERIV</span> NEG '''END''' DUP 2 < '''THEN''' DROP 0 '''END''' R→I DUP ISPRIME? '''THEN''' DROP 1 '''END''' DUP FACTORS HEAD LASTARG 2 GET DUP2 ^ 4 PICK OVER / 1 RND → n p k pk rem ≪ k pk p / rem * rem <span style="color:blue">ADERIV</span> pk * + ≫ '''END''' ≫ '<span style="color:blue">ADERIV</span>' STO ≪ n <span style="color:blue">ADERIV</span> ≫ 'n' -99 100 1 SEQ ≪ 10 m ^ <span style="color:blue">ADERIV</span> 7 / R→I ≫ 'nm' 1 20 1 SEQ {{out}} <pre> 2: {-75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140} 1: {1 20 300 4000 50000 600000 7000000 80000000 900000000 10000000000 110000000000 1200000000000 13000000000000 140000000000000 1500000000000000 16000000000000000 170000000000000000 800000000000000000 19000000000000000000 200000000000000000000} </pre> =={{header\|Rust}}== {{trans\|Python}} <syntaxhighlight lang="rust">use prime_factorization::Factorization; fn d(n: i128) -> i128 { if n < 0 { return -(d(-n)); } else if n < 2 { return 0; } else { let fpairs = Factorization::run(n as u128).prime_factor_repr(); if fpairs.len() == 1 && fpairs[0].1 == 1 { return 1; } return fpairs.iter().fold(0_i128, \|p, q\| p + n * (q.1 as i128) / (q.0 as i128)); } } fn main() { for n in -99..101 { print!("{:5}{}", d(n), { if n % 10 == 0 { "\n" } else {""} }); } println!(); for m in 1..21 { println!("(D for 10 ^ {}) divided by 7 is {}", m, d(10_i128.pow(m)) / 7) } } </syntaxhighlight>{{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 (D for 10 ^ 1) divided by 7 is 1 (D for 10 ^ 2) divided by 7 is 20 (D for 10 ^ 3) divided by 7 is 300 (D for 10 ^ 4) divided by 7 is 4000 (D for 10 ^ 5) divided by 7 is 50000 (D for 10 ^ 6) divided by 7 is 600000 (D for 10 ^ 7) divided by 7 is 7000000 (D for 10 ^ 8) divided by 7 is 80000000 (D for 10 ^ 9) divided by 7 is 900000000 (D for 10 ^ 10) divided by 7 is 10000000000 (D for 10 ^ 11) divided by 7 is 110000000000 (D for 10 ^ 12) divided by 7 is 1200000000000 (D for 10 ^ 13) divided by 7 is 13000000000000 (D for 10 ^ 14) divided by 7 is 140000000000000 (D for 10 ^ 15) divided by 7 is 1500000000000000 (D for 10 ^ 16) divided by 7 is 16000000000000000 (D for 10 ^ 17) divided by 7 is 170000000000000000 (D for 10 ^ 18) divided by 7 is 1800000000000000000 (D for 10 ^ 19) divided by 7 is 19000000000000000000 (D for 10 ^ 20) divided by 7 is 200000000000000000000 </pre> =={{header\|Scala}}== {{trans\|Java}} <syntaxhighlight lang="Scala"> import java.math.BigInteger object ArithmeticDerivative extends App { println("Arithmetic derivatives for -99 to 100 inclusive:") for { n <- -99 to 100 column = n + 100 } print(f"${derivative(BigInteger.valueOf(n))}%4d${if (column % 10 == 0) "\n" else " "}") println() val seven = BigInteger.valueOf(7) for (power <- 1 to 20) { println(f"D(10^$power%d) / 7 = ${derivative(BigInteger.TEN.pow(power)).divide(seven)}") } def derivative(aNumber: BigInteger): BigInteger = { if (aNumber.signum == -1) { return derivative(aNumber.negate()).negate() } if (aNumber == BigInteger.ZERO \|\| aNumber == BigInteger.ONE) { return BigInteger.ZERO } var divisor = BigInteger.TWO while (divisor.multiply(divisor).compareTo(aNumber) <= 0) { if (aNumber.mod(divisor).signum == 0) { val quotient = aNumber.divide(divisor) return quotient.multiply(derivative(divisor)).add(divisor.multiply(derivative(quotient))) } divisor = divisor.add(BigInteger.ONE) } BigInteger.ONE } } </syntaxhighlight> {{out}} <pre> Arithmetic derivatives for -99 to 100 inclusive: -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1) / 7 = 1 D(10^2) / 7 = 20 D(10^3) / 7 = 300 D(10^4) / 7 = 4000 D(10^5) / 7 = 50000 D(10^6) / 7 = 600000 D(10^7) / 7 = 7000000 D(10^8) / 7 = 80000000 D(10^9) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|Wren}}== {{libheader\|Wren-big}} {{libheader\|Wren-fmt}} As integer arithmetic in Wren is inaccurate above 2^53 we need to use BigInt here. <syntaxhighlight lang="wren">import "./big" for BigInt import "./fmt" for Fmt var D = Fn.new { \|n\| if (n < 0) return -D.call(-n) if (n < 2) return BigInt.zero var f = BigInt.primeFactors(n) var c = f.count if (c == 1) return BigInt.one if (c == 2) return f[0] + f[1] var d = n / f[0] return D.call(d) * f[0] + d } var ad = List.filled(200, 0) for (n in -99..100) ad[n+99] = D.call(BigInt.new(n)) Fmt.tprint("$4i", ad, 10) System.print() for (m in 1..20) { Fmt.print("D(10^$-2d) / 7 = $i", m, D.call(BigInt.ten.pow(m))/7) }</syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 D(10^1 ) / 7 = 1 D(10^2 ) / 7 = 20 D(10^3 ) / 7 = 300 D(10^4 ) / 7 = 4000 D(10^5 ) / 7 = 50000 D(10^6 ) / 7 = 600000 D(10^7 ) / 7 = 7000000 D(10^8 ) / 7 = 80000000 D(10^9 ) / 7 = 900000000 D(10^10) / 7 = 10000000000 D(10^11) / 7 = 110000000000 D(10^12) / 7 = 1200000000000 D(10^13) / 7 = 13000000000000 D(10^14) / 7 = 140000000000000 D(10^15) / 7 = 1500000000000000 D(10^16) / 7 = 16000000000000000 D(10^17) / 7 = 170000000000000000 D(10^18) / 7 = 1800000000000000000 D(10^19) / 7 = 19000000000000000000 D(10^20) / 7 = 200000000000000000000 </pre> =={{header\|XPL0}}== {{trans\|ALGOL W}} <syntaxhighlight lang "XPL0">function integer Lagarias (N); \Lagarias arithmetic derivative integer N; integer F, Q; function integer SmallPF (J, K); \Smallest prime factor integer J, K; return if rem(J/K) = 0 then K else SmallPF(J, K+1); begin if N < 0 then return -Lagarias (-N) else if N = 0 or N = 1 then return 0 else begin F := SmallPF (N, 2); Q := N / F; return if Q = 1 then 1 else Q * Lagarias (F) + F * Lagarias (Q) end; end \Lagarias\ ; integer N; begin for N:= -99 to 100 do begin IntOut(0, Lagarias(N) ); if rem(N/10) = 0 then CrLf(0) else ChOut(0, 9\tab\); end; end</syntaxhighlight> {{out}} <pre> -75 -77 -1 -272 -24 -49 -34 -96 -20 -123 -1 -140 -32 -45 -22 -124 -1 -43 -108 -176 -1 -71 -18 -80 -55 -39 -1 -156 -1 -59 -26 -72 -1 -61 -18 -192 -51 -33 -1 -92 -1 -31 -22 -92 -16 -81 -1 -56 -20 -45 -14 -112 -1 -25 -39 -48 -1 -41 -1 -68 -16 -21 -1 -60 -12 -19 -14 -80 -1 -31 -1 -32 -27 -15 -10 -44 -1 -13 -10 -24 -1 -21 -1 -32 -8 -9 -1 -16 -1 -7 -6 -12 -1 -5 -1 -4 -1 -1 0 0 0 1 1 4 1 5 1 12 6 7 1 16 1 9 8 32 1 21 1 24 10 13 1 44 10 15 27 32 1 31 1 80 14 19 12 60 1 21 16 68 1 41 1 48 39 25 1 112 14 45 20 56 1 81 16 92 22 31 1 92 1 33 51 192 18 61 1 72 26 59 1 156 1 39 55 80 18 71 1 176 108 43 1 124 22 45 32 140 1 123 20 96 34 49 24 272 1 77 75 140 </pre>