private static void drawContour(IList <PointF> controlPoints, Image <Bgr, byte> image)
{
const float CONTOUR_TENSION = 0;
/******************** contour and control points *********************/
var pointIndices = CardinalSpline.GetEqualyDistributedPointIndices(controlPoints, CONTOUR_TENSION, 500);
var points = CardinalSpline.InterpolateAt(controlPoints, CONTOUR_TENSION, pointIndices);
var normals = new List <LineSegment2DF>();
var normalIndices = CardinalSpline.GetEqualyDistributedPointIndices(controlPoints, CONTOUR_TENSION, 100);
foreach (var idx in normalIndices)
{
var pt = CardinalSpline.InterpolateAt(controlPoints, CONTOUR_TENSION, idx);
var normalDirection = CardinalSpline.NormalAt(controlPoints, CONTOUR_TENSION, idx);
var orientation = (int)Angle.ToDegrees(System.Math.Atan2(normalDirection.Y, normalDirection.X));
var normal = getLine(orientation, pt, 20);
normals.Add(normal);
}
/******************** contour and control points *********************/
image.Draw(points.ToArray(),
Bgr8.Blue,
3);
image.Draw(controlPoints.Select(x => new CircleF(x, 3)), Bgr8.Red, 3);
image.Draw(normals, Bgr8.Green, 3, false);
}
public static Vector GetCoef_2h(int degree)
{
double[] ksi = GetCardinalValue(degree, 1d);
Matrix A = new Matrix(degree + 1);
Vector y = new Vector(degree + 1);
for (int i = 0; i < y.Length; i++)
{
y[i] = CardinalSpline.Cardinal(degree, i + 1, 0d, 2d);
}
for (int i = 0; i < degree + 1; i++)
{
for (int j = 0; j < ksi.Length; j++)
{
if (i - j >= 0)
{
A[i, i - j] = ksi[ksi.Length - 1 - j];
}
}
}
Matrix A_t = Matrix.Transpose(A);
Console.WriteLine("y = " + y);
Console.WriteLine("A_T*A = " + A);
Vector c = new Vector();
c = Solver.BCGSTAB(A, y, 0.0000001d);
Console.WriteLine("SUM c = " + MyMath.Basic.SumArray(c.ToArray));
return(c);
}
public static Matrix D1_Matrix(int SIZE, double a_border, double b_border,
ICardinalStratagy calculate)
{
int degree = 3;
int N = SIZE;
int M = N + degree - 2;
int m = degree - 2;
Matrix U = new Matrix(m, M);
double h = MyMath.Basic.GetStep(N, a_border, b_border);
CardinalSpline spline = new CardinalSpline(calculate);
Matrix D = (1d / h) * CardinalOperators.DerevetiveMatrix(degree, SIZE);
//условие 1: (c,ksi(a)) = u0
Vector ksi_a = spline.SplineVector(a_border, a_border, b_border, N, degree);
for (int i = 0; i < M; i++)
{
U[0, i] = ksi_a[i];
}
//-------------
//Составляем линейную систему
Matrix A = ConstructMatrix(D, U);
return(A);
}
//u'' = f; u(a) = u0 u(b) = u1
public static void SolveSecondDerevetivWhithBounderyCondition(int SIZE, double a_border, double b_border,
ICardinalStratagy calculate,
double u0, double u1, FunctionLib.Function function)
{
int degree = 4;
int N = SIZE;
int M = N + degree - 2;
int m = degree - 2;
Matrix U = new Matrix(m, M);
double h = MyMath.Basic.GetStep(N, a_border, b_border);
CardinalSpline spline = new CardinalSpline(calculate);
Matrix D = (1d / Math.Pow(h, m)) * CardinalOperators.DerevetiveMatrix(degree, SIZE);
//условие 1: (c,ksi(a)) = u0
Vector ksi_a = spline.SplineVector(a_border, a_border, b_border, N, degree);
//условие 1: (c,ksi(b)) = u1
Vector ksi_b = spline.SplineVector(b_border, a_border, b_border, N, degree);
for (int i = 0; i < M; i++)
{
U[0, i] = ksi_a[i];
U[1, i] = ksi_b[i];
}
//-------------
//Составляем линейную систему
Matrix A = ConstructMatrix(D, U);
//Составляем правую часть
Vector b = MyMath.Basic.GetVectorFunction(N, a_border, b_border, function);
Vector y = Matrix.Transpose(D) * b;
Vector y_prime = new Vector(y.Length + m);
y_prime[y.Length] = u0;
y_prime[y.Length + 1] = u1;
for (int i = 0; i < y.Length; i++)
{
y_prime[i] = y[i];
}
Console.WriteLine("right part = " + y_prime);
// Console.WriteLine(A);
Vector x = Solver.BCG(A, y_prime, 0.0001d);
Console.WriteLine("x = " + x);
Vector c = x.SubVector(0, M);
Vector f = spline.GetVectorFunction(N, a_border, b_border, c, h, degree);
Console.WriteLine("f = " + f);
f = spline.GetVectorFunction(10 * N, a_border, b_border, c, h, degree);
b = MyMath.Basic.GetVectorFunction(10 * N, a_border, b_border, function);
Console.WriteLine("||err|| = " + (f - b).Norm);
}
public MovementDolly(UnitView UnitView, Path <Tile> Path, Unit Carrier)
{
_End = Path.Destination.Center;
if (Path.Distance > 0)
{
_Spline = new CardinalSpline();
foreach (Tile t in Path.Nodes.Where((x, i) => i % 2 == 0 || i == Path.Nodes.Count() - 1))
{
_Spline.Points.Add(t.Center);
}
bool unlimitedMove = Carrier == null
? UnitView.Unit.Configuration.HasUnlimitedMovement()
: Carrier.Configuration.HasUnlimitedMovement();
if (unlimitedMove)
{
_SpeedRecipricol = .0002;
}
else
{
float move = Carrier == null
? UnitView.Unit.Configuration.Movement
: Carrier.Configuration.Movement;
_SpeedRecipricol = .0002 * move / Path.Distance;
}
}
else
{
_Traveled = 1;
}
}
public void DrawControlGridSplines()
{
if (surface.controlPoints == null)
{
//surface.controlPoints = new Array2D<Vector3>(surface.NumberOfControlPointsWidth, surface.NumberOfControlPointsHeight, new Vector3());
return;
}
for (int x = 1; x < surface.NumberOfControlPointsWidth - 1; x++)
{
List <Vector3> points = new List <Vector3>();
for (int y = 0; y < surface.NumberOfControlPointsHeight; y++)
{
points.Add(surface.controlPoints[x, y]);
}
CardinalSpline.DrawCurveGizmo(points, 0.5f, Color.red);
}
for (int y = 1; y < surface.NumberOfControlPointsHeight - 1; y++)
{
List <Vector3> points = new List <Vector3>();
for (int x = 0; x < surface.NumberOfControlPointsWidth; x++)
{
points.Add(surface.controlPoints[x, y]);
}
CardinalSpline.DrawCurveGizmo(points, 0.5f, Color.red);
}
}
public void pr_coef_test1()
{
for (int i = 2; i < 10; i++)
{
Vector c = new Vector(CardinalSpline.pr_coef(i));
Console.WriteLine(c);
}
}
public static double[] GetCardinalValue(int degree, double h)
{
double[] mas = new double[degree - 1];
for (int i = 0; i < degree - 1; i++)
{
mas[i] = CardinalSpline.Cardinal(degree, (i + 1) * h, 0, h);
}
return(mas);
}
private static double[] GetCardinalValue(int degree)
{
double[] mas = new double[degree - 1];
for (int i = 0; i < degree - 1; i++)
{
mas[i] = CardinalSpline.Cardinal(degree, (i + 1), 0d, 1d);
}
return(mas);
}
public void CardinalSpline_SplineVector_Test1()
{
double a = 0, b = 1, x = 0.05;
CardinalSpline spline = new CardinalSpline();
Vector ksi = spline.SplineVector(x, a, b, 5, 5);
Console.WriteLine(ksi + " sum = " + MyMath.Basic.SumArray(ksi.ToArray));
}
public static void DrawCurveGizmo(List <Vector3> points, float s, Color color)
{
List <Vector3> tmpSplinePoints = CardinalSpline.CalculateSplinePoints(points, s, points.Count * 10);
//Debug.Log(tmpSplinePoints.Count);
Gizmos.color = color;
for (int i = 0; i < tmpSplinePoints.Count - 1; i++)
{
Gizmos.DrawLine(tmpSplinePoints[i], tmpSplinePoints[i + 1]);
}
}
public static void DrawCurve(Vector3 P1, Vector3 P2, Vector3 P3, Vector3 P4, float s, int numberOfPoints, Color color)
{
List <Vector3> tmpSplinePoints = CardinalSpline.CalculateSplinePoints(P1, P2, P3, P4, s, numberOfPoints);
Debug.Log(tmpSplinePoints.Count);
Gizmos.color = color;
for (int i = 1; i < tmpSplinePoints.Count; i++)
{
Gizmos.DrawLine(tmpSplinePoints[i - 1], tmpSplinePoints[i]);
}
}
public Vector3 P(int i, int j, float u, float w)
{
Vector3 P3 = CardinalSpline.P(controlPoints[i + 3, j], controlPoints[i + 3, j + 1], controlPoints[i + 3, j + 2], controlPoints[i + 3, j + 3], w, 0.5f);
Vector3 P2 = CardinalSpline.P(controlPoints[i + 2, j], controlPoints[i + 2, j + 1], controlPoints[i + 2, j + 2], controlPoints[i + 2, j + 3], w, 0.5f);
Vector3 P1 = CardinalSpline.P(controlPoints[i + 1, j], controlPoints[i + 1, j + 1], controlPoints[i + 1, j + 2], controlPoints[i + 1, j + 3], w, 0.5f);
Vector3 P0 = CardinalSpline.P(controlPoints[i + 0, j], controlPoints[i + 0, j + 1], controlPoints[i + 0, j + 2], controlPoints[i + 0, j + 3], w, 0.5f);
Vector3 result = CardinalSpline.P(P0, P1, P2, P3, u, 0.5f);
return(result);
}
public static Matrix D4_B_Matrix(int SIZE, double a_border, double b_border,
ICardinalStratagy calculate)
{
int degree = 6;
int N = SIZE;
int M = N + degree - 2;
int m = degree - 2;
double alpha = 0.5d;
Matrix U = new Matrix(m, M);
double h = MyMath.Basic.GetStep(N, a_border, b_border);
double h4 = Math.Pow(h, 4);
CardinalSpline spline = new CardinalSpline(calculate);
Matrix D = (1d / h4) * CardinalOperators.DerevetiveMatrix(degree, SIZE) +
(-Math.Pow(alpha, 1)) * CardinalOperators.InterpolateConditionMatrix(degree, SIZE, calculate);
//условие 1: (c,ksi(a)) = u0
Vector ksi_a = spline.SplineVector(a_border, a_border, b_border, N, degree);
//условие 1: (c,ksi(b)) = u1
Vector ksi_b = spline.SplineVector(b_border, a_border, b_border, N, degree);
//условие 2: (c,TD2*ksi(a,deg - 2)) = du0
Matrix D2 = Matrix.Transpose(((1d / Math.Pow(h, 2)) * CardinalOperators.DerevetiveMatrix(4, SIZE + 2)));
Vector Dksi_a = D2 * spline.SplineVector(a_border, a_border, b_border, N, degree - 2);
//условие 2: (c,TD2*ksi(a,deg - 2)) = du1
Vector Dksi_b = D2 * spline.SplineVector(b_border, a_border, b_border, N, degree - 2);
for (int i = 0; i < M; i++)
{
U[0, i] = ksi_a[i];
U[1, i] = ksi_b[i];
U[2, i] = Dksi_a[i];
U[3, i] = Dksi_b[i];
}
//-------------
//Составляем линейную систему
Matrix A = ConstructMatrix(D, U);
return(A);
}
//Первая тестовая функция для решения дифференциального уравнения второго порядка
public static void SolveSecondDerevitiveEquation(int GridSize, double a_border, double b_border,
ICardinalStratagy calculate,
double u0, double u1, FunctionLib.Function function)
{
int N = GridSize;
int degree = 4;
double h = MyMath.Basic.GetStep(N, a_border, b_border);
CardinalSpline spline = new CardinalSpline(calculate);
Vector f = MyMath.Basic.GetVectorFunction(N, a_border, b_border, function);
Matrix D = CardinalDifferentialEquation.SecondDirevetive(N);
Matrix DD = D * Matrix.Transpose(D);
// Console.WriteLine(DD);
Matrix A = (1d / (h * h)) * DD;
Console.WriteLine(D * f);
Vector Dy = D * f;
Vector b = new Vector(N + 4);
for (int i = 0; i < N + 2; i++)
{
b[i] = Dy[i];
}
b[N + 2] = u0;
b[N + 3] = u1;
Console.WriteLine("b = " + b);
Matrix B = new Matrix(N + 4);
for (int i = 0; i < N + 2; i++)
{
for (int j = 0; j < N + 2; j++)
{
B[i, j] = A[i, j];
}
}
for (int i = 0; i < N + 2; i++)
{
B[N + 2, i] = calculate.Cardinal(degree, a_border, a_border + (i - degree + 1) * h, h);
B[N + 3, i] = calculate.Cardinal(degree, b_border, a_border + (i - degree + 1) * h, h);
B[i, N + 2] = -B[N + 2, i];
B[i, N + 3] = -B[N + 3, i];
}
}
internal void RecalculateLength()
{
if (Node is null)
{
return;
}
Vector3 p0 = BackwardItem is PolylineItem bw
? bw.Node.Position
: Node.Rotation.ToEuler();
Vector3 p1 = Node.Position;
Vector3 p2 = ForwardNode.Position;
Vector3 p3 = ForwardItem is PolylineItem fw
? fw.ForwardNode.Position
: ForwardNode.Rotation.ToEuler();
Length = CardinalSpline.ApproximateLength(p0, p1, p2, p3, 1.2f);
}
public static Matrix Create_Ah(int degree, int Size)
{
Matrix Ah = new Matrix(Size);
int p = degree;
for (int i = 0; i < Size; i++)
{
for (int j = 0; j < Size; j++)
{
Ah[i, j] = 2.0 * CardinalSpline.Cardinal(2 * (p - 1), (i - j) + p - 1, 0, 1);
//if(i - j + 1 < Size)
Ah[i, j] -= CardinalSpline.Cardinal(2 * (p - 1), (i - j) + p - 1 + 1, 0, 1);
//if (i - j - 1 >= 0)
Ah[i, j] -= CardinalSpline.Cardinal(2 * (p - 1), (i - j) + p - 1 - 1, 0, 1);
}
}
return(Ah);
}
private static ITemplate create(IEnumerable <PointF> normalizedPoints,
int scale,
int rotation,
string label = "")
{
var pointTransform = Transforms2D.Combine
(
Transforms2D.Scale(scale, scale),
Transforms2D.Rotation((float)Angle.ToRadians(rotation))
);
var transformedPts = normalizedPoints.Transform(pointTransform).ToList();
var boundingRect = transformedPts.BoundingRect();
var offset = boundingRect.Location;
transformedPts = transformedPts.Transform(Transforms2D.Translation(-offset.X, -offset.Y)).ToList();
var template = new OpenHandTemplate();
var features = new List <Feature>();
//var validIdxRange = CardinalSpline.ValidIndicesRange(transformedPts.Count);
//for (int i = validIdxRange.Min; i <= validIdxRange.Max; i++)
for (int i = CardinalSpline.MIN_INDEX; i < (transformedPts.Count - 1 - CardinalSpline.MAX_INDEX_OFFSET); i++)
{
var intPt = transformedPts[i].Round();
var direction = CardinalSpline.NormalAt(transformedPts, CONTOUR_TENSION, i);
var orientDeg = (int)Angle.ToDegrees(Math.Atan2(direction.Y, direction.X));
orientDeg = (int)Angle.NormalizeDegrees(orientDeg + 180);
var feature = createFeature(intPt.X, intPt.Y, orientDeg);
features.Add(feature);
}
template.Features = features.ToArray();
template.Size = Size.Round(boundingRect.Size);
template.ClassLabel = label;
return(template);
}
public static void MIN_Interpolation_Test(FunctionLib.Function func, ref Vector x, ref Vector expect, ref Vector actual, int degree, int Size, double a_border, double b_border)
{
//setup
double a = a_border;
double b = b_border;
int GridSize = Size;
int deg = degree;
Vector grid = Vector.CreateUniformGrid(GridSize, a, b);
double h = MyMath.Basic.GetStep(GridSize, a, b);
Vector y = MyMath.Basic.GetVectorFunction(GridSize, a, b, func);
Grid tau = new Grid(deg, grid, grid[0], grid.Last, true);
tau.ToPeriodiclineGrid();
//run
Vector min_c = Spline.InterpolateExperiment.Interpolate_By_CardinalSpline(y, deg, h);
// Console.WriteLine("c = " + c);
Console.WriteLine("min_c = " + min_c);
Console.WriteLine("Степень сплайна = " + deg);
//compare
int N = 10 * GridSize;
expect = MyMath.Basic.GetVectorFunction(N - 1, a, b, func);
CardinalSpline spline = new CardinalSpline();
actual = spline.GetVectorFunction(N - 1, a, b, min_c, h, deg);
x = Vector.CreateUniformGrid(N - 1, a, b);
Vector bf = spline.GetVectorFunction(GridSize, a, b, min_c, h, deg);
double result = (expect - actual).Norm;
double interpolation = (y - bf).Norm;
Console.WriteLine("значение f(x) = " + y.ToString());
Console.WriteLine("значение bf(x) = " + bf.ToString());
Console.WriteLine("||c|| = " + min_c.Norm.ToString("0.000000"));
Console.WriteLine("||f - spline|| = " + result.ToString("0.000000"));
}
public static Matrix Create_D2_Ah(int degree, int Size)
{
Matrix Ah = new Matrix(Size);
int p = degree;
int q = p - 2;
for (int k = 0; k < Size; k++)
{
for (int j = 0; j < Size; j++)
{
Ah[k, j] = 6d * CardinalSpline.Cardinal(2 * q, (k - j) + q, 0, 1);
//if (j + 1 < Size)
Ah[k, j] -= 4d * CardinalSpline.Cardinal(2 * q, (k - j) + q + 1, 0, 1);
//if (j - 1 >= 0)
Ah[k, j] -= 4d * CardinalSpline.Cardinal(2 * q, (k - j) + q - 1, 0, 1);
//if ( j + 2 < Size)
Ah[k, j] += CardinalSpline.Cardinal(2 * q, (k - j) + q + 2, 0, 1);
//if (j - 2 >= 0)
Ah[k, j] += CardinalSpline.Cardinal(2 * q, (k - j) + q - 2, 0, 1);
}
}
return(Ah);
}
public void Awake()
{
cardinalSpline = target as CardinalSpline;
}
public void Test()
{
int N = 10;
int degree = 2;
double h = 1;
double a_border = 0, b_border = 1;
double u0 = 1;
Matrix D = CardinalDifferentialEquation.FirstDirevetive(N);
Matrix KSI = CardinalDifferentialEquation.CreateKSIMatrix(degree, h, N + 1);
Matrix DD = D * Matrix.Transpose(D);
//KSI[0, 0] -= KSI[0, 1];
//KSI[N, N] -= KSI[0, 1];
//DD[0, 0] = DD[N, N] = 2d;
Console.WriteLine(DD);
Console.WriteLine(KSI);
Matrix A = KSI * DD;
//KSI[0, 0] += KSI[0, 1];
//KSI[N, N] += KSI[0, 1];
for (int i = 0; i < N + 1; i++)
{
A[i, i] *= 1d;
}
A = 2d * A;
//A[0, 0] = 1.5;
// A[N, N] = 1.5;
Console.WriteLine(A);
Vector y = Vector.GetConstVector(1d, N);
for (int i = 0; i < N; i++)
{
y[i] = i * h;
}
Console.WriteLine(D * y);
Vector Dy = (KSI * D) * y;
Vector b = new Vector(N + 2);
for (int i = 0; i < N + 1; i++)
{
b[i] = 2d * Dy[i];
}
b[N + 1] = u0;
Console.WriteLine("b = " + b);
Matrix B = new Matrix(N + 2);
for (int i = 0; i < N + 1; i++)
{
for (int j = 0; j < N + 1; j++)
{
B[i, j] = A[i, j];
}
}
for (int i = 0; i < N; i++)
{
B[N + 1, i] = CardinalSpline.Cardinal(degree + 1, a_border, a_border + (i - (degree + 1) + 1) * h, h);
B[i, N + 1] = -B[N + 1, i];
}
Console.WriteLine(B);
Vector x = Vector.GetConstVector(2d, N + 2);
x[N + 1] = 0;
for (int i = 0; i < N + 1; i++)
{
x[i] = i + 1;
}
Console.WriteLine("x = " + x);
Console.WriteLine("B*x = " + B * x);
Console.WriteLine("b = " + b);
Vector c = Solver.BCG(B, b, 0.00000001d);
Console.WriteLine("anser = " + c);
Console.WriteLine(B * c);
}
public void SecondDerevitiveSinTest()
{
int N = 50;
int degree = 2;
double a_border = 0, b_border = 6.29;
double h = MyMath.Basic.GetStep(N, a_border, b_border);
double u0 = FunctionLib.cos(a_border), u1 = FunctionLib.cos(b_border);
Vector f = MyMath.Basic.GetVectorFunction(N, a_border, b_border, FunctionLib.cos);
Matrix D = CardinalDifferentialEquation.SecondDirevetive(N);
Matrix DD = D * Matrix.Transpose(D);
// Console.WriteLine(DD);
Matrix A = (1d / (h * h)) * DD;
Console.WriteLine(D * f);
Vector Dy = D * f;
Vector b = new Vector(N + 4);
for (int i = 0; i < N + 2; i++)
{
b[i] = Dy[i];
}
b[N + 2] = u0;
b[N + 3] = u1;
Console.WriteLine("b = " + b);
Matrix B = new Matrix(N + 4);
for (int i = 0; i < N + 2; i++)
{
for (int j = 0; j < N + 2; j++)
{
B[i, j] = A[i, j];
}
}
for (int i = 0; i < N + 2; i++)
{
B[N + 2, i] = CardinalSpline.Cardinal(degree + 2, a_border, a_border + (i - (degree + 2) + 1) * h, h);
B[N + 3, i] = CardinalSpline.Cardinal(degree + 2, b_border, a_border + (i - (degree + 2) + 1) * h, h);
B[i, N + 2] = -B[N + 2, i];
B[i, N + 3] = -B[N + 3, i];
}
// Console.WriteLine(B);
//Console.WriteLine("b = " + b);
Vector c = Solver.BCG(B, b, 0.00000001d);
Console.WriteLine("anser = " + c);
Console.WriteLine("Ax = " + B * c);
Vector d = c.SubVector(0, N + 2);
CardinalSpline spline = new CardinalSpline();
Vector anser = spline.GetVectorFunction(10, a_border, b_border, d, h, degree + 2);
Vector expect = MyMath.Basic.GetVectorFunction(10, a_border, b_border, FunctionLib.cos);
Console.WriteLine(anser); Console.WriteLine(expect);
Console.WriteLine("||u - u_spl|| = " + (expect - anser).Norm);
}
public void SinTest()
{
int N = 50;
int degree = 2;
double a_border = 0, b_border = 6.29;
double h = MyMath.Basic.GetStep(N, a_border, b_border);
double u0 = 0;
Vector f = MyMath.Basic.GetVectorFunction(N, a_border, b_border, FunctionLib.cos);
Matrix D = CardinalDifferentialEquation.FirstDirevetive(N);
//Matrix KSI = CardinalDifferentialEquation.CreateKSIMatrix(degree, h, N + 1);
Matrix DD = D * Matrix.Transpose(D);
//KSI[0, 0] -= KSI[0, 1];
//KSI[N, N] -= KSI[0, 1];
//DD[0, 0] = DD[N, N] = 2d;
Console.WriteLine(DD);
//Console.WriteLine(KSI);
Matrix A = (1d / h) * DD;
// Console.WriteLine(A);
Console.WriteLine(D * f);
Vector Dy = D * f;
Vector b = new Vector(N + 2);
for (int i = 0; i < N + 1; i++)
{
b[i] = Dy[i];
}
b[N + 1] = u0;
Console.WriteLine("b = " + b);
Matrix B = new Matrix(N + 2);
for (int i = 0; i < N + 1; i++)
{
for (int j = 0; j < N + 1; j++)
{
B[i, j] = A[i, j];
}
}
for (int i = 0; i < N; i++)
{
B[N + 1, i] = CardinalSpline.Cardinal(degree + 1, a_border, a_border + (i - (degree + 1) + 1) * h, h);
B[i, N + 1] = -B[N + 1, i];
}
//Console.WriteLine(B);
Console.WriteLine("b = " + b);
Vector c = Solver.BCG(B, b, 0.00000001d);
Console.WriteLine("anser = " + c);
Console.WriteLine("Ax = " + B * c);
Vector d = c.SubVector(0, N + 1);
CardinalSpline spline = new CardinalSpline();
Vector anser = spline.GetVectorFunction(100, a_border, b_border, d, h, degree + 1);
Vector expect = MyMath.Basic.GetVectorFunction(100, a_border, b_border, FunctionLib.sin);
Console.WriteLine("||u - u_spl|| = " + (expect - anser).Norm);
}
void Start()
{
spline = new CardinalSpline(tension);
step = (float)1 / divisions;
}
//u'''' - alpha*u = f; u(a) = u0 u(b) = u1; u(a) = du0 u(b) = du1
public static void D4_B_bc(int SIZE, double a_border, double b_border,
ICardinalStratagy calculate,
double u0, double u1, double du0, double du1,
FunctionLib.Function function)
{
int degree = 6;
int N = SIZE;
int M = N + degree - 2;
int m = degree - 2;
double alpha = 0.5d;
Matrix U = new Matrix(m, M);
double h = MyMath.Basic.GetStep(N, a_border, b_border);
double h4 = Math.Pow(h, 4);
CardinalSpline spline = new CardinalSpline(calculate);
Matrix D = (1d / h4) * CardinalOperators.DerevetiveMatrix(degree, SIZE) +
(-Math.Pow(alpha, 1)) * CardinalOperators.InterpolateConditionMatrix(degree, SIZE, calculate);
//условие 1: (c,ksi(a)) = u0
Vector ksi_a = spline.SplineVector(a_border, a_border, b_border, N, degree);
//условие 1: (c,ksi(b)) = u1
Vector ksi_b = spline.SplineVector(b_border, a_border, b_border, N, degree);
//условие 2: (c,TD2*ksi(a,deg - 2)) = du0
Matrix D2 = Matrix.Transpose(((1d / Math.Pow(h, 2)) * CardinalOperators.DerevetiveMatrix(4, SIZE + 2)));
Vector Dksi_a = D2 * spline.SplineVector(a_border, a_border, b_border, N, degree - 2);
//условие 2: (c,TD2*ksi(a,deg - 2)) = du1
Vector Dksi_b = D2 * spline.SplineVector(b_border, a_border, b_border, N, degree - 2);
for (int i = 0; i < M; i++)
{
U[0, i] = ksi_a[i];
U[1, i] = ksi_b[i];
U[2, i] = Dksi_a[i];
U[3, i] = Dksi_b[i];
}
//-------------
//Составляем линейную систему
Matrix A = ConstructMatrix(D, U);
//Составляем правую часть
Vector b = MyMath.Basic.GetVectorFunction(N, a_border, b_border, function);
Vector y = Matrix.Transpose(D) * b;
Vector y_prime = new Vector(y.Length + m);
y_prime[y.Length] = u0;
y_prime[y.Length + 1] = u1;
y_prime[y.Length + 2] = du0;
y_prime[y.Length + 3] = du1;
for (int i = 0; i < y.Length; i++)
{
y_prime[i] = y[i];
}
Console.WriteLine("right part = " + y_prime);
//Console.WriteLine(A);
A.Save("D4.txt");
/*
* Vector x = Solver.BCG(A, y_prime, 0.0001d);
* Console.WriteLine("x = " + x);
* Vector c = x.SubVector(0, M);
* Vector f = spline.GetVectorFunction(N, a_border, b_border, c, h, degree);
* Console.WriteLine("f = " + f);
* f = spline.GetVectorFunction(10 * N, a_border, b_border, c, h, degree);
* b = MyMath.Basic.GetVectorFunction(10 * N, a_border, b_border, Math.Sin);
* Console.WriteLine("||err|| = " + (f - b).Norm);*/
}
