آی تی پورت

نوع دیگر داده ها در آموزش زبان برنامه نویسی groovy اعداد می باشند. Groovy از انواع مختلف حروف الفبا انتگرالی و حرف های اعشاری پشتیبانی می کند، که توسط انواع typeهای Java پشتیبانی می شود. در جلسه دوم آموزش زبان برنامه نویسی Groovy به مبحث رشته ها و نحوه پیاده سازی آن پرداختیم. در این جلسه ما به معرفی اعداد در این زبان برنامه نویسی پرداخته ایم. با آی تی پورت همراه باشید.

اصطلاحات واقعی

قبلا در آموزش زبان برنامه نویسی groovy خواندیم که انواع داده ها در Groovy همان داده های جاوا هستند:

• byte
• char
• short
• int
• long
• java.lang.BigInteger

می توانید با استفاده از کدهای زیر اعداد صحیح از این نوع را ایجاد کنید:

 

// primitive types
byte  b = 1
char  c = 2
short s = 3
int   i = 4
long  l = 5

// infinite precision
BigInteger bi =  6

اگر با استفاده از کلمه کلیدی def از تایپ اختیاری استفاده کنید، نوع شماره اعداد صحیح متفاوت خواهد بود: یعنی متناسب با ظرفیت نوعی که می تواند آن عدد را نگه دارد، سازگار است.

برای اعداد مثبت:

def a = 1
assert a instanceof Integer

// Integer.MAX_VALUE
def b = 2147483647
assert b instanceof Integer

// Integer.MAX_VALUE + 1
def c = 2147483648
assert c instanceof Long

// Long.MAX_VALUE
def d = 9223372036854775807
assert d instanceof Long

// Long.MAX_VALUE + 1
def e = 9223372036854775808
assert e instanceof BigInteger

و همچنین برای اعداد منفی:

def na = -1
assert na instanceof Integer

// Integer.MIN_VALUE
def nb = -2147483648
assert nb instanceof Integer

// Integer.MIN_VALUE - 1
def nc = -2147483649
assert nc instanceof Long

// Long.MIN_VALUE
def nd = -9223372036854775808
assert nd instanceof Long

// Long.MIN_VALUE - 1
def ne = -9223372036854775809
assert ne instanceof BigInteger

نمایش های غیر پایه ۱۰ جایگزین

همچنین می توان اعداد را در مبنای باینری، هشت هشتی، هگزادسیمال و مبنای اعشاری نشان داد.

اعداد دودویی 

اعداد دودویی با پیشوند ۰b شروع می شوند:

int xInt = 0b10101111
assert xInt == 175

short xShort = 0b11001001
assert xShort == 201 as short

byte xByte = 0b11
assert xByte == 3 as byte

long xLong = 0b101101101101
assert xLong == 2925l

BigInteger xBigInteger = 0b111100100001
assert xBigInteger == 3873g

int xNegativeInt = -0b10101111
assert xNegativeInt == -175

اعداد Octal 

اعداد هشت هشتی در قالب معمولی ۰ و به دنبال آن اعداد مبنای هشت مشخص می شوند.

int xInt = 077
assert xInt == 63

short xShort = 011
assert xShort == 9 as short

byte xByte = 032
assert xByte == 26 as byte

long xLong = 0246
assert xLong == 166l

BigInteger xBigInteger = 01111
assert xBigInteger == 585g

int xNegativeInt = -077
assert xNegativeInt == -63

اعداد هگزادسیمال 

اعداد هگزادسیمال در قالب معمولی ۰x و به دنبال آن رقم hex مشخص می شود.

int xInt = 0x77
assert xInt == 119

short xShort = 0xaa
assert xShort == 170 as short

byte xByte = 0x3a
assert xByte == 58 as byte

long xLong = 0xffff
assert xLong == 65535l

BigInteger xBigInteger = 0xaaaa
assert xBigInteger == 43690g

Double xDouble = new Double('0x1.0p0')
assert xDouble == 1.0d

int xNegativeInt = -0x77
assert xNegativeInt == -119

اعداد اعشاری

در این قسمت از آموزش زبان برنامه نویسی groovy تهیه شده توسط آی تی پورت به اعداد اعشاری می پردازیم. انواع اعداد اعشاری در Groovy همان اعداد اعشاری در جاوا هستند:

• float
• double
• java.lang.BigDecimal

با کد های زیر می توانید اعداد اعشاری از این نوع را ایجاد کنید:

// primitive types
float  f = 1.234
double d = 2.345

// infinite precision
BigDecimal bd =  3.456

اعشار می توانند از نمادهای e یا E و به دنبال یک علامت اختیاری، و یک عدد که نشان دهنده توان است استفاده کنند:

assert 1e3  ==  1_000.0
assert 2E4  == 20_000.0
assert 3e+1 ==     30.0
assert 4E-2 ==      0.04
assert 5e-1 ==      0.5

برای محاسبات دقیق عدد اعشاری، Groovy java.lang.BigDecimal را به عنوان عملگر عدد اعشاری انتخاب می کند. علاوه بر این، float و double هم پشتیبانی می شوند، اما به یک نوع اعلان صریح یا پسوند نیاز دارند. حتی اگر BigDecimal برای اعداد اعشاری بعنوان پیش فرض در نظر بگیریم، float یا double به عنوان انواع پارامتر پذیرفته می شوند.

اعداد اعشاری را نمی توان با استفاده از یک نمایش دودویی، هشت و یا هگزادسیمال نشان داد.

بیان اختصار در حروف 

در آموزش زبان برنامه نویسی groovy فهمیدیم که هنگام نوشتن اعداد لغوی طولانی، دشوار است که بفهمید چگونه برخی از اعداد با هم گروه می شوند.

long creditCardNumber = 1234_5678_9012_3456L
long socialSecurityNumbers = 999_99_9999L
double monetaryAmount = 12_345_132.12
long hexBytes = 0xFF_EC_DE_5E
long hexWords = 0xFFEC_DE5E
long maxLong = 0x7fff_ffff_ffff_ffffL
long alsoMaxLong = 9_223_372_036_854_775_807L
long bytes = 0b11010010_01101001_10010100_10010010

پسوندهای نوع عدد

این بخش از آموزش زبان برنامه نویسی groovy به پسوندها اختصاص دارد. با دادن پسوند (به جدول زیر مراجعه کنید)، می توان یک عدد (از جمله باینری، هشت هشتی و هگزادسیمال) را مجبور کرد که نوع خاصی داشته باشد (به بزرگ یا کوچک بودن حروف توجه کنید).

مثال

assert 42I == new Integer('42')
assert 42i == new Integer('42') // lowercase i more readable
assert 123L == new Long("123") // uppercase L more readable
assert 2147483648 == new Long('2147483648') // Long type used, value too large for an Integer
assert 456G == new BigInteger('456')
assert 456g == new BigInteger('456')
assert 123.45 == new BigDecimal('123.45') // default BigDecimal type used
assert 1.200065D == new Double('1.200065')
assert 1.234F == new Float('1.234')
assert 1.23E23D == new Double('1.23E23')
assert 0b1111L.class == Long // binary
assert 0xFFi.class == Integer // hexadecimal
assert 034G.class == BigInteger // octal

عملیات ریاضی

اگرچه در آموزش زبان برنامه نویسی groovy دیدیم که عملگرها تحت پوشش Groovy قرار دارند، اما بحث در مورد رفتار عملیات ریاضی و اینکه انواع مختلف آنها چیست، نیز مهم است.

عملیات باینری تقسیم و تجمیع (که در زیر آورده شده است)،

عملیات دودویی بین بایت ها، char، short و int خروجی آن منجر به int می شود.

عملیات دودویی شامل طولانی با بایت، char، کوتاه و int خروجی آن منجر به long می شود.

عملیات باینری شامل BigInteger و هر نوع عدد صحیح دیگر خروجی آن منجر به BigInteger می شود.

عملیات دودویی شامل BigDecimal با بایت، char، short، int و BigInteger خروجی آن منجر به BigDecimal می شود.

عملیات باینری بین float، double و BigDecimal خروجی آن منجر به double می شود.

عملیات دودویی بین دو BigDecimal خروجی آن منجر به BigDecimal می شود.

جدول زیر خلاصه ای از این قوانین است:

عملگرهای تقسیم

عملگرهای تقسیم / (و / = برای تقسیم و تخصیص) اگر عملوند float یا double باشد، نتیجه ای double ایجاد می کنند و اگر هر دو عملوند ترکیبی از short, char, byte, int, long, BigInteger or BigDecimal باشند نتیجه BigDecimal خواهد بود.

اگر تقسیم دقیق باشد، تقسیم BigDecimal با متد divide()  انجام می شود (یعنی نتیجه را می توان در همان دقت و مقیاس نشان داد)، یا با استفاده از MathContext با حداکثر دقت دو رقم اعشار رسید.

برای تقسیم عدد صحیح مانند جاوا، باید از متد ()intdiv استفاده کنید، زیرا Groovy نماد عملگر تقسیم عدد صحیح را پشتیبانی نمی کند.

عملگرهای تجمیع

در آموزش زبان برنامه نویسی groovy دیدیم که عملکرد تجمیع توسط عملگر ** نشان داده می شود، با دو پارامتر: پایه و نماد. نتیجه عملکرد تجمیع به عامل های آن و نتیجه عمل بستگی دارد (به ویژه اگر نتیجه را بتوان به عنوان یک مقدار صحیح نشان داد).

برای تعیین نوع حاصل، قوانین زیر توسط عملیات Groovy استفاده می شود:

اگر بازه مقدار اعشاری باشد:

اگر می توان نتیجه را به عنوان یک Integer نشان داد، یک Integer را بازگردانید.

اگر نتیجه را می توان به صورت Long نشان داد، یک Long را بازگردانید، در غیر این صورت Double برگردانید.

اگر توان یک مقدار صحیح است:

اگر نما منفی است، پس، یک عدد Integer, Long or Double را بازگردانید.

اگر نما مثبت یا صفر باشد:

اگر پایه BigDecimal است، مقدار نتیجه BigDecimal را بازگردانید.

اگر پایه BigInteger است، مقدار نتیجه BigInteger را بازگردانید.

اگر پایه یک عدد Integer است، و مقدار آن در نتیجه قرار می گیرد، یک عدد Integer را برگردانید، در غیر اینصورت یک BigInteger بازگردانده می شود.

اگر پایه Long است، و در مقدار نتیجه قرار می گیرد، Long را بازگردانید، در غیر این صورت BigInteger

می توان این قوانین را با چند مثال نشان داد:

// base and exponent are ints and the result can be represented by an Integer
assert    2    **   3    instanceof Integer    //  8
assert   10    **   9    instanceof Integer    //  1_000_000_000

// the base is a long, so fit the result in a Long
// (although it could have fit in an Integer)
assert    5L   **   2    instanceof Long       //  25

// the result can't be represented as an Integer or Long, so return a BigInteger
assert  100    **  10    instanceof BigInteger //  10e20
assert 1234    ** 123    instanceof BigInteger //  170515806212727042875...

// the base is a BigDecimal and the exponent a negative int
// but the result can be represented as an Integer
assert    0.5  **  -2    instanceof Integer    //  4

// the base is an int, and the exponent a negative float
// but again, the result can be represented as an Integer
assert    1    **  -0.3f instanceof Integer    //  1

// the base is an int, and the exponent a negative int
// but the result will be calculated as a Double
// (both base and exponent are actually converted to doubles)
assert   10    **  -1    instanceof Double     //  0.1

// the base is a BigDecimal, and the exponent is an int, so return a BigDecimal
assert    1.2  **  10    instanceof BigDecimal //  6.1917364224

// the base is a float or double, and the exponent is an int
// but the result can only be represented as a Double value
assert    3.4f **   5    instanceof Double     //  454.35430372146965
assert    5.6d **   2    instanceof Double     //  31.359999999999996

// the exponent is a decimal value
// and the result can only be represented as a Double value
assert    7.8  **   1.9  instanceof Double     //  49.542708423868476
assert    2    **   0.1f instanceof Double     //  1.0717734636432956