locutus 2.0.32 → 2.0.34

package/python/math/index.js

@@ -0,0 +1,15 @@
+module.exports.ceil = require('./ceil')
+module.exports.exp = require('./exp')
+module.exports.fabs = require('./fabs')
+module.exports.factorial = require('./factorial')
+module.exports.floor = require('./floor')
+module.exports.gcd = require('./gcd')
+module.exports.isfinite = require('./isfinite')
+module.exports.isinf = require('./isinf')
+module.exports.isnan = require('./isnan')
+module.exports.log = require('./log')
+module.exports.log10 = require('./log10')
+module.exports.log2 = require('./log2')
+module.exports.pow = require('./pow')
+module.exports.sqrt = require('./sqrt')
+module.exports.trunc = require('./trunc')

package/python/math/isfinite.js

@@ -0,0 +1,14 @@
+module.exports = function isfinite(x) {
+  //      discuss at: https://locutus.io/python/isfinite/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns True if x is neither infinity nor NaN
+  //       example 1: isfinite(42)
+  //       returns 1: true
+  //       example 2: isfinite(Infinity)
+  //       returns 2: false
+  //       example 3: isfinite(NaN)
+  //       returns 3: false
+
+  return Number.isFinite(x)
+}

package/python/math/isinf.js

@@ -0,0 +1,14 @@
+module.exports = function isinf(x) {
+  //      discuss at: https://locutus.io/python/isinf/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns True if x is positive or negative infinity
+  //       example 1: isinf(Infinity)
+  //       returns 1: true
+  //       example 2: isinf(-Infinity)
+  //       returns 2: true
+  //       example 3: isinf(42)
+  //       returns 3: false
+
+  return x === Infinity || x === -Infinity
+}

package/python/math/isnan.js

@@ -0,0 +1,14 @@
+module.exports = function isnan(x) {
+  //      discuss at: https://locutus.io/python/isnan/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns True if x is NaN (Not a Number)
+  //       example 1: isnan(NaN)
+  //       returns 1: true
+  //       example 2: isnan(42)
+  //       returns 2: false
+  //       example 3: isnan(Infinity)
+  //       returns 3: false
+
+  return Number.isNaN(x)
+}

package/python/math/log.js

@@ -0,0 +1,16 @@
+module.exports = function log(x, base) {
+  //      discuss at: https://locutus.io/python/log/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the natural logarithm of x (base e)
+  //          note 2: If base is provided, returns log(x) / log(base)
+  //       example 1: log(1)
+  //       returns 1: 0
+  //       example 2: log(2.718281828459045)
+  //       returns 2: 1
+
+  if (base === undefined) {
+    return Math.log(x)
+  }
+  return Math.log(x) / Math.log(base)
+}

package/python/math/log10.js

@@ -0,0 +1,14 @@
+module.exports = function log10(x) {
+  //      discuss at: https://locutus.io/python/log10/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the base-10 logarithm of x
+  //       example 1: log10(1)
+  //       returns 1: 0
+  //       example 2: log10(10)
+  //       returns 2: 1
+  //       example 3: log10(100)
+  //       returns 3: 2
+
+  return Math.log10(x)
+}

package/python/math/log2.js

@@ -0,0 +1,14 @@
+module.exports = function log2(x) {
+  //      discuss at: https://locutus.io/python/log2/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the base-2 logarithm of x
+  //       example 1: log2(1)
+  //       returns 1: 0
+  //       example 2: log2(2)
+  //       returns 2: 1
+  //       example 3: log2(8)
+  //       returns 3: 3
+
+  return Math.log2(x)
+}

package/python/math/pow.js

@@ -0,0 +1,14 @@
+module.exports = function pow(x, y) {
+  //      discuss at: https://locutus.io/python/pow/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns x raised to the power y
+  //       example 1: pow(2, 10)
+  //       returns 1: 1024
+  //       example 2: pow(2.5, 2)
+  //       returns 2: 6.25
+  //       example 3: pow(2, -1)
+  //       returns 3: 0.5
+
+  return Math.pow(x, y)
+}

package/python/math/sqrt.js

@@ -0,0 +1,14 @@
+module.exports = function sqrt(x) {
+  //      discuss at: https://locutus.io/python/sqrt/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the square root of x
+  //       example 1: sqrt(4)
+  //       returns 1: 2
+  //       example 2: sqrt(2)
+  //       returns 2: 1.4142135623730951
+  //       example 3: sqrt(0)
+  //       returns 3: 0
+
+  return Math.sqrt(x)
+}

package/python/math/trunc.js

@@ -0,0 +1,14 @@
+module.exports = function trunc(x) {
+  //      discuss at: https://locutus.io/python/trunc/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the integer part of x, removing the decimal part
+  //       example 1: trunc(3.7)
+  //       returns 1: 3
+  //       example 2: trunc(-3.7)
+  //       returns 2: -3
+  //       example 3: trunc(5)
+  //       returns 3: 5
+
+  return Math.trunc(x)
+}

package/python/string/ascii_letters.js

@@ -1,17 +1,17 @@
-'use strict';
-
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
-
 module.exports = function ascii_letters() {
-  //   original by: Yury Shapkarin (https://shapkarin.me)
-  //   example 1: ascii_letters()
-  //   returns 1: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  // parity verified: Python 3.12
+  //     original by: Yury Shapkarin (https://shapkarin.me)
+  //       example 1: ascii_letters()
+  //       returns 1: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
 
-  var length = 26;
-  var i = 65;
+  const length = 26
+  let i = 65
 
-  return [].concat(_toConsumableArray(Array(length + 6 + length))).reduce(function (accumulator) {
-    return accumulator + String.fromCharCode(i++);
-  }, '').match(/[a-zA-Z]+/g).reverse().join('');
-};
-//# sourceMappingURL=ascii_letters.js.map
+  return [...new Array(length + 6 + length)]
+    .reduce(function (accumulator) {
+      return accumulator + String.fromCharCode(i++)
+    }, '')
+    .match(/[a-zA-Z]+/g)
+    .reverse()
+    .join('')
+}

package/python/string/ascii_lowercase.js

@@ -1,17 +1,13 @@
-'use strict';
-
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
-
 module.exports = function ascii_lowercase() {
-  //   original by: Yury Shapkarin (https://shapkarin.me)
-  //   example 1: ascii_lowercase()
-  //   returns 1: 'abcdefghijklmnopqrstuvwxyz'
-
-  var length = 26;
-  var i = 65 + length + 6;
-
-  return [].concat(_toConsumableArray(Array(length))).reduce(function (accumulator) {
-    return accumulator + String.fromCharCode(i++);
-  }, '');
-};
-//# sourceMappingURL=ascii_lowercase.js.map
+  // parity verified: Python 3.12
+  //     original by: Yury Shapkarin (https://shapkarin.me)
+  //       example 1: ascii_lowercase()
+  //       returns 1: 'abcdefghijklmnopqrstuvwxyz'
+
+  const length = 26
+  let i = 65 + length + 6
+
+  return [...new Array(length)].reduce(function (accumulator) {
+    return accumulator + String.fromCharCode(i++)
+  }, '')
+}

package/python/string/ascii_uppercase.js

@@ -1,17 +1,13 @@
-'use strict';
-
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
-
 module.exports = function ascii_uppercase() {
-  //   original by: Yury Shapkarin (https://shapkarin.me)
-  //   example 1: ascii_uppercase()
-  //   returns 1: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-
-  var length = 26;
-  var i = 65;
-
-  return [].concat(_toConsumableArray(Array(length))).reduce(function (accumulator) {
-    return accumulator + String.fromCharCode(i++);
-  }, '');
-};
-//# sourceMappingURL=ascii_uppercase.js.map
+  // parity verified: Python 3.12
+  //     original by: Yury Shapkarin (https://shapkarin.me)
+  //       example 1: ascii_uppercase()
+  //       returns 1: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+  const length = 26
+  let i = 65
+
+  return [...new Array(length)].reduce(function (accumulator) {
+    return accumulator + String.fromCharCode(i++)
+  }, '')
+}

package/python/string/capwords.js

@@ -1,5 +1,3 @@
-'use strict';
-
 module.exports = function capwords(str) {
   //  discuss at: https://locutus.io/python/capwords/
   // original by: Jonas Raoni Soares Silva (https://www.jsfromhell.com)
@@ -13,9 +11,8 @@ module.exports = function capwords(str) {
   //   example 2: capwords('HELLO WORLD')
   //   returns 2: 'HELLO WORLD'
 
-  var pattern = /^([a-z\u00E0-\u00FC])|\s+([a-z\u00E0-\u00FC])/g;
+  const pattern = /^([a-z\u00E0-\u00FC])|\s+([a-z\u00E0-\u00FC])/g
   return (str + '').replace(pattern, function ($1) {
-    return $1.toUpperCase();
-  });
-};
-//# sourceMappingURL=capwords.js.map
+    return $1.toUpperCase()
+  })
+}

package/python/string/digits.js

@@ -0,0 +1,10 @@
+module.exports = function digits() {
+  //      discuss at: https://locutus.io/python/digits/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the string '0123456789'
+  //       example 1: digits()
+  //       returns 1: '0123456789'
+
+  return '0123456789'
+}

package/python/string/hexdigits.js

@@ -0,0 +1,10 @@
+module.exports = function hexdigits() {
+  //      discuss at: https://locutus.io/python/hexdigits/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the string '0123456789abcdefABCDEF'
+  //       example 1: hexdigits()
+  //       returns 1: '0123456789abcdefABCDEF'
+
+  return '0123456789abcdefABCDEF'
+}

package/python/string/index.js

@@ -1,8 +1,10 @@
-'use strict';
-
-module.exports.ascii_letters = require('./ascii_letters');
-module.exports.ascii_lowercase = require('./ascii_lowercase');
-module.exports.ascii_uppercase = require('./ascii_uppercase');
-module.exports.capwords = require('./capwords');
-module.exports.punctuation = require('./punctuation');
-//# sourceMappingURL=index.js.map
+module.exports.ascii_letters = require('./ascii_letters')
+module.exports.ascii_lowercase = require('./ascii_lowercase')
+module.exports.ascii_uppercase = require('./ascii_uppercase')
+module.exports.capwords = require('./capwords')
+module.exports.digits = require('./digits')
+module.exports.hexdigits = require('./hexdigits')
+module.exports.octdigits = require('./octdigits')
+module.exports.printable = require('./printable')
+module.exports.punctuation = require('./punctuation')
+module.exports.whitespace = require('./whitespace')

package/python/string/octdigits.js

@@ -0,0 +1,10 @@
+module.exports = function octdigits() {
+  //      discuss at: https://locutus.io/python/octdigits/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the string '01234567'
+  //       example 1: octdigits()
+  //       returns 1: '01234567'
+
+  return '01234567'
+}

package/python/string/printable.js

@@ -0,0 +1,15 @@
+module.exports = function printable() {
+  //  discuss at: https://locutus.io/python/printable/
+  // original by: Kevin van Zonneveld (https://kvz.io)
+  //      note 1: Combination of digits, ascii_letters, punctuation, and whitespace
+  //   example 1: printable().length
+  //   returns 1: 100
+
+  const digits = '0123456789'
+  const asciiLowercase = 'abcdefghijklmnopqrstuvwxyz'
+  const asciiUppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  const punctuation = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
+  const whitespace = ' \t\n\r\x0b\x0c'
+
+  return digits + asciiLowercase + asciiUppercase + punctuation + whitespace
+}

package/python/string/punctuation.js

@@ -1,10 +1,8 @@
-'use strict';
-
 module.exports = function punctuation() {
+  // parity verified: Python 3.12
   // Original by: Clari (https://github.com/Clari-7744)
-  //   example 1: punctuation()
-  //   returns 1: "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
+  //       example 1: punctuation()
+  //       returns 1: "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
 
-  return '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
-};
-//# sourceMappingURL=punctuation.js.map
+  return '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
+}

package/python/string/whitespace.js

@@ -0,0 +1,10 @@
+module.exports = function whitespace() {
+  //      discuss at: https://locutus.io/python/whitespace/
+  // parity verified: Python 3.12
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns whitespace characters: space, tab, newline, return, formfeed, vertical tab
+  //       example 1: whitespace()
+  //       returns 1: ' \t\n\r\x0b\x0c'
+
+  return ' \t\n\r\x0b\x0c'
+}

package/r/base/abs.js

@@ -0,0 +1,13 @@
+module.exports = function abs(x) {
+  //      discuss at: https://locutus.io/r/abs/
+  // parity verified: R 4.4
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: abs(-5)
+  //       returns 1: 5
+  //       example 2: abs(3.14)
+  //       returns 2: 3.14
+  //       example 3: abs(0)
+  //       returns 3: 0
+
+  return Math.abs(x)
+}

package/r/base/ceiling.js

@@ -0,0 +1,16 @@
+module.exports = function ceiling(x) {
+  //      discuss at: https://locutus.io/r/ceiling/
+  // parity verified: R 4.4
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the smallest integer >= x
+  //       example 1: ceiling(4.2)
+  //       returns 1: 5
+  //       example 2: ceiling(-0.5)
+  //       returns 2: 0
+  //       example 3: ceiling(3)
+  //       returns 3: 3
+
+  const result = Math.ceil(x)
+  // Convert -0 to 0 for consistency
+  return Object.is(result, -0) ? 0 : result
+}

package/r/base/floor.js

@@ -0,0 +1,14 @@
+module.exports = function floor(x) {
+  //      discuss at: https://locutus.io/r/floor/
+  // parity verified: R 4.4
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the largest integer <= x
+  //       example 1: floor(4.7)
+  //       returns 1: 4
+  //       example 2: floor(-0.5)
+  //       returns 2: -1
+  //       example 3: floor(3)
+  //       returns 3: 3
+
+  return Math.floor(x)
+}

package/r/base/index.js

@@ -0,0 +1,3 @@
+module.exports.abs = require('./abs')
+module.exports.ceiling = require('./ceiling')
+module.exports.floor = require('./floor')

package/ruby/Array/compact.js

@@ -0,0 +1,18 @@
+module.exports = function compact(arr) {
+  // parity verified: Ruby 3.3
+  //      discuss at: https://locutus.io/ruby/Array/compact/
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns a new array with all nil (null/undefined) values removed.
+  //       example 1: compact(['a', null, 'b', undefined, 'c'])
+  //       returns 1: ['a', 'b', 'c']
+  //       example 2: compact([1, 2, 3])
+  //       returns 2: [1, 2, 3]
+
+  if (!Array.isArray(arr)) {
+    return []
+  }
+
+  return arr.filter(function (item) {
+    return item != null
+  })
+}

package/ruby/Array/first.js

@@ -0,0 +1,22 @@
+module.exports = function first(arr, n) {
+  // parity verified: Ruby 3.3
+  //      discuss at: https://locutus.io/ruby/Array/first/
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the first element, or the first n elements, of the array.
+  //       example 1: first(['a', 'b', 'c'])
+  //       returns 1: 'a'
+  //       example 2: first(['a', 'b', 'c'], 2)
+  //       returns 2: ['a', 'b']
+  //       example 3: first([])
+  //       returns 3: undefined
+
+  if (!Array.isArray(arr)) {
+    return undefined
+  }
+
+  if (n === undefined) {
+    return arr[0]
+  }
+
+  return arr.slice(0, n)
+}

package/ruby/Array/flatten.js

@@ -0,0 +1,22 @@
+module.exports = function flatten(arr, depth) {
+  // parity verified: Ruby 3.3
+  //      discuss at: https://locutus.io/ruby/Array/flatten/
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns a new array that is a one-dimensional flattening of the array.
+  //       example 1: flatten([1, [2, 3, [4, 5]]])
+  //       returns 1: [1, 2, 3, 4, 5]
+  //       example 2: flatten([1, [2, [3, [4]]]], 1)
+  //       returns 2: [1, 2, [3, [4]]]
+  //       example 3: flatten([[1, 2], [3, 4]])
+  //       returns 3: [1, 2, 3, 4]
+
+  if (!Array.isArray(arr)) {
+    return []
+  }
+
+  if (depth === undefined) {
+    depth = Infinity
+  }
+
+  return arr.flat(depth)
+}

package/ruby/Array/index.js

@@ -0,0 +1,6 @@
+module.exports.compact = require('./compact')
+module.exports.first = require('./first')
+module.exports.flatten = require('./flatten')
+module.exports.last = require('./last')
+module.exports.sample = require('./sample')
+module.exports.uniq = require('./uniq')

package/ruby/Array/last.js

@@ -0,0 +1,22 @@
+module.exports = function last(arr, n) {
+  // parity verified: Ruby 3.3
+  //      discuss at: https://locutus.io/ruby/Array/last/
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns the last element, or the last n elements, of the array.
+  //       example 1: last(['a', 'b', 'c'])
+  //       returns 1: 'c'
+  //       example 2: last(['a', 'b', 'c'], 2)
+  //       returns 2: ['b', 'c']
+  //       example 3: last([])
+  //       returns 3: undefined
+
+  if (!Array.isArray(arr)) {
+    return undefined
+  }
+
+  if (n === undefined) {
+    return arr[arr.length - 1]
+  }
+
+  return arr.slice(-n)
+}

package/ruby/Array/sample.js

@@ -0,0 +1,31 @@
+module.exports = function sample(arr, n) {
+  //  discuss at: https://locutus.io/ruby/Array/sample/
+  // original by: Kevin van Zonneveld (https://kvz.io)
+  //      note 1: Returns a random element, or n random elements, from the array.
+  //      note 1: Uses Math.random() for randomness.
+  //   example 1: [1, 2, 3].indexOf(sample([1, 2, 3])) !== -1
+  //   returns 1: true
+  //   example 2: sample([1, 2, 3], 2).length
+  //   returns 2: 2
+
+  if (!Array.isArray(arr) || arr.length === 0) {
+    return n === undefined ? undefined : []
+  }
+
+  if (n === undefined) {
+    return arr[Math.floor(Math.random() * arr.length)]
+  }
+
+  // Fisher-Yates shuffle for selecting n unique elements
+  const copy = arr.slice()
+  const result = []
+  const count = Math.min(n, copy.length)
+
+  for (let i = 0; i < count; i++) {
+    const idx = Math.floor(Math.random() * copy.length)
+    result.push(copy[idx])
+    copy.splice(idx, 1)
+  }
+
+  return result
+}

package/ruby/Array/uniq.js

@@ -0,0 +1,16 @@
+module.exports = function uniq(arr) {
+  // parity verified: Ruby 3.3
+  //      discuss at: https://locutus.io/ruby/Array/uniq/
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns a new array with duplicate values removed.
+  //       example 1: uniq([1, 2, 2, 3, 3, 3])
+  //       returns 1: [1, 2, 3]
+  //       example 2: uniq(['a', 'b', 'a', 'c', 'b'])
+  //       returns 2: ['a', 'b', 'c']
+
+  if (!Array.isArray(arr)) {
+    return []
+  }
+
+  return [...new Set(arr)]
+}

package/ruby/Math/acos.js

@@ -1,5 +1,3 @@
-"use strict";
-
 module.exports = function acos(arg) {
   //  discuss at: https://locutus.io/ruby/Math/acos/
   // original by: Onno Marsman (https://twitter.com/onnomarsman)
@@ -8,6 +6,5 @@ module.exports = function acos(arg) {
   //   example 1: (acos(0.3) + '').substr(0, 17)
   //   returns 1: '1.266103672779499'
 
-  return Math.acos(arg);
-};
-//# sourceMappingURL=acos.js.map
+  return Math.acos(arg)
+}

package/ruby/Math/asin.js

@@ -0,0 +1,11 @@
+module.exports = function asin(x) {
+  //      discuss at: https://locutus.io/ruby/Math/asin/
+  // parity verified: Ruby 3.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: asin(0)
+  //       returns 1: 0
+  //       example 2: asin(1)
+  //       returns 2: 1.5707963267948966
+
+  return Math.asin(x)
+}

package/ruby/Math/atan.js

@@ -0,0 +1,11 @@
+module.exports = function atan(x) {
+  //      discuss at: https://locutus.io/ruby/Math/atan/
+  // parity verified: Ruby 3.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: atan(0)
+  //       returns 1: 0
+  //       example 2: atan(1)
+  //       returns 2: 0.7853981633974483
+
+  return Math.atan(x)
+}

package/ruby/Math/cbrt.js

@@ -0,0 +1,13 @@
+module.exports = function cbrt(x) {
+  //      discuss at: https://locutus.io/ruby/Math/cbrt/
+  // parity verified: Ruby 3.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: cbrt(8)
+  //       returns 1: 2
+  //       example 2: cbrt(27)
+  //       returns 2: 3
+  //       example 3: cbrt(1)
+  //       returns 3: 1
+
+  return Math.cbrt(x)
+}

package/ruby/Math/cos.js

@@ -0,0 +1,12 @@
+module.exports = function cos(x) {
+  //      discuss at: https://locutus.io/ruby/Math/cos/
+  // parity verified: Ruby 3.3
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Precision may vary across platforms
+  //       example 1: cos(0)
+  //       returns 1: 1
+  //       example 2: cos(1)
+  //       returns 2: 0.5403023058681398
+
+  return Math.cos(x)
+}