{-# LANGUAGE ForeignFunctionInterface, TypeFamilies, MultiParamTypeClasses, 
             FlexibleInstances, TypeSynonymInstances, 
             EmptyDataDecls, ExistentialQuantification, ScopedTypeVariables #-}

-- module HROOT.Class.Interface where

module HROOT.Class.TH1.Interface where


import Data.Word
import Foreign.ForeignPtr
import HROOT.TypeCast

import HROOT.Class.TH1.RawType
import HROOT.Class.TDirectory.RawType
import HROOT.Class.TF1.RawType
import HROOT.Class.TArrayD.RawType
import HROOT.Class.TAxis.RawType
import HROOT.Class.TDirectory.Interface
import HROOT.Class.TF1.Interface
import HROOT.Class.TAxis.Interface
import HROOT.Class.TNamed.Interface
import HROOT.Class.TAttLine.Interface
import HROOT.Class.TAttFill.Interface
import HROOT.Class.TAttMarker.Interface

-- |  the TH1 class : the mother class of all histogram classes 
--   
--   > class TH1 : TNamed, TAttLine, TAttFill, TAttMarker
--   

class (ITNamed a,ITAttLine a,ITAttFill a,ITAttMarker a) => ITH1 a where
    -- |  
    --   > void TH1::Add( TH1* h1, Double_t c1 ) 
    --   

    add :: (ITH1 c0, FPtr c0) => a -> c0 -> Double -> IO () 
    -- | 
    --   > void TH1::AddBinContent( Int_t bin, Double_t w )
    --   

    addBinContent :: a -> Int -> Double -> IO () 
    -- | 
    --   > Double_t TH1::Chi2Test( const TH1* h2, Option_t* option="UU", Double_t* res=0 ) const
    --   

    chi2Test :: (ITH1 c0, FPtr c0) => a -> c0 -> String -> [Double] -> IO Double 
    -- | 
    --   > Double_t TH1::ComputeIntegral ()
    --   

    computeIntegral :: a -> IO Double 
    -- | 
    --   > void TH1::DirectoryAutoAdd(TDirectory* )
    --   

    directoryAutoAdd :: (ITDirectory c0, FPtr c0) => a -> c0 -> IO () 
    -- | 
    --   > void TH1::Divide(const TH1* h1, const TH1* h2, Double_t c1=1, Double_t c2=1, Option_t* option="")
    --   

    divide :: (ITH1 c1, FPtr c1, ITH1 c0, FPtr c0) => a -> c0 -> c1 -> Double -> Double -> String -> IO () 

    drawCopyTH1 :: a -> String -> IO a 
    -- | 
    --   > TH1* TH1::DrawNormalized (Option_t* option="", Double_t norm=1) const
    --   

    drawNormalized :: a -> String -> Double -> IO TH1 

    drawPanelTH1 :: a -> IO () 

    bufferEmpty :: a -> Int -> IO Int 

    evalF :: (ITF1 c0, FPtr c0) => a -> c0 -> String -> IO () 

    fFT :: (ITH1 c0, FPtr c0) => a -> c0 -> String -> IO TH1 

    fill1 :: a -> Double -> IO Int 

    fill1w :: a -> Double -> Double -> IO Int 

    fillN1 :: a -> Int -> [Double] -> [Double] -> Int -> IO () 

    fillRandom :: (ITH1 c0, FPtr c0) => a -> c0 -> Int -> IO () 

    findBin :: a -> Double -> Double -> Double -> IO Int 

    findFixBin :: a -> Double -> Double -> Double -> IO Int 

    findFirstBinAbove :: a -> Double -> Int -> IO Int 

    findLastBinAbove :: a -> Double -> Int -> IO Int 

    fitPanelTH1 :: a -> IO () 

    getNdivisionA :: a -> String -> IO Int 

    getAxisColorA :: a -> String -> IO Int 

    getLabelColorA :: a -> String -> IO Int 

    getLabelFontA :: a -> String -> IO Int 

    getLabelOffsetA :: a -> String -> IO Double 

    getLabelSizeA :: a -> String -> IO Double 

    getTitleFontA :: a -> String -> IO Int 

    getTitleOffsetA :: a -> String -> IO Double 

    getTitleSizeA :: a -> String -> IO Double 

    getTickLengthA :: a -> String -> IO Double 

    getBarOffset :: a -> IO Double 

    getBarWidth :: a -> IO Double 

    getContour :: a -> [Double] -> IO Int 

    getContourLevel :: a -> Int -> IO Double 

    getContourLevelPad :: a -> Int -> IO Double 

    getBin :: a -> Int -> Int -> Int -> IO Int 

    getBinCenter :: a -> Int -> IO Double 

    getBinContent1 :: a -> Int -> IO Double 

    getBinContent2 :: a -> Int -> Int -> IO Double 

    getBinContent3 :: a -> Int -> Int -> Int -> IO Double 

    getBinError1 :: a -> Int -> IO Double 

    getBinError2 :: a -> Int -> Int -> IO Double 

    getBinError3 :: a -> Int -> Int -> Int -> IO Double 

    getBinLowEdge :: a -> Int -> IO Double 

    getBinWidth :: a -> Int -> IO Double 

    getCellContent :: a -> Int -> Int -> IO Double 

    getCellError :: a -> Int -> Int -> IO Double 

    getEntries :: a -> IO Double 

    getEffectiveEntries :: a -> IO Double 

    getFunction :: a -> String -> IO TF1 

    getDimension :: a -> IO Int 

    getKurtosis :: a -> Int -> IO Double 

    getLowEdge :: a -> [Double] -> IO () 

    getMaximumTH1 :: a -> Double -> IO Double 

    getMaximumBin :: a -> IO Int 

    getMaximumStored :: a -> IO Double 

    getMinimumTH1 :: a -> Double -> IO Double 

    getMinimumBin :: a -> IO Int 

    getMinimumStored :: a -> IO Double 

    getMean :: a -> Int -> IO Double 

    getMeanError :: a -> Int -> IO Double 

    getNbinsX :: a -> IO Double 

    getNbinsY :: a -> IO Double 

    getNbinsZ :: a -> IO Double 

    getQuantilesTH1 :: a -> Int -> [Double] -> [Double] -> IO Int 

    getRandom :: a -> IO Double 
    -- | 
    --   > void     GetStats(Double_t *stats) const;
    --   

    getStats :: a -> [Double] -> IO () 

    getSumOfWeights :: a -> IO Double 

    getSumw2 :: a -> IO TArrayD 

    getSumw2N :: a -> IO Int 

    getRMS :: a -> Int -> IO Double 

    getRMSError :: a -> Int -> IO Double 

    getSkewness :: a -> Int -> IO Double 

    integral1 :: a -> Int -> Int -> String -> IO Double 
    -- | 
    --   > Double_t Interpolate(Double_t x)
    --   

    interpolate1 :: a -> Double -> IO Double 
    -- | 
    --   > Double_t Interpolate(Double_t x, Double_t y)
    --   

    interpolate2 :: a -> Double -> Double -> IO Double 
    -- | 
    --   > Double_t Interpolate(Double_t x, Double_t y, Double_t z)
    --   

    interpolate3 :: a -> Double -> Double -> Double -> IO Double 
    -- | 
    --   > Double_t KolmogorovTest(const TH1 *h2, Option_t *option="") const
    --   

    kolmogorovTest :: (ITH1 c0, FPtr c0) => a -> c0 -> String -> IO Double 
    -- | 
    --   > void     LabelsDeflate(Option_t *axis="X")
    --   

    labelsDeflate :: a -> String -> IO () 
    -- | 
    --   > void     LabelsInflate(Option_t *axis="X")
    --   

    labelsInflate :: a -> String -> IO () 
    -- | 
    --   > void     LabelsOption(Option_t *option="h", Option_t *axis="X")
    --   

    labelsOption :: a -> String -> String -> IO () 

    multiflyF :: (ITF1 c0, FPtr c0) => a -> c0 -> Double -> IO () 
    -- | 
    --   > void     Multiply(const TH1 *h1, const TH1 *h2, Double_t c1=1, Double_t c2=1, Option_t *option=""); // *MENU*
    --   

    multiply :: (ITH1 c1, FPtr c1, ITH1 c0, FPtr c0) => a -> c0 -> c1 -> Double -> Double -> String -> IO () 
    -- | 
    --   > void     PutStats(Double_t *stats)
    --   

    putStats :: a -> [Double] -> IO () 
    -- | 
    --   > TH1     *Rebin(Int_t ngroup=2, const char*newname="", const Double_t *xbins=0);  // *MENU*
    --   

    rebin :: a -> Int -> String -> [Double] -> IO TH1 
    -- | 
    --   > void     RebinAxis(Double_t x, TAxis *axis)
    --   

    rebinAxis :: (ITAxis c0, FPtr c0) => a -> Double -> c0 -> IO () 
    -- | 
    --   > void     Rebuild(Option_t *option="")
    --   

    rebuild :: a -> String -> IO () 
    -- | 
    --   > void     Reset(Option_t *option="")
    --   

    reset :: a -> String -> IO () 
    -- | 
    --   > void     ResetStats()
    --   

    resetStats :: a -> IO () 
    -- | 
    --   > void     Scale(Double_t c1=1, Option_t *option="")
    --   

    scale :: a -> Double -> String -> IO () 
    -- | 
    --   > void     SetAxisColor(Color_t color=1, Option_t *axis="X")
    --   

    setAxisColorA :: a -> Int -> String -> IO () 
    -- | 
    --   > void     SetAxisRange(Double_t xmin, Double_t xmax, Option_t *axis="X")
    --   

    setAxisRange :: a -> Double -> Double -> String -> IO () 
    -- | 
    --   > void     SetBarOffset(Float_t offset=0.25)
    --   

    setBarOffset :: a -> Double -> IO () 
    -- | 
    --   > void     SetBarWidth(Float_t width=0.5) 
    --   

    setBarWidth :: a -> Double -> IO () 
    -- | 
    --   > void     SetBinContent(Int_t bin, Double_t content)
    --   

    setBinContent1 :: a -> Int -> Double -> IO () 
    -- | 
    --   > void     SetBinContent(Int_t binx, Int_t biny, Double_t content)
    --   

    setBinContent2 :: a -> Int -> Int -> Double -> IO () 
    -- | 
    --   > void     SetBinContent(Int_t binx, Int_t biny, Int_t binz, Double_t content)
    --   

    setBinContent3 :: a -> Int -> Int -> Int -> Double -> IO () 

    setBinError1 :: a -> Int -> Double -> IO () 

    setBinError2 :: a -> Int -> Int -> Double -> IO () 

    setBinError3 :: a -> Int -> Int -> Int -> Double -> IO () 

    setBins1 :: a -> Int -> [Double] -> IO () 

    setBins2 :: a -> Int -> [Double] -> Int -> [Double] -> IO () 

    setBins3 :: a -> Int -> [Double] -> Int -> [Double] -> Int -> [Double] -> IO () 

    setBinsLength :: a -> Int -> IO () 

    setBuffer :: a -> Int -> String -> IO () 

    setCellContent :: a -> Int -> Int -> Double -> IO () 

    setContent :: a -> [Double] -> IO () 

    setContour :: a -> Int -> [Double] -> IO () 

    setContourLevel :: a -> Int -> Double -> IO () 

    setDirectory :: (ITDirectory c0, FPtr c0) => a -> c0 -> IO () 

    setEntries :: a -> Double -> IO () 

    setError :: a -> [Double] -> IO () 

    setLabelColorA :: a -> Int -> String -> IO () 

    setLabelSizeA :: a -> Double -> String -> IO () 

    setLabelFontA :: a -> Int -> String -> IO () 

    setLabelOffsetA :: a -> Double -> String -> IO () 

    setMaximum :: a -> Double -> IO () 

    setMinimum :: a -> Double -> IO () 

    setNormFactor :: a -> Double -> IO () 

    setStats :: a -> Int -> IO () 

    setOption :: a -> String -> IO () 

    setXTitle :: a -> String -> IO () 

    setYTitle :: a -> String -> IO () 

    setZTitle :: a -> String -> IO () 
    -- | 
    --   > TH1     *ShowBackground(Int_t niter=20, Option_t *option="same");
    --   

    showBackground :: a -> Int -> String -> IO TH1 
    -- | 
    --   > Int_t    ShowPeaks(Double_t sigma=2, Option_t *option="", Double_t threshold=0.05); // *MENU*
    --   

    showPeaks :: a -> Double -> String -> Double -> IO Int 
    -- | 
    --   > void     Smooth(Int_t ntimes=1, Option_t *option=""); // *MENU*
    --   

    smooth :: a -> Int -> String -> IO () 

    sumw2 :: a -> IO () 

instance Existable TH1 where
  data Exist TH1 = forall a. (FPtr a, ITH1 a) => ETH1 a

upcastTH1 :: (FPtr a, ITH1 a) => a -> TH1
upcastTH1 h = let fh = get_fptr h
                  fh2 :: ForeignPtr RawTH1 = castForeignPtr fh
              in cast_fptr_to_obj fh2