# Converting to size units – our solution and the winner

The task was to convert a number to the size units without using the built-in multipliers. Thank you all for taking the time to participate in this teaser.

Now, let’s present the solution we had in mind. Starting with PowerShell 3.0, we now have two new bitwise arithmetic operators: shift-left (*shl*) and shift-right (*shr*). You can read more about them in the about_Comparison_Operators help topic.

The solution to this teaser is using the *shift-right* operator to convert the value of given number (representing a value in bytes).

Generally speaking, shifting right a number divides it by 2 and rounds the number down. Each division takes the result of the last operation and divides it again by 2.

```
PS> 100 -shr 1
50
PS> 100 -shr 2
25
PS> 100 -shr 3
12
```

Now, let’s take the value of 1KB: 1024. To get to 1024 we need to raise 2 in the power of 10. For 1MB (1048576), we need to raise it in the power of 20. 30 for *1GB*, 40 for *1PB* and so on and so forth.

```
PS> [math]::Pow(2,10)
1024
PS> [math]::Pow(2,20)
1048576
PS> [math]::Pow(2,30)
1073741824
```

We can use the values 10, 20, 30… and shift-right by them to get the corresponding unit sizes in *KB, MB, GB…*. We will use the value of 13947906293.76 (that’s 12.99GB, actually).

```
$value = 13947906293.76
# get the value in KB
PS> $value -shr 10
13621002
# get the value in MB
PS> $value -shr 20
13301
# get the value in GB
PS> $value -shr 30
12
```

If you happen to manage Exchange 2007/2010 you are probably familiar with the size formatting *ToKB/ToMB/ToGB/ToTB* methods. Actually I owe the idea for this teaser to the Exchange team–they calculate the requested size by shifting right the value.

The formatting methods are available on *ByteQuantifiedSize* objects (*[Microsoft.Exchange.Data.ByteQuantifiedSize]*).

Here’s a list of *ByteQuantifiedSize* properties of a Mailbox object:

```
(Get-Mailbox shay).PSObject.Properties |
Where-Object {$_.TypeNameOfValue -like "*ByteQuantifiedSize*"} |
Format-Table name
Name
----
ProhibitSendQuota
ProhibitSendReceiveQuota
RecoverableItemsQuota
RecoverableItemsWarningQuota
IssueWarningQuota
RulesQuota
ArchiveQuota
ArchiveWarningQuota
MaxSendSize
MaxReceiveSize
```

To format the size of *ByteQuantifiedSize* property, you refer to its *Value* property and then to one of the above methods:

```
PS> $mbx.ArchiveQuota
IsUnlimited Value
----------- -----
False 50 GB (53,687,091,200 bytes)
PS> $mbx.ArchiveQuota.Value | Get-Member
TypeName: Microsoft.Exchange.Data.ByteQuantifiedSize
Name MemberType Definition
---- ---------- ----------
CompareTo Method int CompareTo(Microsoft.Exchange.Data.ByteQuantifiedSize other), int IComparable.CompareTo(...
Equals Method bool Equals(System.Object obj), bool Equals(Microsoft.Exchange.Data.ByteQuantifiedSize other)
GetHashCode Method int GetHashCode()
GetType Method type GetType()
RoundUpToUnit Method uint64 RoundUpToUnit(Microsoft.Exchange.Data.ByteQuantifiedSize+Quantifier quantifier)
ToBytes Method uint64 ToBytes()
ToGB Method uint64 ToGB()
ToKB Method uint64 ToKB()
ToMB Method uint64 ToMB()
ToString Method string ToString(), string ToString(string format), string ToString(string format, System.IF...
ToTB Method uint64 ToTB()
PS> $mbx.ArchiveQuota.Value.ToGB()
50
```

Now to the prize. Congratulations Jaap Brasser and Rob Campbell, you get to take with you a copy of the Windows Server 2012 Automation with PowerShell Cookbook eBook. We would like to thank again Packt Publishing for the eBooks.

Jaap and Rob, in the best commmunity spirit, came up with the solution that was the shortest one that returns the right results for all five supported unit sizes:

PS> $s = 12345678964561111 PS> 1..5|%{[long](($s/=1024)-.5)} 12056327113829 11773756947 11497809 11228 10

Let’s rewrite our solution in the same manner:

PS> 1..5|%{$s -shr 10*$_}

Amazingly, we can even remove all spaces, and it’ll still work:

PS> 1..5|%{$s-shr10*$_}

See you in the next brainteaser. 🙂