Arguments for all response tags
Implemented response tags
<externalresponse> implements the ability to have
an external program grade a response, expects either a
<textline> or <textfield> inside the tag.
The response of the remote server needs to be in XML as follows.
<loncapagrade> <awardetail> CORRECT </awardetail> <message> A message to be shown to the students </message> </loncapagrade>
All tags that implement a foil structure have an optional arg of max that controls the maximum number of total foils to show.
All of these tags must appear inside a <*response> tag.
This group of tags implement a mechanism for getting data for students, they will usually be used by a <*response>.
This group of tags generate useful pieces of output.
<randomlabel bgimg="URL" width="12" height="45" texwidth="50"> <labelgroup name="GroupOne" type="image"> <location x="123" y="456" value="10" /> <location x="321" y="654" value="20" /> <location x="213" y="546" value="13" /> <label description="TEXT-1">IMG-URL</label> <label description="TEXT-2">IMG-URL</label> <label description="TEXT-3">IMG-URL</label> </labelgroup> <labelgroup name="GroupTwo" type="text"> <location x="12" y="45" /> <location x="32" y="65" /> <location x="21" y="54" /> <label>TEXT-1</label> <label>TEXT-2</label> <label>TEXT-3</label> </labelgroup> </randomlabel>Arguments:
These tags allow the document to behave programatically
These tags give the problem a structure and take care of the recording of data and giving the student messages.
A list of functions that have been written that are available in the Safe space scripting environment inside a problem.
Detailed descriptions of each function and comparison with CAPA.
CAPA Functions | LON-CAPA | Descriptions | Differences (if any) |
sin(x), cos(x), tan(x) | &sin($x), &cos($x), &tan($x) | Trigonometric functions where x is in radians. $x can be a pure number, i.e., you can call &sin(3.1415) |   |
asin(x), acos(x), atan(x), atan2(y,x) | &asin($x), &acos($x), &atan($x), &atan2($y,$x) | Inverse trigonometric functions. Return value is in radians. For asin and acos the value of x must be between -1 and 1. The atan2 returns a value between -pi and pi the sign of which is determined by y. $x and $y can be pure numbers | |
log(x), log10(x) | &log($x), &log10($x) | Natural and base-10 logarithm. $x can be a pure number | |
exp(x), pow(x,y), sqrt(x) | &exp($x), &pow($x,$y), &sqrt($x) | Exponential, power and square root, i.e.,ex, xy and /x. $x and $y can be pure numbers | |
abs(x), sgn(x) | &abs($x), &sgn($x) | Abs takes the absolute value of x while sgn(x) returns 1, 0 or -1 depending on the value of x. For x>0, sgn(x) = 1, for x=0, sgn(x) = 0 and for x<0, sgn(x) = -1. $x can be a pure number | |
erf(x), erfc(x) | &erf($x), &erfc($x) | Error function. erf = 2/sqrt(pi) integral (0,x) et-sq and erfx(x) = 1.0 - erf(x). $x can be a pure number | |
ceil(x), floor(x) | &ceil($x), &floor($x) | Ceil function returns an integer rounded up whereas floor function returns and integer rounded down. If x is an integer than it returns the value of the integer. $x can be a pure number | |
min(...), max(...) | &min(...), &max(...) | Returns the minimum/ maximum value of a list of arguments if the arguments are numbers. If the arguments are strings then it returns a string sorted according to the ASCII codes | |
factorial(n) | &factorial($n) | Argument (n) must be an integer else it will round down. The largest value for n is 170. $n can be a pure number | |
N%M | $N%$M | N and M are integers and returns the remainder (in integer) of N/M. $N and $M can be pure numbers | |
sinh(x), cosh(x), tanh(x) | &sinh($x), &cosh($x), &tanh($x) | Hyperbolic functions. $x can be a pure number | |
asinh(x), acosh(x), atanh(x) | &asinh($x), &acosh($x), &atanh($x) | Inverse hyperbolic functions. $x can be a pure number | |
/DIS($x,"nn") | &format($x,"nn") | Display or format $x as nn where nn is nF or nE and n is an integer. | The difference is obvious. |
Not in CAPA | &prettyprint($x,"nn") | Display or format $x as nn where nn is nF or nE and n is an integer. In E mode it will attempt to generate a pretty x10^3 rather than a E3 following the number | |
roundto(x,n) | &roundto($x,$n) | Rounds a real number to n decimal points. $x and $n can be pure numbers | |
web("a","b","c") or web(a,b,c) | &web("a","b","c") or &web($a,$b,$c) | Returns either a, b or c depending on the output medium. a is for plain ASCII, b for tex output and c for html output |   |
html("a") or html(a) | &html("a") or &html($a) | Output only if the output mode chosen is in html format | |
jn(m,x) | &j0($x), &j1($x), &jn($m,$x), &jv($y,$x) | Bessel functions of the first kind with orders 0, 1 and m respectively. For jn(m,x), m must be an integer whereas for jv(y,x), y is real. $x can be a pure number. $m must be an integer and can be a pure integer number. $y can be a pure real number | In CAPA, j0, j1 and jn are contained in one function, jn(m,x) where m takes the value of 0, 1 or 2. jv(y,x) is new to LON-CAPA. |
yn(m,x) | &y0($x), &y1($x), &yn($m,$x), &yv($y,$x) | Bessel functions of the second kind with orders 0, 1 and m respectively. For yn(m,x), m must be an integer whereas for yv(y,x), y is real. $x can be a pure number. $m must be an integer and can be a pure integer number. $y can be a pure real number | In CAPA, y0, y1 and yn are contained in one function, yn(m,x) where m takes the value of 0, 1 or 2. yv(y,x) is new to LON-CAPA. |
random(l,u,d) | &random($l,$u,$d) | Returns a uniformly distributed random number between the lower bound, l and upper bound, u in steps of d. $l, $u and $d can be pure numbers | In CAPA, all the 3 arguments must be of the same type. However, now you can mix the type |
choose(i,...) | &choose($i,...) | Choose the ith item from the argument list. i must be an integer greater than 0 and the value of i should not exceed the number of items. $i can be a pure integer | |
/MAP(seed;w,x,y,z;a,b,c,d) | Option 1 - &map($seed,[\$w,\$x,\$y,\$z],[$a,$b,$c,$d]) or Option 2 - &map($seed,\@mappedArray,[$a,$b,$c,$d]) Option 3 - @mappedArray = &map($seed,[$a,$b,$c,$d]) Option 4 - ($w,$x,$y,$z) = &map($seed,\@a) where $a='A' $b='B' $c='B' $d='B' $w, $x, $y, and $z are variables |
Assigns to the variables $w, $x, $y and $z the values of the $a, $b, $c and $c (A, B, C and D). The precise value for $w .. depends on the seed. (Option 1 of calling map). In option 2, the values of $a, $b .. are mapped into the array, @mappedArray. The two options illustrate the different grouping. Options 3 and 4 give a consistent way (with other functions) of mapping the items. For each option, the group can be passed as an array, for example, [$a,$b,$c,$d] => \@a. | In CAPA, the arguments are divided into three groups separated by a semicolon ;. In LON-CAPA, the separation is done by using [] brackets or using an array @a. Note the backslash (\) before the arguments in the second and third groups. |
rmap(seed;a,b,c,d;w,x,y,z) | Option 1 - &rmap($seed,[\$w,\$x,\$y,\$z],[$a,$b,$c,$d]) or Option 2 - &rmap($seed,\@rmappedArray,[$a,$b,$c,$d]) Option 3 - @rmapped_array = &rmap($seed,[$a,$b,$c,$d]) Option 4 - ($w,$x,$y,$z) = &rmap($seed,\@a) where $a='A' $b='B' $c='B' $d='B' $w, $x, $y, and $z are variables |
The rmap functions does the reverse action of map if the same seed is used in calling map and rmap. | In CAPA, the arguments are divided into three groups separated by a semicolon ;. In LON-CAPA, the separation is done by using [] brackets (with create an unamed vector reference) or using an array @a. Note the backslash (\) before the arguments in the second and third groups (Which cause Perl to send to variable locations rather than the variable values, similar to a C pointer). |
NOT IMPLEMENTED IN CAPA | $a=&xmlparse($string) | Runs the internal parser over the argument parsing for display. Warning This will result in different strings in different targets. Don't use the results of this function as an answer. | New to LON-CAPA |
tex(a,b), tex("a","b") | &tex($a,$b), &tex("a","b") | Returns a if the output mode is in tex otherwise returns b | |
var_in_tex(a) | &var_in_tex($a) | Equivalent to tex("a","") | |
to_string(x), to_string(x,y) | &to_string($x), &to_string($x,$y) | If x is an integer, returns a string. If x is real than the output is a string with format given by y. For example, if x = 12.3456, &to_string(x,".3F") = 12.345 and &to_string(x,".3E") = 1.234E+01. | |
capa_id(), class(), section(), set(), problem() | &class(), §ion() | Returns null string, class descriptive name, section number, set number and null string. | capa_id(), set() and problem() are no longer used. Currently, they return a null value. |
name(), student_number() | &name(), &student_number() | Return the full name in the following format: lastname, firstname initial. Student_number returns the student 9-alphanumeric string. If undefined, the functions return null. | |
open_date(), due_date(), answer_date() | &open_date(), &due_date(), &answer_date() | Problem open date, due date and answer date. The time is also included in 24-hr format. | Output format for time is changed slightly. If pass noon, it displays ..pm else it displays ..am. So 23:59 is displayed as 11:59 pm. |
get_seed(), set_seed() | Not implemented | Get and set the random seed. | |
sub_string(a,b,c) | &sub_string($a,$b,$c) perl substr function. However, note the differences |
Retrieve a portion of string a starting from b and length c. For example, $a = "Welcome to LON-CAPA"; $result=&sub_string($a,4,4); then $result is "come" | Perl intrinsic function, substr(string,b,c) starts counting from 0 (as opposed to 1). In the example to the left, substr($a,4,4) returns "ome ". |
array[xx] | @arrayname Array is intrinsic in perl. To access a specific element use $arrayname[$n] where $n is the $n+1 element since the array count starts from 0 |
"xx" can be a variable or a calculation. | In LON-CAPA, an array is defined by @arrayname. It is not necessary to specify the dimension of the array. |
array_moments(B,A) | @B=&array_moments(@A) | Evaluates the moments of an array A and place the result in array B[i] where i = 0 to 4. The contents of B are as follows: B[0] = number of elements, B[1] = mean, B[2] = variance, B[3] = skewness and B[4] = kurtosis. | In CAPA, the moments are passed as an array in the first argument whereas in LON-CAPA, the array containing the moments are set equal to the function. |
array_max(Name), array_min(Name) | &min(@Name), &max(@Name) | In LON-CAPA to find the maximum value of an array, use &max(@arrayname) and to find the minimum value of an array, use &min(@arrayname) | Combined with the min and max functions defined earlier. |
init_array(Name) | undef @name | To destroy the contents of an array, use | Use perl intrinsic undef function. |
random_normal (return_array,item_cnt,seed,av,std_dev) | @return_array=&random_normal ($item_cnt,$seed,$av,$std_dev) | Generate $item_cnt deviates of normal distribution of average $av and standard deviation $std_dev. The distribution is generated from seed $seed | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
random_beta (return_array,item_cnt,seed,aa,bb) | @return_array=&random_beta ($item_cnt,$seed,$aa,$bb) NOTE: Both $aa and $bb MUST be greater than 1.0E-37. |
Generate $item_cnt deviates of beta distribution. The density of beta is: X^($aa-1) *(1-X)^($bb-1) /B($aa,$bb) for 0<X<1. | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
random_gamma (return_array,item_cnt,seed,a,r) | @return_array=&random_gamma ($item_cnt,$seed,$a,$r) NOTE: Both $a and $r MUST be positive. |
Generate $item_cnt deviates of gamma distribution. The density of gamma is: ($a**$r)/gamma($r) * X**($r-1) * exp(-$a*X). | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
random_exponential (return_array,item_cnt,seed,av) | @return_array=&random_exponential ($item_cnt,$seed,$av) NOTE: $av MUST be non-negative. |
Generate $item_cnt deviates of exponential distribution. | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
random_poisson (return_array,item_cnt,seed,mu) | @return_array=&random_poisson ($item_cnt,$seed,$mu) NOTE: $mu MUST be non-negative. |
Generate $item_cnt deviates of poisson distribution. | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
random_chi (return_array,item_cnt,seed,df) | @return_array=&random_chi ($item_cnt,$seed,$df) NOTE: $df MUST be positive. |
Generate $item_cnt deviates of chi_square distribution with $df degrees of freedom. | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
random_noncentral_chi (return_array,item_cnt,seed,df,nonc) | @return_array=&random_noncentral_chi ($item_cnt,$seed,$df,$nonc) NOTE: $df MUST be at least 1 and $nonc MUST be non-negative. |
Generate $item_cnt deviates of noncentral_chi_square distribution with $df degrees of freedom and noncentrality parameter $nonc. | In CAPA the results are passed as the first argument whereas in LON-CAPA the results are set equal to the function. |
NOT IMPLEMENTED IN CAPA | @return_array=&random_f ($item_cnt,$seed,$dfn,$dfd) NOTE: Both $dfn and $dfd MUST be positive. |
Generate $item_cnt deviates of F (variance ratio) distribution with degrees of freedom $dfn (numerator) and $dfd (denominator). | New to LON-CAPA |
NOT IMPLEMENTED IN CAPA | @return_array=&random_noncentral_f ($item_cnt,$seed,$dfn,$dfd,$nonc) NOTE: $dfn must be at least 1, $dfd MUST be positive, and $nonc must be non-negative. |
Generate $item_cnt deviates of noncentral F (variance ratio) distribution with degrees of freedom $dfn (numerator) and $dfd (denominator). $nonc is the noncentrality parameter. | New to LON-CAPA |
NOT DOCUMENTED IN CAPA | @return_array=&random_multivariate_normal ($item_cnt,$seed,\@mean,\@covar) NOTE: @mean should be of length p array of real numbers. @covar should be a length p array of references to length p arrays of real numbers (i.e. a p by p matrix. |
Generate $item_cnt deviates of multivariate_normal distribution with mean vector @mean and variance-covariance matrix. | Note the backslash before the @mean and @covar arrays. |
NOT IMPLEMENTED IN CAPA | @return_array=&random_multinomial ($item_cnt,$seed,@p) NOTE: $item_cnt is rounded with int() and the result must be non-negative. The number of elements in @p must be at least 2. |
Returns single observation from multinomial distribution with $item_cnt events classified into as many categories as the length of @p. The probability of an event being classified into category i is given by ith element of @p. The observation is an array with length equal to @p, so when called in a scalar context it returns the length of @p. The sum of the elements of the obervation is equal to $item_cnt. | New to LON-CAPA |
NOT IMPLEMENTED IN CAPA | @return_array=&random_permutation ($item_cnt,@array) | Returns @array randomly permuted. | New to LON-CAPA |
NOT IMPLEMENTED IN CAPA | @return_array=&random_uniform ($item_cnt,$seed,$low,$high) NOTE: $low must be less than or equal to $high. |
Generate $item_cnt deviates from a uniform distribution. | New to LON-CAPA |
NOT IMPLEMENTED IN CAPA | @return_array=&random_uniform_integer ($item_cnt,$seed,$low,$high) NOTE: $low and $high are both passed through int(). $low must be less than or equal to $high. |
Generate $item_cnt deviates from a uniform distribution in integers. | New to LON-CAPA |
NOT IMPLEMENTED IN CAPA | @return_array=&random_binomial ($item_cnt,$seed,$nt,$p) NOTE: $nt is rounded using int() and the result must be non-negative. $p must be between 0 and 1 inclusive. |
Generate $item_cnt deviates from the binomial distribution with $nt trials and the probabilty of an event in each trial is $p. | New to LON-CAPA |
NOT IMPLEMENTED IN CAPA | @return_array=&random_negative_binomial ($item_cnt,$seed,$ne,$p) NOTE: $ne is rounded using int() and the result must be positive. $p must be between 0 and 1 exclusive. |
Generate an array of $item_cnt outcomes generated from negative binomial distribution with $ne events and the probabilty of an event in each trial is $p. | New to LON-CAPA |
Form elements used for homework editing/response
the form is named lonhomework
tagdepth referes to the current value of the xmlparsers tagdepth couter ($Apache::lonxml::currentdepth)
Note: the file edit.pm has many helper functions for creating the standard elements for editing a tag and it's attributes, all of those functions follow these conventions