Creating User-Defined Types.

Well I had a thread going that branched out to this topic, so rather completely veering off the main topic there, I felt creating a new thread was adequate.

So as the title says, I'm trying to create a user-defined type. It's not a simple type at that but a user here had showed me a way to fix all my problems. That was to create a type BigDecimal. Which my initial thought was to utilize the BigInteger type. Being that the Integer Part, and Fractional parts would be split off into two variables, both BigIntegers. Which would be combined at the end as a "decimal". However I have many many questions see that this is my first attempt at truly creating a type of my own. So as of right now I'm basically swinging in the dark here.


My first concert was assigning the variable. For example if I had...

vbnet Code:

Dim BigDec As BigDecimal = 1000285.00001883

I'm not at all sure of how to accomplish this. I feel it must be in a string format first, split by the decimal point, then split of both sides accordingly..

But truly I'm pretty confused here. Any information or pointers to creating user-defined types of this stature would be extremely helpful.

I also have googled up some information on User-Defined types, but nothing has been what I'm looking for. I did learn a lot however just everything I could find out there wasn't "advanced" but more or less the basic stuff that I could've done myself.

Hi Daves,

It's a good idea to start a new thread on this, but I think your thread title may be misleading. A "user-defined type" could be any Class, Structure, Interface, Enum etc. you define yourself. I know from the last thread that you want to make a BigDecimal type, and it's logical to make that a structure. After all BigIntegers are structures (and if I remember correctly so are Doubles, Decimals and a load of other types in the .Net framework).

A Structure can look very much like a class. It can have Variables, Constants, Properties, a Sub New, other Subs and Functions and so on. The main difference is that a structure is a Value type, while a class is a Reference type.

I'll give you a slightly more detailed quick sketch of my idea of a BigDecimal structure, but please note that I haven't tried it. It could be rubbish and I'm sure it will end up being at least 10 times as long. I certainly wouldn't waste any more time on it without Googling for bigdecimal (which I know will yield some relevant hits) and taking a good look at what other people have done.

vb Code:

Public Structure BigDecimal
    Public MultipliedValue As BigInteger
    Public Shared Property Multiplier As Integer
 
    Public Overrides Function ToString() As String
        Dim str As String = MultipliedValue.ToString
        Return str.Insert(MultipliedValue.Length - Multiplier, ".")
    End Function
 
    Public Function Multiply(bd As BigDecimal) As BigDecimal
        Dim output As BigDecimal
        output.MultipliedValue = Me.MultipliedValue * bd.MultipliedValue / Multiplier
        Return output
    End Function
 
    Public Function Divide(divisor As BigDecimal) As BigDecimal
         'and so on
    End Function
 
End Structure

BB

Also look into overloading the +-*/ and \ operators so that you can use your type in normal equations. You might also want to be able to use them with other numeric types, so there could be a few overloads for you, but it will make for a much more versatile type.

Well this is what I've had so far, since yesterday when I originally posted this. Don't mind some of it though, I'm still experimenting. :)

vbnet Code:

Public Structure BigDecimal
 
            Dim IntegerPart As BigInteger
            Dim FractionalPart As BigInteger
 
 
            Sub New(ByVal value As BigDecimal)
                Me.IntegerPart = value.IntegerPart
                Me.FractionalPart = value.FractionalPart
            End Sub
 
            Public Shared Operator =(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As Boolean
                If value1.Equals(value2) Then
                    Return True
                End If
                Return False
            End Operator
 
            Public Shared Operator <>(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As Boolean
                Return Not value1=value2
            End Operator
        
            Public Shared Operator -(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As BigInteger
 
            End Operator
        
            Public Shared Operator +(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As BigDecimal
                Dim result As New BigDecimal
                Dim fracTmp1 As String = value1.FractionalPart.ToString()
                Dim fracTmp2 As String = value2.FractionalPart.ToString()
 
                With result
                    .IntegerPart = value1.IntegerPart+value2.IntegerPart
                    
                    'Both must be of the same length
                    If fracTmp1.Length > fracTmp2.Length Then
                        fracTmp2.PadRight(fracTmp1.Length, "0"c)
                    ElseIf fracTmp1.Length < fracTmp2.Length Then
                        fracTmp1.PadRight(fracTmp1.Length, "0"c)
                    End If
                    .FractionalPart = 0
                End With
 
                Return result
            End Operator
        
            Public Shared Operator /(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As BigInteger
 
            End Operator
        
            Public Shared Operator *(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As BigInteger
 
            End Operator
        
            Public Shared Operator ^(ByVal value1 As BigDecimal, ByVal value2 As BigDecimal) As BigInteger
 
            End Operator
 
            Public Overloads Function ToString() As String
                Return IntegerPart.ToString & "." & FractionalPart.ToString()
            End Function
 
        End Structure

In the + Overload I found it being difficult to add the fractional parts, for the fact that things can get tricky when handling the decimal point. For example

1.8969 + 1.8888.. For me I have to add the two integer parts, which is 2. Then the fractional parts which is actually 1.7857. There I realized I need to bump my integer part by one, or what have you depending on what the fractional parts add up too. Unless there is an easier way of doing this that I'm unaware of.. I was just going to literally add the fractional parts as you would on a piece of paper. Start at the end and work my way up, in which case if anything must be added to the integer part, it would be left over. However I see this method taking some time if the fractional part is long enough.. except it's simple addition so I'm not aware of the impact it would have, so I'm going to experiment a little bit today and see whats my best option.

Quote:

---

Originally Posted by Shaggy Hiker

Also look into overloading the +-*/ and \ operators so that you can use your type in normal equations. You might also want to be able to use them with other numeric types, so there could be a few overloads for you, but it will make for a much more versatile type.

---

Also, less than, less than or equal, and the greater than counterparts might be useful. Maybe even and, or, xor. I did mention in the other thread that the decimal point location would need to be accounted for.

Quote:

---

Originally Posted by dbasnett

Also, less than, less than or equal, and the greater than counterparts might be useful. Maybe even and, or, xor. I did mention in the other thread that the decimal point location would need to be accounted for.

---

Oh geez, I forgot about >, >=, <, <=. And, Or, and Xor will come lastly once I'm able to make some headway here. I'm still a little stuck on keeping track of the decimal points location - If I used a single BigInteger. Cause of that I'm using two for now. Which will make things a little easier on my part.. I hope.

I haven't had much time at all today to get anything done, so I'm hoping by tonight I'll have some more for you folks to gander at :)

Before I can get started I need a little help...

How do I do this?

vbnet Code:

Dim b As BigDecimal
 
b = BigDecimal.TryParse(TextBox1.text)
'or
b = 1000.0001

I'm having trouble understanding how to first assign the values..

Do I simply have to overload the = operand? One returning a boolean, the other returns BigDecimal..

I'm sure I could figure out the TryParse easily, but the other I'm completely baffled on. I'm just not sure if I'll always have to input the values strictly as a String or BigDecimal seeing that there is no other equivalent data type that could be "equal" to a BigDecimal.

shoot.. I just realized a problem. I cannot convert 00001 into a BigInteger value.. I may need my fractional part in a string format :( I'm considering a single BigInteger then simply keeping track of the decimal.. somehow.

Quote:

---

Originally Posted by DavesChillaxin

shoot.. I just realized a problem. I cannot convert 00001 into a BigInteger value.. I may need my fractional part in a string format :( I'm considering a single BigInteger then simply keeping track of the decimal.. somehow.

---

Maybe you could add an integer field to the Structure to record the number of leading zeros in the fractional part. BB

Quote:

---

Originally Posted by boops boops

Maybe you could add an integer field to the Structure to record the number of leading zeros in the fractional part. BB

---

I actually just thought of this, and I'm attempting it right now. My + operand works, just the leading zeros throw everything off.

My attempt was successful, though I didn't realize how often I'd have to keep track of the leading zeros. First I had to keep track of them when parsing a string value to my BigDecimal. Secondly I had to add them back in before the calculations, then thirdly when returning the result of the calculations(because again I had to parse the values back to BigIntegers)

I'm sure I could finalize a bit, but so far it works :).. just the addition. Attached is screen shot of it at working.


EDIT: I've just realized that at some point this bigdecimal of mine must have a limit of some sort. If I design it to have the capacity of a BigInteger which is infinite, and I do things right then a simple 1/3 could easily trip a never ending process.. eventually maxing the memory limits.

Keep it up, Daves, this is looking really good.
Edit: msdn says for BigInteger that the practical limit is when you get an OutOfMemory exception. You don't want to do that, because it means a crash. You might be able to forestall a crash by using a MemoryFailPoint, which results in an InsufficientMemoryException that you can catch. I've posted about that before so if you're interested, you could possibly search this forum for MemoryFailPoint. Still, it could be a lot of work since you would need it in practically every calculation. As an interim, I see from msdn that the BigInteger.ToString default output is limited to 50 places of decimals. Maybe you could take that as an example, and use 50 places for the Integer part and 50 places for the Fractional part.

BB

I wouldn't bother with And, Or, and XOR. That works well for integers, but becomes really strange when you try to do that with decimals.

It's interesting that you found addition and subtraction of decimals to be difficult. Not surprising, though. Addition and subtraction of Integers is VASTLY easier than multiplication and division, but the reverse is true for floating point values, as you are finding.

Now you should calculate PI and hold it in your BigDecimal

@boops boops First, thanks :) I'm starting to think so myself, and if successful could be useful and helpful to a lot of coders a like.

Secondly...

Quote:

---

Originally Posted by boops boops

As an interim, I see from msdn that the BigInteger.ToString default output is limited to 50 places of decimals.

---

I saw this to while I continuously research along side every step I make. Which is when I got the idea that I could have some out of memory issues when dealing with repeating decimals and irrational numbers such as 1/3 and Pi. The 50 limit seems like a good idea and could avoid any errors I have when converting to strings, but I actually would like to go a little further than that for a limit. I was thinking maybe 500 to 1000 for starters. Simply because thats nothing compared to what our memory can store to date while still giving me extremely larger decimals than ever allowed before.

I'd also like to add that this ToString nonsense of limits and returning useless information (to me), is beginning to be a huge nuisance. I feel in my opinion, ToString should return values exactly as-is, and not in an unspecified format by default. It should have to be by choice to have returned values in a different format, just like they've always been.

Quote:

---

Originally Posted by Shaggy Hiker

It's interesting that you found addition and subtraction of decimals to be difficult. Not surprising, though. Addition and subtraction of Integers is VASTLY easier than multiplication and division, but the reverse is true for floating point values, as you are finding.

---

It's only difficult because this is rather a different thinking to me than what I'm used to. I mean I'm not even sure if my methods are practical, though they work. I'm just a little skeptical that there are better methods out there of accomplishing these similar tasks.

The way I'm "adding" values is.. the integer part simply gets added normally (BigInteger+BigInteger). However I knew the fractional part could not be done this way, just because it almost must be done "backwards". So to do this I convert both values to strings, then in a for loop I start from the end of each variable and working my way backwards to the beginning. Each step of the way extracting a single number from both variables and adding them together, making sure I keep track of any remainders as such. Once the for loop as completed I convert the result string through BigInteger.TryParse() and assign the returning value to the FractionalPart of the returning BigDecimal. Seems a bit much for simple addition. So I can only imagine what I must do for anything more like you stated, such as multiplication and division. Regardless it works for me and seems to be quite quick at that, even for the larger numbers I've tried during tests.

If you have any suggestions of another possible way I could be doing this please feel free to share. It's always much easier to find mistakes when reading others work - as I always say.

Quote:

---

Originally Posted by stepdragon

Now you should calculate PI and hold it in your BigDecimal

---

This is my goal ;) But not quite yet.. I've got a lot to finish first before I'm able to do that. Simply because my BigDecimal will replace all Decimal variable types in my AdvancedMath class.. I need all the same functionality as the Decimal type, and all I have so far is the addition. :cool:

Why can't you just do Two BigInts seperated by a decimal point, and when you need to add, you can add the Whole numbers by themselves, then after the decimal point, just multiply them by the decimal place, do addition, then divide them again. Does that make sense? basically use scientific notation. Then leading zeros make no difference, and you don't have to worry about it.

(as part of this, can't you put an internal property or variable which will keep track of the number of decimal places?) it can simply update itself, that way you can modify leading zeros whenever, and still be able to simplify addition and subtraction.

I hope I'm making sense.

Quote:

---

Originally Posted by stepdragon

Why can't you just do Two BigInts seperated by a decimal point, and when you need to add, you can add the Whole numbers by themselves, then after the decimal point, just multiply them by the decimal place, do addition, then divide them again. Does that make sense? basically use scientific notation. Then leading zeros make no difference, and you don't have to worry about it.

---

It kind of does lol. I mean I'm new to this whole concept. But I'm already using two BigInt values, the integer and fractional part. Both get handled on there own for calculations. The integer part was simple, just the fractional part had proven more difficult. Keeping track of the decimal point was proving to be a lot more work that what I had ended up doing.

Scientific notations is also a new topic to me, though I understand it but only through looking at it, I cannot say I understand it in any more in depth than that.

I like Stepdragon's idea of using scientific notation. Instead of a BigDecimal, you could make a "BigDouble" type. It would have BigInteger for the mantissa, making the precision limitless, and an integer (or even BigInteger) power for the exponent. Tthe exponent could represent a power of 10. Maybe it would prove easier to code than BigDecimal, but I suppose you can't be sure until you try it:D.
B
B

Isn't there loss of precision when using scientific notation? I slightly remember reading about it when doing a little research on them. Still though I'm a little confused how I'd do all this :(.. My first guess it would simply be the process of floating-points, but If I read correctly I could keep track of the precision lost - or the wobble as they so put it.

Another question, does the nine's complement of subtraction method work with decimals? I've search high and low for an example but cannot find a single lead anywhere out there. All examples use either whole numbers or even binary, no decimals.


EDIT: Wait, I just had to define mantissa before I could understand you fully. I see now where you guys are coming at, perhaps I need to read a little more up on scientific notation and see how to use them algebraically. For example, I have no clue how to add or subtract.. etc two SN values together. Unless first they must be converted to there standard decimal form, calculated, then back to scientific notation.. All in all, it makes sense cause he'd be right, I wouldn't have to keep track of any leading zeros.

I think you've understood. The imprecision is in the number of digits in the mantissa: 17 in the case of Double, pseudo-infinity in the case of BigDouble :). BB

Quote:

---

Originally Posted by DavesChillaxin

Isn't there loss of precision when using scientific notation? I slightly remember reading about it when doing a little research on them. Still though I'm a little confused how I'd do all this :(.. My first guess it would simply be the process of floating-points, but If I read correctly I could keep track of the precision lost - or the wobble as they so put it.

Another question, does the nine's complement of subtraction method work with decimals? I've search high and low for an example but cannot find a single lead anywhere out there. All examples use either whole numbers or even binary, no decimals.


EDIT: Wait, I just had to define mantissa before I could understand you fully. I see now where you guys are coming at, perhaps I need to read a little more up on scientific notation and see how to use them algebraically. For example, I have no clue how to add or subtract.. etc two SN values together. Unless first they must be converted to there standard decimal form, calculated, then back to scientific notation.. All in all, it makes sense cause he'd be right, I wouldn't have to keep track of any leading zeros.

---

Quote:

---

Originally Posted by boops boops

I think you've understood. The imprecision is in the number of digits in the mantissa: 17 in the case of Double, pseudo-infinity in the case of BigDouble :). BB

---

So now that we've figure a BigDouble may be more practical. How would I go about handling scientific notations in calculations? StepDragon kind of lost me when he explained? I think? It seems my knowledge of scientific notations isn't as clear as I'd like them to be especially for creating a type that would handle such data.

Quote:

---

Originally Posted by DavesChillaxin

So now that we've figure a BigDouble may be more practical. How would I go about handling scientific notations in calculations? StepDragon kind of lost me when he explained? I think? It seems my knowledge of scientific notations isn't as clear as I'd like them to be especially for creating a type that would handle such data.

---

See Wikipedia on scientific notation. It gives a concise rundown of the basic operations (multiply, divide, add & subtract). So they shouldn't be all that hard to code. I expect ToString and perhaps even power/^ will be reasonably straightforward. Maybe you need a shared Precision property, so you can set a general maximum precision for a particular program or class -- for example with 500 or 1000 as default. That would come into play in the arithmetic methods.

Just thinking about the name. "Double" was so called because it was twice as precise as single, so it seems a bit stupid for something that can be infinitely precise. Maybe "BigFloat" would be a better name. Or is that some kind of ice-cream sundae? Discuss:p.

BB

Well, I have created a fraction class and I was on my way to create a BigDecimal class, I then read this thread, I then read the format specification on normal floating point numbers, now I want to create massive float, and after that I want to make a float with infinite precision. reading through how a IEEE 754(standard floating point) works really shed some light on this subject for me.

And as for the name: In reality it is a Big Decimal number so BigDecimal seems appropriate, although I like the sound of BigDouble more.

Just me thinking out loud...

Code:

---

Imports System.Numerics
Public Class Form1

    Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
        Dim s As String = New String("0"c, 99)
        Dim foo1 As numString = New numString("-001." & New String("0"c, 99) & "1")
        Dim foo2 As numString = New numString("1234." & New String("0"c, 98) & "12")

        'testing the addition of the decimal parts only
        Dim b1 As BigInteger = foo1.DecimalPart
        Dim b2 As BigInteger = foo2.DecimalPart
        Dim b3 As BigInteger = b1 + b2
        Debug.WriteLine(b3.ToString)
        Dim b5 As BigInteger = foo1.IntegerPart 'make sure minus works
        Debug.WriteLine(b5.ToString)
    End Sub
End Class

Class numString

    Private Shared decPT As String = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator
    Private Shared grpSep As String = System.Globalization.NumberFormatInfo.CurrentInfo.NumberGroupSeparator
    Private Shared minusSign As String = System.Globalization.NumberFormatInfo.CurrentInfo.NegativeSign

    Public Sub New(realNumberAsString As String)
        Me.NumParts(realNumberAsString)
    End Sub

    Private Sub NumParts(realNumberAsString As String)
        Dim foo As Integer
        Dim idx As Integer
        Me._integer.Length = 0
        Me._decimal.Length = 0

        For idx = 0 To realNumberAsString.Length - 1
            Dim s As String = realNumberAsString.Substring(idx, 1)
            Select Case s
                Case " "
                Case minusSign
                    Me._minus = True
                Case decPT
                    idx += 1
                    Exit For
                Case grpSep 'ignore
                Case Else
                    If Integer.TryParse(s, foo) Then
                        Me._integer.Append(s)
                    Else
                        'error!!!
                    End If
            End Select
        Next
        For idx = idx To realNumberAsString.Length - 1
            Dim s As String = realNumberAsString.Substring(idx, 1)
            If Integer.TryParse(s, foo) Then
                Me._decimal.Append(s)
            Else
                'error!!!
            End If
        Next

        If Me._integer.Length = 0 Then
            Me._integer.Append("0")
        ElseIf Me._minus Then
            Me._integer.Insert(0, minusSign)
        End If

        If Me._decimal.Length = 0 Then Me._decimal.Append("0")
    End Sub

    Private _integer As New System.Text.StringBuilder
    Private _decimal As New System.Text.StringBuilder
    Private _minus As Boolean = False
    Private Shared max As Integer = 100 '<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

    ReadOnly Property IntegerPart As BigInteger
        Get
            Dim rv As BigInteger = BigInteger.Parse(Me._integer.ToString)
            Return rv
        End Get
    End Property

    ReadOnly Property DecimalPart As BigInteger
        Get
            Dim rv As BigInteger = BigInteger.Parse(Me._decimal.ToString.PadRight(max, "0"c))
            Return rv
        End Get
    End Property
End Class

---

OK HOLD UP!!!!!

I think everyone misunderstood me when I mentioned Scientific Notation... I did *NOT* mean use scientific notation, I was using S.N. as an example to show what I was going for... so let me explain better.


What if you did your type like this:

Lets say we want to hold the number:

1025316452333000.00023000560004

Now, If we already have BigInteger which can hold virtually limitless digits in it lets look at the number like this:

(This is one number, I'm using colors so we don't lose our place)
102531645233300000023000560004

Now we can hold this entire number in a single BigInt. Next, we need to know where the decimal place is. We create a hidden variable within the structure, which will track where the decimal place is (just like the power in scientific notation)

so we would have:

1025316452333000.............. < - 14 places after the decimal.

Therefore 14 places for the decimal.

Now we can store this inside the BigDecimal Structure like this:

BigInt = 102531645233300000023000560004
Dec_P = 14 (hidden to the user, held in an integer within the structure) (I'm assuming this is possible)

Then just output and modify calls accordingly. Does that clarify my suggestion at all?


For the addition, you would simply line up the decimals (by adding leading, or trailing zeros) remove all the decimals, Add the numbers together, and then put back the decimal, and remove any leading or trailing zeros.

Simple, Right?

@Stepdragon. I think that is much the same as what we have been talking about in the past few posts. It is pretty similar to the Decimal type, only bigger. "Scientific representation" isn't limited to the format used in the Double type, with a fractional mantissa and a power of 10.

I'm not sure if it's so important to keep the exponent part (the power of 10 or the number of decimal places, however you like to describe it) hidden. There might turn out to be situations where you want to get or set the mantissa and exponent directly.

BB

@step - I think I like it ;) It shouldn't be real hard to get the decimal points to line up...(famous last words).

From an algorithmic perspective this is interesting, but I can't imagine reading a number like:

4247243572034500204752.0000000000000000000000000000000000000000000000000000000000000000314159265

Quote:

---

Originally Posted by dbasnett

@step - I think I like it ;) It shouldn't be real hard to get the decimal points to line up...(famous last words).

From an algorithmic perspective this is interesting, but I can't imagine reading a number like:

4247243572034500204752.0000000000000000000000000000000000000000000000000000000000000000314159265

---

Why not? its just:
Bigint: 42472435720345002047520000000000000000000000000000000000000000000000000000000000000000314159265
Dec: 73

Oh and aligning decimals is the easy part, just look at the numbers:

Code:

---

  1.005  < - 3
        +
1.000005  < - 6

---

Add Zeros to the end of the number that has fewer digits:

Code:

---

1.005000  < - 6
        +
1.000005  < - 6

---

Remove decimals and add

1005000 + 1000005 = 1005005

Add Decimal Back:

1.005005

Remove any trailing zeros if needed (shouldn't need to do this with addition, other operators may need it) and adjust the decimal count accordingly

Quote:

---

Originally Posted by stepdragon

Why not? its just:
Bigint: 42472435720345002047520000000000000000000000000000000000000000000000000000000000000000314159265
Dec: 73

---

The way I see it, the purpose of the BigDecimal (now my preferred name again) is to allow calculations with accurate intermediate values. Having an output with a huge number of decimal places would be wanted only rarely -- say for testing purposes, to impress your boss, or to satisfy Pi mystics. The default ToString representation could be similar to Double but with a larger exponent range. For example:

4247243572034500204752 * 10^500577832

Of course there should be an option to output more decimal places in the mantissa when required.

BB

Quote:

---

Originally Posted by boops boops

The way I see it, the purpose of the BigDecimal (now my preferred name again) is to allow calculations with accurate intermediate values. Having an output with a huge number of decimal places would be wanted only rarely -- say for testing purposes, to impress your boss, or to satisfy Pi mystics. The default ToString representation could be similar to Double but with a larger exponent range. For example:

4247243572034500204752 * 10^500577832

Of course there should be an option to output more decimal places in the mantissa when required.

BB

---

I would imagine it as holding all of the data, before after, and including the decimal place. And then you could implement different output formats. For example ToString(Format) and having different options, such as Sci-Not. Decimal, or whatever else.


I would also do something like a

.ToDecimal
.ToInteger

and so on, then within the code, check if the currently held number CAN be put into those numbers, if so return it in that format, otherwise return -1 or something. That way you could convert between types when needed.

Same thing with New(Byval Input as Float) and so-on

Quote:

---

Originally Posted by DavesChillaxin

Before I can get started I need a little help...

How do I do this?

vbnet Code:

Dim b As BigDecimal
 
b = BigDecimal.TryParse(TextBox1.text)
'or
b = 1000.0001

I'm having trouble understanding how to first assign the values..

Do I simply have to overload the = operand? One returning a boolean, the other returns BigDecimal..

I'm sure I could figure out the TryParse easily, but the other I'm completely baffled on. I'm just not sure if I'll always have to input the values strictly as a String or BigDecimal seeing that there is no other equivalent data type that could be "equal" to a BigDecimal.

---

Inside the class
---------------------
Public Shared Widening Operator CType(ByVal value As Single) As Bigdecimal
return new bigdecimal(value)
End Operator

Public Shared Narrowing Operator Ctype(ByVal value as String) As Bigdecimal
Return new bigdecimal(value)
End Operator

public sub new(ByVal Value as single)
Do your conversion here
End sub

Public sub new(ByVal Value as String)
Do your conversion here
End sub
--------------------------------------------

Narrowing if there is a loss
Widening if there is no loss

Widening single to bigdecimal because it can hold all the posible single values
Narrowing string to bigdecimal because a big decimal cannot hold letters

Be sure to write al the ctypes you will need from and to other types

If you do it well the compiled will do al the steps for you:
b = 1000.0001 to b= bigdecimal.Ctype(1000.0001) to b = new bigdecimal(1000.0001)

it works for structures too

Steps to do by visual studio:
variable as Type = [write the value directly here]
guess the Type of [Write the value directly here] between the premade types ONLY
call to shared Ctype of class/type/structure of the declared variable if [Write the value directly here] is of another type.
assign the variable in a succesful conversion(if needed) or whine if there is no conversion function.

Holy cow! you guys gave me tons, I mean tons to think about! I knew this wasn't going to be a straight forward project, but one that would take a lot of brain storming and plenty of trial and errors. However I've had tons of homework tonight-seeing that I'm towards the end of my semester, and not to mention I've taken some benadryl. On benadryl my thinking is significantly impaired so I may need to review all of this tomorrow at work :)

Though I may take stepdragons idea, and my initial thought of using just a single BigInteger, and a variable to hold the decimal places location. This would make all calculations a heck of a lot easier.

I appreciate all of your help guy!

Why do you actually need limitless precision ? why not create a floating point datatype that can hold about 50 digits and 50 decimal places, you will never practically require more than 40 digits of precision for anything.

Quote:

---

Originally Posted by BlindSniper

Why do you actually need limitless precision ? why not create a floating point datatype that can hold about 50 digits and 50 decimal places, you will never practically require more than 40 digits of precision for anything.

---

Are you sure you aren't thinking about fixed point? Even Double allows for over 300 decimal places either side of the decimal point, although its precision is limited to 16 significant digits.

The aim of BigDecimal would be to get away from the limitations of trying to pack the the number into 64 bits. Goodbye efficiency, hello precision. And why impose the limitation of a hard coded precision limit when it could be an Integer user setting (with that value as default)? It don't think it would make much difference to the code for the methods and operators. So I would suggest the following main fields:

Code:

---

Public Mantissa As BigInteger 'the integral data value
Public Exponent As Integer 'the position of the decimal point
Public Shared Property MaxPrecision As Integer = 100 'default value

---

BB

Quote:

---

Originally Posted by boops boops

And why impose the limitation of a hard coded precision limit when it could be an Integer user setting (with that value as default)?

---

Yup this is exactly what I was concidering. I though it over last night and realized this would ultimately fix my OutOfMemory error that could and most likely would occur if I had no cap. I wasn't actually thinking of calling it a "limit" though I like precision a lot more.

Also I may stick with a BigDouble, and use a single BigInteger, simply because it would make all the calculations a lot easier. Than again I could do both BigDouble and BigDecimal(I've done quite some code work to function as such, and I'm not willing to throw it all out now). Both having their own specific use and functionality just as types do now.

After I finish my 2 quizzes tonight I'll have something to show you guys. Unfortunately priorities comes first :(

@BB
I just randomly thought of a number and it happened to be 50, but what I mean is for what use could you possibly need limitless precision ? A floating point is 4 bytes and a double is 8, create a 128 byte datatype, and you would have more precision than needed for all practical purposes, and you could possibly not sacrifice too much efficiency.
I guess it all comes down to the speed difference between limited precision and unlimited precision. and which one is easiest to implement.

Quote:

---

Originally Posted by BlindSniper

@BB
I just randomly thought of a number and it happened to be 50, but what I mean is for what use could you possibly need limitless precision ? A floating point is 4 bytes and a double is 8, create a 128 byte datatype, and you would have more precision than needed for all practical purposes, and you could possibly not sacrifice too much efficiency.
I guess it all comes down to the speed difference between limited precision and unlimited precision. and which one is easiest to implement.

---

Daves wants this type for evaluating mathematical expressions (it was clear in his previous thread if not this one). Decimal or even Double might be accurate enough for representing the end results. The trouble is that you can't be sure when the intermediate results could cause overflow. For example, suppose you wanted to evaluate this series (just to make something up):

1 - 2^2/2! + 3^3/3! - 4^4/4! ... n^n/n!

where the exclamation mark represents the factorial 1 * 2 * 3 * 4 ... *n. I happen to know that factorial 28 is too big to represent as decimal, so without a BigInteger or something else big, the evaluation will crash by term 28.

If you want to make an expression evaluator that will evaluate anything the user throws at it, it might be hard to predict in advance just how much precision you need to avoid overflow. OK, evaluation may well take longer than the lifespan of the universe by term 42, but that's something we Magratheans have to deal with:cool:.

PS. my mathematical knowledge is getting seriously overstrained here. How about asking on the Math forum?

BB

Quote:

---

Originally Posted by BlindSniper

what use could you possibly need limitless precision?

---

I honestly know deep down that anything limitless is impossible. For numbers that never end(which we know exist) clearly mean they never end. Memory cannot be limitless, plain and simple. But my goal for this is essentially just because I can. If my function which simplifies algebraic expressions can produce Pi/e with as many as 100,000 digits would be an achievement that I can be proud of.


This all began with my own requiring of a type capable of holding the value of 1/16^20, and then some. Ultimately It would loop to around 1/16^100 for the precision of Pi I seek.

It is daves thread, but moving it to the math forum might prove enlightening. There are some incredibly bright people there.

Quote:

---

Originally Posted by boops boops

PS. my mathematical knowledge is getting seriously overstrained here. How about asking on the Math forum?

---

Oh I'll be sure to hit up that forum once I complete this BigDouble/BigDecimal. I will definitely need help with some mathematical aspects once my calculator is capable of handling most anything a user can throw at it.

Quote:

---

Originally Posted by dbasnett

It is daves thread, but moving it to the math forum might prove enlightening. There are some incredibly bright people there.

---

up to you guys, as long as you all fallow it there. I'm liking this help you've all provided here. I just hope the guys in the math forum aren't too bright to where I struggle to fallow.. seeing as I'm struggling enough as it is here :rolleyes:

Are we all agreed, math forum? I'll get it moved if we are.

Quote:

---

Originally Posted by dbasnett

Are we all agreed, math forum? I'll get it moved if we are.

---

I'm unsure about moving it. This thread has thrown up a some interesting things about structures, precision and number formats. They may be dotnet/computing matters rather VB.Net (apart from the examples). But wouldn't these aspects have been missed on the Math forum? BB

Lets try it this way.

I saw this linked from the math forum. My own thoughts:

This project has been done before a number of times. A brief search found http://sine.codeplex.com/ (amongst others just for .NET). Still, this type of project can be very educational and can also be fun. Certainly, if you're enjoying it, don't stop just because it's been done before. Just keep in mind when it is and isn't worth the time to reinvent the wheel.


Ok, the responsible side of me has been satisfied well enough. Two formats have been proposed, and I have some of my own. I'll list them with pros and cons.

1. A BigInt holding the integer part, and a BigInt holding the fractional part.
   
   • Pros: Mirrors how a human typically thinks about decimals.
   • Cons: You might be tempted to implement your own addition routine to deal with fractional addition (though this can be avoided by multiplying one of the addends by a suitable power of 10). Multiplication is a 4-part operation involving some tedious reasoning. I'm not immediately sure how division could be done.
   
   
2. A single BigInt holding the mantissa, and another BigInt (well, I would use a BigInt) holding the exponent.
   
   • Pros: You don't have to split every calculation into pieces like with the above method. Multiplication is extremely easy. Addition does not have to be difficult either, as above.
   • Cons: Actually, I don't really see any. This is very similar to the format the IEEE settled on for floating point numbers, just with an arbitrary-length mantissa. It makes sense that it's a very good option. Come to think of it, division would be somewhat difficult.
   • Note: You might want to look in to a base 2 exponent rather than base 10. Multiplication by 2 is likely very fast on BigInts (and if it's not, it should be). If you do this, though, you'll have to convert to base 10 to display results.
   
   
3. Arbitrary-precision rational numbers, using a BigInt for the numerator and another BigInt for the denominator.
   
   • Pros: Allows you to store rational numbers without loss of precision. Fundamentally, pretty much everything is built up from basic operations on rational numbers. Also, the Euclidean Algorithm is fast enough to allow you to cancel like terms from the numerator and denominator, keeping things small-ish and allowing you to implement equality testing trivially. Addition, subtraction, multiplication, and division are all simple extensions of the relevant BigInt operations, followed by canceling like terms.
   • Cons: The rational numbers involved can get huge. For practicality's sake you would probably have to implement a "round" routine which trimmed the denominator down to some specified size. That routine would be somewhat interesting to come up with. Also, the ToString() method would need a fair amount of work.
   
   
4. This one is a bit advanced. Allow arbitrary-precision rationals, together with a set of definable symbols (eg. pi, e). An object would be some (finite) combination of rationals, symbols, and operations (+, -, /, *, etc.).
   
   • Pros: I imagine this is essentially what computer algebra systems use. It would be a wonderful exercise in recursively defined data types.
   • Cons: Of very questionable use without a computer algebra system behind the data type to perform simplifications automatically.

There were a few other ideas I wanted to mention.

First is an "exact" flag. A BigDecimal would start with exact = True. Whenever a BigDecimal is created through addition, multiplication, etc., if any rounding occurs whatsoever, exact gets set to False. exact = False propagates as well--adding an exact to an inexact value creates an inexact value. This would probably be most useful with rational numbers.

Second, you may wish to allow the user to specify the precision of intermediate results in addition to the precision of a BigDecimal. Some operations may require several steps (eg. taking integer powers), and you should use more precision in those intermediate steps than actually required to prevent rounding errors from accumulating in the last few places.

Third, if your numbers... actually, I forgot number three. Oh well. Edit: I remembered my point. Be careful about combining precision on different numbers. For instance, adding 37 and 1.0004 increases the precision in 37 to 4 digits after the decimal. Multiplication and division can be trickier.

I think that this thread shouldn't be moved. The Math forum is a great place for hard-core feats of engineering, but this isn't just about a single calculation. Its about creating a programming data type for use IN calculations. I think that that alone makes it worth keeping in this section as it will pertain mostly to programming.

Before we start to turn this whole thread into a debate on where to move it, I still think #2 is the best way to go. Its simple in concept, and has the fewest drawbacks. I also agree that using a Bigint for the Exponent, however I think there should be a defined limit to how many decimals it can go out to. (on a per variable basis)

What I mean by that is, going back to the infinite loop example, we don't want to create something soo huge that it uses up your entire computer's ram. But we do want someone who has 256GB of ram on their custom server board to have the option to calculate PI to enough digits to be reading it for 100 lifetimes.

This is what I've come together for a BigDouble... No operations yet, but simply can store the value. Having that I'm only using a single BigInteger will make the operations and calculations easy and quick. So it wont be to long before I have that added and posted. Tomorrow is my estimation of an update.

vbnet Code:

Public Structure BigDouble
            
            Private _Value As BigInteger
            Public Property Value As BigInteger
                Get
                    Return Me._Value
                End Get
                Set(ByVal value As BigInteger)
                    Me._Value = value
                End Set
            End Property
 
            Private LeadingZeros As Int32
            Private _DecimalPosition As Int32
            Public Property DecimalPosition As Int32
                Get
                    Return Me._DecimalPosition
                End Get
                Set(ByVal value As Int32)
                    Me._DecimalPosition = value
                End Set
            End Property
 
 
            Public Shared Function Zero() As BigDouble
                Dim output As New BigDouble
 
                With output
                    .Value = 0
                    .DecimalPosition = 0
                    .LeadingZeros = 0
                End With
 
                Return output
            End Function
 
            Public Function TryParse(ByVal value As String) As BigDouble
                Dim output As BigDouble = BigDouble.Zero
 
                Try
                    Dim tmp As String = value.Replace(".", vbNullString)
 
                    'There can only be one decimal point within a value.
                    If value.IndexOf("."C) = value.LastIndexOf("."C) Or Not value.Contains(".") Then
                        With output
                            BigInteger.TryParse(tmp, .Value)
                            .DecimalPosition = value.IndexOf("."C)
 
                             'Locate and count each leading zeros.
                            For i As Int32 = 0 To tmp.Length-1
                                If tmp.Substring(i,1) = "0" Then
                                    .LeadingZeros += 1
                                Else: Exit For 'Exit out at the first non zero found(all zeros if any have been located and accounted for).
                                End If
                            Next
                        End With
                    Else
                        Throw New ParseException
                    End If
                Catch ex As ParseException
                    MessageBox.Show(ex.Message)
                End Try
 
                Return output
            End Function
 
            Public Overrides Function ToString() As String
                Dim tmp As String = Value.ToString
 
                If Value > 0 Then 'Check if the value is greater than 0.
                    tmp = tmp.PadLeft(tmp.Length+LeadingZeros, "0"C)
                    If DecimalPosition >= 0 Then
                        tmp = tmp.Insert(DecimalPosition, ".")
                        If tmp.IndexOf("."C) = 0 Then tmp = "0" & tmp
                    End If
                End If
 
                Return tmp
            End Function
 
            Public Class ParseException
                Inherits System.Exception
                
                Public Shadows ReadOnly Property Message As String
                    Get
                        Return "Parse has failed to convert the provided string into a BigDouble!"
                    End Get
                End Property
 
            End Class
 
        End Structure

Quote:

---

Originally Posted by jemidiah

[LIST=1][*]A BigInt holding the integer part, and a BigInt holding the fractional part.

• Pros: Mirrors how a human typically thinks about decimals.
• Cons: You might be tempted to implement your own addition routine to deal with fractional addition (though this can be avoided by multiplying one of the addends by a suitable power of 10). Multiplication is a 4-part operation involving some tedious reasoning. I'm not immediately sure how division could be done.

---

This was actually my first attempt and wast working properly.. though I scratch it yet haven't gotten rid of it yet. But by doing so I noticed doing something such as simple additions was a lot of work. So I couldn't even imagine the amount of work required to do divison and such.

The example I just posted simply uses a single BigInteger and I keep track of the decimal place and any leading zeros(again cause converting 0.000001 to a BigInteger value will give you 1, so I keep track of those leading zeros and place them back in the ToString function.

Perhaps I should have championed rational numbers, option #3, more in my previous post. That seems like an option worth pursuing, far more so than option #1. Of course, option #2 is also good, which seems to be what you've chosen.

The purpose of having both "LeadingZeros" and "DecimalPosition" is not clear to me. You should be able to use a single number to holding the exponent, as in scientific notation, and infer the decimal place from that. I would actually use "Exponent" rather than "DecimalPosition".

Ex: 0.000001 -> Value = 1, Exponent = -6, since 0.000001 = 1 * 10^(-6).

Quote:

---

Originally Posted by jemidiah

[*]Arbitrary-precision rational numbers, using a BigInt for the numerator and another BigInt for the denominator.

• Pros: Allows you to store rational numbers without loss of precision. Fundamentally, pretty much everything is built up from basic operations on rational numbers. Also, the Euclidean Algorithm is fast enough to allow you to cancel like terms from the numerator and denominator, keeping things small-ish and allowing you to implement equality testing trivially. Addition, subtraction, multiplication, and division are all simple extensions of the relevant BigInt operations, followed by canceling like terms.
• Cons: The rational numbers involved can get huge. For practicality's sake you would probably have to implement a "round" routine which trimmed the denominator down to some specified size. That routine would be somewhat interesting to come up with. Also, the ToString() method would need a fair amount of work.

---

I made a fractions class with big integers, and the ToString isn't all that complicated

vb.net Code:

Public Overloads Function ToString(ByVal Digits As Integer) As String
        Dim st As New System.Text.StringBuilder(Digits + 1)
        Dim result As BigInteger = _Numerator / _Denominator
        Dim left As BigInteger = _Numerator Mod _Denominator
        st.Append(result)
         If left <> 0 Then st.Append("."c)
        For i = 1 To Digits
            If left < _Denominator Then left *= 10
            result = left / _Denominator
            If result = 0 Then Exit For
            left = left Mod _Denominator
            st.Append(result)
        Next
        Return st.ToString
    End Function

The variable names are self explanatory.Only thing it doesn't do is round the last digit. I will post it in the codebank when it is done.

I see the Exponent and my LeadingZeros almost working in the same way just expanded. To have the exponent say (-6) if my value is 1 then I still have to determine if I require any leading zeros or not. Which in this case I do so I would have to figure that out, and the exponent variable would be my key to exactly how many. Where as my LeadingZeros variable has already been determined when I parsed the value and directly tells me how many I need when rather figuring it out each time I return the value as a string.

I can try it real quick and see how well I can adapt to using an exponent rather leading zeros and perhaps the benefits of doing such. I only have like half an hour before my next class but I'll get to coding and have something for you guys in a few.


EDIT: I really enjoy this post to by the way. It's getting me to think outside of the box, and expand my thinking and knowledge of other options I have available that I hadn't known prior.

I'm not sure why I'm not getting this here, but as you say 1x10^-6 = 0.000001 right?

so what does 100x10^-6 = ?.. I'm not sure but I'm getting a headache here cause I'm really not getting it right now for some reason.

Quote:

---

Originally Posted by DavesChillaxin

1x10^-6 = 0.000001 right?

---

Yes.

Quote:

---

Originally Posted by DavesChillaxin

100x10^-6 = ...

---

0.0001

Quote:

---

Originally Posted by DavesChillaxin

I'm not sure why I'm not getting this here, but as you say 1x10^-6 = 0.000001 right?

so what does 100x10^-6 = ?.. I'm not sure but I'm getting a headache here cause I'm really not getting it right now for some reason.

---

As a quick rule of thumb:

A x 10 ^ B = Move the Decimal in A to the --> B spaces

and

A x 10 ^ -B = Move the Decimal in A to the <-- B spaces

I know its simple, but its easy to have something to look at, rather than have to remember the simple things

Quote:

---

Originally Posted by jemidiah

Yes.



0.0001

---

Okay okay, thats actually what I had produced with the code I put together earlier. Just I'm not sure why but it just wasn't clicking with me. I thought it was all wrong and got frustrated though what I thought was just as stepdragon had said. Negatives move the the left where as positives move to the right. Back to work!

First I'd like to say Happy Thanksgiving to you all! I hope your day was a great as mine.


Also I've had a lot more success with this project. I noticed a few speed bumps along the way and may need a little clarification.

Here's a few examples of what I can produce so far. You also may notice a few things as I did.

• Parse: 1.00000489373748
  Output 1.00000489373748(Decimal Notation), 100000489373748ᴇ-14(Scientific Notation)
• Parse: 1.009
  Output 1.009(Decimal Notation), 1009ᴇ-3(Scientific Notation)
• Parse: 0.00000000000000013938
  Output 0.00000000000000013938(Decimal Notation), 13938ᴇ-20(Scientific Notation)
• Parse: 0
  Output 0.0(Decimal Notation), 0ᴇ-1(Scientific Notation)
• Parse: 100
  Output 0.100(Decimal Notation), 100ᴇ-3(Scientific Notation)
• Parse: 0.00000000000001
  Output 0.00000000000001(Decimal Notation), 1ᴇ-14(Scientific Notation)

Now what I first had noticed was the fact I could get away without using any positive exponents. For the purpose of just storing the data I could use only negative exponents. So far it's been working as you can see, just I'm unaware of it having any flaws yet

Secondly I studied up on scientific notations I stumbled across "normalized notation" Which is the a, or coefficient of a scientific notation should be less than 10.. This was my first road bump. I tried fallowing this rule but shortly after my first attempt I realized I store my coefficient as a BigInteger. Which is my key to limitless precision. To fix that I'd have to use the type inside itself or use my other BigDecimal type.. I felt this was pointless seeing that 3*10^3, 30*10^2, and 300*10^1 are all equal. Besides in the end the user wont have access to any of this and is simply just for the sake of storing data in a way I can format it later in Decimal Notation. So I concluded I wouldn't have to fallow all the rules, just so long as my output(in decimal notation) was always correct to what the user parsed.

I also know the 100, should trim the trailing 0's. I'm getting to that shortly..

But other than that let me know what you think and if you agree.

Quote:

---

Originally Posted by DavesChillaxin

First I'd like to say Happy Thanksgiving to you all! I hope your day was a great as mine.


Also I've had a lot more success with this project. I noticed a few speed bumps along the way and may need a little clarification.

Here's a few examples of what I can produce so far. You also may notice a few things as I did.

• Parse: 1.00000489373748
  Output 1.00000489373748(Decimal Notation), 100000489373748ᴇ-14(Scientific Notation)
• Parse: 1.009
  Output 1.009(Decimal Notation), 1009ᴇ-3(Scientific Notation)
• Parse: 0.00000000000000013938
  Output 0.00000000000000013938(Decimal Notation), 13938ᴇ-20(Scientific Notation)
• Parse: 0
  Output 0.0(Decimal Notation), 0ᴇ-1(Scientific Notation)
• Parse: 100
  Output 0.100(Decimal Notation), 100ᴇ-3(Scientific Notation)
• Parse: 0.00000000000001
  Output 0.00000000000001(Decimal Notation), 1ᴇ-14(Scientific Notation)

Now what I first had noticed was the fact I could get away without using any positive exponents. For the purpose of just storing the data I could use only negative exponents. So far it's been working as you can see, just I'm unaware of it having any flaws yet

Secondly I studied up on scientific notations I stumbled across "normalized notation" Which is the a, or coefficient of a scientific notation should be less than 10.. This was my first road bump. I tried fallowing this rule but shortly after my first attempt I realized I store my coefficient as a BigInteger. Which is my key to limitless precision. To fix that I'd have to use the type inside itself or use my other BigDecimal type.. I felt this was pointless seeing that 3*10^3, 30*10^2, and 300*10^1 are all equal. Besides in the end the user wont have access to any of this and is simply just for the sake of storing data in a way I can format it later in Decimal Notation. So I concluded I wouldn't have to fallow all the rules, just so long as my output(in decimal notation) was always correct to what the user parsed.

I also know the 100, should trim the trailing 0's. I'm getting to that shortly..

But other than that let me know what you think and if you agree.

---

Is that an error or a typo? I saw you explained the trailing zeros, but what about the fact that you input 100 and output .1

also, happy thanksgiving back to you

I wouldn't call your format (#2 in my list) "scientific notation". Don't let the "mantissa < 10" convention in real scientific notation bother you. It's best to just ignore it here, as you seem to have concluded.

I also wouldn't ignore positive exponents. Consider the number 1234 * 10^(10^(10 trillion)). The exponent has approximately 10 trillion digits, even though your number only has 4 digits of precision. If you disallow positive exponents, you would need to store all 10 trillion digits, even though all but 4 are 0.