Numeric error propagation: Difference between revisions

Specification of a generic type Approximation.Number, providing all the operations required to solve the task ... and some more operations, for completeness.

 

type Real is digits <>;

with function Sqrt(X: Real) return Real;

Sigma: Real;

end record;

 

The implementation:

 

 

package body Approximation is

end Put;

 

 

Instantiating the package with Float operations, to compute the distance:

 

 

procedure Test_Approximations is

((X1-X2)**2 + (Y1 - Y2)**2)**0.5,

Sigma_Fore => 1);

 

Output:

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

MODE UNCERTAIN = STRUCT( REAL v, uncertainty );

 

UNCERTAIN d = ( ( ( x1 - x2 ) ^ 2 ) + ( y1 - y2 ) ^ 2 ) ^ 0.5;

 

{{out}}

<pre>

=={{header|C}}==

Rewrote code to make it more compact and added a nice formatting function for imprecise values so that they are printed out in a technically correct way i.e. with the symbol '±' . Output pasted after code.

#include <stdlib.h>

#include <string.h>

return 0;

}

 

<pre>

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

numeric_error.hpp

 

#include <cmath>

private:

double v, s;

numeric_error.cpp

#include <iostream>

#include "numeric_error.hpp"

 

return EXIT_SUCCESS;

{{out}}

<pre>111.803398874989 ±2.938366893361</pre>

 

=={{header|Common Lisp}}==

(value 0 :type number)

(uncertainty 0 :type number))

(d (~expt (~+ (~expt (~- x1 x2) 2) (~expt (~- y1 y2) 2))

1/2)))

{{out}}

<pre>d = 111.80 ± 2.49</pre>

 

=={{header|D}}==

 

const struct Imprecise {

writefln("Point p2: (%s, %s)", p2[0], p2[1]);

writeln("Distance(p1, p2): ", distance(p1, p2));

{{out}}

<pre>Point p1: (I(value=100, delta=1.1), I(value=50, delta=1.2))

 

=={{header|F_Sharp|F#}}==

let abs (x : float) = System.Math.Abs x

let pow = System.Math.Pow

 

printfn "Distance: %A" ((((x1 %- x2) %^ 2.) %+ ((y1 %- y2) %^ 2.)) %^ 0.5)

{{out}}

<pre>Distance: 111.80 ±2.49</pre>

This version defines a new type, <code>imprecise</code>, and also defines a custom syntax similar to the syntax for complex numbers. It uses multi-methods to handle various combinations of scalar and compound values. The <code>multi-methods</code> vocabulary is described as experimental, but aside from a (probably intentional) clunky interface which requires the programmer to disambiguate generic word definitions, and the fact that multi-methods don't show up in the help browser properly, I had no issues with them. In some stress tests, they don't appear to suffer from speed issues.

{{works with|Factor|0.99 2019-10-06}}

multi-methods parser prettyprint prettyprint.custom sequences ;

RENAME: GENERIC: multi-methods => MM-GENERIC:

PRIVATE>

 

{{out}}

<pre>

 

{{works with|Factor|0.99 2019-10-06}}

prettyprint sequences sequences.extras ;

IN: uncertain

PRIVATE>

 

{{out}}

<pre>

=={{header|Fortran}}==

===Direct calculation===

REAL X1, Y1, X2, Y2 !The co-ordinates.

REAL X1E,Y1E,X2E,Y2E !Their standard deviation.

WRITE (6,2) D,C,E !Ahh, the relief.

2 FORMAT ("Distance",F6.1,A1,F4.2) !Sizes to fit the example.

This is old-style Fortran, except for the CHARACTER variable caused by problems with character codes and their screen glyphs. As can be seen, the formulae invite mistakes which is why there is no attempt to produce a single arithmetic expression for the result and its error estimate. Further, rather than attempt to emplace appropriate instances of the formula for a value raised to some power (squaring, and square root), risking all manner of misthinks, a function to do so is prepared, here using Fortran's "arithmetic statement function" protocol, expressly intended for such situations. And the results are...

<pre>

 

===More general===

INTEGER VSP,VMAX !Do so with an arithmetic stack.

PARAMETER (VMAX = 28) !Surely sufficient.

WRITE (6,2) STACKV(1),PM,STACKE(1) !Ahh, the relief.

2 FORMAT ("Distance",F6.1,A1,F4.2) !Sizes to fit the example.

This is closer to the idea of extending the language to supply additional facilities. At the cost of hand-compiling the arithmetic expression into a sequence of pseudo-machine code subroutines, it is apparent that the mind-tangling associated error formulae need no longer be worried over. The various arithmetic subroutines have to be coded correctly with careful attention to the V or E statements in fact being for the V and E terms (cut&paste followed by inadequate adjustment the culprit here: such mistakes are less likely when using a card punch because copying is more troublesome), but this is a straightforward matter of checking. And indeed the VPOW(2) routine has the same effect as VSQUARE. Output:

<pre>

 

===Fortran 90 ''et seq''.===

REAL VALUE

REAL SD

END TYPE POINT

TYPE(POINT) P1,P2

Whereupon, instead of a swarm of separate variables named according to some scheme, you can have a collection of variables with subcomponents named systematically. Further, via a great deal of syntax one can devise functions dealing with those compound types and moreover, prepare procedures that will perform operations such as addition and subtraction, etc. and merge these with the ordinary usages of addition, etc. of ordinary variables. One would then write the formula to be calculated, and it would all just happen. This has been done for arithmetic with rational numbers, in [[Arithmetic/Rational#Fortran]] for example.

 

 

=={{header|FreeBASIC}}==

' definition of a "measurement" type with value and uncartainty

' and operators that can operate on them

y2.unc = 2.3

 

{{out}}<pre>

111.80340 +- 2.4872

=={{header|Go}}==

Variance from task requirements is that the following does not "extend the language." It simply defines a type with associated functions and methods as required to solve the remainder of the task.

 

import (

fmt.Println("d: ", d.n)

fmt.Println("error:", d.errorTerm())

Output:

<pre>

 

=={{header|Haskell}}==

 

instance (Floating a) => Num (Error a) where

x2 = Error 200 2.2

y2 = Error 100 2.3

{{out}}

<pre>Error {value = 111.80339887498948, uncertainty = 2.4871670631463423}</pre>

The following solution works in both languages.

 

 

procedure main(a)

return (numeric(a)^numeric(b)) |

num(f := a.val^numeric(b), abs(f*b*(a.err/a.val)))

 

The output is:

First, we will need some utilities. <code>num</code> will extract the number part of a number. <code>unc</code> will extract the uncertainty part of a number, and will also be used to associate uncertainty with a number. <code>dist</code> will compute the distance between two numbers (which is needed for multiplicative uncertainty).

 

unc=: {:@}."1 : ,.

 

Note that if a number has no uncertainty assigned to it, we assume the uncertainty is zero.

Jumping into the example values, for illustration purposes:

 

y1=: 50 unc 1.2

 

x2=: 200 unc 2.2

 

Above, we see <code>unc</code> being used to associate a number with its uncertainty. Here's how to take them apart again:

 

100

unc x1

 

Note that these operations "do the right thing" for normal numbers:

 

100

unc 100

 

And, a quick illustration of the distance function:

 

Next, we need to define our arithmetic operations:

 

sub=: -&num unc dist&unc

mul=: *&num unc |@(*&num * dist&(unc%num))

div=: %&num unc |@(%&num * dist&(unc%num))

 

Finally, our required example:

 

 

=={{header|Java}}==

private double value;

private double error;

System.out.println(x1);

}

{{out}}

<pre>111.80339887498948±2.4871670631463423</pre>

=={{header|Julia}}==

=== Using Measurements library ===

using Measurements

 

@show d

@show d.val, d.err

The Measurements library will round to correct decimal place precision when displaying tolerances, so the fields are shown to show the calculations are equivalent.

<pre>

 

=== With custom module ===

 

import Base: convert, promote_rule, +, -, *, /, ^

 

@show x1 y1 x2 y2 sqrt((x1 - x2) ^ 2 + (y1 - y2) ^ 2)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

data class Approx(val ν: Double, val σ: Double = 0.0) {

val y2 = Approx(100.0, 2.3)

println(((x1 - x2).pow(2.0) + (y1 - y2).pow(2.0)).pow(0.5))

{{out}}

<pre>111.80339887498948 ±2.4871670631463423</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

PlusMinus /: a_ ± σa_ + b_ ± σb_ := N[(a + b) ± Norm@{σa, σb}];

PlusMinus /: c_?NumericQ (a_ ± σa_) := N[c a ± Abs[c σa]];

PlusMinus /: (a_ ± σa_) (b_ ± σb_) := N[a b ± (a b Norm@{σa/a, σb/b})^2];

y1 = 50 ± 1.2;

x2 = 200 ± 2.2;

y2 = 100 ± 2.3;

{{Out}}

<pre>111.803 ± 2.48717</pre>

===Native implementation===

y1 = Around[50, 1.2];

x2 = Around[200, 2.2];

y2 = Around[100, 2.3];

{{out}}

<pre>111.8\[PlusMinus]2.5</pre>

 

=={{header|Nim}}==

import math

 

var y2 = Imprecise(x: 100, σ: 2.3)

 

{{out}}

<pre>

=={{header|PARI/GP}}==

''This is a work-in-progress.''

sub(a,b)=if(type(a)==type(b), [a[1]-b[1],a[2]+b[2]], if(type(a)=="t_VEC",a-[b,0],[a,0]-b));

mult(a,b)=if(type(a)=="t_VEC", if(type(b)=="t_VEC", [a[1]*b[1], abs(a[1]*b[1])*sqrt(norml2([a[2]/a[1],b[2]/b[1]]))], [b*a[1], abs(b)*a[2]]), [a*b[1], abs(a)*b[2]]);

pow(a,b)=[a[1]^b, abs(a[1]^b*b*a[2]/a[1])];

x1=[100,1.1];y1=[50,1.2];x2=[200,2.2];y2=[100,2.3];

 

=={{header|Perl}}==

package ErrVar;

 

}

 

use overload

;

 

# make a variable with mean value and a list of coefficient to

# variables providing independent errors

 

# mean value of the var, or just the input if it's not of this class

 

# return variance index array

 

}

 

}

 

 

# to determine if a var is probably zero. we use 1σ here

}

 

}

 

}

 

}

 

}

 

}

 

}

 

}

 

}

 

}

 

}

 

 

package main;

 

my $z1 = sqrt(($x1 - $x2) ** 2 + ($y1 - $y2) ** 2);

 

# this is not for task requirement

my $a = $x1 + $x2;

my $b = $y1 - 2 * $x2;

 

=={{header|Phix}}==

Aside: obviously you don't ''have'' to use tmp1/2 like that, but I find that style often makes things much easier to debug.

{{out}}

 

The overloaded +, -, * and / operators look a bit complicated, because they must handle an arbitrary number of arguments to be compatible with the standard operators.

(load "@lib/math.l")

 

(round (car N) 10)

" ± "

Test:

(**

(+ (** (- X1 X2) 2.0) (** (- Y1 Y2) 2.0))

(unc 50. 1.2)

(unc 200. 2.2)

Output:

<pre>Distance: 111.8033988750 ± 2.48716706</pre>

 

=={{header|Python}}==

import math

p1, p2 = (x1, y1), (x2, y2)

print("Distance between points\n p1: %s\n and p2: %s\n = %r" % (

 

;Sample output:

=={{header|Racket}}==

{{trans|Mathematica}}

 

(struct ± (x dx) #:transparent

(define x2 (± 200 2.2))

(define y2 (± 100 2.3))

 

{{output}}

{{Works with|rakudo|2018.03}}

{{trans|Perl}}

# (Because Raku does not yet have a longest-zip metaoperator.)

my @INDEP;

my $a = $x1 + $x2;

my $b = $y1 - 2 * $x2;

{{out}}

<pre>distance: 111.803±2.49

=={{header|REXX}}==

{{trans|Fortran}}

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

if a=='' | a=="," then a= '100±1.1, 50±1.2' /*Not given? Then use default.*/

m.= 9; do j=0 while h>9; m.j= h; h= h%2+1; end /*j*/

do k=j+5 to 0 by -1; numeric digits m.k; g= (g+x/g)*.5; end /*k*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ruby}}==

def initialize(number, error)

@num = number

y2 = NumberWithUncertainty.new(100, 2.3)

 

{{out}}

<pre>111.803398874989 ± 2.48716706314634</pre>

=={{header|Scala}}==

{{trans|Kotlin}}

 

class Approx(val ν: Double, val σ: Double = 0.0) {

val y2 = Approx(100.0, 2.3)

println(√(((x1 - x2)^2.0) + ((y1 - y2)^2.0))) // => 111.80339887498948 ±2.938366893361004

{{out}}

<pre>111.80339887498948 ±2.938366893361004</pre>

=={{header|Swift}}==

 

 

precedencegroup ExponentiationGroup {

let d = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

 

 

{{out}}

{{works with|Tcl|8.6}}

Firstly, some support code for doing RAII-like things, evolved from code in the [[Quaternion type#Tcl|quaternion]] solution:

oo::class create RAII-support {

constructor {} {

try $script on ok msg {$msg return}

] [uplevel 1 {namespace current}]] {*}$vals

The implementation of the number+error class itself:

variable N E

constructor {number {error 0.0}} {

 

export + - * / **

Demonstrating:

set x2 [Err 200 2.2]

set y1 [Err 50 1.2]

[[[$x1 - $x2] ** 2] + [[$y1 - $y2] ** 2]] ** 0.5

}]

Output:

<pre>

=={{header|Wren}}==

{{trans|Kotlin}}

construct new(nu, sigma) {

_nu = nu

var x2 = Approx.new(200, 2.2)

var y2 = Approx.new(100, 2.3)

 

{{out}}