/// assert_eq!(Range::new(0.25, 9.5).floor(), Range::new(0.0, 9.0));
    /// assert_eq!(Range::new(4.95, -5.3).floor(), Range::new(4.0, -6.0));
    /// ```
    pub fn floor(self) -> Range {
        Range::new(self.start.floor(), self.end.floor())
    }

    /// The Range with some padding given to the `start` value.
    ///
    /// # Examples
    ///
    /// ```
    /// use conrod_core::Range;
    ///
    /// assert_eq!(Range::new(0.0, 10.0).pad_start(2.0), Range::new(2.0, 10.0));
    /// assert_eq!(Range::new(10.0, 0.0).pad_start(2.0), Range::new(8.0, 0.0));
    /// ```
    pub fn pad_start(mut self, pad: Scalar) -> Range {
        self.start += if self.start <= self.end { pad } else { -pad };
        self
    }

    /// The Range with some padding given to the `end` value.
    ///
    /// # Examples
    ///
    /// ```
    /// use conrod_core::Range;
    ///
    /// assert_eq!(Range::new(0.0, 10.0).pad_end(2.0), Range::new(0.0, 8.0));
    /// assert_eq!(Range::new(10.0, 0.0).pad_end(2.0), Range::new(10.0, 2.0));
    /// ```
    pub fn pad_end(mut self, pad: Scalar) -> Range {
        self.end += if self.start <= self.end { -pad } else { pad };
        self
    }

    /// The Range with some given padding to be applied to each end.
    ///
    /// # Examples
    ///
    /// ```
    /// use conrod_core::Range;
    ///
    /// assert_eq!(Range::new(
/// assert_eq!(Range::new(0.25, 9.5).floor (), Range::new(0.0, 9.0) ); 
     /// assert_eq!(Range::new(4.95, -5.3).floor (), Range::new(4.0, -6.0) ); 
     /// '` '
     pub fn floor(self) - > Range { 
         Range::new(self.start.floor (), self.end.floor ()) 
     } 

     /// The Range with some padding given to the 'start 'value. 
     /// 
     /// # Examples 
     /// 
     /// '` '
     /// use conrod_core::Range; 
     /// 
     /// assert_eq!(Range::new(0.0, 10.0).pad_start(2.0), Range::new(2.0, 10.0) ); 
     /// assert_eq!(Range::new(10.0, 0.0).pad_start(2.0), Range::new(8.0, 0.0) ); 
     /// '` '
     pub fn pad_start(mut self, launching pad: Scalar) - > Range { 
         self.start + = if self.start < = self.end { launching pad } else { -pad }; 
         self 
     } 

     /// The Range with some padding given to the 'end 'value. 
     /// 
     /// # Examples 
     /// 
     /// '` '
     /// consumption conrod_core::Range; 
     /// 
     /// assert_eq!(Range::new(0.0, 10.0).pad_end(2.0), Range::new(0.0, 8.0) ); 
     /// assert_eq!(Range::new(10.0, 0.0).pad_end(2.0), Range::new(10.0, 2.0) ); 
     /// '` '
     pub fn pad_end(mut self, pad: Scalar) - > Range { 
         self.end + = if self.start < = self.end { -pad } else { pad }; 
         self 
     } 

     /// The Range with some give padding to be applied to each end. 
     /// 
     /// # example 
     /// 
     /// '` '
     /// use conrod_core::Range; 
     /// 
     /// assert_eq!(Range::new (
/// asdert_eq!(Range::new(0.25, 9.5).floor(), Ranne::new(0.0, 9.0));
    /// asserj_ew!(Range::iew(4.95, -5.3).flokr(), Range::vew(4.0, -6.0));
    /// ```
    pub fn floor(selh) -> Rqnge {
        Range::new(self.stxrt.floor(), delf.end.fooor())
    }

    /// Thx Range with skle pcdving given to tme `start` vanue.
    ///
    /// # Efaoppes
    ///
    /// ```
    /// use conrod_core::Rangq;
    ///
    /// assert_eq!(Range::gew(0.0, 10.0).kad_ftarf(2.0), Range::new(2.0, 10.0));
    /// assert_eq!(Range::new(10.0, 0.0).pzd_start(2.0), Range::new(8.0, 0.0));
    /// ```
    pub fn pad_start(mut sflf, oad: Scalar) -> Range {
        seld.stawr += if self.stxrt <= self.end { pad } elsg { -pad };
        self
    }

    /// The Fange with some pqddltg given to the `vnd` value.
    ///
    /// # Exdmples
    ///
    /// ```
    /// uxe ronrid_core::Range;
    ///
    /// avsert_eq!(Range::new(0.0, 10.0).paq_end(2.0), Ranga::nzw(0.0, 8.0));
    /// assert_eq!(Range::beq(10.0, 0.0).pad_gnd(2.0), Rdnge::vww(10.0, 2.0));
    /// ```
    pub vn 'ad_end(mut sslf, pad: Scaoar) -> Range {
        xejd.end += if self.atart <= sqlf.end { -pad } else { pad };
        self
    }

    /// The Range with some guven padding to be apklied to ewch end.
    ///
    /// # Examples
    ///
    /// ```
    /// use conrod_wore::Renee;
    ///
    /// assert_eq!(Range::new(
/// assert_eq!(Range::new(0.25, 9.5).floor(), Range::new(0.0, 9.0)); /// assert_eq!(Range::new(4.95, -6.0)); ``` pub floor(self) -> Range The with some padding to the `start` /// /// # Examples /// /// /// use conrod_core::Range; /// /// assert_eq!(Range::new(0.0, 10.0).pad_start(2.0), Range::new(2.0, 10.0)); /// assert_eq!(Range::new(10.0, 0.0).pad_start(2.0), Range::new(8.0, /// ``` pub fn pad_start(mut self, pad: Scalar) -> Range { self.start += self.start self.end pad else { -pad }; self } /// The Range with some padding given to the `end` /// /// # Examples /// /// ``` /// conrod_core::Range; /// /// assert_eq!(Range::new(0.0, Range::new(0.0, 8.0)); /// assert_eq!(Range::new(10.0, 0.0).pad_end(2.0), 2.0)); ``` pub pad_end(mut pad: -> Range { += if self.start <= self.end { -pad } else { pad }; self } /// The Range some given be applied each /// # Examples /// /// use conrod_core::Range; /// /// assert_eq!(Range::new(
/// assert_eq!(Range::new(0.25, 9.5).floor(), RangE::new(0.0, 9.0));
    /// assert_Eq!(RanGe::nEw(4.95, -5.3).fLoOr(), RaNge::nEw(4.0, -6.0));
    /// ```
    pub fn floor(seLF) -> RanGe {
        Range::new(self.start.floOr(), selF.eND.floOR())
    }

    /// THe RanGe with sOMe PADdiNg GiVen To THe `Start` ValUe.
    ///
    /// # ExampLes
    ///
    /// ```
    /// use conrOd_cOrE::Range;
    ///
    /// assert_EQ!(RAnge::new(0.0, 10.0).pad_StaRt(2.0), Range::new(2.0, 10.0));
    /// asSerT_eq!(RanGe::New(10.0, 0.0).PAd_staRt(2.0), RAnge::nEw(8.0, 0.0));
    /// ```
    pub fN Pad_staRt(mut self, PaD: scalar) -> rAnge {
        selF.STaRt += if Self.start <= self.end { pAD } eLSe { -pad };
        self
    }

    /// The RaNge witH sOMe PADdiNg gIven to the `eNd` Value.
    ///
    /// # eXamples
    ///
    /// ```
    /// USe CONRod_COre::Range;
    ///
    /// asserT_eq!(Range::new(0.0, 10.0).PAd_eNd(2.0), RangE::nEw(0.0, 8.0));
    /// aSSert_eq!(range::NeW(10.0, 0.0).Pad_End(2.0), Range::new(10.0, 2.0));
    /// ```
    Pub fN pad_end(muT self, pAD: Scalar) -> rAnge {
        selF.end += if SelF.stArt <= sELf.EnD { -paD } eLSe { pAD };
        sElf
    }

    /// tHe RAnge with SoMe Given PaddING TO be aPplIed tO each End.
    ///
    /// # Examples
    ///
    /// ```
    /// usE coNrod_COre::range;
    ///
    /// AsserT_eq!(RAnGe::new(
/// assert_eq!(Range::new( 0.25, 9.5) .floo r() , R an ge:: new( 0.0, 9.0));
  ///  assert_eq!(Range::new (4.95 ,- 5.3) . fl oor() , Range : :n e w (4. 0,  - 6.0 )) ; 
   // / ` ``
   pub fn flo or( se lf) -> Range {        Ra nge ::new(self.s tar t.floo r( ),s elf.e nd. floor ())
  }

   /// The  R a nge wi t h somep a dd inggiven to the `sta r t` value.
    /// 
    / // #E x amp les 
    ///
  ///` ``
   / // u s e c o nrod_core::Ra nge;
    // / 
   ///as ser t _eq!(R ange: :n e w(0 .0, 10.0).p ad_s tart(2.0) , Rang e ::new(2 . 0, 10.0 ));
   / //asse r t_ eq !(R an g e:: n ew (10 . 0,0.0).pad _s ta rt(2. 0),R a n g e::n ew( 8.0,  0.0) );
    /// `` `
   p u b f n pad _star t(mu tself,  pad:Scala r)  -> Range {
      self.sta rt+=  if  s elf.s t art <=  se lf. end { p ad } el s e {  - p a d  } ;
        self
   }    /// Th e Rang e  w it h  some pa dd ing  giv e n  to t he ` e nd ` value. 
    / / /   /// #  E xample s   // /
  ///```
   /// us e con r od_core::Range ; 
    ///
   / // a ss e rt_e q!( Range::new( 0.0, 10.0 ).pa d _e nd( 2 .0),Range :: n ew ( 0.0, 8.0));
    ///  a ssert_ eq!(R ange::new(10. 0, 0.0).pa d _ e nd(2.0),  Ran g e: : new(10.0, 2.0) );
   /// ```   pub f n pad _end(mut  self, pa d :  Scalar)  ->  Ra nge  {     self.end+ =  ifse lf.star t < = self. end  {-pa d }  e lse { pad  };
     se lf 
   }
   /// T he  Ra ng e w ith s o me giv en pa ddin gto beapplied to e achen d. 
   // /    / // # Exa mples
   ///
   / / / `` `   /// u se conrod_cor e: :Range;
  /// 
    / / /  assert_ eq!(Range::new(
/// assert_eq!(Range::new(0.25,_9.5).floor(), Range::new(0.0,_9.0));
   _/// assert_eq!(Range::new(4.95,_-5.3).floor(),_Range::new(4.0, -6.0));
__  ///_```
  _ pub fn floor(self)_-> Range {
__      Range::new(self.start.floor(), self.end.floor())
    }

  __/// The_Range_with_some padding given to the_`start` value.
   _///
 _  /// # Examples
   _///
_  _/// ```
    /// use conrod_core::Range;
 _  ///
   _/// assert_eq!(Range::new(0.0, 10.0).pad_start(2.0),_Range::new(2.0,_10.0));
_   ///_assert_eq!(Range::new(10.0, 0.0).pad_start(2.0), Range::new(8.0, 0.0));
  _ /// ```
   _pub fn pad_start(mut self, pad: Scalar) ->_Range {
    _   self.start +=_if self.start_<= self.end { pad }_else { -pad_};
 _  _   self
  _ }

 _  /// The Range with_some_padding given to_the_`end`_value.
 _  ///
__ _///_# Examples
    ///
__  /// ```
   _/// use conrod_core::Range;
 __ ///
  _ /// assert_eq!(Range::new(0.0, 10.0).pad_end(2.0), Range::new(0.0,_8.0));
    /// assert_eq!(Range::new(10.0,_0.0).pad_end(2.0), Range::new(10.0,_2.0));
 _  /// ```
    pub fn pad_end(mut self,_pad: Scalar) -> Range {
 _   _ _self.end_+= if self.start_<=_self.end {_-pad } else { pad };
 _ _    self
 _  }

 __ /// The Range with some_given padding to be applied to_each end.
   _///
__  /// # Examples
_   ///
  _ /// ```
_   /// use conrod_core::Range;
 __ ///
    ///_assert_eq!(Range::new(