private static List <Func <Vector, double> > w(int dim, int order, PolynomType polynomType, List <Func <double, double> > b) { List <Func <Vector, double> > ret = new List <Func <Vector, double> >(); for (int i = order; i >= 1; --i) { List <Func <Vector, double> > left = w(dim, order - i, polynomType, b); for (int j = 0; j < dim; ++j) { Func <Vector, double> a = (xx => b[i](xx[j])); if (i == order) { ret.Add(a); } else // add linear combinations { for (j = 0; j < left.Count; ++j) { ret.Add(xx => a(xx * left[j](xx))); } } } } return(ret); }
public static List<Func<double, double>> pathBasisSystem(int order, PolynomType polynomType) { List<Func<double, double>> ret = new List<Func<double, double>>(); for (int i=0; i<=order; ++i) { switch (polynomType) { case PolynomType.Monomial: ret.Add(new MonomialFct(i).value); break; case PolynomType.Laguerre: ret.Add((x) => new GaussLaguerrePolynomial().weightedValue(i, x)); break; case PolynomType.Hermite: ret.Add((x) => new GaussHermitePolynomial().weightedValue(i, x)); break; case PolynomType.Hyperbolic: ret.Add((x) => new GaussHyperbolicPolynomial().weightedValue(i, x)); break; case PolynomType.Legendre: ret.Add((x) => new GaussLegendrePolynomial().weightedValue(i, x)); break; case PolynomType.Chebyshev: ret.Add((x) => new GaussChebyshevPolynomial().weightedValue(i, x)); break; case PolynomType.Chebyshev2th: ret.Add((x) => new GaussChebyshev2ndPolynomial().weightedValue(i, x)); break; default: throw new ApplicationException("unknown regression type"); } } return ret; }
public static List<Func<Vector, double>> multiPathBasisSystem(int dim, int order, PolynomType polynomType) { List<Func<double, double>> b = pathBasisSystem(order, polynomType); List<Func<Vector, double>> ret = new List<Func<Vector,double>>(); ret.Add((xx) => 1.0); for (int i=1; i<=order; ++i) { List<Func<Vector, double>> a = w(dim, i, polynomType, b); foreach (var iter in a) { ret.Add(iter); } } // remove-o-zap: now remove redundant functions. // usually we do have a lot of them due to the construction schema. // We use a more "hands on" method here. List<bool> rm = new InitializedList<bool>(ret.Count, true); Vector x = new Vector(dim), v = new Vector(ret.Count); MersenneTwisterUniformRng rng = new MersenneTwisterUniformRng(1234UL); for (int i=0; i<10; ++i) { int k; // calculate random x vector for (k=0; k<dim; ++k) { x[k] = rng.next().value; } // get return values for all basis functions for (k = 0; k < ret.Count; ++k) { v[k] = ret[k](x); } // find duplicates for (k = 0; k < ret.Count; ++k) { if (v.First(xx => (Math.Abs(v[k] - xx) <= 10*v[k]*Const.QL_Epsilon)) == v.First() + k) { // don't remove this item, it's unique! rm[k] = false; } } } int iter2 = 0; for (int i = 0; i < rm.Count; ++i) { if (rm[i]) { ret.RemoveAt(iter2); } else { ++iter2; } } return ret; }
public static List <Func <double, double> > pathBasisSystem(int order, PolynomType polynomType) { List <Func <double, double> > ret = new List <Func <double, double> >(); for (int i = 0; i <= order; ++i) { switch (polynomType) { case PolynomType.Monomial: ret.Add(new MonomialFct(i).value); break; case PolynomType.Laguerre: ret.Add((x) => new GaussLaguerrePolynomial().weightedValue(i, x)); break; case PolynomType.Hermite: ret.Add((x) => new GaussHermitePolynomial().weightedValue(i, x)); break; case PolynomType.Hyperbolic: ret.Add((x) => new GaussHyperbolicPolynomial().weightedValue(i, x)); break; case PolynomType.Legendre: ret.Add((x) => new GaussLegendrePolynomial().weightedValue(i, x)); break; case PolynomType.Chebyshev: ret.Add((x) => new GaussChebyshevPolynomial().weightedValue(i, x)); break; case PolynomType.Chebyshev2th: ret.Add((x) => new GaussChebyshev2ndPolynomial().weightedValue(i, x)); break; default: Utils.QL_FAIL("unknown regression type"); break; } } return(ret); }
public static List <Func <Vector, double> > multiPathBasisSystem(int dim, int order, PolynomType polynomType) { List <Func <double, double> > b = pathBasisSystem(order, polynomType); List <Func <Vector, double> > ret = new List <Func <Vector, double> >(); ret.Add((xx) => 1.0); for (int i = 1; i <= order; ++i) { List <Func <Vector, double> > a = w(dim, i, polynomType, b); foreach (var iter in a) { ret.Add(iter); } } // remove-o-zap: now remove redundant functions. // usually we do have a lot of them due to the construction schema. // We use a more "hands on" method here. List <bool> rm = new InitializedList <bool>(ret.Count, true); Vector x = new Vector(dim), v = new Vector(ret.Count); MersenneTwisterUniformRng rng = new MersenneTwisterUniformRng(1234UL); for (int i = 0; i < 10; ++i) { int k; // calculate random x vector for (k = 0; k < dim; ++k) { x[k] = rng.next().value; } // get return values for all basis functions for (k = 0; k < ret.Count; ++k) { v[k] = ret[k](x); } // find duplicates for (k = 0; k < ret.Count; ++k) { if (v.First(xx => (Math.Abs(v[k] - xx) <= 10 * v[k] * Const.QL_EPSILON)) == v.First() + k) { // don't remove this item, it's unique! rm[k] = false; } } } int iter2 = 0; for (int i = 0; i < rm.Count; ++i) { if (rm[i]) { ret.RemoveAt(iter2); } else { ++iter2; } } return(ret); }
private static List<Func<Vector, double>> w(int dim, int order, PolynomType polynomType, List<Func<double, double>> b) { List<Func<Vector, double>> ret = new List<Func<Vector,double>>(); for (int i=order; i>=1; --i) { List<Func<Vector, double>> left = w(dim, order-i, polynomType, b); for (int j=0; j<dim; ++j) { Func<Vector, double> a = (xx => b[i](xx[j])); if (i == order) ret.Add(a); else // add linear combinations for (j=0; j<left.Count; ++j) ret.Add( xx => a(xx * left[j](xx))); } } return ret; }