Ignore:
Timestamp:
04/06/07 10:35:17 (17 years ago)
Author:
pinsard
Message:

improvements/corrections of some *.pro headers + replace some message by some report

Location:
trunk/SRC/Interpolation
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/SRC/Interpolation/angle.pro

    r238 r242  
    3838  RETURN, {x:x, y:y} 
    3939END 
     40; 
    4041;+ 
    4142; 

  • trunk/SRC/Interpolation/clickincell.pro

    r238 r242  
    2626; 
    2727; @keyword IJ 
    28 ; see outputs 
     28; see returns 
    2929; 
    3030; @keyword _EXTRA 

  • trunk/SRC/Interpolation/cutpar.pro

    r231 r242  
    1616; @param y3 {in}{required} 
    1717; 1d arrays of p elements, giving the edge positions. 
    18 ; The edges must be given as in plot to draw the parallelogram. (see example). 
     18; The edges must be given as in <proidl>plot</proidl> to draw the  
     19; parallelogram. (see example). 
    1920; 
    2021; @param n {in}{required} 
    … …  
    2223; 
    2324; @keyword ENDPOINTS 
    24 ; see outputs 
     25; see returns 
    2526; 
    2627; @keyword ONSPHERE 
    2728; to specify that the points are located on a 
    28 ; sphere. In this case, x and y corresponds to longitude and 
     29; sphere. In this case, x and y correspond to longitude and 
    2930; latitude in degrees. 
    3031; 

  • trunk/SRC/Interpolation/cutsegment.pro

    r231 r242  
    1717; 
    1818; @keyword ENDPOINTS 
    19 ; see outputs 
     19; see returns 
    2020; 
    2121; @keyword ONSPHERE 
    2222; to specify that the points are located on a sphere. 
    23 ; In this case, x and y corresponds to longitude and latitude in degrees. 
     23; In this case, x and y correspond to longitude and latitude in degrees. 
    2424; 
    2525; @returns 
    … …  
    3030; 
    3131; @examples 
    32 ; 
    3332; IDL> x0=[2,5] 
    3433; IDL> y0=[5,1] 

  • trunk/SRC/Interpolation/extrapolate.pro

    r238 r242  
    1717; 
    1818; @param nb_iteration {in}{optional}{type=integer scalar}{default=10.E20} 
    19 ; Maximum number if iterations done in the extrapolation process. If there 
     19; Maximum number of iterations done in the extrapolation process. If there 
    2020; is no more masked values we exit extrapolate before reaching nb_iteration 
    2121; (to be sure to fill everything, you can use a very large value) 

  • trunk/SRC/Interpolation/extrapsmooth.pro

    r238 r242  
    33; @file_comments 
    44; similar to <pro>extrapolate</pro> but could to the job in a better way 
    5 ; because the ; extrapolated values are smoothed... 
     5; because the extrapolated values are smoothed... 
    66; takes more time than <pro>extrapolate</pro>. 
    77; extrapolate data where mskin is equal 0 by filling 

  • trunk/SRC/Interpolation/get_gridparams.pro

    r238 r242  
    66; 
    77; or 
    8 ; 2) given longitude and latitude arrays get their dimensions and make 
     8; 2) given longitude and latitude arrays, get their dimensions and make 
    99; sure they are 1D or 2D arrays 
    1010; 
    … …  
    2424; @param in1 {in}{required} 
    2525; Case 1: the name of the netcdf file 
    26 ; Case 2: 1d or 2D arrays defining longitudes and latitudes. 
     26; Case 2: 1d or 2d arrays defining longitudes and latitudes. 
    2727; Out: the variable that will contain the longitudes 
    2828; 
    2929; @param in2 {in}{required} 
    3030; Case 1: the name of the variable that contains the longitude in the NetCDF file 
    31 ; Case 2: 1d or 2D arrays defining longitudes and latitudes. 
     31; Case 2: 1d or 2d arrays defining longitudes and latitudes. 
    3232;         Note that these arrays are also outputs and can therefore be modified. 
    3333; Out: the variable that will contain the latitudes 

  • trunk/SRC/Interpolation/imoms3.pro

    r231 r242  
    11;+ 
    2 ; 
    32; 
    43; @param xin {in}{required} 

  • trunk/SRC/Interpolation/inquad.pro

    r240 r242  
    4747; 
    4848; @returns 
    49 ; a n element vector. Where n is the number of elements of 
     49; a n elements vector where n is the number of elements of 
    5050; x. res[i]=j means that the point number i is located in the 
    5151; quadrilateral number j with (0 <= j <= n_elements(x0)-1) 

  • trunk/SRC/Interpolation/ll_narcs_distances.pro

    r238 r242  
    3636; 
    3737; @returns 
    38 ; a (2, n) array containing the longitude/latitude of the resulting points. 
     38; a (2,n) array containing the longitude/latitude of the resulting points. 
    3939; Values are in radians unless the keyword DEGREES is set. 
    4040; 

  • trunk/SRC/Interpolation/map_npoints.pro

    r238 r242  
    3636; 
    3737; @keyword TWO_BY_TWO 
    38 ; If given, then map_npoints returns the distances between number n of 
    39 ; P0 points and number n of P1 points 
     38; If given, then <pro>map_npoints</pro> returns the distances between  
     39; number n of P0 points and number n of P1 pointsi. 
    4040; In that case, np0 and np1 must be equal. 
    4141; 
    … …  
    4444; points P0 and np1 points P1. Element (i,j) of the output is the 
    4545; distance between element P0[i] and P1[j]. 
    46 ; If keyword /TWO_BY_TWO is given then map_npoints returns 
    47 ; an np-element vector giving the distance in meter between P0[i] 
     46; If keyword /TWO_BY_TWO is given then <pro>map_npoints</pro> returns 
     47; an np-elements vector giving the distance in meter between P0[i] 
    4848; and P1[i] (in that case, we have np0 = np1 = np) ; if /MIDDLE see this keyword. 
    4949; @examples 
    … …  
    105105FUNCTION map_npoints, lon0, lat0, lon1, lat1, AZIMUTH = azimuth $ 
    106106 , RADIANS = radians, RADIUS = radius, MIDDLE = middle, TWO_BY_TWO = two_by_two 
    107  
     107; 
    108108 compile_opt idl2, strictarrsubs 
    109  
     109; 
    110110 IF (N_PARAMS() LT 4) THEN $ 
    111  MESSAGE, 'Incorrect number of arguments.' 
     111 ras = report('Incorrect number of arguments.') 
    112112 
    113113 np0 = n_elements(lon0) 
    114114 IF n_elements(lat0) NE np0 THEN $ 
    115  MESSAGE, 'lon0 and lat0 must have the same number of elements' 
     115 ras = report('lon0 and lat0 must have the same number of elements') 
    116116 np1 = n_elements(lon1) 
    117117 IF n_elements(lat1) NE np1 THEN $ 
    118  MESSAGE, 'lon1 and lat1 must have the same number of elements' 
     118 ras = report('lon1 and lat1 must have the same number of elements') 
    119119 if keyword_set(two_by_two) AND np0 NE np1 then $ 
    120  MESSAGE, 'When using two_by_two keyword, P0 and P1 must have the same number of elements' 
     120 ras = report('When using two_by_two keyword, P0 and P1 must have the same number of elements') 
    121121 
    122122 mx = MAX(ABS([lat0[*], lat1[*]])) 
    123123 pi2 = !dpi/2 
    124124 IF (mx GT (KEYWORD_SET(radians) ? pi2 : 90)) THEN $ 
    125  MESSAGE, 'Value of Latitude is out of allowed range.' 
     125 ras = report('Value of Latitude is out of allowed range.') 
    126126 
    127127 k = KEYWORD_SET(radians) ? 1.0d0 : !dpi/180.0 

  • trunk/SRC/Interpolation/neighbor.pro

    r238 r242  
    88; Maps 
    99; 
    10 ; @param p0lon {in}{required} 
    11 ; scalar. longitudes of point P0. 
     10; @param p0lon {in}{required} {type=scalar} 
     11; longitudes of point P0. 
    1212; 
    13 ; @param p0lat {in}{required} 
    14 ; scalar. latitudes of point P0. 
     13; @param p0lat {in}{required} {type=scalar} 
     14; latitudes of point P0. 
    1515; 
    1616; @param neighlon {in}{optional} 
    … …  
    4747;- 
    4848; 
    49 FUNCTION neighbor, p0lon, p0lat, neighlon, neighlat, sphere = sphere, distance = distance, radians = radians 
     49FUNCTION neighbor, p0lon, p0lat, neighlon, neighlat, SPHERE = sphere, DISTANCE = distance, RADIANS = radians 
    5050; 
    5151  compile_opt idl2, strictarrsubs 
    5252; 
    53 ; somme checks 
    54   IF  n_elements(p0lon) NE 1 THEN MESSAGE, 'Sorry p0lon must be a scalar' 
     53; some checks 
     54  IF  n_elements(p0lon) NE 1 THEN ras = report('Sorry p0lon must be a scalar') 
    5555  p0lon = p0lon[0] 
    56   IF  n_elements(p0lat) NE 1 THEN MESSAGE, 'Sorry p0lat must be a scalar' 
     56  IF  n_elements(p0lat) NE 1 THEN ras = report('Sorry p0lat must be a scalar') 
    5757  p0lat = p0lat[0] 
    5858  nneig = n_elements(neighlon) 
    5959  IF  n_elements(neighlat) NE nneig  THEN $ 
    60     MESSAGE, 'neighlon and neighlat must have the same number of elements' 
     60    ras = report('neighlon and neighlat must have the same number of elements') 
    6161; distance between P0 and the others points 
    6262  IF keyword_set(sphere) THEN BEGIN 

  • trunk/SRC/Interpolation/quadrilateral2square.pro

    r238 r242  
    4141; 
    4242; @returns 
    43 ; (2,n) array: the new coordinates (xout, yout) of the (xin,yin) point(s) after 
     43; (2,n) array: the new coordinates (xout,yout) of the (xin,yin) point(s) after 
    4444; mapping. 
    4545; If xin is a scalar, then n is equal to the number of elements of x0. 
    46 ; If xin is an array , then n is equal to the number of elements of xin. 
     46; If xin is an array, then n is equal to the number of elements of xin. 
    4747; 
    4848; @restrictions 

  • trunk/SRC/Interpolation/spl_fstdrv.pro

    r238 r242  
    77; 
    88; Given the arrays X and Y, which tabulate a function (with the X[i] 
    9 ; AND Y[i] in ascending order), and given an input value X2, the 
     9; and Y[i] in ascending order), and given an input value X2, the 
    1010; <pro>spl_incr</pro> function returns an interpolated value for the given 
    1111; values of X2. The interpolation method is based on cubic spline, corrected 
    … …  
    1616; 
    1717; @param x {in}{required} 
    18 ; An n-element (at least 2) input vector that specifies the 
     18; An n-elements (at least 2) input vector that specifies the 
    1919; tabulate points in ascending order. 
    2020; 
    2121; @param y {in}{required} 
    22 ; f(x) = y. An n-element input vector that specifies the values 
     22; f(x) = y. An n-elements input vector that specifies the values 
    2323; of the tabulated function F(Xi) corresponding to Xi. 
    2424; 
    … …  
    2626; The output from <proidl>SPL_INIT</pro> for the specified X and Y. 
    2727; 
    28 ; @param x2 {in}{required} 
     28; @param x2 {in}{required} {type= scalar or array} 
    2929; The input values for which the first derivative values are desired. 
    30 ; X can be scalar or an array of values. 
    3130; 
    3231; @returns 

  • trunk/SRC/Interpolation/spl_incr.pro

    r238 r242  
    22; 
    33; @file_comments 
    4 ; 
    54; Given the arrays X and Y, which tabulate a function (with the X[i] 
    65; AND Y[i] in ascending order), and given an input value X2, the 
    … …  
    109; 
    1110; @param x1 {in}{required} 
    12 ; An n-element (at least 2) input vector that specifies the tabulate points in 
     11; An n-elements (at least 2) input vector that specifies the tabulate points in 
    1312; a strict ascending order. 
    1413; 
    1514; @param y1 {in}{required} 
    16 ; f(x) = y. An n-element input vector that specifies the values 
     15; f(x) = y. An n-elements input vector that specifies the values 
    1716; of the tabulated function F(Xi) corresponding to Xi. As f is 
    1817; supposed to be monotonically increasing, y values must be 
    … …  
    2827; 
    2928; @returns 
    30 ; 
    31 ;    y2: f(x2) = y2. Double precision array 
     29; y2: f(x2) = y2. Double precision array 
    3230; 
    3331; @restrictions 
    … …  
    3634; 
    3735; @examples 
    38 ; 
    3936; IDL> n = 100L 
    4037; IDL> x = (dindgen(n))^2 
    … …  
    8784; 
    8885; @param x1 {in}{required} 
    89 ; An n-element (at least 2) input vector that specifies the tabulate points in 
     86; An n-elements (at least 2) input vector that specifies the tabulate points in 
    9087; a strict ascending order. 
    9188; 
    9289; @param y1 {in}{required} 
    93 ; f(x) = y. An n-element input vector that specifies the values 
     90; f(x) = y. An n-elements input vector that specifies the values 
    9491;    of the tabulated function F(Xi) corresponding to Xi. As f is 
    9592;    supposed to be monotonically increasing, y values must be 
    … …  
    10198; 
    10299; @param der2 
     100; 
    103101; @param x 
    104102; 
    … …  
    135133;    point X0. If YP0 is omitted, the second derivative at the 
    136134;    boundary is set to zero, resulting in a "natural spline." 
     135; 
    137136; @keyword YPN_1 
    138137; The first derivative of the interpolating function at the 

  • trunk/SRC/Interpolation/spl_keep_mean.pro

    r238 r242  
    22; 
    33; @file_comments 
    4 ; 
    54; Given the arrays X and Y, which tabulate a function (with the X[i] 
    65; AND Y[i] in ascending order), and given an input value X2, the 
    7 ; spl_incr function returns an interpolated value for the given values 
     6; <pro>spl_incr</pro> function returns an interpolated value for the given values 
    87; of X2. The interpolation method is based on cubic spline, corrected 
    98; in a way that integral of the interpolated values is the same as the 
    … …  
    1312; 
    1413; @param x {in}{required} 
    15 ; An n-element (at least 2) input vector that specifies the tabulate points in 
     14; An n-elements (at least 2) input vector that specifies the tabulate points in 
    1615; a strict ascending order. 
    1716; 

  • trunk/SRC/Interpolation/square2quadrilateral.pro

    r238 r242  
    3333; 
    3434; @returns 
    35 ; (2,n) array: the new coordinates (xout, yout) of the (xin,yin) 
     35; (2,n) array: the new coordinates (xout,yout) of the (xin,yin) 
    3636; point(s) after mapping. 
    3737; If xin is a scalar, then n is equal to the number of elements of 
    3838; x0. If xin is an array , then n is equal to the number of 
    3939; elements of xin. 
    40 ; If xin and yin are omited, square2quadrilateral returns the 
     40; If xin and yin are omited, <pro>square2quadrilateral</pro> returns the 
    4141; matrix A which is used for the inverse transformation. 
    4242; 
Note: See TracChangeset for help on using the changeset viewer.