
#r "BoSSSpad.dll"

using System;
using System.Collections.Generic;
using System.Linq;
using ilPSP;
using ilPSP.Utils;
using BoSSS.Platform;
using BoSSS.Foundation;
using BoSSS.Foundation.Grid;
using BoSSS.Foundation.Grid.Classic;
using BoSSS.Foundation.IO;
using BoSSS.Solution;
using BoSSS.Solution.Control;
using BoSSS.Solution.GridImport;
using BoSSS.Solution.Statistic;
using BoSSS.Solution.Utils;
using BoSSS.Solution.Gnuplot;
using BoSSS.Application.BoSSSpad;
using BoSSS.Application.XNSE_Solver;
using static BoSSS.Application.BoSSSpad.BoSSSshell;
Init();


int i;


i = 9;

i


int j    = 9;
double x = 4.6;


i = j + (int)x; // cast x to int; add to j; store result in i
i


double y = j + x;
y


y = y + 1;
y


y += 1;
y


y++;
y


string s = "some Text";

s

some Text


string t = " and more string";


s + t

some Text and more string


s + t + ": " + j

some Text and more string: 9


int[] A = new int[5];

A


A[2] = 7;

A


string[] B = new string[] { "Zero", "One", "Two" };

B


int[,] M = new int[3,4];
M[2,1] = 3;


MultidimensionalArray Q = MultidimensionalArray.Create(5,3,4);


class MyVector {
    // public variables. 
    public double x;
    public double y;
    public string Name;
}


(5,19): warning CS0649: Field 'MyVector.Name' is never assigned to, and will always have its default value null


(4,19): warning CS0649: Field 'MyVector.y' is never assigned to, and will always have its default value 0


(3,19): warning CS0649: Field 'MyVector.x' is never assigned to, and will always have its default value 0


MyVector vec = new MyVector();


vec.x    = 1.2;
vec.y    = 4.1;
vec.Name = "BoSSS";


MyVector vec2 = new MyVector();


vec2.x    = -3.1;
vec2.y    = 22.4;
vec2.Name = "Another BoSSS";


vec.Name

BoSSS


vec2.Name

Another BoSSS


class MyAdvancedVector {
    // two private variables, which cannot be accessed from outside:
    double x;    
    double y;
 
    // a function which only manipulates internal data, but has neither 
    // a return value nor an input argument:
    public void Rotate90Deg() {
        double temp = x; // back-up x in a local variable
        x           = y; // overwrite x
        y           = -temp; // set y
    }
 
    // a function with an input argument:
    public void Scale(double factor) {
        x *= factor; 
        y *= factor;   
    }
 
    // a function which only returns a value:
    public double LengthSquared() {
        double sqSum = 0;;
        sqSum += x*x; 
        sqSum += y*y; 
        return sqSum; // returning the result of the function   
    }
 
    // a function with multiple input arguments, and a return value;
    // to avoid confusion, it is better to chose names for the input arguments
    // that do not conflict with member variables:
    public double Set_xy(double new_x, double new_y) {
        x = new_x;
        y = new_y;
        return LengthSquared();
    }
}


MyAdvancedVector vecX = new MyAdvancedVector();


vecX.LengthSquared()


vecX.Set_xy(2,3)


vecX.Rotate90Deg()


vecX.LengthSquared()


class PropertiesDemo {
    // a private variable:
    int i1;
 
    // reading/setting the value through methods:
    // (old-fashioned)
    public int Get_i1() {
        return i1;    
    }
    public void Set_i1(int new_i1) {
        // here, one can put code to perform additional operations,
        // e.g. check that the passed argument is positive, (if this is desired)    
        i1 = new_i1;
    }
 
    // reading/setting the value i1 through a property
    public int I1 {
        get {
            // the get-part: like a function, 
            //    * no arguments
            //    * returns int
            return i1;
        }    
        set {
            // the set-part: like a function, 
            //    * one argument of type int, vamed value
            //    * no return value/void return value
            i1 = value;
        }
    }
}


PropertiesDemo p = new PropertiesDemo();


p.Set_i1(49);


p.Get_i1()


p.I1


p.I1 = 33;


p.I1


class StaticDemo {
    // in addition to normal functions, static functions are decorated
    // with the keyword static:
    static public int Summation(int a, int b) {
        return a + b;
    }    
}


StaticDemo.Summation(1, 2)


Console.WriteLine("Hello World!");

Hello World!


Math.Sin(2.0);


System.Console.WriteLine("Hello World!");

Hello World!


System.Math.Sin(2.0);


System.Collections.BitArray ba = new System.Collections.BitArray(3);


using System.Collections;


BitArray ba = new BitArray(3);


Random rnd       = new Random(); // Generate new random number generator object
double randomVal = rnd.NextDouble();
Console.WriteLine("Random number is " + randomVal);
 
// here, the if-clause
if(randomVal > 0.5) { // some condition, which is ether true or false
    // Code that will be executed when the condition is true
    Console.WriteLine("greater than 1/2");    
} else {
    // Code that will be executed when the condition is false
    Console.WriteLine("smaller or equal to 1/2");  
}

Random number is 0.8152774167597996

greater than 1/2


int J = 7;
for(int j = 0; j < J; j++) {
    // code which is executed repeatedly 
    double s = Math.Sin(j);
    Console.WriteLine("The sinus of " + j + " is " + s);
}

The sinus of 0 is 0

The sinus of 1 is 0.8414709848078965

The sinus of 2 is 0.9092974268256817

The sinus of 3 is 0.1411200080598672

The sinus of 4 is -0.7568024953079282

The sinus of 5 is -0.9589242746631385

The sinus of 6 is -0.27941549819892586


double[] SomeValues = new double[] { 1.2, -3.4, 7.3, 3.1, 3.14 };
foreach(double x in SomeValues) {
    double s = Math.Sin(x);
    Console.WriteLine("The sinus of " + x + " is " + s);
}

The sinus of 1.2 is 0.9320390859672263

The sinus of -3.4 is 0.2555411020268312

The sinus of 7.3 is 0.8504366206285644

The sinus of 3.1 is 0.04158066243329049

The sinus of 3.14 is 0.0015926529164868282


class DelDemo {
    public static double Pow2(int x, float z) {
        return x*x*z;
    }
    public static void Print(int x, double y) {
        Console.Write("Got the numbers " + x + " and " + y + ".");
    }    
}


Func<int,float,double> delPow2 = DelDemo.Pow2;


delPow2(2, 1.1f)


Action<int,double> a = DelDemo.Print;


a(1,1.2)

Got the numbers 1 and 1.2.


delPow2 = delegate(int x, float z) {
    double retval;
    retval = x*x*z*2.0;
    return retval;
};


delPow2(2, 1.1f);


delPow2 = (x, z) => x*x*z*4.0;


delPow2(2, 1.1f)


Action<Action<int,double>,Func<int,float,double>,int> apply = 
    delegate(Action<int,double> act, Func<int,float,double> fun, int i) {
        float f = 1.0f;
 
        double y = fun(i, f); // apply function 'fun' to argument 'i'
        act(i, y);            // hand both numbers to action 'act'
 
        return; 
    };


apply(a,delPow2,2);

Got the numbers 2 and 16.


class BaseClass {
    public int num;     
 
    // this is a normal method, which will be accessible form 
    // any derived class
    public void Method1() {
        Console.WriteLine("BaseClass: Hello from Method1, num is " + num);    
    }
 
    // this is a virtual method, its functionality can be overriden in derived
    // classes
    public virtual void VirtMeth(int i) {
        Console.WriteLine("BaseClass: VirtMethod, i is " + i);
    }
}


(2,16): warning CS0649: Field 'BaseClass.num' is never assigned to, and will always have its default value 0


class DerivA : BaseClass { // indicates that thes class is derived 
                           // from 'BaseClass'
 
    // We can add new members:
    public double SomeVal;
 
    // a private member:
    Random rnd = new Random();
 
    // And override functionality from the base class
    public override void VirtMeth(int i) {
        SomeVal = rnd.NextDouble() + i;
        Console.WriteLine("DerivA: VirtMethod, random value is " + SomeVal);     
    }
}


class DerivB : BaseClass {
 
    // Again, some override:
    public override void VirtMeth(int i) {
        num += i; // we can modify members of the base class
        Console.WriteLine("DerivB: VirtMethod, num is " + num);     
    }
}


BaseClass b = new BaseClass();
b.Method1();
b.VirtMeth(1); // calls base implementation

BaseClass: Hello from Method1, num is 0

BaseClass: VirtMethod, i is 1


BaseClass b = new DerivA(); // we instantiate an object of type 'DerivA'
                            // but the variable is of type 'BaseClass'.
b.Method1();   // non-overridden functionality: from base implementation
b.VirtMeth(1); // calls override implementation

BaseClass: Hello from Method1, num is 0

DerivA: VirtMethod, random value is 1.2455715600832251


b = new DerivB();
b.Method1();
b.VirtMeth(1); // 'DerivB.VirtMeth' modifies the internal state of the object,
b.VirtMeth(1); // so the result is different for each call

BaseClass: Hello from Method1, num is 0

DerivB: VirtMethod, num is 1

DerivB: VirtMethod, num is 2


object o; // The 'object' keyword is a build-in alias for 'System.Object'
o = new BaseClass();
o.ToString()  // 'ToString' is a virtual method of 'System.Object', which,
              // if not overriden only retunrs the name of the class

Submission#69+BaseClass


abstract class AbstractBase { // if the class conatains any abstract member,
                              // it must be declared as abstract.
 
    public int num;     
 
    // like above, a normal method:
    public void Method1() {
        Console.WriteLine("AbstractBase: Hello from Method1, num is " + num);    
    }
 
    // this is an abstract method, for which only the 
    // signature (return value, arguments, etc.) is specified, but no 
    // implementation is given:
    public abstract void VirtMeth(int i);
}


(4,16): warning CS0649: Field 'AbstractBase.num' is never assigned to, and will always have its default value 0


class DerivC : AbstractBase {
    // we are enforced to override the base method
    public override void VirtMeth(int i) {
        Console.WriteLine("DerivC: VirtMeth, i is " + i);    
    }
}


AbstractBase a;   // use 'AbstractBase' as a variable type
a = new DerivC(); // instantiate a 'DerivC' object, store it in 'a'
a.VirtMeth(2);    // call the objects methods

DerivC: VirtMeth, i is 2


interface IMethodsInterface {
    void MethodA(); // methods in an interface are always public and need   
    void MethodB(); // no modifier.
    public void MethodC() {
        Console.WriteLine("DerivD: MethodA");
    }
}


interface IPropertyInterface {
    int Property { get; set; }    
}


class DerivD : AbstractBase, IMethodsInterface, IPropertyInterface {
    // form 'AbstractBase'
    public override void VirtMeth(int i) {
        Console.WriteLine("DerivD: VirtMeth, i is " + i);    
    }
 
    // from 'IMethodsInterface'
    public void MethodA() {
        Console.WriteLine("DerivD: MethodA");
    }
    public void MethodB() {
        Console.WriteLine("DerivD: MethodB");
    }
 
    // form 'IPropertyInterface'
    public int Property { 
        get { 
            Console.WriteLine("This is the get property.");
            return num;  
        } 
        set { num = value; }
    }
}


DerivD d = new DerivD();
d.VirtMeth(1);
d.MethodB();

DerivD: VirtMeth, i is 1

DerivD: MethodB


IMethodsInterface imd = new DerivD();
imd.MethodA();
imd.MethodB();

DerivD: MethodA

DerivD: MethodB


IPropertyInterface ipd = new DerivD();
ipd.Property           = 44;
ipd.Property

This is the get property.


int i = 9;           // int-definition


double i = 1.1;      // double-definition


Math.Cos(i)         // depends on last 'i'

C# and Jupyter/BoSSSpad introduction¶

Whats new?¶

Declaration of primitive variables¶

Note:¶

Arrays¶

Multi-dimensional arrays¶

Classes¶

Member Functions (Methods)¶

Properties¶

Static functions¶

Class libraries and Namespaces¶

Control Flow¶

Functions, Methods and Delegates¶

Inheritance¶

Abstract Classes¶

Interfaces¶

Note:¶

Further reading¶

index	value
0	0
1	0
2	0
3	0
4	0

index	value
0	0
1	0
2	7
3	0
4	0

index	value
0	Zero
1	One
2	Two