Session One: Problem Engine/Special Targets (grade, edit, print) (Guy)

Tags

Arguments for all response tags

Implemented response tags

o      <externalresponse> implements the ability to have an external program grade a response, expects either a <textline> or <textfield> inside the tag.

Arguments:

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:

Internal tags:

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.

<script> Functions

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(), &section()

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

<script> Variables

Form internals

Form elements used for homework editing/response

the form is named lonhomework

Viewing a problem (either CSTR or RES space)

Editing a problem (Edit mode)

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

Symbs

To identify a specific instance of a resource, LON-CAPA uses symbols or Òsymbs.Ó These identifiers are built from the URL of the map, the resource number of the resource in the map, and the URL of the resource itself. The latter is somewhat redundant, but might help if maps change.

An example is

 msu/korte/parts/part1.sequence___19___msu/korte/tests/part12.problem

The respective map entry is

 <resource id="19" src="/res/msu/korte/tests/part12.problem"    

  title="Problem 2">

 </resource>

Symbs are used by the random number generator, as well as to store and restore data specific to a certain instance of for example a problem.

Store / Restore

2 important functions in lonnet.pm are &Apache::lonnet::cstore() and &Apache::lonnet:restore() (and &Apache::lonnet::store(), which is is the non-critical message twin of cstore). These functions are for handlers to store a perl hash to a userÕs permanent data space in an easy manner, and to retrieve it again on another call. It is expected that a handler would use this once at the beginning to retrieve data, and then again once at the end to send only the new data back.

The data is stored in the userÕs data directory on the userÕs homeserver under the ID of the course.

The hash that is returned by restore will have all of the previous value for all of the elements of the hash.

Example:

#creating a hash

my %hash;

$hash{'foo'}='bar';

#storing it

&Apache::lonnet::cstore(\%hash);

#changing a value

$hash{'foo'}='notbar';

#adding a new value

$hash{'bar'}='foo';

&Apache::lonnet::cstore(\%hash);

#retrieving the hash

my %history=&Apache::lonnet::restore();

#print the hash

foreach my $key (sort(keys(%history))) {

    print("\%history{$key} = $history{$key}");

}

Will print out:

%history{1:foo} = bar

%history{1:keys} = foo:timestamp

%history{1:timestamp} = 990455579

%history{2:bar} = foo

%history{2:foo} = notbar

%history{2:keys} = foo:bar:timestamp

%history{2:timestamp} = 990455580

%history{bar} = foo

%history{foo} = notbar

%history{timestamp} = 990455580

%history{version} = 2

Note that the special hash entries keys, version and timestamp were added to the hash. version will be equal to the total number of versions of the data that have been stored. The timestamp attribute will be the UNIX time the hash was stored. keys is available in every historical section to list which keys were added or changed at a specific historical revision of a hash.

Warning do not store the hash that restore returns directly. This will cause a mess since it will restore the historical keys as if the were new keys. I.E. 1:foo will become 1:1:foo etc.

Calling convention:

  my %record=&Apache::lonnet::restore($symb,$courseid,$domain,$uname,$home);

  &Apache::lonnet::cstore(\%newrecord,$symb,$courseid,$domain,$uname,$home);

Arguments (only %newrecord is required the rest are somewhat optional, read the details):

á      $symb - a string containing the internal name of the specific instance of a resource. Usually this value can be gotten from &Apache::lonnet::symbread($filename). If the argument is blank, it will attempt to use symbread() for it. If the result is ambiguous store/restore will fail.

á      $courseid - the internal name for a course, usually found in $env{'request.course.id'} which is what will be looked at if no value is passed to the functions.

á      $domain - the domain that the user belongs to, usually found in $env{'user.domain'} which is what will be looked at if no value is passed to the functions.

á      $uname - the login name for the user, usually found in $env{'user.name'} which is what will be looked at if no value is passed to the functions.

á      $home - the homeserver for the user, usually found in $env{'user.home'} but can be easily gotten from a domain and name through &Apache::lonnet::homeserver($uname,$domain). If no value is passed to store/restore the value in %env will be used.

á      %newrecord - the hash to store being passed by reference

Return values:

á      an empty string - the function was unable to determine exactly where to store or restore from. At least one of the "optional" arguments was unable to be determined.

á      a hash - restore successfully read a old hash for this specific user / resource instance.

á      no_such_host - the $home specfied desn't exist in the network.

á      con_delayed - the $home was uncontactable at this time. The store will be delayed until it is again available.

á      con_failed - the $home was uncontactable at this time and store was unable to delay the store until a later time. The store failed.

á      ok - the store completed succesfully

á      error: - remote server failied to store or restore the reason follows the :

Mandatory Homework Data

 
<Provided by &EXT() and set external to the resource, required>
resource.partid.opendate   #unix time of when the local machine should let the
                           #student in
 
resource.partid.duedate    #unix time of when the local machine should stop
                           #accepting answers
 
resource.partid.answerdate #unix time of when the local machine should
                           #provide the correct answer to the student
 
resource.partid.weight     # points the problem is worth
 
resource.partid.maxtries   # maximum number of attempts the student can have
 
resource.partid.type       # type of problem homework can be:
                           # homework - randomized, graded, stored with 
                           #            requesting user, full feeback
                           # exam - randomized, graded, stored with 
                           #        requesting user, minimal feedback
                           # form - unrandomized, ungraded, stored with 
                           #        specified user, full feedback
                           # survey - unrandomized, ungraded, stored with 
                           #          requesting user, full feedback
 
 
 
<numerical/formula/response needed: (has a default if nonexistant)>
 
resource.partid.responseid.tol   # lots of possibilities here
                    # percentage, range (inclusive and exclusive),
                     # variable name, etc
                    # 3%
                    # 0.5
                    # .05+
                    # 3%+
                    # 0.5+,.005
 
resource.partid.responseid.sig  # one or two comma sepearted integers,    
                                # specifying the number of significatn figures
                                # a student must use
 
 
 
<Problem sets using cstore (required):>
resource.partid.solved # if not set, problem yet to be viewed
                # incorrect_attempted == incorrect and attempted
                # correct_by_student == correct by student work
                # correct_by_override == correct, instructor override
                # incorrect_by_override == incorrect, instructor override
                # excused == excused, problem no longer counts for student
                # '' (empty) == not attempted
                # ungraded_attempted == an ungraded answer has been
                                          sumbitted and stored
resource.partid.tries  # positive integer of number of unsuccessful attempts
                # made, malformed answers don't count if feedback is
                # on
 
resource.partid.awarded # float between 0 and 1, percentage of
                 # resource.weight that the stundent earned.
 
resource.partid.award # final detailed award that was applied to the entire
                      # part of the question, check awarddetail below for
                      # possibilities
 
resource.partid.previous # boolean, is this submission a previous submission
 
resource.partid.responseid.submissons
                    # the student submitted string for the part.response
 
resource.partid.responseid.awarddetail
                     # list of all of the results of grading the submissions
                     # in detailed form of the specific failure
                      #Possible values:
                     # EXACT_ANS, APPROX_ANS : student is correct
                     # NO_RESPONSE : student submitted no response
                     # MISSING_ANSWER : student submitted some but not
                     #                   all parts of a response
                     # WANTED_NUMERIC : expected a numeric answer and
                     #                   didn't get one
                      # SIG_FAIL : incorrect number of Significant Figures
                     # UNIT_FAIL : incorrect unit
                     # UNIT_NOTNEEDED : Submitted a unit when one shouldn't
                     # NO_UNIT : needed a unit but none was submitted
                      # BAD_FORMULA : syntax error in submitted formula
                     # INCORRECT : answer was wrong
                     # SUBMITTED : submission wasn't graded
                     # ERROR : unable to get a grade
 
resource.partid.responseid.message (optional) (not yet supported)
                       # a message that should be shown to the student
 
resource.partid.bonustries (optional) (not yet supported)
                     # if set, added to the maxtries parameter for student 
                     # total number of tries overall
 

Sample Problems

A Simple Problem

<problem>

        <script type="loncapa/perl">

$length=&random(10,99,.1);

$width=&random(1,10,.01);

@area=($length*($width*10));

        </script>

What is the area of a box $length mm in length and

&format($width,"2E") cm in width.

        <numericalresponse id="11" answer="@area" units="mm^2">

                <textline></textline>

                <responseparam name="tol" type="tolerance" default="5%"></responseparam>

        </numericalresponse>

</problem>

A More Complex Problem

<problem>

<displayduedate />

<p><displaytitle /></p>

<script type="loncapa/perl">

$vF="<b> F<sub>1</sub> </b>";

$vF1="<b> F<sub>1</sub> </b>";

$vF2="<b> F<sub>2</sub> </b>";

$mF="|<b>F</b>|";

$F1mag="|<b>F<sub>1</sub></b>|";

$F2mag="|<b>F<sub>2</sub></b>|";

$trq1mag="|<b> <font face=symbol>t</font><sub>1</sub></b>|";

$trq2mag="|<b> <font face=symbol>t</font><sub>2</sub></b>|";

$Q1="Q<sub>1</sub>";

$Q2="Q<sub>2</sub>";

$tau="<font face=symbol>t</font>";

$tau1="<font face=symbol><b>t</b></font><sub>1</sub>";

   $val=&random(1,4,1);

   $tp=&choose($val,"her","her","his","his");

   $sd=&choose($val,"daughter","niece","nephew","son");

</script>

<startouttext />

$trq1mag and $trq2mag are the magnitudes of the torques produced repectively by

forces $vF1 and $vF2 with respect the pivot P. The magnitudes of $vF1 is

$F1mag and that of $vF2 is $F2mag. $Q1 and $Q2 are the locations

on a rigid body where $vF1 and $vF2 act. 

<endouttext />

<optionresponse max="600">

        <foilgroup options="('Correct','Incorrect','Can not tell')">

                <conceptgroup concept="Effect of the moment-arm on the torque">

                        <foil name="1a" value="Incorrect">

                          For $F1mag larger than $F2mag , $trq1mag is larger than $trq2mag

                        </foil>

                        <foil name="1b" value="Incorrect">

                          For $F1mag smaller than $F2mag , $trq1mag is smaller than $trq2mag

                        </foil>

                        <foil name="1c" value="Correct">

                          For $F1mag larger than $F2mag , $trq1mag can be less  than $trq2mag

                        </foil>

                        <foil name="1d" value="Correct">

                          For $F1mag smaller than $F2mag , $trq1mag can be larger  than $trq2mag

                        </foil>

                </conceptgroup>

                <conceptgroup concept="For a given pivot, relation of force vector to torque.">

                        <foil name="2a" value="Correct">

                  The moment-arm of $vF is the shortest distance from P to the line along $vF .

                        </foil>

                        <foil name="2b" value="Incorrect">

                          The moment-arm of $vF is the shortest distance from P to $vF vector.

                        </foil>

                        <foil name="2c" value="Correct">

                          The moment-arm of $vF is not the distance from P to Q<sub>1</sub>.

                        </foil>

                        <foil name="2d" value="Incorrect">

                          The moment-arm of $vF is the distance from P to Q<sub>1</sub>.

                        </foil>

                </conceptgroup>

                <conceptgroup concept="Torque is force x moment-arm.">

                        <foil name="3a" value="Correct">

                          $trq1mag equals to the product of the moment-arm and $F1mag .

                      </foil>

                        <foil name="3b" value="Incorrect">

                        $trq1mag equals to $F1mag times the distance from Q<sub>1</sub> to P.

                        </foil>

                        <foil name="3c" value="Correct">

                          $trq1mag is not equal to the product of $F1mag and the distance from Q<sub>1</sub> to P.

                        </foil>

                        <foil name="3d" value="Incorrect">

                        $trq1mag is not equal to the product of the moment-arm and $F1mag .

                        </foil>

                </conceptgroup>

                <conceptgroup concept="Pivot point is required to calculate torque">

                        <foil name="4a" value="Correct">

                         $tau1 vector depends on the location of P.

                        </foil>

                        <foil name="4b" value="Incorrect">

                         $tau1 vector does not depend on the location of P.

                        </foil>

                        <foil name="4c" value="Correct">

                         $tau1 vector has no meaning unless a pivot is selected.

                        </foil>

                        <foil name="4d" value="Incorrect">

                         $tau1 vector can be determined without selecting P.

                        </foil>

                </conceptgroup>

                <conceptgroup concept="torque from 2 forces acting along same line">

                        <foil name="5a" value="Correct">

                          Two equal forces, acting on a body along the same line but at different positions, produce equal torques with respect to a given pivot."

                        </foil>

                        <foil name="5b" value="Incorrect">

                          Two equal forces, along the same line, produce equal torques with respect to a given pivot only if they act at the same point on a body."

                        </foil>

                        <foil name="5c" value="Incorrect">

                          Two equal forces acting on a body along the same line but at different positions, produce equal torques for only one pivot."

                        </foil>

                </conceptgroup>

                <foil name="6" value="unused">

                        This foil will never display since it is unused.

                </foil>

        </foilgroup>

        <notsolved>

                <hintgroup>

Think the definition of the torque. The force and the moment-arm respect to the pivot. 

                </hintgroup>

        </notsolved>

</optionresponse>

</problem>

 

Fig. 3.1.1 Ð Internal Structure of Homework Handler