Elixir 1.7

Integer




elixir

Integer

पूर्णांक के साथ काम करने के लिए कार्य।

पूर्णांक पर काम करने वाले कुछ कार्य Kernel में पाए जाते हैं:

सारांश

कार्य

अंक (पूर्णांक, आधार \\ 10)

दिए गए integer लिए दिए गए अंकों को लौटाता है

floor_div (लाभांश, भाजक)

एक पूर्णांक पूर्णांक विभाजन करता है

gcd (पूर्णांक 1, पूर्णांक 2)

दिए गए पूर्णांकों के दो सबसे बड़े सामान्य विभाजक लौटाता है

is_even(integer)

निर्धारित करता है कि एक integer सम है

is_odd(integer)

यह निर्धारित करता है कि integer विषम है या नहीं

आधुनिक (लाभांश, भाजक)

पूर्णांक विभाजन के शेष मॉड्यूल की गणना करता है

पार्स (बाइनरी, आधार \\ 10)

एक पूर्णांक का एक पाठ प्रतिनिधित्व पार्स करता है

to_charlist(integer)

एक चारलिस्ट देता है जो दिए गए integer के पाठ प्रतिनिधित्व से मेल खाती है

to_charlist (पूर्णांक, आधार)

एक चारलिस्ट देता है जो दिए गए base में integer के पाठ प्रतिनिधित्व से मेल खाती है

to_string(integer)

एक बाइनरी लौटाता है जो integer के पाठ प्रतिनिधित्व से मेल खाती है

to_string (पूर्णांक, आधार)

एक बाइनरी लौटाता है जो दिए गए base में integer के पाठ प्रतिनिधित्व से मेल खाती है

अविभाज्य (अंक, आधार \\ 10)

दिए गए digits द्वारा प्रतिनिधित्व पूर्णांक लौटाता है

कार्य

अंक (पूर्णांक, आधार \\ 10)

digits(integer(), pos_integer()) :: [integer(), ...]

दिए गए integer लिए दिए गए अंकों को लौटाता है।

एक वैकल्पिक base मान लौटाए गए अंकों के लिए मूलांक का प्रतिनिधित्व कर सकता है। यह एक पूर्णांक> = 2 होना चाहिए।

उदाहरण

iex> Integer.digits(123)
[1, 2, 3]

iex> Integer.digits(170, 2)
[1, 0, 1, 0, 1, 0, 1, 0]

iex> Integer.digits(-170, 2)
[-1, 0, -1, 0, -1, 0, -1, 0]

floor_div (लाभांश, भाजक) (1.4.0 के बाद से)

floor_div(integer(), neg_integer() | pos_integer()) :: integer()

एक पूर्णांक पूर्णांक विभाजन करता है।

यदि कोई तर्क पूर्णांक नहीं है, या जब divisor 0 है, तो एक ArithmeticError अपवाद को उठाता है।

Integer.floor_div/2 पूर्णांक विभाजन को दर्शाता है । इसका मतलब है कि परिणाम हमेशा नकारात्मक अनंत की ओर गोल होता है।

यदि आप पूर्णांक पूर्णांक विभाजन (शून्य की ओर गोल) करना चाहते हैं, तो इसके स्थान पर div/2 उपयोग करें।

उदाहरण

iex> Integer.floor_div(5, 2)
2
iex> Integer.floor_div(6, -4)
-2
iex> Integer.floor_div(-99, 2)
-50

gcd (पूर्णांक 1, पूर्णांक 2) (1.5.0 से)

gcd(integer(), integer()) :: pos_integer()
gcd(0, 0) :: 0

दिए गए पूर्णांकों के दो सबसे बड़े सामान्य विभाजक लौटाता है।

पूर्णांक integer1 और पूर्णांक 2 का सबसे बड़ा सामान्य भाजक (GCD) सबसे बड़ा धनात्मक पूर्णांक है जो पूर्णांक integer1 और पूर्णांक 2 दोनों को विभाजित करता है, शेष को छोड़े बिना।

सम्मेलन, gcd(0, 0) रिटर्न 0

उदाहरण

iex> Integer.gcd(2, 3)
1

iex> Integer.gcd(8, 12)
4

iex> Integer.gcd(8, -12)
4

iex> Integer.gcd(10, 0)
10

iex> Integer.gcd(7, 7)
7

iex> Integer.gcd(0, 0)
0

is_even (पूर्णांक) (मैक्रो)

निर्धारित करता है कि एक integer सम है।

यदि integer एक सम संख्या है, तो true है, अन्यथा यह false

गार्ड क्लॉस में अनुमति है।

उदाहरण

iex> Integer.is_even(10)
true

iex> Integer.is_even(5)
false

iex> Integer.is_even(-10)
true

iex> Integer.is_even(0)
true

is_odd (पूर्णांक) (मैक्रो)

यह निर्धारित करता है कि integer विषम है या नहीं।

यदि integer एक विषम संख्या है तो true है, अन्यथा यह false

गार्ड क्लॉस में अनुमति है।

उदाहरण

iex> Integer.is_odd(5)
true

iex> Integer.is_odd(6)
false

iex> Integer.is_odd(-5)
true

iex> Integer.is_odd(0)
false

मॉड (लाभांश, भाजक) (1.4.0 से)

mod(integer(), neg_integer() | pos_integer()) :: integer()

पूर्णांक विभाजन के शेष मॉड्यूल की गणना करता है।

Integer.mod/2 फ्लोर्ड डिवीजन का उपयोग करता है, जिसका अर्थ है कि परिणाम में हमेशा divisor का चिह्न होगा।

यदि कोई तर्क पूर्णांक नहीं है, या जब divisor 0 है, तो एक ArithmeticError अपवाद को उठाता है।

उदाहरण

iex> Integer.mod(5, 2)
1
iex> Integer.mod(6, -4)
-2

पार्स (बाइनरी, आधार \\ 10)

parse(binary(), 2..36) :: {integer(), binary()} | :error

एक पूर्णांक का एक पाठ प्रतिनिधित्व पार्स करता है।

संबंधित पूर्णांक के लिए एक वैकल्पिक base प्रदान किया जा सकता है। यदि base नहीं दिया गया है, तो 10 का उपयोग किया जाएगा।

यदि सफल हो, तो {integer, remainder_of_binary} के रूप में एक टपल लौटाता है। अन्यथा :error

यदि base 2 से कम है या 36 से अधिक है, तो एक त्रुटि उठाता है।

यदि आप एक स्ट्रिंग-स्वरूपित पूर्णांक को सीधे पूर्णांक में परिवर्तित करना चाहते हैं, String.to_integer/1 इसके बजाय String.to_integer/1 या String.to_integer/2 का उपयोग किया जा सकता है।

उदाहरण

iex> Integer.parse("34")
{34, ""}

iex> Integer.parse("34.5")
{34, ".5"}

iex> Integer.parse("three")
:error

iex> Integer.parse("34", 10)
{34, ""}

iex> Integer.parse("f4", 16)
{244, ""}

iex> Integer.parse("Awww++", 36)
{509216, "++"}

iex> Integer.parse("fab", 10)
:error

iex> Integer.parse("a2", 38)
** (ArgumentError) invalid base 38

to_charlist (पूर्णांक)

to_charlist(integer()) :: charlist()

एक चारलिस्ट देता है जो दिए गए integer के पाठ प्रतिनिधित्व से मेल खाती है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Integer.to_charlist(123)
'123'

iex> Integer.to_charlist(+456)
'456'

iex> Integer.to_charlist(-789)
'-789'

iex> Integer.to_charlist(0123)
'123'

to_charlist (पूर्णांक, आधार)

to_charlist(integer(), 2..36) :: charlist()

एक चारलिस्ट देता है जो दिए गए base में integer के पाठ प्रतिनिधित्व से मेल खाती है।

base 2 और 36 के बीच पूर्णांक हो सकता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Integer.to_charlist(100, 16)
'64'

iex> Integer.to_charlist(-100, 16)
'-64'

iex> Integer.to_charlist(882_681_651, 36)
'ELIXIR'

to_string (पूर्णांक)

to_string(integer()) :: String.t()

एक बाइनरी लौटाता है जो integer के पाठ प्रतिनिधित्व से मेल खाती है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Integer.to_string(123)
"123"

iex> Integer.to_string(+456)
"456"

iex> Integer.to_string(-789)
"-789"

iex> Integer.to_string(0123)
"123"

to_string (पूर्णांक, आधार)

to_string(integer(), 2..36) :: String.t()

एक बाइनरी लौटाता है जो दिए गए base में integer के पाठ प्रतिनिधित्व से मेल खाती है।

base 2 और 36 के बीच पूर्णांक हो सकता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> Integer.to_string(100, 16)
"64"

iex> Integer.to_string(-100, 16)
"-64"

iex> Integer.to_string(882_681_651, 36)
"ELIXIR"

अविभाज्य (अंक, आधार \\ 10)

undigits([integer()], pos_integer()) :: integer()

दिए गए digits द्वारा प्रतिनिधित्व पूर्णांक लौटाता है।

digits लिए मूलांक का प्रतिनिधित्व करते हुए एक वैकल्पिक base मूल्य प्रदान किया जा सकता है। आधार का पूर्णांक 2 से अधिक या बराबर होना चाहिए।

उदाहरण

iex> Integer.undigits([1, 2, 3])
123

iex> Integer.undigits([1, 4], 16)
20

iex> Integer.undigits([])
0