2021-11-07 20:53:18 +00:00
<!doctype html>
< html lang = "en" >
< head >
< meta charset = "utf-8" >
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
2022-02-15 12:25:34 +00:00
< meta name = "generator" content = "pdoc 10.0.1" / >
2021-11-07 20:53:18 +00:00
< title > pyerrors API documentation< / title >
2022-02-14 14:08:21 +00:00
< style > / * ! * B o o t s t r a p R e b o o t v 5 . 0 . 0 ( h t t p s : / / g e t b o o t s t r a p . c o m / ) * C o p y r i g h t 2 0 1 1 - 2 0 2 1 T h e B o o t s t r a p A u t h o r s * C o p y r i g h t 2 0 1 1 - 2 0 2 1 T w i t t e r , I n c . * L i c e n s e d u n d e r M I T ( h t t p s : / / g i t h u b . c o m / t w b s / b o o t s t r a p / b l o b / m a i n / L I C E N S E ) * F o r k e d f r o m N o r m a l i z e . c s s , l i c e n s e d M I T ( h t t p s : / / g i t h u b . c o m / n e c o l a s / n o r m a l i z e . c s s / b l o b / m a s t e r / L I C E N S E . m d ) * / * , : : a f t e r , : : b e f o r e { b o x - s i z i n g : b o r d e r - b o x } @ m e d i a ( p r e f e r s - r e d u c e d - m o t i o n : n o - p r e f e r e n c e ) { : r o o t { s c r o l l - b e h a v i o r : s m o o t h } } b o d y { m a r g i n : 0 ; f o n t - f a m i l y : s y s t e m - u i , - a p p l e - s y s t e m , " S e g o e U I " , R o b o t o , " H e l v e t i c a N e u e " , A r i a l , " N o t o S a n s " , " L i b e r a t i o n S a n s " , s a n s - s e r i f , " A p p l e C o l o r E m o j i " , " S e g o e U I E m o j i " , " S e g o e U I S y m b o l " , " N o t o C o l o r E m o j i " ; f o n t - s i z e : 1 r e m ; f o n t - w e i g h t : 4 0 0 ; l i n e - h e i g h t : 1 . 5 ; c o l o r : # 2 1 2 5 2 9 ; b a c k g r o u n d - c o l o r : # f f f ; - w e b k i t - t e x t - s i z e - a d j u s t : 1 0 0 % ; - w e b k i t - t a p - h i g h l i g h t - c o l o r : t r a n s p a r e n t } h r { m a r g i n : 1 r e m 0 ; c o l o r : i n h e r i t ; b a c k g r o u n d - c o l o r : c u r r e n t C o l o r ; b o r d e r : 0 ; o p a c i t y : . 2 5 } h r : n o t ( [ s i z e ] ) { h e i g h t : 1 p x } h 1 , h 2 , h 3 , h 4 , h 5 , h 6 { m a r g i n - t o p : 0 ; m a r g i n - b o t t o m : . 5 r e m ; f o n t - w e i g h t : 5 0 0 ; l i n e - h e i g h t : 1 . 2 } h 1 { f o n t - s i z e : c a l c ( 1 . 3 7 5 r e m + 1 . 5 v w ) } @ m e d i a ( m i n - w i d t h : 1 2 0 0 p x ) { h 1 { f o n t - s i z e : 2 . 5 r e m } } h 2 { f o n t - s i z e : c a l c ( 1 . 3 2 5 r e m + . 9 v w ) } @ m e d i a ( m i n - w i d t h : 1 2 0 0 p x ) { h 2 { f o n t - s i z e : 2 r e m } } h 3 { f o n t - s i z e : c a l c ( 1 . 3 r e m + . 6 v w ) } @ m e d i a ( m i n - w i d t h : 1 2 0 0 p x ) { h 3 { f o n t - s i z e : 1 . 7 5 r e m } } h 4 { f o n t - s i z e : c a l c ( 1 . 2 7 5 r e m + . 3 v w ) } @ m e d i a ( m i n - w i d t h : 1 2 0 0 p x ) { h 4 { f o n t - s i z e : 1 . 5 r e m } } h 5 { f o n t - s i z e : 1 . 2 5 r e m } h 6 { f o n t - s i z e : 1 r e m } p { m a r g i n - t o p : 0 ; m a r g i n - b o t t o m : 1 r e m } a b b r [ d a t a - b s - o r i g i n a l - t i t l e ] , a b b r [ t i t l e ] { - w e b k i t - t e x t - d e c o r a t i o n : u n d e r l i n e d o t t e d ; t e x t - d e c o r a t i o n : u n d e r l i n e d o t t e d ; c u r s o r : h e l p ; - w e b k i t - t e x t - d e c o r a t i o n - s k i p - i n k : n o n e ; t e x t - d e c o r a t i o n - s k i p - i n k : n o n e } a d d r e s s { m a r g i n - b o t t o m : 1 r e m ; f o n t - s t y l e : n o r m a l ; l i n e - h e i g h t : i n h e r i t } o l , u l { p a d d i n g - l e f t : 2 r e m } d l , o l , u l { m a r g i n - t o p : 0 ; m a r g i n - b o t t o m : 1 r e m } o l o l , o l u l , u l o l , u l u l { m a r g i n - b o t t o m : 0 } d t { f o n t - w e i g h t : 7 0 0 } d d { m a r g i n - b o t t o m : . 5 r e m ; m a r g i n - l e f t : 0 } b l o c k q u o t e { m a r g i n : 0 0 1 r e m } b , s t r o n g { f o n t - w e i g h t : b o l d e r } s m a l l { f o n t - s i z e : . 8 7 5 e m } m a r k { p a d d i n g : . 2 e m ; b a c k g r o u n d - c o l o r : # f c f 8 e 3 } s u b , s u p { p o s i t i o n : r e l a t i v e ; f o n t - s i z e : . 7 5 e m ; l i n e - h e i g h t : 0 ; v e r t i c a l - a l i g n : b a s e l i n e } s u b { b o t t o m : - . 2 5 e m } s u p { t o p : - . 5 e m } a { c o l o r : # 0 d 6 e f d ; t e x t - d e c o r a t i o n : u n d e r l i n e } a : h o v e r { c o l o r : # 0 a 5 8 c a } a : n o t ( [ h r e f ] ) : n o t ( [ c l a s s ] ) , a : n o t ( [ h r e f ] ) : n o t ( [ c l a s s ] ) : h o v e r { c o l o r : i n h e r i t ; t e x t - d e c o r a t i o n : n o n e } c o d e , k b d , p r e , s a m p { f o n t - f a m i l y : S F M o n o - R e g u l a r , M e n l o , M o n a c o , C o n s o l a s , " L i b e r a t i o n M o n o " , " C o u r i e r N e w " , m o n o s p a c e ; f o n t - s i z e : 1 e m ; d i r e c t i o n : l t r ; u n i c o d e - b i d i : b i d i - o v e r r i d e } p r e { d i s p l a y : b l o c k ; m a r g i n - t o p : 0 ; m a r g i n - b o t t o m : 1 r e m ; o v e r f l o w : a u t o ; f o n t - s i z e : . 8 7 5 e m } p r e c o d e { f o n t - s i z e : i n h e r i t ; c o l o r : i n h e r i t ; w o r d - b r e a k : n o r m a l } c o d e { f o n t - s i z e : . 8 7 5 e m ; c o l o r : # d 6 3 3 8 4 ; w o r d - w r a p : b r e a k - w o r d } a > c o d e { c o l o r : i n h e r i t } k b d { p a d d i n g : . 2 r e m . 4 r e m ; f o n t - s i z e : . 8 7 5 e m ; c o l o r : # f f f ; b a c k g r o u n d - c o l o r : # 2 1 2 5 2 9 ; b o r d e r - r a d i u s : . 2 r e m } k b d k b d { p a d d i n g : 0 ; f o n t - s i z e : 1 e m ; f o n t - w e i g h t : 7 0 0 } f i g u r e { m a r g i n : 0 0 1 r e m } i m g , s v g { v e r t i c a l - a l i g n : m i d d l e } t a b l e { c a p t i o n - s i d e : b o t t o m ; b o r d e r - c o l l a p s e : c o l l a p s e } c a p t i o n { p a d d i n g - t o p : . 5 r e m ; p a d d i n g - b o t t o m : . 5 r e m ; c o l o r : # 6 c 7 5 7 d ; t e x t - a l i g n : l e f t } t h { t e x t - a l i g n : i n h e r i t ; t e x t - a l i g n : - w e b k i t - m a t c h - p a r e n t } t b o d y , t d , t f o o t , t h , t h e a d , t r { b o r d e r - c o l o r : i n h e r i t ; b o r d e r - s t y l e : s o l i d ; b o r d e r - w i d t h : 0 } l a b e l { d i s p l a y : i n l i n e - b l o c k } b u t t o n { b o r d e r - r a d i u s : 0 } b u t t o n : f o c u s : n o t ( : f o c u s - v i s i b l e ) { o u t l i n e : 0 } b u t t o n , i n p u t , o p t g r o u p , s e l e c t , t e x t a r e a { m a r g i n : 0 ; f o n t - f a m i l y : i n h e r i t ; f o n t - s i z e : i n h e r i t ; l i n e - h e i g h t : i n h e r i t } b u t t o n , s e l e c t { t e x t - t r a n s f o r m : n o n e } [ r o l e = b u t t o n ] { c u r s o r : p o i n t e r } s e l e c t { w o r d - w r a p : n o r m a l } s e l e c t : d i s a b l e d { o p a c i t y : 1 } [ l i s t ] : : - w e b k i t - c a l e n d a r - p i c k e r - i n d i c a t o r { d i s p l a y : n o n e } [ t y p e = b u t t o n ] , [ t y p e = r e s e t ] , [ t y p e = s u b m i t ] , b u t t o n { - w e b k i t - a p p e a r a n c e : b u t t o n } [ t y p e = b u t t o n ] : n o t ( : d i s a b l e d ) , [ t y p e = r e s e t ] : n o t ( : d i s a b l e d ) , [ t y p e = s u b m i t ] : n o t ( : d i s a b l e d ) , b u t t o n : n o t ( : d i s a b l e d ) { c u r s o r : p o i n t e r } : : - m o z - f o c u s - i n n e r { p a d d i n g : 0 ; b o r d e r - s t y l e : n o n e } t e x t a r e a { r e s i z e : v e r t i c a l } f i e l d s e t { m i n - w i d t h : 0 ; p a d d i n g : 0 ; m a r g i n : 0 ; b o r d e r : 0 } l e g e n d { f l o a t : l e f t ; w i d t h : 1 0 0 % ; p a d d i n g : 0 ; m a r g i n - b o t t o m : . 5 r e m ; f o n t - s i z e : c a l c ( 1 . 2 7 5 r e m + . 3 v w ) ; l i n e - h e i g h t : i n h e r i t } @ m e d i a ( m i n - w i d t h : 1 2 0 0 p x ) { l e g e n d { f o n t - s i z e : 1 . 5 r e m } } l e g e n d + * { c l e a r : l e f t } : : - w e b k i t - d a t e t i m e - e d i t - d a y - f i e l d , : : - w e b k i t - d a t e t i m e - e d i t - f i e l d s - w r a p p e r , : : - w e b k i t - d a t e t i m e - e d i t - h o u r - f i e l d , : : - w e b k i t - d a t e t i m e - e d i t - m i n u t e , : : - w e b k i t - d a t e t i m e - e d i t - m o n t h - f i e
< style > /*! syntax-highlighting.css */ pre { line-height : 125 % ; } span . linenos { color : inherit ; background-color : transparent ; padding-left : 5 px ; padding-right : 20 px ; } . pdoc-code . hll { background-color : #ffffcc } . pdoc-code { background : #f8f8f8 ; } . pdoc-code . c { color : #3D7B7B ; font-style : italic } . pdoc-code . err { border : 1 px solid #FF0000 } . pdoc-code . k { color : #008000 ; font-weight : bold } . pdoc-code . o { color : #666666 } . pdoc-code . ch { color : #3D7B7B ; font-style : italic } . pdoc-code . cm { color : #3D7B7B ; font-style : italic } . pdoc-code . cp { color : #9C6500 } . pdoc-code . cpf { color : #3D7B7B ; font-style : italic } . pdoc-code . c1 { color : #3D7B7B ; font-style : italic } . pdoc-code . cs { color : #3D7B7B ; font-style : italic } . pdoc-code . gd { color : #A00000 } . pdoc-code . ge { font-style : italic } . pdoc-code . gr { color : #E40000 } . pdoc-code . gh { color : #000080 ; font-weight : bold } . pdoc-code . gi { color : #008400 } . pdoc-code . go { color : #717171 } . pdoc-code . gp { color : #000080 ; font-weight : bold } . pdoc-code . gs { font-weight : bold } . pdoc-code . gu { color : #800080 ; font-weight : bold } . pdoc-code . gt { color : #0044DD } . pdoc-code . kc { color : #008000 ; font-weight : bold } . pdoc-code . kd { color : #008000 ; font-weight : bold } . pdoc-code . kn { color : #008000 ; font-weight : bold } . pdoc-code . kp { color : #008000 } . pdoc-code . kr { color : #008000 ; font-weight : bold } . pdoc-code . kt { color : #B00040 } . pdoc-code . m { color : #666666 } . pdoc-code . s { color : #BA2121 } . pdoc-code . na { color : #687822 } . pdoc-code . nb { color : #008000 } . pdoc-code . nc { color : #0000FF ; font-weight : bold } . pdoc-code . no { color : #880000 } . pdoc-code . nd { color : #AA22FF } . pdoc-code . ni { color : #717171 ; font-weight : bold } . pdoc-code . ne { color : #CB3F38 ; font-weight : bold } . pdoc-code . nf { color : #0000FF } . pdoc-code . nl { color : #767600 } . pdoc-code . nn { color : #0000FF ; font-weight : bold } . pdoc-code . nt { color : #008000 ; font-weight : bold } . pdoc-code . nv { color : #19177C } . pdoc-code . ow { color : #AA22FF ; font-weight : bold } . pdoc-code . w { color : #bbbbbb } . pdoc-code . mb { color : #666666 } . pdoc-code . mf { color : #666666 } . pdoc-code . mh { color : #666666 } . pdoc-code . mi { color : #666666 } . pdoc-code . mo { color : #666666 } . pdoc-code . sa { color : #BA2121 } . pdoc-code . sb { color : #BA2121 } . pdoc-code . sc { color : #BA2121 } . pdoc-code . dl { color : #BA2121 } . pdoc-code . sd { color : #BA2121 ; font-style : italic } . pdoc-code . s2 { color : #BA2121 } . pdoc-code . se { color : #AA5D1F ; font-weight : bold } . pdoc-code . sh { color : #BA2121 } . pdoc-code . si { color : #A45A77 ; font-weight : bold } . pdoc-code . sx { color : #008000 } . pdoc-code . sr { color : #A45A77 } . pdoc-code . s1 { color : #BA2121 } . pdoc-code . ss { color : #19177C } . pdoc-code . bp { color : #008000 } . pdoc-code . fm { color : #0000FF } . pdoc-code . vc { color : #19177C } . pdoc-code . vg { color : #19177C } . pdoc-code . vi { color : #19177C } . pdoc-code . vm { color : #19177C } . pdoc-code . il { color : #666666 } < / style >
< style > /*! theme.css */ : root { --pdoc-background : #fff ; } . pdoc { --text : #212529 ; --muted : #6c757d ; --link : #3660a5 ; --link-hover : #1659c5 ; --code : #f8f8f8 ; --active : #fff598 ; --accent : #eee ; --accent2 : #c1c1c1 ; --nav-hover : rgba ( 255 , 255 , 255 , 0.5 ) ; --name : #0066BB ; --def : #008800 ; --annotation : #007020 ; } < / style >
< style > /*! layout.css */ html , body { width : 100 % ; height : 100 % ; } html , main { scroll-behavior : smooth ; } body { background-color : var ( - - pdoc - background ) ; } @ media ( max-width : 769px ) { # navtoggle { cursor : pointer ; position : absolute ; width : 50 px ; height : 40 px ; top : 1 rem ; right : 1 rem ; border-color : var ( - - text ) ; color : var ( - - text ) ; display : flex ; opacity : 0.8 ; } # navtoggle : hover { opacity : 1 ; } # togglestate + div { display : none ; } # togglestate : checked + div { display : inherit ; } main , header { padding : 2 rem 3 vw ; } header + main { margin-top : -3 rem ; } . git-button { display : none !important ; } nav input [ type = "search" ] { max-width : 77 % ; } nav input [ type = "search" ] : first-child { margin-top : -6 px ; } nav input [ type = "search" ] : valid ~ * { display : none !important ; } } @ media ( min-width : 770px ) { : root { --sidebar-width : clamp ( 12.5 rem , 28 vw , 22 rem ) ; } nav { position : fixed ; overflow : auto ; height : 100 vh ; width : var ( - - sidebar - width ) ; } main , header { padding : 3 rem 2 rem 3 rem calc ( var ( - - sidebar - width ) + 3 rem ) ; width : calc ( 54 rem + var ( - - sidebar - width ) ) ; max-width : 100 % ; } header + main { margin-top : -4 rem ; } # navtoggle { display : none ; } } # togglestate { position : absolute ; height : 0 ; } nav . pdoc { --pad : 1.75 rem ; --indent : 1.5 rem ; background-color : var ( - - accent ) ; border-right : 1 px solid var ( - - accent2 ) ; box-shadow : 0 0 20 px rgba ( 50 , 50 , 50 , .2 ) inset ; padding : 0 0 0 var ( - - pad ) ; overflow-wrap : anywhere ; scrollbar-width : thin ; scrollbar-color : var ( - - accent2 ) transparent } nav . pdoc :: -webkit-scrollbar { width : .4 rem ; } nav . pdoc :: -webkit-scrollbar-thumb { background-color : var ( - - accent2 ) ; } nav . pdoc > div { padding : var ( - - pad ) 0 ; } nav . pdoc . module-list-button { display : inline-flex ; align-items : center ; color : var ( - - text ) ; border-color : var ( - - muted ) ; margin-bottom : 1 rem ; } nav . pdoc . module-list-button : hover { border-color : var ( - - text ) ; } nav . pdoc input [ type = search ] { display : block ; outline-offset : 0 ; width : calc ( 100 % - var ( - - pad ) ) ; } nav . pdoc . logo { max-width : calc ( 100 % - var ( - - pad ) ) ; max-height : 35 vh ; display : block ; margin : 0 auto 1 rem ; transform : translate ( calc ( -.5 * var ( - - pad ) ) , 0 ) ; } nav . pdoc ul { list-style : none ; padding-left : 0 ; } nav . pdoc li { display : block ; margin : 0 ; padding : .2 rem 0 .2 rem var ( - - indent ) ; transition : all 100 ms ; } nav . pdoc > div > ul > li { padding-left : 0 ; } nav . pdoc li : hover { background-color : var ( - - nav - hover ) ; } nav . pdoc a , nav . pdoc a : hover { color : var ( - - text ) ; } nav . pdoc a { display : block ; } nav . pdoc > h2 : first-of-type { margin-top : 1.5 rem ; } nav . pdoc . class : before { content : "class " ; color : var ( - - muted ) ; } nav . pdoc . function : after { content : "()" ; color : var ( - - muted ) ; } nav . pdoc footer : before { content : "" ; display : block ; width : calc ( 100 % - var ( - - pad ) ) ; border-top : solid var ( - - accent2 ) 1 px ; margin-top : 1.5 rem ; padding-top : .5 rem ; } nav . pdoc footer { font-size : small ; } < / style >
2022-02-15 12:25:34 +00:00
< style > /*! content.css */ . pdoc { color : var ( - - text ) ; box-sizing : border-box ; line-height : 1.5 ; background : none ; } . pdoc . pdoc-button { display : inline-block ; border : solid black 1 px ; border-radius : 2 px ; font-size : .75 rem ; padding : calc ( 0.5 em - 1 px ) 1 em ; transition : 100 ms all ; } . pdoc . visually-hidden { position : absolute !important ; width : 1 px !important ; height : 1 px !important ; padding : 0 !important ; margin : -1 px !important ; overflow : hidden !important ; clip : rect ( 0 , 0 , 0 , 0 ) !important ; white-space : nowrap !important ; border : 0 !important ; } . pdoc h1 , . pdoc h2 , . pdoc h3 { font-weight : 300 ; margin : .3 em 0 ; padding : .2 em 0 ; } . pdoc a { text-decoration : none ; color : var ( - - link ) ; } . pdoc a : hover { color : var ( - - link - hover ) ; } . pdoc blockquote { margin-left : 2 rem ; } . pdoc pre { border-top : 1 px solid var ( - - accent2 ) ; border-bottom : 1 px solid var ( - - accent2 ) ; margin-top : 0 ; margin-bottom : 1 em ; padding : .5 rem 0 .5 rem .5 rem ; overflow-x : auto ; background-color : var ( - - code ) ; } . pdoc code { color : var ( - - text ) ; padding : .2 em .4 em ; margin : 0 ; font-size : 85 % ; background-color : var ( - - code ) ; border-radius : 6 px ; } . pdoc a > code { color : inherit ; } . pdoc pre > code { display : inline-block ; font-size : inherit ; background : none ; border : none ; padding : 0 ; } . pdoc . modulename { margin-top : 0 ; font-weight : bold ; } . pdoc . modulename a { color : var ( - - link ) ; transition : 100 ms all ; } . pdoc . git-button { float : right ; border : solid var ( - - link ) 1 px ; } . pdoc . git-button : hover { background-color : var ( - - link ) ; color : var ( - - pdoc - background ) ; } . pdoc details { filter : opacity ( 1 ) ; } . pdoc details : not ( [ open ] ) { height : 0 ; } . pdoc details > summary { position : absolute ; top : -35 px ; right : 0 ; font-size : .75 rem ; color : var ( - - muted ) ; padding : 0 .7 em ; user-select : none ; cursor : pointer ; } . pdoc details > summary : focus { outline : 0 ; } . pdoc . docstring { margin-bottom : 1.5 rem ; } . pdoc > section : first-of-type > . docstring { margin-bottom : 2.5 rem ; } . pdoc . docstring . pdoc-code { margin-left : 1 em ; margin-right : 1 em ; } . pdoc h1 : target , . pdoc h2 : target , . pdoc h3 : target , . pdoc h4 : target , . pdoc h5 : target , . pdoc h6 : target { background-color : var ( - - active ) ; box-shadow : -1 rem 0 0 0 var ( - - active ) ; } . pdoc div : target > . attr , . pdoc section : target > . attr , . pdoc dd : target > a { background-color : var ( - - active ) ; } . pdoc . attr : hover { filter : contrast ( 0.95 ) ; } . pdoc . headerlink { position : absolute ; width : 0 ; margin-left : -1.5 rem ; line-height : 1.4 rem ; font-size : 1.5 rem ; font-weight : normal ; transition : all 100 ms ease-in-out ; opacity : 0 ; user-select : none ; } . pdoc . attr > . headerlink { margin-left : -2.5 rem ; } . pdoc * : hover > . headerlink , . pdoc * : target > . attr > . headerlink { opacity : 1 ; } . pdoc . attr { display : block ; color : var ( - - text ) ; margin : .5 rem 0 .5 rem ; padding : .4 rem 5 rem .4 rem 1 rem ; background-color : var ( - - accent ) ; } . pdoc . classattr { margin-left : 2 rem ; } . pdoc . name { color : var ( - - name ) ; font-weight : bold ; } . pdoc . def { color : var ( - - def ) ; font-weight : bold ; } . pdoc . signature { white-space : pre-wrap ; } . pdoc . annotation { color : var ( - - annotation ) ; } . pdoc . inherited { margin-left : 2 rem ; } . pdoc . inherited dt { font-weight : 700 ; } . pdoc . inherited dt , . pdoc . inherited dd { display : inline ; margin-left : 0 ; margin-bottom : .5 rem ; } . pdoc . inherited dd : not ( : last-child ) : after { content : ", " ; } . pdoc . inherited . class : before { content : "class " ; } . pdoc . inherited . function a : after { content : "()" ; } . pdoc . search-result . docstring { overflow : auto ; max-height : 25 vh ; } . pdoc . search-result . focused > . attr { background-color : var ( - - active ) ; } . pdoc . attribution { margin-top : 2 rem ; display : block ; opacity : 0.5 ; transition : all 200 ms ; filter : grayscale ( 100 % ) ; } . pdoc . attribution : hover { opacity : 1 ; filter : grayscale ( 0 % ) ; } . pdoc . attribution img { margin-left : 5 px ; height : 35 px ; vertical-align : middle ; width : 70 px ; transition : all 200 ms ; } . pdoc table { display : block ; width : max-content ; max-width : 100 % ; overflow : auto ; margin-bottom : 1 rem ; } . pdoc table th { font-weight : 600 ; } . pdoc table th , . pdoc table td { padding : 6 px 13 px ; border : 1 px solid var ( - - accent2 ) ; } < / style >
< style > /*! custom.css */ < / style > < script >
2021-11-07 20:53:18 +00:00
window.MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
}
};
< / script >
< script src = "https://polyfill.io/v3/polyfill.min.js?features=es6" > < / script >
< script id = "MathJax-script" async src = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" > < / script >
< script >
/* Re-invoke MathJax when DOM content changes, for example during search. */
document.addEventListener("DOMContentLoaded", () => {
new MutationObserver(() => MathJax.typeset()).observe(
document.querySelector("main.pdoc").parentNode,
{childList: true}
);
})
2022-02-14 14:08:21 +00:00
< / script > < / head >
< body >
< nav class = "pdoc" >
< label id = "navtoggle" for = "togglestate" class = "pdoc-button" > < svg xmlns = 'http://www.w3.org/2000/svg' viewBox = '0 0 30 30' > < path stroke-linecap = 'round' stroke = "currentColor" stroke-miterlimit = '10' stroke-width = '2' d = 'M4 7h22M4 15h22M4 23h22' / > < / svg > < / label >
< input id = "togglestate" type = "checkbox" aria-hidden = "true" tabindex = "-1" >
< div >
< input type = "search" placeholder = "Search..." role = "searchbox" aria-label = "search"
pattern=".+" required>
< h2 > Contents< / h2 >
< ul >
2021-11-07 20:53:18 +00:00
< li > < a href = "#what-is-pyerrors" > What is pyerrors?< / a >
< ul >
2021-11-16 11:46:28 +00:00
< li > < a href = "#basic-example" > Basic example< / a > < / li >
2021-11-07 20:53:18 +00:00
< / ul > < / li >
< li > < a href = "#the-obs-class" > The < code > Obs< / code > class< / a >
< ul >
2021-11-09 11:51:27 +00:00
< li > < a href = "#error-propagation" > Error propagation< / a > < / li >
2022-01-16 15:44:50 +00:00
< li > < a href = "#error-estimation" > Error estimation< / a > < / li >
< li > < a href = "#multiple-ensemblesreplica" > Multiple ensembles/replica< / a > < / li >
2021-11-07 20:53:18 +00:00
< li > < a href = "#irregular-monte-carlo-chains" > Irregular Monte Carlo chains< / a > < / li >
< / ul > < / li >
2021-11-07 21:09:48 +00:00
< li > < a href = "#correlators" > Correlators< / a > < / li >
2022-02-14 14:08:21 +00:00
< li > < a href = "#complex-valued-observables" > Complex valued observables< / a > < / li >
< li > < a href = "#error-propagation-in-iterative-algorithms" > Error propagation in iterative algorithms< / a >
< ul >
< li > < a href = "#least-squares-fits" > Least squares fits< / a > < / li >
< li > < a href = "#total-least-squares-fits" > Total least squares fits< / a > < / li >
< / ul > < / li >
2021-11-07 20:53:18 +00:00
< li > < a href = "#matrix-operations" > Matrix operations< / a > < / li >
2021-11-15 14:30:41 +00:00
< li > < a href = "#export-data" > Export data< / a >
< ul >
< li > < a href = "#jackknife-samples" > Jackknife samples< / a > < / li >
< / ul > < / li >
2022-02-14 14:08:21 +00:00
< li > < a href = "#citing" > Citing< / a > < / li >
2021-11-07 20:53:18 +00:00
< / ul >
2022-02-14 14:08:21 +00:00
< h2 > Submodules< / h2 >
< ul >
< li > < a href = "pyerrors/correlators.html" > pyerrors.correlators< / a > < / li >
< li > < a href = "pyerrors/covobs.html" > pyerrors.covobs< / a > < / li >
< li > < a href = "pyerrors/dirac.html" > pyerrors.dirac< / a > < / li >
< li > < a href = "pyerrors/fits.html" > pyerrors.fits< / a > < / li >
< li > < a href = "pyerrors/input.html" > pyerrors.input< / a > < / li >
< li > < a href = "pyerrors/linalg.html" > pyerrors.linalg< / a > < / li >
< li > < a href = "pyerrors/misc.html" > pyerrors.misc< / a > < / li >
< li > < a href = "pyerrors/mpm.html" > pyerrors.mpm< / a > < / li >
< li > < a href = "pyerrors/obs.html" > pyerrors.obs< / a > < / li >
< li > < a href = "pyerrors/roots.html" > pyerrors.roots< / a > < / li >
< li > < a href = "pyerrors/version.html" > pyerrors.version< / a > < / li >
< / ul >
< a class = "attribution" title = "pdoc: Python API documentation generator" href = "https://pdoc.dev" >
built with < span class = "visually-hidden" > pdoc< / span > < img
alt="pdoc logo"
src="data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A//www.w3.org/2000/svg%22%20role%3D%22img%22%20aria-label%3D%22pdoc%20logo%22%20width%3D%22300%22%20height%3D%22150%22%20viewBox%3D%22-1%200%2060%2030%22%3E%3Ctitle%3Epdoc%3C/title%3E%3Cpath%20d%3D%22M29.621%2021.293c-.011-.273-.214-.475-.511-.481a.5.5%200%200%200-.489.503l-.044%201.393c-.097.551-.695%201.215-1.566%201.704-.577.428-1.306.486-2.193.182-1.426-.617-2.467-1.654-3.304-2.487l-.173-.172a3.43%203.43%200%200%200-.365-.306.49.49%200%200%200-.286-.196c-1.718-1.06-4.931-1.47-7.353.191l-.219.15c-1.707%201.187-3.413%202.131-4.328%201.03-.02-.027-.49-.685-.141-1.763.233-.721.546-2.408.772-4.076.042-.09.067-.187.046-.288.166-1.347.277-2.625.241-3.351%201.378-1.008%202.271-2.586%202.271-4.362%200-.976-.272-1.935-.788-2.774-.057-.094-.122-.18-.184-.268.033-.167.052-.339.052-.516%200-1.477-1.202-2.679-2.679-2.679-.791%200-1.496.352-1.987.9a6.3%206.3%200%200%200-1.001.029c-.492-.564-1.207-.929-2.012-.929-1.477%200-2.679%201.202-2.679%202.679A2.65%202.65%200%200%200%20.97%206.554c-.383.747-.595%201.572-.595%202.41%200%202.311%201.507%204.29%203.635%205.107-.037.699-.147%202.27-.423%203.294l-.137.461c-.622%202.042-2.515%208.257%201.727%2010.643%201.614.908%203.06%201.248%204.317%201.248%202.665%200%204.492-1.524%205.322-2.401%201.476-1.559%202.886-1.854%206.491.82%201.877%201.393%203.514%201.753%204.861%201.068%202.223-1.713%202.811-3.867%203.399-6.374.077-.846.056-1.469.054-1.537zm-4.835%204.313c-.054.305-.156.586-.242.629-.034-.007-.131-.022-.307-.157-.145-.111-.314-.478-.456-.908.221.121.432.25.675.355.115.039.219.051.33.081zm-2.251-1.238c-.05.33-.158.648-.252.694-.022.001-.125-.018-.307-.157-.217-.166-.488-.906-.639-1.573.358.344.754.693%201.198%201.036zm-3.887-2.337c-.006-.116-.018-.231-.041-.342.635.145%201.189.368%201.599.625.097.231.166.481.174.642-.03.049-.055.101-.067.158-.046.013-.128.026-.298.004-.278-.037-.901-.57-1.367-1.087zm-1.127-.497c.116.306.176.625.12.71-.019.014-.117.045-.345.016-.206-.027-.604-.332-.986-.695.41-.051.816-.056%201.211-.031zm-4.535%201.535c.209.22.379.47.358.598-.006.041-.088.138-.351.234-.144.055-.539-.063-.979-.259a11.66%2011.66%200%200%200%20.972-.573zm.983-.664c.359-.237.738-.418%201.126-.554.25.237.479.548.457.694-.006.042-.087.138-.351.235-.174.064-.694-.105-1.232-.375zm-3.381%201.794c-.022.145-.061.29-.149.401-.133.166-.358.248-.69.251h-.002c-.133%200-.306-.26-.45-.621.417.091.854.07%201.291-.031zm-2.066-8.077a4.78%204.78%200%200%201-.775-.584c.172-.115.505-.254.88-.378l-.105.962zm-.331%202.302a10.32%2010.32%200%200%201-.828-.502c.202-.143.576-.328.984-.49l-.156.992zm-.45%202.157l-.701-.403c.214-.115.536-.249.891-.376a11.57%2011.57%200%200%201-.19.779zm-.181%201.716c.064.398.194.702.298.893-.194-.051-.435-.162-.736-.398.061-.119.224-.3.438-.495zM8.87%204.141c0%20.152-.123.276-.276.276s-.275-.124-.275-.276.123-.276.276-.276.275.124.275.276zm-.735-.389a1.15%201.15%200%200%200-.314.783%201.16%201.16%200%200%200%201.162%201.162c.457%200%20.842-.27%201.032-.653.026.117.042.238.042.362a1.68%201.68%200%200%201-1.679%201.679%201.68%201.68%200%200%201-1.679-1.679c0-.843.626-1.535%201.436-1.654zM5.059%205.406A1.68%201.68%200%200%201%203.38%207.085a1.68%201.68%200%200%201-1.679-1.679c0-.037.009-.072.011-.109.21.3.541.508.935.508a1.16%201.16%200%200%200%201.162-1.162%201.14%201.14%200%200%200-.474-.912c.015%200%20.03-.005.045-.005.926.001%201.679.754%201.679%201.68zM3.198%204.141c0%20.152-.123.276-.276.276s-.275-.124-.275-.276.123-.276.276-.276.275.124.275.276zM1.375%208.964c0-.52.103-1.035.288-1.52.466.394%201.06.64%201.717.64%201.144%200%202.116-.725%202.499-1.738.383%201.012%201.355%201.738%202.499%201.738.867%200%201.631-.421%202.121-1.062.307.605.478%201.267.478%201.942%200%202.486-2.153%204.51-4.801%204.51s-4.801-2.023-4.801-4.51zm24.342%2019.349c-.985.498-2.267.168-3.813-.979-3.073-2.281-5.453-3.199-7.813-.705-1.315%201.391-4.163%203.365-8.423.97-3.174-1.786-2.239-6.266-1.261-9.479l.146-.492c.276-1.02.395-2.457.444-3.268a6.11%206.11%200%200%200%201.18.115%206.01%206.01%200%200%200%202.536-.562l-.006.175c-.802.215-1.848.612
< / a >
< / div >
< / nav >
2021-11-07 20:53:18 +00:00
< main class = "pdoc" >
< section >
< h1 class = "modulename" >
pyerrors < / h1 >
< div class = "docstring" > < h1 id = "what-is-pyerrors" > What is pyerrors?< / h1 >
2021-11-07 21:04:06 +00:00
< p > < code > < a href = "" > pyerrors< / a > < / code > is a python package for error computation and propagation of Markov chain Monte Carlo data.
2021-12-11 23:00:30 +00:00
It is based on the gamma method < a href = "https://arxiv.org/abs/hep-lat/0306017" > arXiv:hep-lat/0306017< / a > . Some of its features are:< / p >
2021-11-07 21:04:06 +00:00
< ul >
2021-12-11 23:00:30 +00:00
< li > automatic differentiation for exact liner error propagation as suggested in < a href = "https://arxiv.org/abs/1809.01289" > arXiv:1809.01289< / a > (partly based on the < a href = "https://github.com/HIPS/autograd" > autograd< / a > package).< / li >
< li > treatment of slow modes in the simulation as suggested in < a href = "https://arxiv.org/abs/1009.5228" > arXiv:1009.5228< / a > .< / li >
< li > coherent error propagation for data from different Markov chains.< / li >
< li > non-linear fits with x- and y-errors and exact linear error propagation based on automatic differentiation as introduced in < a href = "https://arxiv.org/abs/1809.01289" > arXiv:1809.01289< / a > .< / li >
< li > real and complex matrix operations and their error propagation based on automatic differentiation (Matrix inverse, Cholesky decomposition, calculation of eigenvalues and eigenvectors, singular value decomposition...).< / li >
2021-11-07 21:04:06 +00:00
< / ul >
2021-11-07 20:53:18 +00:00
2021-12-11 23:00:30 +00:00
< p > There exist similar publicly available implementations of gamma method error analysis suites in < a href = "https://gitlab.ift.uam-csic.es/alberto/aderrors" > Fortran< / a > , < a href = "https://gitlab.ift.uam-csic.es/alberto/aderrors.jl" > Julia< / a > and < a href = "https://github.com/mbruno46/pyobs" > Python< / a > .< / p >
2021-11-30 14:58:46 +00:00
2021-11-16 11:46:28 +00:00
< h2 id = "basic-example" > Basic example< / h2 >
2021-11-07 20:53:18 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "kn" > import< / span > < span class = "nn" > numpy< / span > < span class = "k" > as< / span > < span class = "nn" > np< / span >
2021-11-07 20:53:18 +00:00
< span class = "kn" > import< / span > < span class = "nn" > pyerrors< / span > < span class = "k" > as< / span > < span class = "nn" > pe< / span >
2021-11-16 11:50:48 +00:00
< span class = "n" > my_obs< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > ])< / span > < span class = "c1" > # Initialize an Obs object< / span >
2021-11-16 11:46:28 +00:00
< span class = "n" > my_new_obs< / span > < span class = "o" > =< / span > < span class = "mi" > 2< / span > < span class = "o" > *< / span > < span class = "n" > np< / span > < span class = "o" > .< / span > < span class = "n" > log< / span > < span class = "p" > (< / span > < span class = "n" > my_obs< / span > < span class = "p" > )< / span > < span class = "o" > /< / span > < span class = "n" > my_obs< / span > < span class = "o" > **< / span > < span class = "mi" > 2< / span > < span class = "c1" > # Construct derived Obs object< / span >
2021-11-16 11:50:48 +00:00
< span class = "n" > my_new_obs< / span > < span class = "o" > .< / span > < span class = "n" > gamma_method< / span > < span class = "p" > ()< / span > < span class = "c1" > # Estimate the statistical error< / span >
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_new_obs< / span > < span class = "p" > )< / span > < span class = "c1" > # Print the result to stdout< / span >
2021-11-15 13:13:15 +00:00
< span class = "o" > > < / span > < span class = "mf" > 0.31498< / span > < span class = "p" > (< / span > < span class = "mi" > 72< / span > < span class = "p" > )< / span >
2021-11-07 20:53:18 +00:00
< / code > < / pre > < / div >
< h1 id = "the-obs-class" > The < code > Obs< / code > class< / h1 >
2021-11-09 11:51:27 +00:00
< p > < code > < a href = "" > pyerrors< / a > < / code > introduces a new datatype, < code > Obs< / code > , which simplifies error propagation and estimation for auto- and cross-correlated data.
2022-02-21 14:52:31 +00:00
An < code > Obs< / code > object can be initialized with two arguments, the first is a list containing the samples for an observable from a Monte Carlo chain.
2021-11-09 11:51:27 +00:00
The samples can either be provided as python list or as numpy array.
The second argument is a list containing the names of the respective Monte Carlo chains as strings. These strings uniquely identify a Monte Carlo chain/ensemble.< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "kn" > import< / span > < span class = "nn" > pyerrors< / span > < span class = "k" > as< / span > < span class = "nn" > pe< / span >
2021-11-07 20:53:18 +00:00
< span class = "n" > my_obs< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > ])< / span >
< / code > < / pre > < / div >
2021-11-09 11:51:27 +00:00
< h2 id = "error-propagation" > Error propagation< / h2 >
2022-02-21 14:52:31 +00:00
< p > When performing mathematical operations on < code > Obs< / code > objects the correct error propagation is intrinsically taken care of using a first order Taylor expansion
2021-11-16 11:46:28 +00:00
$$\delta_f^i=\sum_\alpha \bar{f}_\alpha \delta_\alpha^i\,,\quad \delta_\alpha^i=a_\alpha^i-\bar{a}_\alpha\,,$$
2021-11-16 11:50:48 +00:00
as introduced in < a href = "https://arxiv.org/abs/hep-lat/0306017" > arXiv:hep-lat/0306017< / a > .
The required derivatives $\bar{f}_\alpha$ are evaluated up to machine precision via automatic differentiation as suggested in < a href = "https://arxiv.org/abs/1809.01289" > arXiv:1809.01289< / a > .< / p >
2021-11-09 11:51:27 +00:00
< p > The < code > Obs< / code > class is designed such that mathematical numpy functions can be used on < code > Obs< / code > just as for regular floats.< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "kn" > import< / span > < span class = "nn" > numpy< / span > < span class = "k" > as< / span > < span class = "nn" > np< / span >
2021-11-09 11:51:27 +00:00
< span class = "kn" > import< / span > < span class = "nn" > pyerrors< / span > < span class = "k" > as< / span > < span class = "nn" > pe< / span >
< span class = "n" > my_obs1< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples1< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > ])< / span >
< span class = "n" > my_obs2< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples2< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > ])< / span >
< span class = "n" > my_sum< / span > < span class = "o" > =< / span > < span class = "n" > my_obs1< / span > < span class = "o" > +< / span > < span class = "n" > my_obs2< / span >
< span class = "n" > my_m_eff< / span > < span class = "o" > =< / span > < span class = "n" > np< / span > < span class = "o" > .< / span > < span class = "n" > log< / span > < span class = "p" > (< / span > < span class = "n" > my_obs1< / span > < span class = "o" > /< / span > < span class = "n" > my_obs2< / span > < span class = "p" > )< / span >
2021-11-16 11:46:28 +00:00
< span class = "n" > iamzero< / span > < span class = "o" > =< / span > < span class = "n" > my_m_eff< / span > < span class = "o" > -< / span > < span class = "n" > my_m_eff< / span >
< span class = "c1" > # Check that value and fluctuations are zero within machine precision< / span >
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > iamzero< / span > < span class = "o" > ==< / span > < span class = "mf" > 0.0< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "kc" > True< / span >
2021-11-09 11:51:27 +00:00
< / code > < / pre > < / div >
< h2 id = "error-estimation" > Error estimation< / h2 >
2021-11-15 15:17:23 +00:00
< p > The error estimation within < code > < a href = "" > pyerrors< / a > < / code > is based on the gamma method introduced in < a href = "https://arxiv.org/abs/hep-lat/0306017" > arXiv:hep-lat/0306017< / a > .
After having arrived at the derived quantity of interest the < code > gamma_method< / code > can be called as detailed in the following example.< / p >
2021-11-15 10:12:16 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > gamma_method< / span > < span class = "p" > ()< / span >
2021-11-15 15:17:23 +00:00
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_sum< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mf" > 1.70< / span > < span class = "p" > (< / span > < span class = "mi" > 57< / span > < span class = "p" > )< / span >
2021-11-15 10:12:16 +00:00
< span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
2021-11-15 15:17:23 +00:00
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 1.70000000e+00< / span > < span class = "o" > +/-< / span > < span class = "mf" > 5.72046658e-01< / span > < span class = "o" > +/-< / span > < span class = "mf" > 7.56746598e-02< / span > < span class = "p" > (< / span > < span class = "mf" > 33.650< / span > < span class = "o" > %< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "n" > t_int< / span > < span class = "mf" > 2.71422900e+00< / span > < span class = "o" > +/-< / span > < span class = "mf" > 6.40320983e-01< / span > < span class = "n" > S< / span > < span class = "o" > =< / span > < span class = "mf" > 2.00< / span >
2021-11-15 10:43:47 +00:00
< span class = "o" > > < / span > < span class = "mi" > 1000< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > :< / span > < span class = "mi" > 1000< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 1000< / span > < span class = "p" > )< / span >
2021-11-15 10:12:16 +00:00
< / code > < / pre > < / div >
2021-11-15 15:50:10 +00:00
< p > We use the following definition of the integrated autocorrelation time established in < a href = "https://link.springer.com/article/10.1007/BF01022990" > Madras & Sokal 1988< / a >
2021-11-16 11:46:28 +00:00
$$\tau_\mathrm{int}=\frac{1}{2}+\sum_{t=1}^{W}\rho(t)\geq \frac{1}{2}\,.$$
2021-12-11 23:07:13 +00:00
The window $W$ is determined via the automatic windowing procedure described in < a href = "https://arxiv.org/abs/hep-lat/0306017" > arXiv:hep-lat/0306017< / a > .
2021-11-15 15:50:10 +00:00
The standard value for the parameter $S$ of this automatic windowing procedure is $S=2$. Other values for $S$ can be passed to the < code > gamma_method< / code > as parameter.< / p >
2021-11-15 10:12:16 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > gamma_method< / span > < span class = "p" > (< / span > < span class = "n" > S< / span > < span class = "o" > =< / span > < span class = "mf" > 3.0< / span > < span class = "p" > )< / span >
2021-11-15 10:12:16 +00:00
< span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
2021-11-15 15:17:23 +00:00
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 1.70000000e+00< / span > < span class = "o" > +/-< / span > < span class = "mf" > 6.30675201e-01< / span > < span class = "o" > +/-< / span > < span class = "mf" > 1.04585650e-01< / span > < span class = "p" > (< / span > < span class = "mf" > 37.099< / span > < span class = "o" > %< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "n" > t_int< / span > < span class = "mf" > 3.29909703e+00< / span > < span class = "o" > +/-< / span > < span class = "mf" > 9.77310102e-01< / span > < span class = "n" > S< / span > < span class = "o" > =< / span > < span class = "mf" > 3.00< / span >
2021-11-15 10:43:47 +00:00
< span class = "o" > > < / span > < span class = "mi" > 1000< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > :< / span > < span class = "mi" > 1000< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 1000< / span > < span class = "p" > )< / span >
2021-11-15 10:12:16 +00:00
< / code > < / pre > < / div >
2021-11-15 17:41:36 +00:00
< p > The integrated autocorrelation time $\tau_\mathrm{int}$ and the autocorrelation function $\rho(W)$ can be monitored via the methods < code > < a href = "pyerrors/obs.html#Obs.plot_tauint" > pyerrors.obs.Obs.plot_tauint< / a > < / code > and < code > < a href = "pyerrors/obs.html#Obs.plot_tauint" > pyerrors.obs.Obs.plot_tauint< / a > < / code > .< / p >
2021-11-15 10:12:16 +00:00
2022-02-21 14:52:31 +00:00
< p > If the parameter $S$ is set to zero it is assumed that the dataset does not exhibit any autocorrelation and the windowsize is chosen to be zero.
2021-11-17 13:43:40 +00:00
In this case the error estimate is identical to the sample standard error.< / p >
2021-11-09 11:51:27 +00:00
< h3 id = "exponential-tails" > Exponential tails< / h3 >
2021-11-15 10:57:31 +00:00
< p > Slow modes in the Monte Carlo history can be accounted for by attaching an exponential tail to the autocorrelation function $\rho$ as suggested in < a href = "https://arxiv.org/abs/1009.5228" > arXiv:1009.5228< / a > . The longest autocorrelation time in the history, $\tau_\mathrm{exp}$, can be passed to the < code > gamma_method< / code > as parameter. In this case the automatic windowing procedure is vacated and the parameter $S$ does not affect the error estimate.< / p >
2021-11-15 10:12:16 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > gamma_method< / span > < span class = "p" > (< / span > < span class = "n" > tau_exp< / span > < span class = "o" > =< / span > < span class = "mf" > 7.2< / span > < span class = "p" > )< / span >
2021-11-15 10:12:16 +00:00
< span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
2021-11-15 15:17:23 +00:00
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 1.70000000e+00< / span > < span class = "o" > +/-< / span > < span class = "mf" > 6.28097762e-01< / span > < span class = "o" > +/-< / span > < span class = "mf" > 5.79077524e-02< / span > < span class = "p" > (< / span > < span class = "mf" > 36.947< / span > < span class = "o" > %< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "n" > t_int< / span > < span class = "mf" > 3.27218667e+00< / span > < span class = "o" > +/-< / span > < span class = "mf" > 7.99583654e-01< / span > < span class = "n" > tau_exp< / span > < span class = "o" > =< / span > < span class = "mf" > 7.20< / span > < span class = "p" > ,< / span > < span class = "n" > N_sigma< / span > < span class = "o" > =< / span > < span class = "mi" > 1< / span >
2021-11-15 10:43:47 +00:00
< span class = "o" > > < / span > < span class = "mi" > 1000< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble_name' < / span > < span class = "p" > :< / span > < span class = "mi" > 1000< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 1000< / span > < span class = "p" > )< / span >
2021-11-15 10:12:16 +00:00
< / code > < / pre > < / div >
2021-12-11 23:07:13 +00:00
< p > For the full API see < code > < a href = "pyerrors/obs.html#Obs.gamma_method" > pyerrors.obs.Obs.gamma_method< / a > < / code > .< / p >
2021-11-15 10:12:16 +00:00
2021-11-07 20:53:18 +00:00
< h2 id = "multiple-ensemblesreplica" > Multiple ensembles/replica< / h2 >
2021-11-15 10:57:31 +00:00
< p > Error propagation for multiple ensembles (Markov chains with different simulation parameters) is handled automatically. Ensembles are uniquely identified by their < code > name< / code > .< / p >
2021-11-08 14:53:27 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > obs1< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples1< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ])< / span >
2021-11-09 12:09:45 +00:00
< span class = "n" > obs2< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples2< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble2' < / span > < span class = "p" > ])< / span >
2021-11-08 14:53:27 +00:00
< span class = "n" > my_sum< / span > < span class = "o" > =< / span > < span class = "n" > obs1< / span > < span class = "o" > +< / span > < span class = "n" > obs2< / span >
< span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
2021-11-16 12:00:28 +00:00
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 2.00697958e+00< / span >
2021-11-08 14:53:27 +00:00
< span class = "o" > > < / span > < span class = "mi" > 1500< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 2< / span > < span class = "n" > ensembles< / span > < span class = "p" > :< / span >
2021-11-15 09:55:51 +00:00
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > :< / span > < span class = "mi" > 1000< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 1000< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble2' < / span > < span class = "p" > :< / span > < span class = "mi" > 500< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 500< / span > < span class = "p" > )< / span >
2021-11-08 14:53:27 +00:00
< / code > < / pre > < / div >
2021-11-15 14:30:41 +00:00
< p > < code > < a href = "" > pyerrors< / a > < / code > identifies multiple replica (independent Markov chains with identical simulation parameters) by the vertical bar < code > |< / code > in the name of the data set.< / p >
2021-11-08 14:53:27 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > obs1< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples1< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1|r01' < / span > < span class = "p" > ])< / span >
2021-11-09 12:09:45 +00:00
< span class = "n" > obs2< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples2< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1|r02' < / span > < span class = "p" > ])< / span >
2021-11-08 14:53:27 +00:00
2021-11-15 09:55:51 +00:00
< span class = "o" > > < / span > < span class = "n" > my_sum< / span > < span class = "o" > =< / span > < span class = "n" > obs1< / span > < span class = "o" > +< / span > < span class = "n" > obs2< / span >
< span class = "o" > > < / span > < span class = "n" > my_sum< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
2021-11-16 12:00:28 +00:00
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 2.00697958e+00< / span >
2021-11-08 14:53:27 +00:00
< span class = "o" > > < / span > < span class = "mi" > 1500< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
2021-11-15 09:55:51 +00:00
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble1' < / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Replicum< / span > < span class = "s1" > ' r01' < / span > < span class = "p" > :< / span > < span class = "mi" > 1000< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 1000< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Replicum< / span > < span class = "s1" > ' r02' < / span > < span class = "p" > :< / span > < span class = "mi" > 500< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 1< / span > < span class = "n" > to< / span > < span class = "mi" > 500< / span > < span class = "p" > )< / span >
2021-11-08 14:53:27 +00:00
< / code > < / pre > < / div >
2021-11-15 10:12:16 +00:00
< h3 id = "error-estimation-for-multiple-ensembles" > Error estimation for multiple ensembles< / h3 >
2021-11-15 10:57:31 +00:00
< p > In order to keep track of different error analysis parameters for different ensembles one can make use of global dictionaries as detailed in the following example.< / p >
2021-11-15 10:12:16 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "o" > .< / span > < span class = "n" > S_dict< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ]< / span > < span class = "o" > =< / span > < span class = "mf" > 2.5< / span >
2021-11-15 10:12:16 +00:00
< span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "o" > .< / span > < span class = "n" > tau_exp_dict< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble2' < / span > < span class = "p" > ]< / span > < span class = "o" > =< / span > < span class = "mf" > 8.0< / span >
< span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "o" > .< / span > < span class = "n" > tau_exp_dict< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble3' < / span > < span class = "p" > ]< / span > < span class = "o" > =< / span > < span class = "mf" > 2.0< / span >
< / code > < / pre > < / div >
2021-11-15 10:43:47 +00:00
< p > In case the < code > gamma_method< / code > is called without any parameters it will use the values specified in the dictionaries for the respective ensembles.
Passing arguments to the < code > gamma_method< / code > still dominates over the dictionaries.< / p >
2021-11-07 20:53:18 +00:00
< h2 id = "irregular-monte-carlo-chains" > Irregular Monte Carlo chains< / h2 >
2022-01-21 14:55:18 +00:00
< p > < code > Obs< / code > objects defined on irregular Monte Carlo chains can be initialized with the parameter < code > idl< / code > .< / p >
2021-11-08 14:53:27 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "c1" > # Observable defined on configurations 20 to 519< / span >
2021-11-08 15:04:55 +00:00
< span class = "n" > obs1< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples1< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ],< / span > < span class = "n" > idl< / span > < span class = "o" > =< / span > < span class = "p" > [< / span > < span class = "nb" > range< / span > < span class = "p" > (< / span > < span class = "mi" > 20< / span > < span class = "p" > ,< / span > < span class = "mi" > 520< / span > < span class = "p" > )])< / span >
2021-11-16 12:00:28 +00:00
< span class = "n" > obs1< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 9.98319881e-01< / span >
< span class = "o" > > < / span > < span class = "mi" > 500< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > :< / span > < span class = "mi" > 500< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 20< / span > < span class = "n" > to< / span > < span class = "mi" > 519< / span > < span class = "p" > )< / span >
2021-11-08 15:10:26 +00:00
2021-11-08 15:04:55 +00:00
< span class = "c1" > # Observable defined on every second configuration between 5 and 1003< / span >
< span class = "n" > obs2< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples2< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ],< / span > < span class = "n" > idl< / span > < span class = "o" > =< / span > < span class = "p" > [< / span > < span class = "nb" > range< / span > < span class = "p" > (< / span > < span class = "mi" > 5< / span > < span class = "p" > ,< / span > < span class = "mi" > 1005< / span > < span class = "p" > ,< / span > < span class = "mi" > 2< / span > < span class = "p" > )])< / span >
2021-11-16 12:00:28 +00:00
< span class = "n" > obs2< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 9.99100712e-01< / span >
< span class = "o" > > < / span > < span class = "mi" > 500< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > :< / span > < span class = "mi" > 500< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "kn" > from< / span > < span class = "mi" > 5< / span > < span class = "n" > to< / span > < span class = "mi" > 1003< / span > < span class = "ow" > in< / span > < span class = "n" > steps< / span > < span class = "n" > of< / span > < span class = "mi" > 2< / span > < span class = "p" > )< / span >
2021-11-08 15:10:26 +00:00
2021-11-08 15:04:55 +00:00
< span class = "c1" > # Observable defined on configurations 2, 9, 28, 29 and 501< / span >
< span class = "n" > obs3< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples3< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ],< / span > < span class = "n" > idl< / span > < span class = "o" > =< / span > < span class = "p" > [[< / span > < span class = "mi" > 2< / span > < span class = "p" > ,< / span > < span class = "mi" > 9< / span > < span class = "p" > ,< / span > < span class = "mi" > 28< / span > < span class = "p" > ,< / span > < span class = "mi" > 29< / span > < span class = "p" > ,< / span > < span class = "mi" > 501< / span > < span class = "p" > ]])< / span >
2021-11-16 12:00:28 +00:00
< span class = "n" > obs3< / span > < span class = "o" > .< / span > < span class = "n" > details< / span > < span class = "p" > ()< / span >
< span class = "o" > > < / span > < span class = "n" > Result< / span > < span class = "mf" > 1.01718064e+00< / span >
< span class = "o" > > < / span > < span class = "mi" > 5< / span > < span class = "n" > samples< / span > < span class = "ow" > in< / span > < span class = "mi" > 1< / span > < span class = "n" > ensemble< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "err" > ·< / span > < span class = "n" > Ensemble< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > :< / span > < span class = "mi" > 5< / span > < span class = "n" > configurations< / span > < span class = "p" > (< / span > < span class = "n" > irregular< / span > < span class = "nb" > range< / span > < span class = "p" > )< / span >
2021-11-08 14:53:27 +00:00
< / code > < / pre > < / div >
2022-01-21 14:55:18 +00:00
< p > < code > Obs< / code > objects defined on regular and irregular histories of the same ensemble can be computed with each other and the correct error propagation and estimation is automatically taken care of.< / p >
2021-11-08 15:04:55 +00:00
< p > < strong > Warning:< / strong > Irregular Monte Carlo chains can result in odd patterns in the autocorrelation functions.
2021-11-15 10:57:31 +00:00
Make sure to check the autocorrelation time with e.g. < code > < a href = "pyerrors/obs.html#Obs.plot_rho" > pyerrors.obs.Obs.plot_rho< / a > < / code > or < code > < a href = "pyerrors/obs.html#Obs.plot_tauint" > pyerrors.obs.Obs.plot_tauint< / a > < / code > .< / p >
2021-11-08 15:04:55 +00:00
2021-12-11 23:07:13 +00:00
< p > For the full API see < code > < a href = "pyerrors/obs.html#Obs" > pyerrors.obs.Obs< / a > < / code > .< / p >
2021-11-07 20:53:18 +00:00
2021-11-09 11:51:27 +00:00
< h1 id = "correlators" > Correlators< / h1 >
2021-11-07 20:53:18 +00:00
2022-02-15 12:25:34 +00:00
< p > When one is not interested in single observables but correlation functions, < code > < a href = "" > pyerrors< / a > < / code > offers the < code > Corr< / code > class which simplifies the corresponding error propagation and provides the user with a set of standard methods. In order to initialize a < code > Corr< / code > objects one needs to arrange the data as a list of < code > Obs< / code > < / p >
2021-12-23 15:43:56 +00:00
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_corr< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Corr< / span > < span class = "p" > ([< / span > < span class = "n" > obs_0< / span > < span class = "p" > ,< / span > < span class = "n" > obs_1< / span > < span class = "p" > ,< / span > < span class = "n" > obs_2< / span > < span class = "p" > ,< / span > < span class = "n" > obs_3< / span > < span class = "p" > ])< / span >
2021-12-23 15:43:56 +00:00
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_corr< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "n" > x0< / span > < span class = "o" > /< / span > < span class = "n" > a< / span > < span class = "n" > Corr< / span > < span class = "p" > (< / span > < span class = "n" > x0< / span > < span class = "o" > /< / span > < span class = "n" > a< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "o" > ------------------< / span >
< span class = "o" > > < / span > < span class = "mi" > 0< / span > < span class = "mf" > 0.7957< / span > < span class = "p" > (< / span > < span class = "mi" > 80< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 1< / span > < span class = "mf" > 0.5156< / span > < span class = "p" > (< / span > < span class = "mi" > 51< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 2< / span > < span class = "mf" > 0.3227< / span > < span class = "p" > (< / span > < span class = "mi" > 33< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 3< / span > < span class = "mf" > 0.2041< / span > < span class = "p" > (< / span > < span class = "mi" > 21< / span > < span class = "p" > )< / span >
< / code > < / pre > < / div >
< p > In case the correlation functions are not defined on the outermost timeslices, for example because of fixed boundary conditions, a padding can be introduced.< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_corr< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Corr< / span > < span class = "p" > ([< / span > < span class = "n" > obs_0< / span > < span class = "p" > ,< / span > < span class = "n" > obs_1< / span > < span class = "p" > ,< / span > < span class = "n" > obs_2< / span > < span class = "p" > ,< / span > < span class = "n" > obs_3< / span > < span class = "p" > ],< / span > < span class = "n" > padding< / span > < span class = "o" > =< / span > < span class = "p" > [< / span > < span class = "mi" > 1< / span > < span class = "p" > ,< / span > < span class = "mi" > 1< / span > < span class = "p" > ])< / span >
2021-12-23 15:43:56 +00:00
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_corr< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "n" > x0< / span > < span class = "o" > /< / span > < span class = "n" > a< / span > < span class = "n" > Corr< / span > < span class = "p" > (< / span > < span class = "n" > x0< / span > < span class = "o" > /< / span > < span class = "n" > a< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "o" > ------------------< / span >
< span class = "o" > > < / span > < span class = "mi" > 0< / span >
< span class = "o" > > < / span > < span class = "mi" > 1< / span > < span class = "mf" > 0.7957< / span > < span class = "p" > (< / span > < span class = "mi" > 80< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 2< / span > < span class = "mf" > 0.5156< / span > < span class = "p" > (< / span > < span class = "mi" > 51< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 3< / span > < span class = "mf" > 0.3227< / span > < span class = "p" > (< / span > < span class = "mi" > 33< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 4< / span > < span class = "mf" > 0.2041< / span > < span class = "p" > (< / span > < span class = "mi" > 21< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 5< / span >
< / code > < / pre > < / div >
< p > The individual entries of a correlator can be accessed via slicing< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_corr< / span > < span class = "p" > [< / span > < span class = "mi" > 3< / span > < span class = "p" > ])< / span >
2021-12-23 15:43:56 +00:00
< span class = "o" > > < / span > < span class = "mf" > 0.3227< / span > < span class = "p" > (< / span > < span class = "mi" > 33< / span > < span class = "p" > )< / span >
< / code > < / pre > < / div >
< p > Error propagation with the < code > Corr< / code > class works very similar to < code > Obs< / code > objects. Mathematical operations are overloaded and < code > Corr< / code > objects can be computed together with other < code > Corr< / code > objects, < code > Obs< / code > objects or real numbers and integers.< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_new_corr< / span > < span class = "o" > =< / span > < span class = "mf" > 0.3< / span > < span class = "o" > *< / span > < span class = "n" > my_corr< / span > < span class = "p" > [< / span > < span class = "mi" > 2< / span > < span class = "p" > ]< / span > < span class = "o" > *< / span > < span class = "n" > my_corr< / span > < span class = "o" > *< / span > < span class = "n" > my_corr< / span > < span class = "o" > +< / span > < span class = "mi" > 12< / span > < span class = "o" > /< / span > < span class = "n" > my_corr< / span >
2021-12-23 15:43:56 +00:00
< / code > < / pre > < / div >
< p > < code > < a href = "" > pyerrors< / a > < / code > provides the user with a set of regularly used methods for the manipulation of correlator objects:< / p >
< ul >
< li > < code > Corr.gamma_method< / code > applies the gamma method to all entries of the correlator.< / li >
< li > < code > Corr.m_eff< / code > to construct effective masses. Various variants for periodic and fixed temporal boundary conditions are available.< / li >
< li > < code > Corr.deriv< / code > returns the first derivative of the correlator as < code > Corr< / code > . Different discretizations of the numerical derivative are available.< / li >
< li > < code > Corr.second_deriv< / code > returns the second derivative of the correlator as < code > Corr< / code > . Different discretizations of the numerical derivative are available.< / li >
< li > < code > Corr.symmetric< / code > symmetrizes parity even correlations functions, assuming periodic boundary conditions.< / li >
< li > < code > Corr.anti_symmetric< / code > anti-symmetrizes parity odd correlations functions, assuming periodic boundary conditions.< / li >
< li > < code > Corr.T_symmetry< / code > averages a correlator with its time symmetry partner, assuming fixed boundary conditions.< / li >
< li > < code > Corr.plateau< / code > extracts a plateau value from the correlator in a given range.< / li >
< li > < code > Corr.roll< / code > periodically shifts the correlator.< / li >
< li > < code > Corr.reverse< / code > reverses the time ordering of the correlator.< / li >
< li > < code > Corr.correlate< / code > constructs a disconnected correlation function from the correlator and another < code > Corr< / code > or < code > Obs< / code > object.< / li >
< li > < code > Corr.reweight< / code > reweights the correlator.< / li >
< / ul >
2022-01-21 14:55:18 +00:00
< p > < code > < a href = "" > pyerrors< / a > < / code > can also handle matrices of correlation functions and extract energy states from these matrices via a generalized eigenvalue problem (see < code > < a href = "pyerrors/correlators.html#Corr.GEVP" > pyerrors.correlators.Corr.GEVP< / a > < / code > ).< / p >
2021-12-23 15:43:56 +00:00
2021-12-11 23:07:13 +00:00
< p > For the full API see < code > < a href = "pyerrors/correlators.html#Corr" > pyerrors.correlators.Corr< / a > < / code > .< / p >
2021-11-07 20:53:18 +00:00
2022-02-14 14:08:21 +00:00
< h1 id = "complex-valued-observables" > Complex valued observables< / h1 >
2021-11-07 21:09:48 +00:00
2021-11-15 14:59:01 +00:00
< p > < code > < a href = "" > pyerrors< / a > < / code > can handle complex valued observables via the class < code > < a href = "pyerrors/obs.html#CObs" > pyerrors.obs.CObs< / a > < / code > .
< code > CObs< / code > are initialized with a real and an imaginary part which both can be < code > Obs< / code > valued.< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_real_part< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples1< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ])< / span >
2021-11-15 14:59:01 +00:00
< span class = "n" > my_imag_part< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Obs< / span > < span class = "p" > ([< / span > < span class = "n" > samples2< / span > < span class = "p" > ],< / span > < span class = "p" > [< / span > < span class = "s1" > ' ensemble1' < / span > < span class = "p" > ])< / span >
< span class = "n" > my_cobs< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > CObs< / span > < span class = "p" > (< / span > < span class = "n" > my_real_part< / span > < span class = "p" > ,< / span > < span class = "n" > my_imag_part< / span > < span class = "p" > )< / span >
< span class = "n" > my_cobs< / span > < span class = "o" > .< / span > < span class = "n" > gamma_method< / span > < span class = "p" > ()< / span >
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_cobs< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "p" > (< / span > < span class = "mf" > 0.9959< / span > < span class = "p" > (< / span > < span class = "mi" > 91< / span > < span class = "p" > )< / span > < span class = "o" > +< / span > < span class = "mf" > 0.659< / span > < span class = "p" > (< / span > < span class = "mi" > 28< / span > < span class = "p" > )< / span > < span class = "n" > j< / span > < span class = "p" > )< / span >
< / code > < / pre > < / div >
< p > Elementary mathematical operations are overloaded and samples are properly propagated as for the < code > Obs< / code > class.< / p >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_derived_cobs< / span > < span class = "o" > =< / span > < span class = "p" > (< / span > < span class = "n" > my_cobs< / span > < span class = "o" > +< / span > < span class = "n" > my_cobs< / span > < span class = "o" > .< / span > < span class = "n" > conjugate< / span > < span class = "p" > ())< / span > < span class = "o" > /< / span > < span class = "n" > np< / span > < span class = "o" > .< / span > < span class = "n" > abs< / span > < span class = "p" > (< / span > < span class = "n" > my_cobs< / span > < span class = "p" > )< / span >
2021-11-15 14:59:01 +00:00
< span class = "n" > my_derived_cobs< / span > < span class = "o" > .< / span > < span class = "n" > gamma_method< / span > < span class = "p" > ()< / span >
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "n" > my_derived_cobs< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "p" > (< / span > < span class = "mf" > 1.668< / span > < span class = "p" > (< / span > < span class = "mi" > 23< / span > < span class = "p" > )< / span > < span class = "o" > +< / span > < span class = "mf" > 0.0< / span > < span class = "n" > j< / span > < span class = "p" > )< / span >
< / code > < / pre > < / div >
2021-11-07 21:09:48 +00:00
2022-02-14 14:08:21 +00:00
< h1 id = "error-propagation-in-iterative-algorithms" > Error propagation in iterative algorithms< / h1 >
< p > < code > < a href = "" > pyerrors< / a > < / code > supports exact linear error propagation for iterative algorithms like various variants of non-linear least sqaures fits or root finding. The derivatives required for the error propagation are calculated as described in < a href = "https://arxiv.org/abs/1809.01289" > arXiv:1809.01289< / a > .< / p >
< h2 id = "least-squares-fits" > Least squares fits< / h2 >
< p > Standard non-linear least square fits with errors on the dependent but not the independent variables can be performed with < code > < a href = "pyerrors/fits.html#least_squares" > pyerrors.fits.least_squares< / a > < / code > . As default solver the Levenberg-Marquardt algorithm implemented in < a href = "https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html" > scipy< / a > is used.< / p >
< p > Fit functions have to be of the following form< / p >
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "kn" > import< / span > < span class = "nn" > autograd.numpy< / span > < span class = "k" > as< / span > < span class = "nn" > anp< / span >
< span class = "k" > def< / span > < span class = "nf" > func< / span > < span class = "p" > (< / span > < span class = "n" > a< / span > < span class = "p" > ,< / span > < span class = "n" > x< / span > < span class = "p" > ):< / span >
< span class = "k" > return< / span > < span class = "n" > a< / span > < span class = "p" > [< / span > < span class = "mi" > 1< / span > < span class = "p" > ]< / span > < span class = "o" > *< / span > < span class = "n" > anp< / span > < span class = "o" > .< / span > < span class = "n" > exp< / span > < span class = "p" > (< / span > < span class = "o" > -< / span > < span class = "n" > a< / span > < span class = "p" > [< / span > < span class = "mi" > 0< / span > < span class = "p" > ]< / span > < span class = "o" > *< / span > < span class = "n" > x< / span > < span class = "p" > )< / span >
< / code > < / pre > < / div >
2022-02-21 14:52:31 +00:00
< p > < strong > It is important that numerical functions refer to < code > autograd.numpy< / code > instead of < code > numpy< / code > for the automatic differentiation in iterative algorithms to work properly.< / strong > < / p >
2022-02-14 14:08:21 +00:00
< p > Fits can then be performed via< / p >
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > fit_result< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > fits< / span > < span class = "o" > .< / span > < span class = "n" > least_squares< / span > < span class = "p" > (< / span > < span class = "n" > x< / span > < span class = "p" > ,< / span > < span class = "n" > y< / span > < span class = "p" > ,< / span > < span class = "n" > func< / span > < span class = "p" > )< / span >
< span class = "nb" > print< / span > < span class = "p" > (< / span > < span class = "s2" > " < / span > < span class = "se" > \n< / span > < span class = "s2" > " < / span > < span class = "p" > ,< / span > < span class = "n" > fit_result< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "n" > Fit< / span > < span class = "k" > with< / span > < span class = "mi" > 2< / span > < span class = "n" > parameters< / span >
< span class = "o" > > < / span > < span class = "n" > Method< / span > < span class = "p" > :< / span > < span class = "n" > Levenberg< / span > < span class = "o" > -< / span > < span class = "n" > Marquardt< / span >
< span class = "o" > > < / span > < span class = "err" > `< / span > < span class = "n" > ftol< / span > < span class = "err" > `< / span > < span class = "n" > termination< / span > < span class = "n" > condition< / span > < span class = "ow" > is< / span > < span class = "n" > satisfied< / span > < span class = "o" > .< / span >
< span class = "o" > > < / span > < span class = "n" > chisquare< / span > < span class = "o" > /< / span > < span class = "n" > d< / span > < span class = "o" > .< / span > < span class = "n" > o< / span > < span class = "o" > .< / span > < span class = "n" > f< / span > < span class = "o" > .< / span > < span class = "p" > :< / span > < span class = "mf" > 0.9593035785160936< / span >
< span class = "o" > > < / span > < span class = "n" > Goodness< / span > < span class = "n" > of< / span > < span class = "n" > fit< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "n" > χ< / span > < span class = "err" > ²< / span > < span class = "o" > /< / span > < span class = "n" > d< / span > < span class = "o" > .< / span > < span class = "n" > o< / span > < span class = "o" > .< / span > < span class = "n" > f< / span > < span class = "o" > .< / span > < span class = "o" > =< / span > < span class = "mf" > 0.959304< / span >
< span class = "o" > > < / span > < span class = "n" > p< / span > < span class = "o" > -< / span > < span class = "n" > value< / span > < span class = "o" > =< / span > < span class = "mf" > 0.5673< / span >
< span class = "o" > > < / span > < span class = "n" > Fit< / span > < span class = "n" > parameters< / span > < span class = "p" > :< / span >
< span class = "o" > > < / span > < span class = "mi" > 0< / span > < span class = "mf" > 0.0548< / span > < span class = "p" > (< / span > < span class = "mi" > 28< / span > < span class = "p" > )< / span >
< span class = "o" > > < / span > < span class = "mi" > 1< / span > < span class = "mf" > 1.933< / span > < span class = "p" > (< / span > < span class = "mi" > 64< / span > < span class = "p" > )< / span >
< / code > < / pre > < / div >
< p > where x is a < code > list< / code > or < code > numpy.array< / code > of < code > floats< / code > and y is a < code > list< / code > or < code > numpy.array< / code > of < code > Obs< / code > .< / p >
< p > Data stored in < code > Corr< / code > objects can be fitted directly using the < code > Corr.fit< / code > method.< / p >
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "n" > my_corr< / span > < span class = "o" > =< / span > < span class = "n" > pe< / span > < span class = "o" > .< / span > < span class = "n" > Corr< / span > < span class = "p" > (< / span > < span class = "n" > y< / span > < span class = "p" > )< / span >
< span class = "n" > fit_result< / span > < span class = "o" > =< / span > < span class = "n" > my_corr< / span > < span class = "o" > .< / span > < span class = "n" > fit< / span > < span class = "p" > (< / span > < span class = "n" > func< / span > < span class = "p" > ,< / span > < span class = "n" > fitrange< / span > < span class = "o" > =< / span > < span class = "p" > [< / span > < span class = "mi" > 12< / span > < span class = "p" > ,< / span > < span class = "mi" > 25< / span > < span class = "p" > ])< / span >
< / code > < / pre > < / div >
< p > this can simplify working with absolute fit ranges and takes care of gaps in the data automatically.< / p >
< p > For fit functions with multiple independent variables the fit function can be of the form< / p >
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < code > < span class = "k" > def< / span > < span class = "nf" > func< / span > < span class = "p" > (< / span > < span class = "n" > a< / span > < span class = "p" > ,< / span > < span class = "n" > x< / span > < span class = "p" > ):< / span >
< span class = "p" > (< / span > < span class = "n" > x1< / span > < span class = "p" > ,< / span > < span class = "n" > x2< / span > < span class = "p" > )< / span > < span class = "o" > =< / span > < span class = "n" > x< / span >
< span class = "k" > return< / span > < span class = "n" > a< / span > < span class = "p" > [< / span > < span class = "mi" > 0< / span > < span class = "p" > ]< / span > < span class = "o" > *< / span > < span class = "n" > x1< / span > < span class = "o" > **< / span > < span class = "mi" > 2< / span > < span class = "o" > +< / span > < span class = "n" > a< / span > < span class = "p" > [< / span > < span class = "mi" > 1< / span > < span class = "p" > ]< / span > < span class = "o" > *< / span > < span class = "n" > x2< / span >
< / code > < / pre > < / div >
2021-11-07 20:53:18 +00:00
2022-02-14 14:08:21 +00:00
< h2 id = "total-least-squares-fits" > Total least squares fits< / h2 >
< p > < code > < a href = "" > pyerrors< / a > < / code > can also fit data with errors on both the dependent and independent variables using the total least squares method also referred to orthogonal distance regression as implemented in < a href = "https://docs.scipy.org/doc/scipy/reference/odr.html" > scipy< / a > , see < code > < a href = "pyerrors/fits.html#least_squares" > pyerrors.fits.least_squares< / a > < / code > . The syntax is identical to the standard least squares case, the only diffrence being that < code > x< / code > also has to be a < code > list< / code > or < code > numpy.array< / code > of < code > Obs< / code > .< / p >
< p > For the full API see < code > < a href = "pyerrors/fits.html" > pyerrors.fits< / a > < / code > for fits and < code > < a href = "pyerrors/roots.html" > pyerrors.roots< / a > < / code > for finding roots of functions.< / p >
2021-11-07 21:09:48 +00:00
2021-11-07 20:53:18 +00:00
< h1 id = "matrix-operations" > Matrix operations< / h1 >
2022-02-14 14:26:48 +00:00
< p > < code > < a href = "" > pyerrors< / a > < / code > provides wrappers for < code > Obs< / code > - and < code > CObs< / code > -valued matrix operations based on < code > numpy.linalg< / code > . The supported functions include:< / p >
2022-01-21 14:55:18 +00:00
< ul >
< li > < code > inv< / code > for the matrix inverse.< / li >
< li > < code > cholseky< / code > for the Cholesky decomposition.< / li >
< li > < code > det< / code > for the matrix determinant.< / li >
< li > < code > eigh< / code > for eigenvalues and eigenvectors of hermitean matrices.< / li >
< li > < code > eig< / code > for eigenvalues of general matrices.< / li >
< li > < code > pinv< / code > for the Moore-Penrose pseudoinverse.< / li >
< li > < code > svd< / code > for the singular-value-decomposition.< / li >
< / ul >
< p > For the full API see < code > < a href = "pyerrors/linalg.html" > pyerrors.linalg< / a > < / code > .< / p >
2021-11-07 21:09:48 +00:00
2021-11-15 14:30:41 +00:00
< h1 id = "export-data" > Export data< / h1 >
2022-02-21 14:52:31 +00:00
< p > The preferred exported file format within < code > < a href = "" > pyerrors< / a > < / code > is json.gz. The exact specifications of this format will be listed here soon.< / p >
2021-11-15 14:30:41 +00:00
< h2 id = "jackknife-samples" > Jackknife samples< / h2 >
2021-12-11 23:07:13 +00:00
< p > For comparison with other analysis workflows < code > < a href = "" > pyerrors< / a > < / code > can generate jackknife samples from an < code > Obs< / code > object or import jackknife samples into an < code > Obs< / code > object.
See < code > < a href = "pyerrors/obs.html#Obs.export_jackknife" > pyerrors.obs.Obs.export_jackknife< / a > < / code > and < code > < a href = "pyerrors/obs.html#import_jackknife" > pyerrors.obs.import_jackknife< / a > < / code > for details.< / p >
2021-11-15 14:30:41 +00:00
2022-02-14 14:08:21 +00:00
< h1 id = "citing" > Citing< / h1 >
< p > If you use < code > < a href = "" > pyerrors< / a > < / code > for research that leads to a publication please consider citing:< / p >
< ul >
2022-02-14 14:19:54 +00:00
< li > Ulli Wolff, < em > Monte Carlo errors with less errors< / em > . Comput.Phys.Commun. 156 (2004) 143-153, Comput.Phys.Commun. 176 (2007) 383 (erratum).< / li >
< li > Stefan Schaefer, Rainer Sommer, Francesco Virotta, < em > Critical slowing down and error analysis in lattice QCD simulations< / em > . Nucl.Phys.B 845 (2011) 93-119.< / li >
< li > Alberto Ramos, < em > Automatic differentiation for error analysis of Monte Carlo data< / em > . Comput.Phys.Commun. 238 (2019) 19-35.< / li >
2022-02-14 14:08:21 +00:00
< / ul >
2021-11-07 20:53:18 +00:00
< / div >
< details >
< summary > View Source< / summary >
2022-02-14 14:08:21 +00:00
< div class = "pdoc-code codehilite" > < pre > < span > < / span > < span class = "sa" > r< / span > < span class = "sd" > ' ' ' < / span >
2021-11-07 20:53:18 +00:00
< span class = "sd" > # What is pyerrors?< / span >
< span class = "sd" > `pyerrors` is a python package for error computation and propagation of Markov chain Monte Carlo data.< / span >
2021-12-11 23:00:30 +00:00
< span class = "sd" > It is based on the gamma method [arXiv:hep-lat/0306017](https://arxiv.org/abs/hep-lat/0306017). Some of its features are:< / span >
< span class = "sd" > - automatic differentiation for exact liner error propagation as suggested in [arXiv:1809.01289](https://arxiv.org/abs/1809.01289) (partly based on the [autograd](https://github.com/HIPS/autograd) package).< / span >
< span class = "sd" > - treatment of slow modes in the simulation as suggested in [arXiv:1009.5228](https://arxiv.org/abs/1009.5228).< / span >
< span class = "sd" > - coherent error propagation for data from different Markov chains.< / span >
< span class = "sd" > - non-linear fits with x- and y-errors and exact linear error propagation based on automatic differentiation as introduced in [arXiv:1809.01289](https://arxiv.org/abs/1809.01289).< / span >
< span class = "sd" > - real and complex matrix operations and their error propagation based on automatic differentiation (Matrix inverse, Cholesky decomposition, calculation of eigenvalues and eigenvectors, singular value decomposition...).< / span >
< span class = "sd" > There exist similar publicly available implementations of gamma method error analysis suites in [Fortran](https://gitlab.ift.uam-csic.es/alberto/aderrors), [Julia](https://gitlab.ift.uam-csic.es/alberto/aderrors.jl) and [Python](https://github.com/mbruno46/pyobs).< / span >
2021-11-30 14:58:46 +00:00
2021-11-16 11:46:28 +00:00
< span class = "sd" > ## Basic example< / span >
2021-11-07 20:53:18 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > import numpy as np< / span >
< span class = "sd" > import pyerrors as pe< / span >
2021-11-16 11:50:48 +00:00
< span class = "sd" > my_obs = pe.Obs([samples], [' ensemble_name' ]) # Initialize an Obs object< / span >
2021-11-16 11:46:28 +00:00
< span class = "sd" > my_new_obs = 2 * np.log(my_obs) / my_obs ** 2 # Construct derived Obs object< / span >
2021-11-16 11:50:48 +00:00
< span class = "sd" > my_new_obs.gamma_method() # Estimate the statistical error< / span >
< span class = "sd" > print(my_new_obs) # Print the result to stdout< / span >
2021-11-15 13:13:15 +00:00
< span class = "sd" > > 0.31498(72)< / span >
2021-11-07 20:53:18 +00:00
< span class = "sd" > ```< / span >
2021-11-15 13:13:15 +00:00
2021-11-07 20:53:18 +00:00
< span class = "sd" > # The `Obs` class< / span >
2021-11-09 11:51:27 +00:00
< span class = "sd" > `pyerrors` introduces a new datatype, `Obs`, which simplifies error propagation and estimation for auto- and cross-correlated data.< / span >
2022-02-21 14:52:31 +00:00
< span class = "sd" > An `Obs` object can be initialized with two arguments, the first is a list containing the samples for an observable from a Monte Carlo chain.< / span >
2021-11-09 11:51:27 +00:00
< span class = "sd" > The samples can either be provided as python list or as numpy array.< / span >
< span class = "sd" > The second argument is a list containing the names of the respective Monte Carlo chains as strings. These strings uniquely identify a Monte Carlo chain/ensemble.< / span >
2021-11-07 20:53:18 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > import pyerrors as pe< / span >
< span class = "sd" > my_obs = pe.Obs([samples], [' ensemble_name' ])< / span >
< span class = "sd" > ```< / span >
2021-11-09 11:51:27 +00:00
< span class = "sd" > ## Error propagation< / span >
2022-02-21 14:52:31 +00:00
< span class = "sd" > When performing mathematical operations on `Obs` objects the correct error propagation is intrinsically taken care of using a first order Taylor expansion< / span >
2021-11-16 11:46:28 +00:00
< span class = "sd" > $$\delta_f^i=\sum_\alpha \bar{f}_\alpha \delta_\alpha^i\,,\quad \delta_\alpha^i=a_\alpha^i-\bar{a}_\alpha\,,$$< / span >
2021-11-09 11:51:27 +00:00
< span class = "sd" > as introduced in [arXiv:hep-lat/0306017](https://arxiv.org/abs/hep-lat/0306017).< / span >
< span class = "sd" > The required derivatives $\bar{f}_\alpha$ are evaluated up to machine precision via automatic differentiation as suggested in [arXiv:1809.01289](https://arxiv.org/abs/1809.01289).< / span >
< span class = "sd" > The `Obs` class is designed such that mathematical numpy functions can be used on `Obs` just as for regular floats.< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > import numpy as np< / span >
< span class = "sd" > import pyerrors as pe< / span >
< span class = "sd" > my_obs1 = pe.Obs([samples1], [' ensemble_name' ])< / span >
< span class = "sd" > my_obs2 = pe.Obs([samples2], [' ensemble_name' ])< / span >
< span class = "sd" > my_sum = my_obs1 + my_obs2< / span >
< span class = "sd" > my_m_eff = np.log(my_obs1 / my_obs2)< / span >
2021-11-16 11:46:28 +00:00
< span class = "sd" > iamzero = my_m_eff - my_m_eff< / span >
< span class = "sd" > # Check that value and fluctuations are zero within machine precision< / span >
< span class = "sd" > print(iamzero == 0.0)< / span >
< span class = "sd" > > True< / span >
2021-11-09 11:51:27 +00:00
< span class = "sd" > ```< / span >
< span class = "sd" > ## Error estimation< / span >
2021-11-15 10:57:31 +00:00
< span class = "sd" > The error estimation within `pyerrors` is based on the gamma method introduced in [arXiv:hep-lat/0306017](https://arxiv.org/abs/hep-lat/0306017).< / span >
< span class = "sd" > After having arrived at the derived quantity of interest the `gamma_method` can be called as detailed in the following example.< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > my_sum.gamma_method()< / span >
2021-11-15 15:17:23 +00:00
< span class = "sd" > print(my_sum)< / span >
< span class = "sd" > > 1.70(57)< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > my_sum.details()< / span >
2021-11-15 15:17:23 +00:00
< span class = "sd" > > Result 1.70000000e+00 +/- 5.72046658e-01 +/- 7.56746598e-02 (33.650%)< / span >
< span class = "sd" > > t_int 2.71422900e+00 +/- 6.40320983e-01 S = 2.00< / span >
2021-11-15 10:43:47 +00:00
< span class = "sd" > > 1000 samples in 1 ensemble:< / span >
< span class = "sd" > > · Ensemble ' ensemble_name' : 1000 configurations (from 1 to 1000)< / span >
2021-11-15 15:17:23 +00:00
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```< / span >
2021-11-15 15:50:10 +00:00
< span class = "sd" > We use the following definition of the integrated autocorrelation time established in [Madras & Sokal 1988](https://link.springer.com/article/10.1007/BF01022990)< / span >
2021-11-16 11:46:28 +00:00
< span class = "sd" > $$\tau_\mathrm{int}=\frac{1}{2}+\sum_{t=1}^{W}\rho(t)\geq \frac{1}{2}\,.$$< / span >
2021-12-11 23:07:13 +00:00
< span class = "sd" > The window $W$ is determined via the automatic windowing procedure described in [arXiv:hep-lat/0306017](https://arxiv.org/abs/hep-lat/0306017).< / span >
2021-11-15 15:50:10 +00:00
< span class = "sd" > The standard value for the parameter $S$ of this automatic windowing procedure is $S=2$. Other values for $S$ can be passed to the `gamma_method` as parameter.< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > my_sum.gamma_method(S=3.0)< / span >
< span class = "sd" > my_sum.details()< / span >
2021-11-15 15:17:23 +00:00
< span class = "sd" > > Result 1.70000000e+00 +/- 6.30675201e-01 +/- 1.04585650e-01 (37.099%)< / span >
< span class = "sd" > > t_int 3.29909703e+00 +/- 9.77310102e-01 S = 3.00< / span >
2021-11-15 10:43:47 +00:00
< span class = "sd" > > 1000 samples in 1 ensemble:< / span >
< span class = "sd" > > · Ensemble ' ensemble_name' : 1000 configurations (from 1 to 1000)< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```< / span >
2021-11-15 17:41:36 +00:00
< span class = "sd" > The integrated autocorrelation time $\tau_\mathrm{int}$ and the autocorrelation function $\rho(W)$ can be monitored via the methods `pyerrors.obs.Obs.plot_tauint` and `pyerrors.obs.Obs.plot_tauint`.< / span >
2021-11-15 10:12:16 +00:00
2022-02-21 14:52:31 +00:00
< span class = "sd" > If the parameter $S$ is set to zero it is assumed that the dataset does not exhibit any autocorrelation and the windowsize is chosen to be zero.< / span >
2021-11-17 13:43:40 +00:00
< span class = "sd" > In this case the error estimate is identical to the sample standard error.< / span >
2021-11-09 11:51:27 +00:00
< span class = "sd" > ### Exponential tails< / span >
2021-11-15 10:57:31 +00:00
< span class = "sd" > Slow modes in the Monte Carlo history can be accounted for by attaching an exponential tail to the autocorrelation function $\rho$ as suggested in [arXiv:1009.5228](https://arxiv.org/abs/1009.5228). The longest autocorrelation time in the history, $\tau_\mathrm{exp}$, can be passed to the `gamma_method` as parameter. In this case the automatic windowing procedure is vacated and the parameter $S$ does not affect the error estimate.< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```python< / span >
2021-11-15 10:43:47 +00:00
< span class = "sd" > my_sum.gamma_method(tau_exp=7.2)< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > my_sum.details()< / span >
2021-11-15 15:17:23 +00:00
< span class = "sd" > > Result 1.70000000e+00 +/- 6.28097762e-01 +/- 5.79077524e-02 (36.947%)< / span >
< span class = "sd" > > t_int 3.27218667e+00 +/- 7.99583654e-01 tau_exp = 7.20, N_sigma = 1< / span >
2021-11-15 10:43:47 +00:00
< span class = "sd" > > 1000 samples in 1 ensemble:< / span >
< span class = "sd" > > · Ensemble ' ensemble_name' : 1000 configurations (from 1 to 1000)< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```< / span >
2021-12-11 23:07:13 +00:00
< span class = "sd" > For the full API see `pyerrors.obs.Obs.gamma_method`.< / span >
2021-11-15 10:12:16 +00:00
2021-11-07 20:53:18 +00:00
< span class = "sd" > ## Multiple ensembles/replica< / span >
2021-11-15 10:57:31 +00:00
< span class = "sd" > Error propagation for multiple ensembles (Markov chains with different simulation parameters) is handled automatically. Ensembles are uniquely identified by their `name`.< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > obs1 = pe.Obs([samples1], [' ensemble1' ])< / span >
2021-11-09 12:09:45 +00:00
< span class = "sd" > obs2 = pe.Obs([samples2], [' ensemble2' ])< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > my_sum = obs1 + obs2< / span >
< span class = "sd" > my_sum.details()< / span >
2021-11-16 12:00:28 +00:00
< span class = "sd" > > Result 2.00697958e+00< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > > 1500 samples in 2 ensembles:< / span >
2021-11-15 09:55:51 +00:00
< span class = "sd" > > · Ensemble ' ensemble1' : 1000 configurations (from 1 to 1000)< / span >
< span class = "sd" > > · Ensemble ' ensemble2' : 500 configurations (from 1 to 500)< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > ```< / span >
2021-11-15 14:30:41 +00:00
< span class = "sd" > `pyerrors` identifies multiple replica (independent Markov chains with identical simulation parameters) by the vertical bar `|` in the name of the data set.< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > obs1 = pe.Obs([samples1], [' ensemble1|r01' ])< / span >
2021-11-09 12:09:45 +00:00
< span class = "sd" > obs2 = pe.Obs([samples2], [' ensemble1|r02' ])< / span >
2021-11-08 14:53:27 +00:00
2021-11-15 09:55:51 +00:00
< span class = "sd" > > my_sum = obs1 + obs2< / span >
< span class = "sd" > > my_sum.details()< / span >
2021-11-16 12:00:28 +00:00
< span class = "sd" > > Result 2.00697958e+00< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > > 1500 samples in 1 ensemble:< / span >
2021-11-15 09:55:51 +00:00
< span class = "sd" > > · Ensemble ' ensemble1' < / span >
< span class = "sd" > > · Replicum ' r01' : 1000 configurations (from 1 to 1000)< / span >
< span class = "sd" > > · Replicum ' r02' : 500 configurations (from 1 to 500)< / span >
2021-11-08 14:53:27 +00:00
< span class = "sd" > ```< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ### Error estimation for multiple ensembles< / span >
2021-11-15 10:57:31 +00:00
< span class = "sd" > In order to keep track of different error analysis parameters for different ensembles one can make use of global dictionaries as detailed in the following example.< / span >
2021-11-15 10:12:16 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > pe.Obs.S_dict[' ensemble1' ] = 2.5< / span >
< span class = "sd" > pe.Obs.tau_exp_dict[' ensemble2' ] = 8.0< / span >
< span class = "sd" > pe.Obs.tau_exp_dict[' ensemble3' ] = 2.0< / span >
< span class = "sd" > ```< / span >
2021-11-15 10:43:47 +00:00
< span class = "sd" > In case the `gamma_method` is called without any parameters it will use the values specified in the dictionaries for the respective ensembles.< / span >
< span class = "sd" > Passing arguments to the `gamma_method` still dominates over the dictionaries.< / span >
2021-11-07 20:53:18 +00:00
< span class = "sd" > ## Irregular Monte Carlo chains< / span >
2022-01-21 14:55:18 +00:00
< span class = "sd" > `Obs` objects defined on irregular Monte Carlo chains can be initialized with the parameter `idl`.< / span >
2021-11-08 15:04:55 +00:00
2021-11-08 14:53:27 +00:00
< span class = "sd" > ```python< / span >
2021-11-08 15:04:55 +00:00
< span class = "sd" > # Observable defined on configurations 20 to 519< / span >
< span class = "sd" > obs1 = pe.Obs([samples1], [' ensemble1' ], idl=[range(20, 520)])< / span >
2021-11-16 12:00:28 +00:00
< span class = "sd" > obs1.details()< / span >
< span class = "sd" > > Result 9.98319881e-01< / span >
< span class = "sd" > > 500 samples in 1 ensemble:< / span >
< span class = "sd" > > · Ensemble ' ensemble1' : 500 configurations (from 20 to 519)< / span >
2021-11-08 15:10:26 +00:00
2021-11-08 15:04:55 +00:00
< span class = "sd" > # Observable defined on every second configuration between 5 and 1003< / span >
< span class = "sd" > obs2 = pe.Obs([samples2], [' ensemble1' ], idl=[range(5, 1005, 2)])< / span >
2021-11-16 12:00:28 +00:00
< span class = "sd" > obs2.details()< / span >
< span class = "sd" > > Result 9.99100712e-01< / span >
< span class = "sd" > > 500 samples in 1 ensemble:< / span >
< span class = "sd" > > · Ensemble ' ensemble1' : 500 configurations (from 5 to 1003 in steps of 2)< / span >
2021-11-08 15:10:26 +00:00
2021-11-08 15:04:55 +00:00
< span class = "sd" > # Observable defined on configurations 2, 9, 28, 29 and 501< / span >
< span class = "sd" > obs3 = pe.Obs([samples3], [' ensemble1' ], idl=[[2, 9, 28, 29, 501]])< / span >
2021-11-16 12:00:28 +00:00
< span class = "sd" > obs3.details()< / span >
< span class = "sd" > > Result 1.01718064e+00< / span >
< span class = "sd" > > 5 samples in 1 ensemble:< / span >
< span class = "sd" > > · Ensemble ' ensemble1' : 5 configurations (irregular range)< / span >
2021-11-08 15:04:55 +00:00
< span class = "sd" > ```< / span >
2021-11-08 14:53:27 +00:00
2022-01-21 14:55:18 +00:00
< span class = "sd" > `Obs` objects defined on regular and irregular histories of the same ensemble can be computed with each other and the correct error propagation and estimation is automatically taken care of.< / span >
2021-11-08 15:04:55 +00:00
< span class = "sd" > **Warning:** Irregular Monte Carlo chains can result in odd patterns in the autocorrelation functions.< / span >
2021-11-15 10:57:31 +00:00
< span class = "sd" > Make sure to check the autocorrelation time with e.g. `pyerrors.obs.Obs.plot_rho` or `pyerrors.obs.Obs.plot_tauint`.< / span >
2021-11-08 14:53:27 +00:00
2021-12-11 23:07:13 +00:00
< span class = "sd" > For the full API see `pyerrors.obs.Obs`.< / span >
2021-11-07 20:53:18 +00:00
2021-11-07 21:09:48 +00:00
< span class = "sd" > # Correlators< / span >
2022-02-15 12:25:34 +00:00
< span class = "sd" > When one is not interested in single observables but correlation functions, `pyerrors` offers the `Corr` class which simplifies the corresponding error propagation and provides the user with a set of standard methods. In order to initialize a `Corr` objects one needs to arrange the data as a list of `Obs`< / span >
2021-12-23 15:43:56 +00:00
< span class = "sd" > ```python< / span >
< span class = "sd" > my_corr = pe.Corr([obs_0, obs_1, obs_2, obs_3])< / span >
< span class = "sd" > print(my_corr)< / span >
< span class = "sd" > > x0/a Corr(x0/a)< / span >
< span class = "sd" > > ------------------< / span >
< span class = "sd" > > 0 0.7957(80)< / span >
< span class = "sd" > > 1 0.5156(51)< / span >
< span class = "sd" > > 2 0.3227(33)< / span >
< span class = "sd" > > 3 0.2041(21)< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > In case the correlation functions are not defined on the outermost timeslices, for example because of fixed boundary conditions, a padding can be introduced.< / span >
< span class = "sd" > ```python< / span >
2022-01-18 15:09:34 +00:00
< span class = "sd" > my_corr = pe.Corr([obs_0, obs_1, obs_2, obs_3], padding=[1, 1])< / span >
2021-12-23 15:43:56 +00:00
< span class = "sd" > print(my_corr)< / span >
< span class = "sd" > > x0/a Corr(x0/a)< / span >
< span class = "sd" > > ------------------< / span >
< span class = "sd" > > 0< / span >
< span class = "sd" > > 1 0.7957(80)< / span >
< span class = "sd" > > 2 0.5156(51)< / span >
< span class = "sd" > > 3 0.3227(33)< / span >
< span class = "sd" > > 4 0.2041(21)< / span >
< span class = "sd" > > 5< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > The individual entries of a correlator can be accessed via slicing< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > print(my_corr[3])< / span >
< span class = "sd" > > 0.3227(33)< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > Error propagation with the `Corr` class works very similar to `Obs` objects. Mathematical operations are overloaded and `Corr` objects can be computed together with other `Corr` objects, `Obs` objects or real numbers and integers.< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > my_new_corr = 0.3 * my_corr[2] * my_corr * my_corr + 12 / my_corr< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > `pyerrors` provides the user with a set of regularly used methods for the manipulation of correlator objects:< / span >
< span class = "sd" > - `Corr.gamma_method` applies the gamma method to all entries of the correlator.< / span >
< span class = "sd" > - `Corr.m_eff` to construct effective masses. Various variants for periodic and fixed temporal boundary conditions are available.< / span >
< span class = "sd" > - `Corr.deriv` returns the first derivative of the correlator as `Corr`. Different discretizations of the numerical derivative are available.< / span >
< span class = "sd" > - `Corr.second_deriv` returns the second derivative of the correlator as `Corr`. Different discretizations of the numerical derivative are available.< / span >
< span class = "sd" > - `Corr.symmetric` symmetrizes parity even correlations functions, assuming periodic boundary conditions.< / span >
< span class = "sd" > - `Corr.anti_symmetric` anti-symmetrizes parity odd correlations functions, assuming periodic boundary conditions.< / span >
< span class = "sd" > - `Corr.T_symmetry` averages a correlator with its time symmetry partner, assuming fixed boundary conditions.< / span >
< span class = "sd" > - `Corr.plateau` extracts a plateau value from the correlator in a given range.< / span >
< span class = "sd" > - `Corr.roll` periodically shifts the correlator.< / span >
< span class = "sd" > - `Corr.reverse` reverses the time ordering of the correlator.< / span >
< span class = "sd" > - `Corr.correlate` constructs a disconnected correlation function from the correlator and another `Corr` or `Obs` object.< / span >
< span class = "sd" > - `Corr.reweight` reweights the correlator.< / span >
2022-01-21 14:55:18 +00:00
< span class = "sd" > `pyerrors` can also handle matrices of correlation functions and extract energy states from these matrices via a generalized eigenvalue problem (see `pyerrors.correlators.Corr.GEVP`).< / span >
2021-12-23 15:43:56 +00:00
2021-12-11 23:07:13 +00:00
< span class = "sd" > For the full API see `pyerrors.correlators.Corr`.< / span >
2021-11-09 11:51:27 +00:00
2022-02-14 14:08:21 +00:00
< span class = "sd" > # Complex valued observables< / span >
2021-11-15 14:59:01 +00:00
< span class = "sd" > `pyerrors` can handle complex valued observables via the class `pyerrors.obs.CObs`.< / span >
< span class = "sd" > `CObs` are initialized with a real and an imaginary part which both can be `Obs` valued.< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > my_real_part = pe.Obs([samples1], [' ensemble1' ])< / span >
< span class = "sd" > my_imag_part = pe.Obs([samples2], [' ensemble1' ])< / span >
< span class = "sd" > my_cobs = pe.CObs(my_real_part, my_imag_part)< / span >
< span class = "sd" > my_cobs.gamma_method()< / span >
< span class = "sd" > print(my_cobs)< / span >
< span class = "sd" > > (0.9959(91)+0.659(28)j)< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > Elementary mathematical operations are overloaded and samples are properly propagated as for the `Obs` class.< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > my_derived_cobs = (my_cobs + my_cobs.conjugate()) / np.abs(my_cobs)< / span >
< span class = "sd" > my_derived_cobs.gamma_method()< / span >
< span class = "sd" > print(my_derived_cobs)< / span >
< span class = "sd" > > (1.668(23)+0.0j)< / span >
< span class = "sd" > ```< / span >
2021-11-07 21:09:48 +00:00
2022-02-14 14:08:21 +00:00
< span class = "sd" > # Error propagation in iterative algorithms< / span >
< span class = "sd" > `pyerrors` supports exact linear error propagation for iterative algorithms like various variants of non-linear least sqaures fits or root finding. The derivatives required for the error propagation are calculated as described in [arXiv:1809.01289](https://arxiv.org/abs/1809.01289).< / span >
< span class = "sd" > ## Least squares fits< / span >
< span class = "sd" > Standard non-linear least square fits with errors on the dependent but not the independent variables can be performed with `pyerrors.fits.least_squares`. As default solver the Levenberg-Marquardt algorithm implemented in [scipy](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html) is used.< / span >
< span class = "sd" > Fit functions have to be of the following form< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > import autograd.numpy as anp< / span >
< span class = "sd" > def func(a, x):< / span >
< span class = "sd" > return a[1] * anp.exp(-a[0] * x)< / span >
< span class = "sd" > ```< / span >
2022-02-21 14:52:31 +00:00
< span class = "sd" > **It is important that numerical functions refer to `autograd.numpy` instead of `numpy` for the automatic differentiation in iterative algorithms to work properly.**< / span >
2022-02-14 14:08:21 +00:00
< span class = "sd" > Fits can then be performed via< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > fit_result = pe.fits.least_squares(x, y, func)< / span >
< span class = "sd" > print(" \n" , fit_result)< / span >
< span class = "sd" > > Fit with 2 parameters< / span >
< span class = "sd" > > Method: Levenberg-Marquardt< / span >
< span class = "sd" > > `ftol` termination condition is satisfied.< / span >
< span class = "sd" > > chisquare/d.o.f.: 0.9593035785160936< / span >
< span class = "sd" > > Goodness of fit:< / span >
< span class = "sd" > > χ²/d.o.f. = 0.959304< / span >
< span class = "sd" > > p-value = 0.5673< / span >
< span class = "sd" > > Fit parameters:< / span >
< span class = "sd" > > 0 0.0548(28)< / span >
< span class = "sd" > > 1 1.933(64)< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > where x is a `list` or `numpy.array` of `floats` and y is a `list` or `numpy.array` of `Obs`.< / span >
< span class = "sd" > Data stored in `Corr` objects can be fitted directly using the `Corr.fit` method.< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > my_corr = pe.Corr(y)< / span >
< span class = "sd" > fit_result = my_corr.fit(func, fitrange=[12, 25])< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > this can simplify working with absolute fit ranges and takes care of gaps in the data automatically.< / span >
< span class = "sd" > For fit functions with multiple independent variables the fit function can be of the form< / span >
< span class = "sd" > ```python< / span >
< span class = "sd" > def func(a, x):< / span >
< span class = "sd" > (x1, x2) = x< / span >
< span class = "sd" > return a[0] * x1 ** 2 + a[1] * x2< / span >
< span class = "sd" > ```< / span >
< span class = "sd" > ## Total least squares fits< / span >
< span class = "sd" > `pyerrors` can also fit data with errors on both the dependent and independent variables using the total least squares method also referred to orthogonal distance regression as implemented in [scipy](https://docs.scipy.org/doc/scipy/reference/odr.html), see `pyerrors.fits.least_squares`. The syntax is identical to the standard least squares case, the only diffrence being that `x` also has to be a `list` or `numpy.array` of `Obs`.< / span >
< span class = "sd" > For the full API see `pyerrors.fits` for fits and `pyerrors.roots` for finding roots of functions.< / span >
2021-11-07 21:09:48 +00:00
2021-11-07 20:53:18 +00:00
< span class = "sd" > # Matrix operations< / span >
2022-02-14 14:26:48 +00:00
< span class = "sd" > `pyerrors` provides wrappers for `Obs`- and `CObs`-valued matrix operations based on `numpy.linalg`. The supported functions include:< / span >
2022-01-21 14:55:18 +00:00
< span class = "sd" > - `inv` for the matrix inverse.< / span >
< span class = "sd" > - `cholseky` for the Cholesky decomposition.< / span >
< span class = "sd" > - `det` for the matrix determinant.< / span >
< span class = "sd" > - `eigh` for eigenvalues and eigenvectors of hermitean matrices.< / span >
< span class = "sd" > - `eig` for eigenvalues of general matrices.< / span >
< span class = "sd" > - `pinv` for the Moore-Penrose pseudoinverse.< / span >
< span class = "sd" > - `svd` for the singular-value-decomposition.< / span >
< span class = "sd" > For the full API see `pyerrors.linalg`.< / span >
2021-11-07 20:53:18 +00:00
2021-11-15 14:30:41 +00:00
< span class = "sd" > # Export data< / span >
2022-02-14 14:19:54 +00:00
2022-02-21 14:52:31 +00:00
< span class = "sd" > The preferred exported file format within `pyerrors` is json.gz. The exact specifications of this format will be listed here soon.< / span >
2021-11-15 14:30:41 +00:00
< span class = "sd" > ## Jackknife samples< / span >
2021-12-11 23:07:13 +00:00
< span class = "sd" > For comparison with other analysis workflows `pyerrors` can generate jackknife samples from an `Obs` object or import jackknife samples into an `Obs` object.< / span >
< span class = "sd" > See `pyerrors.obs.Obs.export_jackknife` and `pyerrors.obs.import_jackknife` for details.< / span >
2021-11-15 14:30:41 +00:00
2022-02-14 14:08:21 +00:00
< span class = "sd" > # Citing< / span >
< span class = "sd" > If you use `pyerrors` for research that leads to a publication please consider citing:< / span >
2022-02-14 14:19:54 +00:00
< span class = "sd" > - Ulli Wolff, *Monte Carlo errors with less errors*. Comput.Phys.Commun. 156 (2004) 143-153, Comput.Phys.Commun. 176 (2007) 383 (erratum).< / span >
< span class = "sd" > - Stefan Schaefer, Rainer Sommer, Francesco Virotta, *Critical slowing down and error analysis in lattice QCD simulations*. Nucl.Phys.B 845 (2011) 93-119.< / span >
< span class = "sd" > - Alberto Ramos, *Automatic differentiation for error analysis of Monte Carlo data*. Comput.Phys.Commun. 238 (2019) 19-35.< / span >
2021-11-07 20:53:18 +00:00
< span class = "sd" > ' ' ' < / span >
< span class = "kn" > from< / span > < span class = "nn" > .obs< / span > < span class = "kn" > import< / span > < span class = "o" > *< / span >
< span class = "kn" > from< / span > < span class = "nn" > .correlators< / span > < span class = "kn" > import< / span > < span class = "o" > *< / span >
< span class = "kn" > from< / span > < span class = "nn" > .fits< / span > < span class = "kn" > import< / span > < span class = "o" > *< / span >
2021-11-24 17:27:16 +00:00
< span class = "kn" > from< / span > < span class = "nn" > .misc< / span > < span class = "kn" > import< / span > < span class = "o" > *< / span >
2021-11-07 20:53:18 +00:00
< span class = "kn" > from< / span > < span class = "nn" > .< / span > < span class = "kn" > import< / span > < span class = "n" > dirac< / span >
2021-11-11 10:51:37 +00:00
< span class = "kn" > from< / span > < span class = "nn" > .< / span > < span class = "kn" > import< / span > < span class = "nb" > input< / span >
2021-11-07 20:53:18 +00:00
< span class = "kn" > from< / span > < span class = "nn" > .< / span > < span class = "kn" > import< / span > < span class = "n" > linalg< / span >
< span class = "kn" > from< / span > < span class = "nn" > .< / span > < span class = "kn" > import< / span > < span class = "n" > mpm< / span >
< span class = "kn" > from< / span > < span class = "nn" > .< / span > < span class = "kn" > import< / span > < span class = "n" > roots< / span >
< span class = "kn" > from< / span > < span class = "nn" > .version< / span > < span class = "kn" > import< / span > < span class = "n" > __version__< / span >
< / pre > < / div >
< / details >
< / section >
< / main >
< script >
function escapeHTML(html) {
return document.createElement('div').appendChild(document.createTextNode(html)).parentNode.innerHTML;
}
const originalContent = document.querySelector("main.pdoc");
let currentContent = originalContent;
function setContent(innerHTML) {
let elem;
if (innerHTML) {
elem = document.createElement("main");
elem.classList.add("pdoc");
elem.innerHTML = innerHTML;
} else {
elem = originalContent;
}
if (currentContent !== elem) {
currentContent.replaceWith(elem);
currentContent = elem;
}
}
function getSearchTerm() {
return (new URL(window.location)).searchParams.get("search");
}
const searchBox = document.querySelector(".pdoc input[type=search]");
searchBox.addEventListener("input", function () {
let url = new URL(window.location);
if (searchBox.value.trim()) {
url.hash = "";
url.searchParams.set("search", searchBox.value);
} else {
url.searchParams.delete("search");
}
history.replaceState("", "", url.toString());
onInput();
});
window.addEventListener("popstate", onInput);
let search, searchErr;
async function initialize() {
try {
search = await new Promise((resolve, reject) => {
const script = document.createElement("script");
script.type = "text/javascript";
script.async = true;
script.onload = () => resolve(window.pdocSearch);
script.onerror = (e) => reject(e);
script.src = "search.js";
document.getElementsByTagName("head")[0].appendChild(script);
});
} catch (e) {
console.error("Cannot fetch pdoc search index");
searchErr = "Cannot fetch search index.";
}
onInput();
document.querySelector("nav.pdoc").addEventListener("click", e => {
if (e.target.hash) {
searchBox.value = "";
searchBox.dispatchEvent(new Event("input"));
}
});
}
function onInput() {
setContent((() => {
const term = getSearchTerm();
if (!term) {
return null
}
if (searchErr) {
return `< h3 > Error: ${searchErr}< / h3 > `
}
if (!search) {
return "< h3 > Searching...< / h3 > "
}
window.scrollTo({top: 0, left: 0, behavior: 'auto'});
const results = search(term);
let html;
if (results.length === 0) {
html = `No search results for '${escapeHTML(term)}'.`
} else {
html = `< h4 > ${results.length} search result${results.length > 1 ? "s" : ""} for '${escapeHTML(term)}'.< / h4 > `;
}
for (let result of results.slice(0, 10)) {
let doc = result.doc;
let url = `${doc.modulename.replaceAll(".", "/")}.html`;
if (doc.qualname) {
url += `#${doc.qualname}`;
}
let heading;
switch (result.doc.type) {
case "function":
2022-01-16 15:44:50 +00:00
heading = `< span class = "def" > ${doc.funcdef}< / span > < span class = "name" > ${doc.fullname}< / span > < span class = "signature" > ${doc.signature}:< / span > `;
2021-11-07 20:53:18 +00:00
break;
case "class":
heading = `< span class = "def" > class< / span > < span class = "name" > ${doc.fullname}< / span > `;
2022-01-16 15:44:50 +00:00
if (doc.bases)
heading += `< wbr > (< span class = "base" > ${doc.bases}< / span > )`;
heading += `:`;
break;
case "variable":
heading = `< span class = "name" > ${doc.fullname}< / span > `;
if (doc.annotation)
heading += `< span class = "annotation" > ${doc.annotation}< / span > `;
if (doc.default_value)
heading += `< span class = "default_value" > ${doc.default_value}< / span > `;
2021-11-07 20:53:18 +00:00
break;
default:
heading = `< span class = "name" > ${doc.fullname}< / span > `;
break;
}
html += `
< section class = "search-result" >
< a href = "${url}" class = "attr ${doc.type}" > ${heading}< / a >
< div class = "docstring" > ${doc.doc}< / div >
< / section >
`;
}
return html;
})());
}
if (getSearchTerm()) {
initialize();
searchBox.value = getSearchTerm();
onInput();
} else {
searchBox.addEventListener("focus", initialize, {once: true});
}
searchBox.addEventListener("keydown", e => {
if (["ArrowDown", "ArrowUp", "Enter"].includes(e.key)) {
let focused = currentContent.querySelector(".search-result.focused");
if (!focused) {
currentContent.querySelector(".search-result").classList.add("focused");
} else if (
e.key === "ArrowDown"
& & focused.nextElementSibling
& & focused.nextElementSibling.classList.contains("search-result")
) {
focused.classList.remove("focused");
focused.nextElementSibling.classList.add("focused");
focused.nextElementSibling.scrollIntoView({
behavior: "smooth",
block: "nearest",
inline: "nearest"
});
} else if (
e.key === "ArrowUp"
& & focused.previousElementSibling
& & focused.previousElementSibling.classList.contains("search-result")
) {
focused.classList.remove("focused");
focused.previousElementSibling.classList.add("focused");
focused.previousElementSibling.scrollIntoView({
behavior: "smooth",
block: "nearest",
inline: "nearest"
});
} else if (
e.key === "Enter"
) {
focused.querySelector("a").click();
}
}
});
< / script > < / body >
< / html >
