Chebyshev coefficients: Difference between revisions

Calculate coefficients:   cosine function,   '''10'''   coefficients,   interval   '''0   1'''

<br><br>

=={{header|11l}}==

{{trans|Python}}

 

R cos(x)

 

0.950 0.5816830895 0.5816830895 -8.98e-14

</pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

Given the limitations of the language, only 8 coefficients are calculated

dim cheby(n)

dim coef(n)

{{works with|QuickBasic|4.5}}

{{trans|FreeBASIC}}

a = 0: b = 1: n = 10

DIM cheby!(n)

 

==={{header|FreeBASIC}}===

Dim As Double i, w, j

Dim As Double a = 0, b = 1, n = 10

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

dim cheby(n)

dim coef(n)

8 : 6.5963e-10

9 : -1.0022e-11</pre>

=={{header|C}}==

C99.

#include <string.h>

#include <math.h>

return 0;

}</syntaxhighlight>

=={{header|C sharp|C#}}==

{{trans|C++}}

using System.Collections.Generic;

using System.Linq;

0.900 0.62160996827066 0.62160996827111 4.444223E-013

0.950 0.58168308946388 0.58168308946379 -8.992806E-014</pre>

=={{header|C++}}==

Based on the C99 implementation above. The main improvement is that, because C++ containers handle memory for us, we can use a more functional style.

The wrapper class ChebyshevApprox_ supports very terse user code.

 

#include <iostream>

#include <iomanip>

}

</syntaxhighlight>

=={{header|D}}==

This imperative code retains some of the style of the original C version.

 

/// Map x from range [min, max] to [min_to, max_to].

0.900 0.62160996827066445648 0.62160996827066445674 2.71e-19

0.950 0.58168308946388349416 0.58168308946388349403 -1.63e-19</pre>

=={{header|EasyLang}}==

a = 0

b = 1

print cheby[i]

.</syntaxhighlight>

=={{header|Go}}==

Wikipedia gives a formula for coefficients in a section [https://en.wikipedia.org/wiki/Chebyshev_polynomials#Example_1 "Example 1"]. Read past the bit about the inner product to where it gives the technique based on the discrete orthogonality condition. The N of the WP formulas is the parameter nNodes in the code here. It is not necessarily the same as n, the number of polynomial coefficients, the parameter nCoeff here.

 

Two variances here from the WP presentation and most mathematical presentations follow other examples on this page and so keep output directly comparable. One variance is that the Kronecker delta factor is dropped, which has the effect of doubling the first coefficient. This simplifies both coefficient generation and polynomial evaluation. A further variance is that there is no scaling for the range of function values. The result is that coefficients are not necessarily bounded by 1 (2 for the first coefficient) but by the maximum function value over the argument range from min to max (or twice that for the first coefficient.)

 

import (

1.0 0.54030231 0.54030231 -4.476e-13

</pre>

=={{header|Groovy}}==

{{trans|Java}}

static double map(double x, double min_x, double max_x, double min_to, double max_to) {

return (x - min_x) / (max_x - min_x) * (max_to - min_to) + min_to

6.59630183807991E-10

-1.0021913854352249E-11</pre>

=={{header|J}}==

From 'J for C Programmers: Calculating Chebyshev Coefficients [[http://www.jsoftware.com/learning/a_first_look_at_j_programs.htm#_Toc191734318]]

chebft =: adverb define

:

</syntaxhighlight>

Calculate coefficients:

10 (2&o.) chebft 0 1

1.64717 _0.232299 _0.0537151 0.00245824 0.000282119 _7.72223e_6 _5.89856e_7 1.15214e_8 6.59629e_10 _1.00227e_11

</syntaxhighlight>

=={{header|Java}}==

Partial translation of [[Chebyshev_coefficients#C|C]] via [[Chebyshev_coefficients#D|D]]

{{works with|Java|8}}

import java.util.function.Function;

 

6.59630183807991E-10

-1.0021913854352249E-11</pre>

=={{header|jq}}==

'''Adapted from [[#Wren|Wren]]'''

 

'''Preliminaries'''

def rpad($len; $fill): tostring | ($len - length) as $l | . + ($fill * $l)[:$l];

 

end;</syntaxhighlight>

'''Chebyshev Coefficients'''

(($x - $min)/($max - $min))*($maxTo - $minTo) + $minTo;

1.00 0.54030230 0.54030230 4.47e-13

</pre>

=={{header|Julia}}==

{{works with|Julia|0.6}}

{{trans|Go}}

 

c::Vector{Float64}

min::Float64

0.9 0.62160997 0.62160997 -4.449e-13

1.0 0.54030231 0.54030231 -4.476e-13</pre>

=={{header|Kotlin}}==

{{trans|C}}

 

typealias DFunc = (Double) -> Double

1.000 0.54030231 0.54030231 4.5e-13

</pre>

=={{header|Lua}}==

{{trans|Java}}

return (x - min_x) / (max_x - min_x) * (max_to - min_to) + min_to

end

6.5963018380799e-010

-1.0021913854352e-011</pre>

=={{header|Microsoft Small Basic}}==

{{trans|Perl}}

pi=Math.pi

a=0

9 : -0,0000000000100189955816952521

</pre>

=={{header|Nim}}==

{{trans|Go}}

 

type Cheb = object

0.9 0.62160997 0.62160997 -4.450e-13

1.0 0.54030231 0.54030231 -4.476e-13</pre>

=={{header|Perl}}==

{{trans|C}}

 

 

sub chebft {

+6.5962992e-10

-1.0021994e-11</pre>

=={{header|Phix}}==

{{trans|Go}}

<span style="color: #008080;">function</span> <span style="color: #000000;">Cheb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">cmin</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cmax</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">ncoeff</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">nnodes</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">c</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ncoeff</span><span style="color: #0000FF;">),</span>

1.0 0.54030231 0.54030231 -4.477e-13

</pre>

=={{header|Python}}==

{{trans|C++}}

 

def test_func(x):

0.900 0.6216099683 0.6216099683 4.46e-13

0.950 0.5816830895 0.5816830895 -8.99e-14</pre>

=={{header|Racket}}==

 

{{trans|C}}

 

(: chebft (Real Real Nonnegative-Integer (Real -> Real) -> (Vectorof Real)))

(define (chebft a b n func)

6.596299173544651e-010

-1.0022016549982027e-011)</pre>

=={{header|Raku}}==

(formerly Perl 6)

 

{{trans|C}}

 

my \bma = ½ × (b - a);

+6.5962992e-10

-1.0021994e-11</pre>

=={{header|REXX}}==

{{trans|C}}

 

The numeric precision is dependent on the number of decimal digits specified in the value of '''pi'''.

numeric digits length( pi() ) - length(.) /*DIGITS default is nine, but use 71. */

parse arg a b N . /*obtain optional arguments from the CL*/

19 Chebyshev coefficient is: 2.859065292763079576513213370136E-29

</pre>

=={{header|Ruby}}==

return (x - min_x) / (max_x - min_x) * (max_to - min_to) + min_to

end

6.59630183807991e-10

-1.0021913854352249e-11</pre>

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/DqRNe2A/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/M5Ye6h8ZRkmTCNzexUh3uw Scastie (remote JVM)].

 

object ChebyshevCoefficients extends App {

 

}</syntaxhighlight>

=={{header|Sidef}}==

{{trans|Raku}}

 

var bma = (0.5 * b-a);

-1.0022591709e-11

</pre>

=={{header|Swift}}==

 

{{trans|Kotlin}}

 

 

typealias DFunc = (Double) -> Double

0.950 0.58168309 0.58168309 -9.0e-14

1.000 0.54030231 0.54030231 4.5e-13</pre>

=={{header|VBScript}}==

{{trans|Microsoft Small Basic}}

To run in console mode with cscript.

Dim coef(10),cheby(10)

pi=4*Atn(1)

9 : -1,0022016549982E-11

</pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Structure ChebyshevApprox

0.950 0.58168308946388 0.58168308946379 -8.992806E-014

1.000 0.54030230586814 0.54030230586859 4.468648E-013</pre>

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var mapRange = Fn.new { |x, min, max, minTo, maxTo| (x - min)/(max - min)*(maxTo - minTo) + minTo }

1.000 0.54030231 0.54030231 4.47e-13

</pre>

=={{header|zkl}}==

{{trans|C}}{{trans|Perl}}

fcn chebft(a,b,n,func){

bma,bpa,fac := 0.5*(b - a), 0.5*(b + a), 2.0/n;