Re: HZH_Controls.Controls.UCTextBoxEx Cast Object Error Problem - C# Discussion Boards

Re: Invalid expression term 'uint'

15-May-22 1:09

Check your C# version - the syntax Foo(out type varName) was only added at C#7.0

"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!

mbah obiora15-May-22 2:54

mbah obiora

15-May-22 2:54

Thanks for your answer. It was a version issue.

ooooo

Re: Invalid expression term 'uint'

OriginalGriff15-May-22 3:05

Parse complex numbers from string

15-May-22 3:05

You're welcome!

Member 1563407112-May-22 9:28

Member 15634071

12-May-22 9:28

Complex class from Numerics does not have any Parse method
How to write parse method

public static bool TryParse(string s,out Complex z)
{
     /* Here following formats should be accepted
        z = a+bi
        z = a+bj
        z = (a,b)
        where type of a and b is double
        Decimal point depends on CultureInfo  
        fe for US and UK it is a dot 
        in CE (Central Europe) where I live it is comma
        */
}

OriginalGriff12-May-22 10:42

12-May-22 10:42

And?
What have you tried?
Where are you stuck?
What help do you need?

jsc4213-May-22 1:13

13-May-22 1:13

Member 15634071 wrote:
in CE (Central Europe) where I live it is comma

Yes, that makes it 'interesting' if parsing the (a,b) format as you have no idea whether the ',' is a dec point or a value separator. e.g. (1,2,3,4) could only be 1.2+3.4i but (1,2,3) could be 1.2+3i or 1+2.3i Smile | :)

Just to make it even more fun, US / UK / other countries have numbers where a comma can be a thousands separator e.g. (234.567,999,888.000) could be one of several complex numbers. e.g. 234.567+999888.0i, 234.567999+888.0i, or 234.567999888+0i.
Have you looked at how Point objects are parsed (they too can have an (x,y) format where x and y are decimal numbers)?

Member 1563407116-May-22 9:02

Member 15634071

16-May-22 9:02

Can you write en example ?
Normally not in the comment section

jsc4217-May-22 4:19

17-May-22 4:19

There doesn't seem to be a Point.Parse() / Point.TryParse() so that did not get very far!
Normally, we don't give working answers, just rough pointers. However, I had wanted to create a Point.Parse() / Point.TryParse() for a different project, but had not got around to it; so this was a good excuse to write one Smile | :)

.

This version allows (x-yi) and (x-yb) as well as your formats plus you can use (x, y) [with a space after the real/imaginary separator] to disambigute for cultures that use ',' as a decimal point.

My basic functions look like:

public static class Complex2
 {
     public static Complex ComplexParse(string text)   // (x, y) or (x+yi) or (x+yj) or (x-yi) or (x-yj)
     {
         string[] parts;
         string parsedText = text.Trim();
         if (parsedText.StartsWith("(") && parsedText.EndsWith(")"))
         {
             parsedText = parsedText.Substring(1, parsedText.Length - 2).Trim(); // Drop parentheses
             if (parsedText.Contains("+") && (parsedText.EndsWith("i") || parsedText.EndsWith("j")))
             {
                 parts = parsedText.Split('+');
                 if (parts.Length == 2)
                     return
                         new Complex(
                             real: double.Parse(parts[0].Trim()),
                             imaginary: double.Parse(parts[1].Substring(0, parts[1].Length - 1).Trim())
                             );

                 throw new ArgumentException("Complex number format not recognised (multiple '+' chars)");
             }
             else if (parsedText.Substring(1).Contains("-") && (parsedText.EndsWith("i") || parsedText.EndsWith("j")))   // (x-yi) or (x-yj) // Beware of (-x-yi) or (-x-yj)
             {
                 parts = parsedText.Substring(1).Split('-');
                 if (parts.Length == 2)
                     return
                         new Complex(
                             real: double.Parse(parsedText.Substring(0, 1) + parts[0].Trim()),
                             imaginary: -double.Parse(parts[1].Substring(0, parts[1].Length - 1).Trim())
                             );

                 throw new ArgumentException("Complex number format not recognised (multiple '+' chars)");
             }
             else if (parsedText.Contains(","))  // Hopefully in the form x, y
             {
                 parts = parsedText.Split(',');
                 if (parts.Length == 2)
                     return
                         new Complex(
                             real: Double.Parse(parts[0].Trim()),
                             imaginary: Double.Parse(parts[1].Trim())
                             );

                 // Too many commas. Can only diambiguate if one is followed by a space
                 int ix = parsedText.IndexOf(", ");
                 if (ix < 1)     // ", " not found or there is an empty real part
                     throw new ArgumentException("Complex number format not recognised (ambiguous use of commas)");

                 return
                     new Complex(
                         real: double.Parse(parsedText.Substring(0, ix).Trim()),
                         imaginary: double.Parse(parsedText.Substring(ix + 1).Trim())
                         );
             }
             else
                 throw new ArgumentException("Complex number format not recognised");
         }
         else
             throw new ArgumentException("Complex number not enclosed in parentheses");
     }

     public static bool ComplexTryParse(string text, out Complex ComplexOut)
     {
         try
         {
             ComplexOut = ComplexParse(text);
             return true;
         }
         catch (Exception)
         {
             ComplexOut = new Complex(0.0, 0.0);
             return false;
         }
     }
 }

and to use as extension methods for string:

public static class StringExtensions
 {
     public static Complex ComplexParse(this string fromText) =>
         Complex2.ComplexParse(fromText);

     public static bool ComplexTryParse(this string fromText, out Complex result) =>
         Complex2.ComplexTryParse(fromText, out result);
 }

Sample testing:

class Program
{
    static void Main(string[] args)
    {
        // Should pass
        TryComplex("(1.0,0.5)");
        TryComplex("(1.1+0.55i)");
        TryComplex(" ( 1.023 + 0.512 j ) ");
        TryComplex("(0, -1)");
        TryComplex("(0-1i)");
        TryComplex("(-10-2j)");
        TryComplex("(-10,-3)");
        TryComplex(" ( 1.8-1i ) ");
        TryComplex(" ( 1.9+1i ) ");

        // Culture specific
        TryComplex("(1,4, 2,5)");   // (14, 25) in UK (extra ','s ignored)

        // Should fail
        TryComplex(" ( 1,1i ) ");
        TryComplex("(1,4,2,5)");
        TryComplex(" ( 1.023 + 0.512 + j ) ");
        TryComplex(" ( 1.023, 0.512 j ) ");
        TryComplex(" ( 1.023i 0.512 j ) ");

        Console.ReadKey();  // Wait to close the console window
    }

    static void TryComplex(string text)
    {
        Console.Write($"Trying {text}: ");

        try
        {
            Complex result = text.ComplexParse();
            Console.WriteLine($"({result.Real}, {result.Imaginary})");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"*** Failed: {ex.Message} ***");
        }
    }
}

Note: For these to work, I have used

using System.Numerics;
using static ComplexParser.Complex2;    // Where ComplexParser is my outer namespace that contains the static class Complex2

to save having to use namespace prefixes

Hope this is of some use.

Richard Deeming17-May-22 4:26

Richard Deeming

17-May-22 4:26

There's a few edge cases that would break that code - including complex numbers shown in the Microsoft docs. For example:

TryComplex("(-8.98846567431158E+307, -8.98846567431158E+307)");

That's probably why Microsoft doesn't support the X+Yi syntax by default. Smile | :)

"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer

jsc4217-May-22 6:05

17-May-22 6:05

There's probably a lot of edge cases that would break the code. It uses the QAD design model (Quick And Dirty) aka "just good enough".

jsc4217-May-22 23:16

"interface hack" to make private nested class instances available to outer class methods ?

17-May-22 23:16

I've just tried your example (plus its x+yi and x-yi equivalents) with the code that I wrote yesterday and the results are not as bad as one might have expected:

Trying (-8.98846567431158E+307, -8.98846567431158E+307): (-8.98846567431158E+307, -8.98846567431158E+307)
Trying (-8.98846567431158E+307,-8.98846567431158E+307): (-8.98846567431158E+307, -8.98846567431158E+307)
Trying (-8.98846567431158E+307+-8.98846567431158E+307i): *** Failed: Complex number format not recognised (multiple '+' chars) ***
Trying (-8.98846567431158E+307-8.98846567431158E+307i): *** Failed: Complex number format not recognised (multiple '+' chars) ***

The sample you cited works! As does dropping the space after the comma.
The x+yi and x-yi equivalents do throw an exception, but the exception message is reasonably explicit as to where the problem is. If the OP wants to check for + after an E/e followed by zero or more spaces then I'll leave it as an exercise ... it isn't rocket science to do, but could get a bit messy.

BillWoodruff11-May-22 2:25

BillWoodruff

11-May-22 2:25

If you are not familiar with this technique, I will publish a Tip/Trick soon.

Assuming you know how a nested inner class (which implements an Interface) can be declared 'private, and still be accessed by public methods in the enclosing outer class: which does make direct access to inner classes of the OuterClass prohibited.

Do you think the technique shown here is evil, undesirable, or ... ?

usage:

// necessary depending on use
// using NestedClassExample1;

OuterClass1 oc1 = new OuterClass1();

var cat1 = oc1.AddSomething(new Cat("cat1", "meow"));
var cat2 = oc1.AddSomething(new Cat("cat2", "hiss"));
var dog1 = oc1.AddSomething(new Dog("dog1"));

var cat1instance = oc1.GetSomething("cat1");

class:

using System;
using System.Collections.Generic;
using System.Linq;

namespace NestedClassExample1
{
    public interface ISomething1
    {
        string Name { get; }
    }

    public class OuterClass1
    {
        private List<ISomething1> Somethings = new List<ISomething1>();

        internal ISomething1 AddSomething(ISomething1 newsomething)
        {
            Somethings.Add(newsomething);
            return newsomething;
        }

        internal ISomething1 GetSomething(string name)
        {
            return Somethings.FirstOrDefault(smtng => smtng.Name == name);
        }
    }

    public class Cat : ISomething1
    {
        public Cat(string name, string sound = "")
        {
            Name = name;
            CatSound = sound;
        }
        public string Name { get; }
        public string CatSound { set; get; }
    }

    public class Dog : ISomething1
    {
        public Dog(string name, string sound = "")
        {
            Name = name;
            DogSound = sound;
        }

        public string Name { get; }
        public string DogSound { set; get; }
    }

    public class Tiger : ISomething1
    {
        public Tiger(string name) { Name = name; }
        public string Name { get; }
    }
}

«The mind is not a vessel to be filled but a fire to be kindled» Plutarch

modified 12-May-22 6:18am.

Re: "interface hack" to make private nested class instances available to outer class methods ?

OriginalGriff11-May-22 3:15