From 6c20d1bace2080bae95cb5943668de82a60032b1 Mon Sep 17 00:00:00 2001
From: Sylvia Pearce <spearce@edx.org>
Date: Mon, 3 Mar 2014 17:24:03 -0500
Subject: [PATCH] Consolidate information from data.edx.org, Appendix E, and problem types
---
docs/en_us/course_authors/source/Images/NumericalInput_Complex.png | Bin 63304 -> 0 bytes
docs/en_us/course_authors/source/Images/image292.png | Bin 268494 -> 0 bytes
docs/en_us/course_authors/source/additional_tools.rst | 261 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------------------------------------
docs/en_us/course_authors/source/advanced_problems.rst | 549 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
docs/en_us/course_authors/source/appendices/e.rst | 1588 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
docs/en_us/course_authors/source/common_problems.rst | 500 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
docs/en_us/course_authors/source/create_problem_component.rst | 35 +++++++++++++++++++++++++++++++----
7 files changed, 1434 insertions(+), 1499 deletions(-)
diff --git a/docs/en_us/course_authors/source/Images/NumericalInput_Complex.png b/docs/en_us/course_authors/source/Images/NumericalInput_Complex.png
index 134f14b..d8a30d1 100644
Binary files a/docs/en_us/course_authors/source/Images/NumericalInput_Complex.png and b/docs/en_us/course_authors/source/Images/NumericalInput_Complex.png differ
diff --git a/docs/en_us/course_authors/source/Images/image292.png b/docs/en_us/course_authors/source/Images/image292.png
index 58e1193..eceeae7 100644
Binary files a/docs/en_us/course_authors/source/Images/image292.png and b/docs/en_us/course_authors/source/Images/image292.png differ
diff --git a/docs/en_us/course_authors/source/additional_tools.rst b/docs/en_us/course_authors/source/additional_tools.rst
index f014ad8..18de2df 100644
--- a/docs/en_us/course_authors/source/additional_tools.rst
+++ b/docs/en_us/course_authors/source/additional_tools.rst
@@ -13,64 +13,15 @@ Individual course teams frequently create tools and problem types that don't hav
Below, we provide you with all the files and code that you need to create the following tools and problem types.
-* :ref:`Gene Explorer`
* :ref:`Chemical Equation`
+* :ref:`Conditional Module`
+* :ref:`Gene Explorer`
* :ref:`Interactive Periodic Table`
* :ref:`Molecule Editor`
* :ref:`Multiple Choice and Numerical Input`
* :ref:`Polls`
* :ref:`Protein Builder`
-.. _Gene Explorer:
-
-**************************
-Gene Explorer
-**************************
-
-The Gene Explorer (GeneX), from the biology department at `UMB <http://www.umb.edu/>`_, simulates the transcription, splicing, processing, and translation of a small hypothetical eukaryotic gene. GeneX allows students to make specific mutations in a gene sequence, and it then calculates and displays the effects of the mutations on the mRNA and protein.
-
-Specifically, the Gene Explorer does the following:
-
-#. Finds the promoter and terminator
-#. Reads the DNA sequence to produce the pre-mRNA
-#. Finds the splice sites
-#. Splices and tails the mRNA
-#. Finds the start codon
-#. Translates the mRNA
-
-.. image:: /Images/GeneExplorer.png
- :alt: Image of the Gene Explorer
-
-For more information about the Gene Explorer, see `The Gene Explorer <http://intro.bio.umb.edu/GX/>`_.
-
-=====================
-Gene Explorer Code
-=====================
-
-::
-
- <problem>
- <p>Make a single base pair substitution mutation in the gene below that results in a protein that is longer than the protein produced by the original gene. When you are satisfied with your change and its effect, click the <b>SUBMIT</b> button.</p>
- <p>Note that a "single base pair substitution mutation" is when a single base is changed to another base; for example, changing the A at position 80 to a T. Deletions and insertions are not allowed.</p>
- <script type="loncapa/python">
- def genex_grader(expect,ans):
- if ans=="CORRECT": return True
- import json
- ans=json.loads(ans)
- return ans["genex_answer"]=="CORRECT"
- </script>
- <customresponse cfn="genex_grader">
- <editageneinput width="818" height="1000" dna_sequence="TAAGGCTATAACCGAGATTGATGCCTTGTGCGATAAGGTGTGTCCCCCCCCAAAGTGTCGGATGTCGAGTGCGCGTGCAAAAAAAAACAAAGGCGAGGACCTTAAGAAGGTGTGAGGGGGCGCTCGAT" genex_dna_sequence="TAAGGCTATAACCGAGATTGATGCCTTGTGCGATAAGGTGTGTCCCCCCCCAAAGTGTCGGATGTCGAGTGCGCGTGCAAAAAAAAACAAAGGCGAGGACCTTAAGAAGGTGTGAGGGGGCGCTCGAT" genex_problem_number="2"/>
- </customresponse>
- </problem>
-
-In this code:
-
-* **width** and **height** specify the dimensions of the application, in pixels.
-* **genex_dna_sequence** is the default DNA sequence that appears when the problem opens.
-* **dna_sequence** contains the application's state and the student's answer. This value must be the same as **genex_dna_sequence**.
-* **genex_problem_number** specifies the number of the problem. This number is based on the five gene editor problems in the MITx 7.00x course--for example, if you want this problem to look like the second gene editor problem in the 7.00x course, you would set the **genex_problem_number** value to 2. The number must be 1, 2, 3, 4, or 5.
-
.. _Chemical Equation:
@@ -78,7 +29,7 @@ In this code:
Chemical Equation Problem
**************************
-The chemical equation problem type allows the student to enter chemical equations. The grader evaluates student responses by using a Python script that you create and embed in the problem.
+The chemical equation problem type allows the student to enter text that represents a chemical equation into a text box. The LMS converts that text into a chemical equation below the text box. The grader evaluates the student's response by using a Python script that you create and embed in the problem.
.. image:: /Images/ChemicalEquationExample.png
:alt: Image of a chemical equation response problem
@@ -87,6 +38,8 @@ The chemical equation problem type allows the student to enter chemical equation
Create the Chemical Equation Problem
====================================
+Chemical equation problems use MathJax to create formulas. For more information about using MathJax in Studio, see :ref:`MathJax in Studio`.
+
To create the above chemical equation problem:
#. In the unit where you want to create the problem, click **Problem** under **Add New Component**, and then click the **Advanced** tab.
@@ -96,12 +49,8 @@ To create the above chemical equation problem:
#. Click **Save**.
-
-
-
-====================================
-Chemical Equation Problem Code
-====================================
+Sample Chemical Equation Problem Code
+-------------------------------------
.. code-block:: xml
@@ -141,6 +90,140 @@ Chemical Equation Problem Code
</solution>
</problem>
+.. _Conditional Module:
+
+******************
+Conditional Module
+******************
+
+==================
+Format description
+==================
+
+The main tag of Conditional module input is:
+
+.. code-block:: xml
+
+ <conditional> ... </conditional>
+
+``conditional`` can include any number of any xmodule tags (``html``, ``video``, ``poll``, etc.) or ``show`` tags.
+
+conditional tag
+---------------
+
+The main container for a single instance of Conditional module. The following attributes can
+be specified for this tag::
+
+ sources - location id of required modules, separated by ';'
+ [message | ""] - message for case, where one or more are not passed. Here you can use variable {link}, which generate link to required module.
+
+ [submitted] - map to `is_submitted` module method.
+ (pressing RESET button makes this function to return False.)
+
+ [correct] - map to `is_correct` module method
+ [attempted] - map to `is_attempted` module method
+ [poll_answer] - map to `poll_answer` module attribute
+ [voted] - map to `voted` module attribute
+
+show tag
+--------
+
+Symlink to some set of xmodules. The following attributes can
+be specified for this tag::
+
+ sources - location id of modules, separated by ';'
+
+=======
+Example
+=======
+
+Examples of conditional depends on poll
+-------------------------------------------
+
+.. code-block:: xml
+
+ <conditional sources="i4x://MITx/0.000x/poll_question/first_real_poll_seq_with_reset" poll_answer="man"
+ message="{link} must be answered for this to become visible.">
+ <html>
+ <h2>You see this, cause your vote value for "First question" was "man"</h2>
+ </html>
+ </conditional>
+
+Examples of conditional depends on poll (use <show> tag)
+--------------------------------------------------------
+
+.. code-block:: xml
+
+ <conditional sources="i4x://MITx/0.000x/poll_question/first_real_poll_seq_with_reset" poll_answer="man"
+ message="{link} must be answered for this to become visible.">
+ <html>
+ <show sources="i4x://MITx/0.000x/problem/test_1; i4x://MITx/0.000x/Video/Avi_resources; i4x://MITx/0.000x/problem/test_1"/>
+ </html>
+ </conditional>
+
+Examples of conditional depends on problem
+-------------------------------------------
+
+.. code-block:: xml
+
+ <conditional sources="i4x://MITx/0.000x/problem/Conditional:lec27_Q1" attempted="True">
+ <html display_name="HTML for attempted problem">You see this, cause "lec27_Q1" is attempted.</html>
+ </conditional>
+ <conditional sources="i4x://MITx/0.000x/problem/Conditional:lec27_Q1" attempted="False">
+ <html display_name="HTML for not attempted problem">You see this, cause "lec27_Q1" is not attempted.</html>
+ </conditional>
+
+
+.. _Gene Explorer:
+
+**************************
+Gene Explorer
+**************************
+
+The Gene Explorer (GeneX), from the biology department at `UMB <http://www.umb.edu/>`_, simulates the transcription, splicing, processing, and translation of a small hypothetical eukaryotic gene. GeneX allows students to make specific mutations in a gene sequence, and it then calculates and displays the effects of the mutations on the mRNA and protein.
+
+Specifically, the Gene Explorer does the following:
+
+#. Finds the promoter and terminator
+#. Reads the DNA sequence to produce the pre-mRNA
+#. Finds the splice sites
+#. Splices and tails the mRNA
+#. Finds the start codon
+#. Translates the mRNA
+
+.. image:: /Images/GeneExplorer.png
+ :alt: Image of the Gene Explorer
+
+For more information about the Gene Explorer, see `The Gene Explorer <http://intro.bio.umb.edu/GX/>`_.
+
+=====================
+Gene Explorer Code
+=====================
+
+::
+
+ <problem>
+ <p>Make a single base pair substitution mutation in the gene below that results in a protein that is longer than the protein produced by the original gene. When you are satisfied with your change and its effect, click the <b>SUBMIT</b> button.</p>
+ <p>Note that a "single base pair substitution mutation" is when a single base is changed to another base; for example, changing the A at position 80 to a T. Deletions and insertions are not allowed.</p>
+ <script type="loncapa/python">
+ def genex_grader(expect,ans):
+ if ans=="CORRECT": return True
+ import json
+ ans=json.loads(ans)
+ return ans["genex_answer"]=="CORRECT"
+ </script>
+ <customresponse cfn="genex_grader">
+ <editageneinput width="818" height="1000" dna_sequence="TAAGGCTATAACCGAGATTGATGCCTTGTGCGATAAGGTGTGTCCCCCCCCAAAGTGTCGGATGTCGAGTGCGCGTGCAAAAAAAAACAAAGGCGAGGACCTTAAGAAGGTGTGAGGGGGCGCTCGAT" genex_dna_sequence="TAAGGCTATAACCGAGATTGATGCCTTGTGCGATAAGGTGTGTCCCCCCCCAAAGTGTCGGATGTCGAGTGCGCGTGCAAAAAAAAACAAAGGCGAGGACCTTAAGAAGGTGTGAGGGGGCGCTCGAT" genex_problem_number="2"/>
+ </customresponse>
+ </problem>
+
+In this code:
+
+* **width** and **height** specify the dimensions of the application, in pixels.
+* **genex_dna_sequence** is the default DNA sequence that appears when the problem opens.
+* **dna_sequence** contains the application's state and the student's answer. This value must be the same as **genex_dna_sequence**.
+* **genex_problem_number** specifies the number of the problem. This number is based on the five gene editor problems in the MITx 7.00x course--for example, if you want this problem to look like the second gene editor problem in the 7.00x course, you would set the **genex_problem_number** value to 2. The number must be 1, 2, 3, 4, or 5.
+
.. _Interactive Periodic Table:
@@ -494,6 +577,68 @@ Create a Poll
* A .csv file that contains student responses to the problem is not currently available for polls. However, you can obtain the aggregate data directly in the problem.
+==================
+Format description
+==================
+
+The main tag of Poll module input is:
+
+.. code-block:: xml
+
+ <poll_question> ... </poll_question>
+
+``poll_question`` can include any number of the following tags:
+any xml and ``answer`` tag. All inner xml, except for ``answer`` tags, we call "question".
+
+poll_question tag
+-----------------
+
+Xmodule for creating poll functionality - voting system. The following attributes can
+be specified for this tag::
+
+ name - Name of xmodule.
+ [display_name| AUTOGENERATE] - Display name of xmodule. When this attribute is not defined - display name autogenerate with some hash.
+ [reset | False] - Can reset/revote many time (value = True/False)
+
+
+answer tag
+----------
+
+Define one of the possible answer for poll module. The following attributes can
+be specified for this tag::
+
+ id - unique identifier (using to identify the different answers)
+
+Inner text - Display text for answer choice.
+
+Example
+=======
+
+Examples of poll
+----------------
+
+.. code-block:: xml
+
+ <poll_question name="second_question" display_name="Second question">
+ <h3>Age</h3>
+ <p>How old are you?</p>
+ <answer id="less18">< 18</answer>
+ <answer id="10_25">from 10 to 25</answer>
+ <answer id="more25">> 25</answer>
+ </poll_question>
+
+Examples of poll with unable reset functionality
+------------------------------------------------
+
+.. code-block:: xml
+
+ <poll_question name="first_question_with_reset" display_name="First question with reset"
+ reset="True">
+ <h3>Your gender</h3>
+ <p>You are man or woman?</p>
+ <answer id="man">Man</answer>
+ <answer id="woman">Woman</answer>
+ </poll_question>
.. _Protein Builder:
diff --git a/docs/en_us/course_authors/source/advanced_problems.rst b/docs/en_us/course_authors/source/advanced_problems.rst
index 8c5d76c..d0c67ad 100644
--- a/docs/en_us/course_authors/source/advanced_problems.rst
+++ b/docs/en_us/course_authors/source/advanced_problems.rst
@@ -9,7 +9,6 @@ Advanced tab when you create a new Problem component. Studio provides
templates for these problems, but the problems open directly in the
**Advanced Editor** and have to be created in XML.
-- :ref:`Chemical Equation` In chemical equation problems, students enter text that represents a chemical equation into a text box.
- :ref:`Circuit Schematic Builder` In circuit schematic problems, students
create and modify circuits on an interactive grid and submit
computer-generated analyses of the circuits for grading.
@@ -33,104 +32,6 @@ These problems are easy to access in Studio. To create them, click
**Problem** under **Add New Component**, click the **Advanced** tab, and
then click the name of the problem that you want to create.
-To add a label for an advanced problem, you'll add a **label** attribute to one of the XML tags for the problem. For more information, see :ref:`Appendix E`.
-
-.. _Chemical Equation Input:
-
-Chemical Equation
------------------
-
-In chemical equation problems, students enter text that represents a chemical equation into a text box. The LMS converts that text into a chemical equation below the text box.
-
-**Sample Problem**
-
-.. image:: /Images/ChemicalEquationExample.png
- :alt: Image of a chemical equation problem
-
-**Required Tags**
-
-.. list-table::
- :widths: 20 80
-
- * - ``<customresponse>``
- - Indicates that this problem has a custom response. The ``<customresponse>`` tags must surround the ``<chemicalequation>`` tags.
- * - ``<chemicalequationinput>``
- - A child of ``<customresponse>``. Indicates that the answer to this problem is a chemical equation. Must contain the ``size`` and ``label`` attributes.
- * - ``<answer type=loncapa/python>``
- - A child of ``<chemicalequationinput>``. Contains the Python script that grades the problem.
-
-Chemical equation problems use MathJax to create formulas. For more information about using MathJax in Studio, see :ref:`MathJax in Studio`.
-
-**Sample Problem XML**:
-
-.. code-block:: xml
-
- <problem>
- <startouttext/>
- <p>Some problems may ask for a particular chemical equation. Practice by writing out the following reaction in the box below.</p>
-
- \( \text{H}_2\text{SO}_4 \longrightarrow \text { H}^+ + \text{ HSO}_4^-\)
-
- <customresponse>
- <chemicalequationinput size="50" label="Practice by writing out the following reaction in the box below."/>
- <answer type="loncapa/python">
-
- if chemcalc.chemical_equations_equal(submission[0], 'H2SO4 -> H^+ + HSO4^-'):
- correct = ['correct']
- else:
- correct = ['incorrect']
-
- </answer>
- </customresponse>
- <p>Some tips:</p>
- <ul>
- <li>Use real element symbols.</li>
- <li>Create subscripts by using plain text.</li>
- <li>Create superscripts by using a caret (^).</li>
- <li>Create the reaction arrow (\(\longrightarrow\)) by using "->".</li>
- </ul>
-
- <endouttext/>
-
- <solution>
- <div class="detailed-solution">
- <p>Solution</p>
- <p>To create this equation, enter the following:</p>
- <p>H2SO4 -> H^+ + HSO4^-</p>
- </div>
- </solution>
- </problem>
-
-**Problem Template**:
-
-.. code-block:: xml
-
- <problem>
- <startouttext/>
- <p>Problem text</p>
-
- <customresponse>
- <chemicalequationinput size="50" label="label text"/>
- <answer type="loncapa/python">
-
- if chemcalc.chemical_equations_equal(submission[0], 'TEXT REPRESENTING CHEMICAL EQUATION'):
- correct = ['correct']
- else:
- correct = ['incorrect']
-
- </answer>
- </customresponse>
-
- <endouttext/>
-
- <solution>
- <div class="detailed-solution">
- <p>Solution or Explanation Header</p>
- <p>Solution or explanation text</p>
- </div>
- </solution>
- </problem>
-
.. _Circuit Schematic Builder:
@@ -155,31 +56,32 @@ Create a Circuit Schematic Builder Problem
#. In the component editor, replace the example code with your own code.
#. Click **Save**.
-**Problem Code**:
+**Problem Code**
-.. code-block:: xml
+To create the problem in the picture, paste the following code into the Advanced Editor.
+.. code-block:: xml
- <problem>
- <p>Make a voltage divider that splits the provided voltage evenly.</p>
- <schematicresponse>
- <center>
- <schematic height="500" width="600" parts="g,r" analyses="dc"
- initial_value="[["v",[168,144,0],{"value":"dc(1)","_json_":0},["1","0"]],["r",[296,120,0],{"r":"1","_json_":1},["1","output"]],["L",[296,168,3],{"label":"output","_json_":2},["output"]],["w",[296,216,168,216]],["w",[168,216,168,192]],["w",[168,144,168,120]],["w",[168,120,296,120]],["g",[168,216,0],{"_json_":7},["0"]],["view",-67.49999999999994,-78.49999999999994,1.6000000000000003,"50","10","1G",null,"100","1","1000"]]"
- />
- </center>
- <answer type="loncapa/python">
- dc_value = "dc analysis not found"
- for response in submission[0]:
- if response[0] == 'dc':
- for node in response[1:]:
- dc_value = node['output']
- if dc_value == .5:
- correct = ['correct']
- else:
- correct = ['incorrect']
- </answer>
- </schematicresponse>
+ <problem>
+ <p>Make a voltage divider that splits the provided voltage evenly.</p>
+ <schematicresponse>
+ <center>
+ <schematic height="500" width="600" parts="g,r" analyses="dc"
+ initial_value="[["v",[168,144,0],{"value":"dc(1)","_json_":0},["1","0"]],["r",[296,120,0],{"r":"1","_json_":1},["1","output"]],["L",[296,168,3],{"label":"output","_json_":2},["output"]],["w",[296,216,168,216]],["w",[168,216,168,192]],["w",[168,144,168,120]],["w",[168,120,296,120]],["g",[168,216,0],{"_json_":7},["0"]],["view",-67.49999999999994,-78.49999999999994,1.6000000000000003,"50","10","1G",null,"100","1","1000"]]"
+ />
+ </center>
+ <answer type="loncapa/python">
+ dc_value = "dc analysis not found"
+ for response in submission[0]:
+ if response[0] == 'dc':
+ for node in response[1:]:
+ dc_value = node['output']
+ if dc_value == .5:
+ correct = ['correct']
+ else:
+ correct = ['incorrect']
+ </answer>
+ </schematicresponse>
<schematicresponse>
<p>Make a high pass filter.</p>
<center>
@@ -211,15 +113,15 @@ Create a Circuit Schematic Builder Problem
<p><img src="/c4x/edX/edX101/asset/images_high_pass_filter.png"/></p>
</div>
</solution>
- </problem>
+ </problem>
.. _Custom JavaScript Display and Grading:
Custom JavaScript Display and Grading
-------------------------------------
-Custom JavaScript display and grading problems (also called custom JavaScript problems
-or JS Input problems) allow you to create a custom problem or tool that uses JavaScript
+Custom JavaScript display and grading problems (also called *custom JavaScript problems*
+or *JS Input problems*) allow you to create a custom problem or tool that uses JavaScript
and then add the problem or tool directly into Studio. When you create a JS Input problem,
Studio embeds the problem in an inline frame (IFrame) so that your students can interact with
it in the LMS. You can grade your students’ work using JavaScript and some basic Python, and
@@ -269,25 +171,12 @@ To re-create the example problem above, you'll need the following files.
- webGLDemo.css
- three.min.js
-You'll create the first three files using the code in :ref:`Appendix F`. The three.min.js file is a library
-file that you'll download.
+To download these files in a .zip archive, go to http://files.edx.org/JSInput.zip.
-#. Go to :ref:`Appendix F` and use the code samples to create the following files.
+..note:: If you need to bypass the SOP, you'll also need the **jschannel.js** file, and your webGLDemo.html file will be slightly different. To download all these files in a .zip archive, go to http://files.edx.org/JSInput_BypassSOP.zip.
- - webGLDemo.html
- - webGLDemo.js
- - webGLDemo.css
-
-#. Download the **three.min.js** file. To do this, go to the `three.js home page <http://threejs.org>`_,
- and then click **Download** in
- the left pane. After the .zip file has finished downloading, open the .zip file, and then
- open the **build** folder to access the three.min.js file.
-
- **Note** If you need to bypass the SOP, you'll also need the **jschannel.js** file. To do
- this, go to the `jschannel.js <https://github.com/mozilla/jschannel/blob/master/src/jschannel.js>`_
- page, copy the code for the file into a text editor, and then save the file as jschannel.js.
-
-#. On the **Files & Uploads** page, upload all the files you just created or downloaded.
+#. Download and unpackage the files in either the JSInput.zip file or the JSInput_BypassSOP.zip file.
+#. On the **Files & Uploads** page, upload all the files from the .zip file.
#. Create a new custom JavaScript display and grading problem component.
#. On the **Settings** tab, set **Maximum Attempts** to a number larger than
zero.
@@ -295,9 +184,9 @@ file that you'll download.
#. Click **Save.**
JavaScript Input Problem Code
-#############################
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-::
+.. code-block:: xml
<problem display_name="webGLDemo">
In the image below, click the cone.
@@ -336,21 +225,19 @@ JavaScript Input Problem Code
.. note:: When you create this problem, keep the following in mind.
- - The webGLDemo.js file defines the three JavaScript functions (**WebGLDemo.getGrade**, **WebGLDemo.getState**, and **WebGLDemo.setState**).
-
- - The JavaScript input problem code uses **WebGLDemo.getGrade**, **WebGLDemo.getState**, and **WebGLDemo.setState** to grade, save, or restore a problem. These functions must be global in scope.
-
- - **WebGLDemo.getState** and **WebGLDemo.setState** are optional. You only have to define these functions if you want to conserve the state of the problem.
+ - The webGLDemo.js file defines the three JavaScript functions (**WebGLDemo.getGrade**, **WebGLDemo.getState**, and **WebGLDemo.setState**).
- - **Width** and **height** represent the dimensions of the IFrame that holds the application.
+ - The JavaScript input problem code uses **WebGLDemo.getGrade**, **WebGLDemo.getState**, and **WebGLDemo.setState** to grade, save, or restore a problem. These functions must be global in scope.
- - When the problem opens, the cone and the cube are both blue, or "unselected." When you click either shape once, the shape becomes yellow, or "selected." To unselect the shape, click it again. Continue clicking the shape to select and unselect it.
+ - **WebGLDemo.getState** and **WebGLDemo.setState** are optional. You only have to define these functions if you want to conserve the state of the problem.
- - The response is graded as correct if the cone is selected (yellow) when the user clicks **Check**.
+ - **Width** and **height** represent the dimensions of the IFrame that holds the application.
- - Clicking **Check** or **Save** registers the problem's current state.
+ - When the problem opens, the cone and the cube are both blue, or "unselected." When you click either shape once, the shape becomes yellow, or "selected." To unselect the shape, click it again. Continue clicking the shape to select and unselect it.
+ - The response is graded as correct if the cone is selected (yellow) when the user clicks **Check**.
+ - Clicking **Check** or **Save** registers the problem's current state.
.. _Custom Python Evaluated Input:
@@ -358,27 +245,190 @@ Custom Python-Evaluated Input ("Write-Your-Own-Grader")
-------------------------------------------------------
-In custom Python-evaluated input (also called "write-your-own-grader problems" problems), the grader evaluates a student's response using a Python script that you create and embed in the problem. These problems can be any type. Numerical input and text input problems are the most popular write-your-own-grader problems.
+In custom Python-evaluated input (also called "write-your-own-grader problems" problems), the grader uses a Python script that you create and embed in the problem to evaluates a student's response or provide hints. These problems can be any type. Numerical input and text input problems are the most popular write-your-own-grader problems.
.. image:: Images/CustomPythonExample.png
:alt: Image of a write your own grader problem
-Create a Write-Your-Own-Grader Problem
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Custom Python-evaluated input problems can include the following:
+
+* :ref:`Chemical Equation`
+* :ref:`Custom JavaScript Display and Grading`
+* :ref:`Custom Python Evaluated Input`
+* :ref:`Gene Explorer`
+* :ref:`Molecule Editor`
+* :ref:`Protein Builder`
+
+.. list-table::
+ :widths: 20 80
+
+ * - ``<script type="loncapa/python">``
+ - Indicates that the problem contains a Python script.
+ * - ``<customresponse cfn="test_add_to_ten">``
+ -
+ * - ``<customresponse cfn="test_add" expect="20">``
+ -
+ * - <textline size="10" correct_answer="3"/>
+ - This tag includes the ``size``, ``correct_answer``, and ``label`` attributes. The ``correct_answer`` attribute is optional.
+
+You can create one of these problems in :ref:`Answer Tag Format` or :ref:`Script Tag Format`.
+
+.. _Answer Tag Format:
+
+Answer Tag Format
+~~~~~~~~~~~~~~~~~
+
+The answer tag format encloses the Python script in an ``<answer>`` tag:
+
+.. code-block:: xml
+
+ <answer>
+ if answers[0] == expect:
+ correct[0] = 'correct'
+ overall_message = 'Good job!'
+ else:
+ correct[0] = 'incorrect'
+ messages[0] = 'This answer is incorrect'
+ overall_message = 'Please try again'
+ </answer>
+
+.. important:: Python honors indentation. Within the ``<answer>`` tag, you must begin your script with no indentation.
-To create a write-your-own-grader problem:
+The Python script interacts with these variables in the global context:
+
+* ``answers``: An ordered list of answers the student provided. For example, if the student answered ``6``, ``answers[0]`` would equal ``6``.
+* ``expect``: The value of the ``expect`` attribute of ``<customresponse>`` (if provided).
+* ``correct``: An ordered list of strings indicating whether the student answered the question correctly. Valid values are ``"correct"``, ``"incorrect"``, and ``"unknown"``. You can set these values in the script.
+* ``messages``: An ordered list of messages that appear under each response field in the problem. You can use this to provide hints to users. For example, if you include ``messages[0] = "The capital of California is Sacramento"``, that message appears under the first response field in the problem.
+* ``overall_message``: A message that appears beneath the entire problem. You can use this to provide a hint that applies to the entire problem rather than a particular response field.
+
+Create a Custom Python-Evaluated Input Problem in Answer Tag Format
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To create a custom Python-evaluated input problem using an ``<answer>`` tag:
#. In the unit where you want to create the problem, click **Problem**
under **Add New Component**, and then click the **Advanced** tab.
#. Click **Custom Python-Evaluated Input**.
#. In the component that appears, click **Edit**.
-#. In the component editor, replace the example code with your own code.
+#. In the component editor, replace the example code with the following code.
#. Click **Save**.
-For more information about write-your-own-grader problems, see `CustomResponse XML and Python
-Script <https://edx.readthedocs.org/en/latest/course_data_formats/custom_response.html>`_.
+.. code-block:: xml
+
+ <problem>
+ <p>What is the sum of 2 and 3?</p>
+
+ <customresponse expect="5">
+ <textline math="1" />
+ </customresponse>
+
+ <answer>
+ if answers[0] == expect:
+ correct[0] = 'correct'
+ overall_message = 'Good job!'
+ else:
+ correct[0] = 'incorrect'
+ messages[0] = 'This answer is incorrect'
+ overall_message = 'Please try again'
+ </answer>
+ </problem>
+
+.. important:: Python honors indentation. Within the ``<answer>`` tag, you must begin your script with no indentation.
+
+.. _Script Tag Format:
+
+Script Tag Format
+~~~~~~~~~~~~~~~~~
-**Sample Problem XML**:
+The script tag format encloses a Python script that contains a "check function" in a ``<script>`` tag, and adds the ``cfn`` attribute of the ``<customresponse>`` tag to reference that function:
+
+.. code-block:: xml
+
+ <problem>
+
+ <script type="loncapa/python">
+
+ def test_add(expect, ans):
+ try:
+ a1=int(ans[0])
+ a2=int(ans[1])
+ return (a1+a2) == int(expect)
+ except ValueError:
+ return False
+
+ def test_add_to_ten(expect, ans):
+ return test_add(10, ans)
+
+ </script>
+
+ <p>Enter two integers that sum to 10. </p>
+ <customresponse cfn="test_add_to_ten">
+ <textline size="10"/><br/>
+ <textline size="10/>
+ </customresponse>
+
+ </problem>
+
+**Important**: Python honors indentation. Within the ``<script>`` tag, the ``def check_func(expect, ans):`` line must have no indentation.
+
+The **check** function accepts two arguments:
+
+* ``expect`` is the value of the ``expect`` attribute of ``<customresponse>`` (if provided)
+* ``answer`` is either:
+
+ * The value of the answer the student provided, if the problem only has one response field.
+ * An ordered list of answers the student provided, if the problem has multiple response fields.
+
+The **check** function can return any of the following to indicate whether the student's answer is correct:
+
+* ``True``: Indicates that the student answered correctly for all response fields.
+* ``False``: Indicates that the student answered incorrectly. All response fields are marked as incorrect.
+* A dictionary of the form: ``{ 'ok': True, 'msg': 'Message' }``
+ If the dictionary's value for ``ok`` is set to ``True``, all response fields are marked correct; if it is set to ``False``, all response fields are marked incorrect. The ``msg`` is displayed beneath all response fields, and it may contain XHTML markup.
+* A dictionary of the form
+
+.. code-block:: xml
+
+
+ { 'overall_message': 'Overall message',
+ 'input_list': [
+ { 'ok': True, 'msg': 'Feedback for input 1'},
+ { 'ok': False, 'msg': 'Feedback for input 2'},
+ ... ] }
+
+The last form is useful for responses that contain multiple response fields. It allows you to provide feedback for each response field individually, as well as a message that applies to the entire response.
+
+Example of a checking function:
+
+.. code-block:: python
+
+ def check_func(expect, answer_given):
+ check1 = (int(answer_given[0]) == 1)
+ check2 = (int(answer_given[1]) == 2)
+ check3 = (int(answer_given[2]) == 3)
+ return {'overall_message': 'Overall message',
+ 'input_list': [
+ { 'ok': check1, 'msg': 'Feedback 1'},
+ { 'ok': check2, 'msg': 'Feedback 2'},
+ { 'ok': check3, 'msg': 'Feedback 3'} ] }
+
+The function checks that the user entered ``1`` for the first input, ``2`` for the second input, and ``3`` for the third input. It provides feedback messages for each individual input, as well as a message displayed beneath the entire problem.
+
+
+Create a Custom Python-Evaluated Input Problem in Script Tag Format
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To create a custom Python-evaluated input problem using a ``<script>`` tag:
+
+#. In the unit where you want to create the problem, click **Problem**
+ under **Add New Component**, and then click the **Advanced** tab.
+#. Click **Custom Python-Evaluated Input**.
+#. In the component that appears, click **Edit**.
+#. In the component editor, replace the example code with the following code.
+#. Click **Save**.
+
+**Problem Code**:
.. code-block:: xml
@@ -436,7 +486,6 @@ The following template includes answers that appear when the student clicks **Sh
return (a1+a2)== float(expect)
</script>
-
<p>Problem text</p>
<customresponse cfn="test_add" expect="20">
<textline size="10" correct_answer="11" label="Integer #1"/><br/>
@@ -464,7 +513,6 @@ The following template does not return answers when the student clicks **Show An
return (a1+a2)== float(expect)
</script>
-
<p>Enter two real numbers that sum to 20: </p>
<customresponse cfn="test_add" expect="20">
<textline size="10" label="Integer #1"/><br/>
@@ -479,6 +527,7 @@ The following template does not return answers when the student clicks **Show An
</solution>
</problem>
+
.. _Drag and Drop:
Drag and Drop
@@ -493,18 +542,50 @@ text or objects to a specific location on an image.
Create a Drag and Drop Problem
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-To create a drag and drop problem:
+To create a drag and drop problem, you'll need the following files:
-#. In the unit where you want to create the problem, click **Problem**
- under **Add New Component**, and then click the **Advanced** tab.
+* Allopurinol.gif
+* AllopurinolAnswer.gif
+
+To download both these files in a .zip archive, go to http://files.edx.org/DragAndDropProblemFiles.zip.
+
+To create the molecule editor that appears in the image above, you'll upload the files for this problem, and then paste the code below into a Problem component.
+
+#. Upload the Allopurinol.gif and AllopurinolAnswer.gif files to the **Files & Uploads** page.
+#. In the unit where you want to create the problem, click **Problem** under **Add New Component**, and then click the **Advanced** tab.
#. Click **Drag and Drop**.
#. In the component that appears, click **Edit**.
-#. In the component editor, replace the example code with your own code.
+#. In the component editor, replace the example code with the following code.
#. Click **Save**.
+**Problem Code**:
+
+.. code-block:: xml
+
+ <problem>
+ <p> Allopurinol is a drug used to treat and prevent gout, a very painful form of arthritis. Once only a “rich man’s disease”, gout has become more and more common in recent decades – affecting about 3 million people in the United States alone. Deposits of needle-like crystals of uric acid in connective tissue or joint spaces cause the symptoms of swelling, stiffness and intense pain. Individuals with gout overproduce uric acid because they cannot eliminate it efficiently. Allopurinol treats and prevents gout by stopping the overproduction of uric acid through inhibition of an enzyme required for the synthesis of uric acid. </p>
+ <p> You are shown one of many possible molecules. On the structure of allopurinol below, identify the functional groups that are present by dragging the functional group name listed onto the appropriate target boxes on the structure. If you want to change an answer, you have to drag off the name as well. You may need to scroll through the names of functional groups to see all options. </p>
+ <customresponse>
+ <drag_and_drop_input no_labels="true" one_per_target="true" target_outline="true" img="/static/Allopurinol.gif">
+ <draggable can_reuse="true" label="methyl" id="1"/>
+ <draggable can_reuse="true" label="hydroxyl" id="2"/>
+ <draggable can_reuse="true" label="amino" id="3"/>
+ <draggable can_reuse="true" label="carboxyl" id="4"/>
+ <draggable can_reuse="true" label="aldehyde" id="5"/>
+ <draggable can_reuse="true" label="phosphate" id="6"/>
+ <draggable can_reuse="true" label="sulfhydryl" id="7"/>
+ <draggable can_reuse="true" label="phenyl" id="8"/>
+ <draggable can_reuse="true" label="none" id="none"/>
+ <target id="0" h="53" w="66" y="55.100006103515625" x="131.5"/>
+ <target id="1" h="113" w="55" y="140.10000610351562" x="181.5"/>
+ </drag_and_drop_input>
+ <answer type="loncapa/python"> correct_answer = [ {'draggables': ['2'], 'targets': ['0' ], 'rule':'unordered_equal' }, {'draggables': ['none'], 'targets': ['1' ], 'rule':'unordered_equal' }] if draganddrop.grade(submission[0], correct_answer): correct = ['correct'] else: correct = ['incorrect'] </answer>
+ </customresponse>
+ <solution>
+ <img src="/static/AllopurinolAnswer.gif"/>
+ </solution>
+ </problem>
-For more information about drag and drop problems, see `XML Format of Drag and Drop Input
-<https://edx.readthedocs.org/en/latest/course_data_formats/drag_and_drop/drag_and_drop_input.html>`_.
.. _Image Mapped Input:
@@ -515,7 +596,7 @@ In an image mapped input problem, students click inside a defined area
in an image. You define this area by including coordinates in the body
of the problem.
-.. image:: Images/ImageMappedInputExample.gif
+.. image:: Images/image294.png
:alt: Image of an image mapped input problem
Create an Image Mapped Input Problem
@@ -544,18 +625,7 @@ To create a image mapped input problem:
</imageresponse>
</problem>
-**Problem Template**
-.. code-block:: xml
-
- <problem>
- <startouttext/>
- <p>In the image below, click the triangle.</p>
- <endouttext/>
- <imageresponse>
- <imageinput src="IMAGE FILE PATH" width="NUMBER" height="NUMBER" rectangle="(X-AXIS,Y-AXIS)-(X-AXIS,Y-AXIS)" />
- </imageresponse>
- </problem>
.. _Math Expression Input:
@@ -573,52 +643,7 @@ Unlike numerical input problems, which only allow integers and a few select cons
When you create a math expression input problem in Studio, you'll use `MathJax <http://www.mathjax.org>`_ to change your plain text into "beautiful math." For more information about how to use MathJax in Studio, see :ref:`MathJax in Studio`.
-**Notes for Students**
-When you answer a math expression input problem, follow these guidelines.
-
-* Use standard arithmetic operation symbols.
-* Indicate multiplication explicitly by using an asterisk (*).
-* Use a caret (^) to raise to a power.
-* Use an underscore (_) to indicate a subscript.
-* Use parentheses to specify the order of operations.
-
-The LMS automatically converts the following Greek letter names into the corresponding Greek characters when a student types them in the answer field:
-
-.. list-table::
- :widths: 20 20 20 20
- :header-rows: 0
-
- * - alpha
- - beta
- - gamma
- - delta
- * - epsilon
- - varepsilon
- - zeta
- - eta
- * - theta
- - vartheta
- - iota
- - kappa
- * - lambda
- - mu
- - nu
- - xi
- * - pi
- - rho
- - sigma
- - tau
- * - upsilon
- - phi
- - varphi
- - chi
- * - psi
- - omega
- -
- -
-
-note:: ``epsilon`` is the lunate version, whereas ``varepsilon`` looks like a backward 3.
Create a Math Expression Input Problem
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -632,18 +657,7 @@ To create a math expression input problem:
#. In the component editor, replace the example code with your own code.
#. Click **Save**.
-.. list-table::
- :widths: 20 80
- :header-rows: 1
-
- * - ``<formularesponse>``
- -
- * - ``<formulaequationinput>``
- - This tag includes the ``size`` and ``label`` attributes.
- * - ``<script type="loncapa/python">``
- -
-
-**Sample Problem XML**
+**Problem Code**
.. code-block:: xml
@@ -677,33 +691,52 @@ To create a math expression input problem:
</solution>
</problem>
-**Template XML**
-
-.. code-block:: xml
+**Notes for Students**
- <problem>
- <p>Problem text</p>
- <formularesponse type="ci" samples="VARIABLES@LOWER_BOUNDS:UPPER_BOUNDS#NUMBER_OF_SAMPLES" answer="$VoVi">
- <responseparam type="tolerance" default="0.00001"/>
- <formulaequationinput size="20" label="Enter the equation"/>
- </formularesponse>
+When you answer a math expression input problem, follow these guidelines.
- <script type="loncapa/python">
- VoVi = "(R_1*R_2)/R_3"
- </script>
+* Use standard arithmetic operation symbols.
+* Indicate multiplication explicitly by using an asterisk (*).
+* Use a caret (^) to raise to a power.
+* Use an underscore (_) to indicate a subscript.
+* Use parentheses to specify the order of operations.
- <solution>
- <div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
- </div>
- </solution>
- </problem>
+The LMS automatically converts the following Greek letter names into the corresponding Greek characters when a student types them in the answer field:
+.. list-table::
+ :widths: 20 20 20 20
+ :header-rows: 0
+ * - alpha
+ - beta
+ - gamma
+ - delta
+ * - epsilon
+ - varepsilon
+ - zeta
+ - eta
+ * - theta
+ - vartheta
+ - iota
+ - kappa
+ * - lambda
+ - mu
+ - nu
+ - xi
+ * - pi
+ - rho
+ - sigma
+ - tau
+ * - upsilon
+ - phi
+ - varphi
+ - chi
+ * - psi
+ - omega
+ -
+ -
-For more information, see `Symbolic Response
-<https://edx.readthedocs.org/en/latest/course_data_formats/symbolic_response.html>`_.
+note:: ``epsilon`` is the lunate version, whereas ``varepsilon`` looks like a backward 3.
.. _Problem with Adaptive Hint:
diff --git a/docs/en_us/course_authors/source/appendices/e.rst b/docs/en_us/course_authors/source/appendices/e.rst
index 0fa3bed..1a6fe47 100644
--- a/docs/en_us/course_authors/source/appendices/e.rst
+++ b/docs/en_us/course_authors/source/appendices/e.rst
@@ -1,30 +1,29 @@
.. _Appendix E:
-
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+################################
APPENDIX E: Problem and Tool XML
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+################################
-This appendix provides information about the XML for most problem and tool types in Studio:
+This appendix provides information about the XML tags for most problem and tool types in Studio:
* :ref:`General`
-* :ref:`Choice Response`
-* :ref:`Chemical Equation Input`
-* :ref:`Custom Response`
-* :ref:`Formula Response`
-* :ref:`Image Response`
-* :ref:`Multiple Choice Response`
-* :ref:`Numerical Response`
-* :ref:`Option Response`
-* :ref:`Schematic Response`
-* :ref:`String Response`
-
+* :ref:`Checkbox Problem XML`
+* :ref:`Chemical Equation Problem XML`
+* :ref:`Drag and Drop Problem XML`
+* :ref:`Dropdown Problem XML`
+* :ref:`Image Mapped Input Problem XML`
+* :ref:`JS Input Problem XML`
+* :ref:`Multiple Choice Problem XML`
+* :ref:`Numerical Input Problem XML`
+* :ref:`Math Expression Input Problem XML`
+* :ref:`Text Input Problem XML`
.. _General:
+=======
General
--------
+=======
Most problems have the following tags.
@@ -32,8 +31,7 @@ Most problems have the following tags.
:widths: 20 80
* - ``<problem> </problem>``
- - These must be the first and last tags for any content created in the Advanced
- Editor in a Problem component.
+ - These must be the first and last tags for any content created in the Advanced Editor in a Problem component.
* - ``<startouttext/>``
- The ``<startouttext />`` tag indicates the beginning of a line or block of text.
* - ``<endouttext/>``
@@ -42,70 +40,17 @@ Most problems have the following tags.
- If you want to include more information in the problem, such as a detailed explanation of the problem's answer, you'll enter the text between the two ``<div>`` tags, which are inside the ``<solution>`` tags. (These tags do not have to be on the same line.)
Additionally, all problems must include a **label** attribute. This attribute adds a descriptive label that helps visually impaired students navigate through the problem.
-You'll add a **label** attribute to one of the XML tags for the problem. Each example problem below includes a label.
-
-.. _Choice Response:
-
-Choice Response (Checkbox Problems)
------------------------------------
-
-Although you can create checkbox problems by using the Simple Editor in Studio, you may want to see or change the problem's underlying XML.
-
-**Sample Problem**
-
-.. image:: ../Images/CheckboxExample.gif
- :alt: Image of a checkbox problem
-
-**Tags**
-
-.. list-table::
- :widths: 20 80
-
- * - ``<choiceresponse>``
- - Specifies that the problem lists answer options for students to choose from.
- * - ``<checkboxgroup>``
- - A child of ``<choiceresponse>``. Specifies that the problem is a checkbox problem. Can include a ``direction`` attribute and a ``label`` attribute.
- * - ``<choice>``
- - A child of ``<checkboxgroup>``. Designates an answer option. Each choice must include the ``correct`` attribute, set to ``true`` (for a correct answer) or ``false`` (for an incorrect answer). For checkbox problems, more than one option can be a correct answer.
-
-**Sample Problem XML**
-.. code-block:: xml
-
- <problem>
- <startouttext/>
- <p>Learning about the benefits of preventative healthcare can be particularly
- difficult. Check all of the reasons below why this may be the case.</p>
-
- <choiceresponse>
- <checkboxgroup direction="vertical" label="Check all of the reasons below why this may be the case">
- <choice correct="true"><text>A large amount of time passes between undertaking
- a preventative measure and seeing the result.</text></choice>
- <choice correct="false"><text>Non-immunized people will always fall sick.</text>
- </choice>
- <choice correct="true"><text>If others are immunized, fewer people will fall
- sick regardless of a particular individual's choice to get immunized or not.
- </text></choice>
- <choice correct="true"><text>Trust in healthcare professionals and government
- officials is fragile.</text></choice>
- </checkboxgroup>
+You'll add a **label** attribute to one of the XML tags for the problem. Each example problem below includes a label.
- <solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>People who are not immunized against a disease may still not fall sick from the
- disease. If someone is trying to learn whether or not preventative measures
- against the disease have any impact, he or she may see these people and conclude,
- since they have remained healthy despite not being immunized, that immunizations
- have no effect. Consequently, he or she would tend to believe that immunization
- (or other preventative measures) have fewer benefits than they actually do.</p>
- </div>
- </solution>
- </choiceresponse>
- </problem>
+.. _Checkbox Problem XML:
+=============================
+Checkbox Problem XML
+=============================
-**Template**
+Template
+--------
.. code-block:: xml
@@ -130,73 +75,74 @@ Although you can create checkbox problems by using the Simple Editor in Studio,
</choiceresponse>
</problem>
-.. _Chemical Equation Input:
+Tags
+----
-Chemical Equation Input (Chemical Equation Problems)
-----------------------------------------------------
+* ``<choiceresponse>`` (required): Specifies that the problem contains options for students to choose from.
+* ``<checkboxgroup>`` (required): Specifies that the problem is a checkbox problem.
+* ``<choice>`` (required): Designates an answer option.
-In chemical equation problems, students enter text that represents a chemical equation into a text box. The LMS converts that text into a chemical equation below the text box.
+**Tag:** ``<choiceresponse>``
-**Sample Problem**
+Specifies that the problem contains options for students to choose from.
-.. image:: ../Images/ChemicalEquationExample.png
- :alt: Image of a chemical equation response problem
+ Attributes
-**Required Tags**
+ (none)
-.. list-table::
- :widths: 20 80
+ Children
- * - ``<customresponse>``
- - Indicates that this problem has a custom response. The ``<customresponse>`` tags must surround the ``<chemicalequation>`` tags.
- * - ``<chemicalequationinput>``
- - A child of ``<customresponse>``. Indicates that the answer to this problem is a chemical equation. Must contain the ``size`` and ``label`` attributes.
- * - ``<answer type=loncapa/python>``
- - A child of ``<chemicalequationinput>``. Contains the Python script that grades the problem.
+ * ``<checkboxgroup>``
-Chemical equation problems use MathJax to create formulas. For more information about using MathJax in Studio, see :ref:`MathJax in Studio`.
+**Tag:** ``<checkboxgroup>``
-**Sample Problem XML**:
+Specifies that the problem is a checkbox problem.
-.. code-block:: xml
+ Attributes
- <problem>
- <startouttext/>
- <p>Some problems may ask for a particular chemical equation. Practice by writing out the following reaction in the box below.</p>
-
- \( \text{H}_2\text{SO}_4 \longrightarrow \text { H}^+ + \text{ HSO}_4^-\)
+ .. list-table::
+ :widths: 20 80
- <customresponse>
- <chemicalequationinput size="50" label="Practice by writing out the following reaction in the box below."/>
- <answer type="loncapa/python">
+ * - Attribute
+ - Description
+ * - direction (optional)
+ - Specifies the orientation of the list of answers. The default is vertical.
+ * - label (required)
+ - Specifies the name of the response field.
- if chemcalc.chemical_equations_equal(submission[0], 'H2SO4 -> H^+ + HSO4^-'):
- correct = ['correct']
- else:
- correct = ['incorrect']
+ Children
- </answer>
- </customresponse>
- <p>Some tips:</p>
- <ul>
- <li>Use real element symbols.</li>
- <li>Create subscripts by using plain text.</li>
- <li>Create superscripts by using a caret (^).</li>
- <li>Create the reaction arrow (\(\longrightarrow\)) by using "->".</li>
- </ul>
+ * ``<choice>``
- <endouttext/>
+**Tag:** ``<choice>``
+
+Designates an answer option.
+
+ Attributes
+
+ .. list-table::
+ :widths: 20 80
+
+ * - Attribute
+ - Description
+ * - true (at least one required)
+ - Indicates a correct answer. For checkbox problems, one or more ``<choice>`` tags can contain a correct answer.
+ * - false (at least one required)
+ - Indicates an incorrect answer.
+
+ Children
- <solution>
- <div class="detailed-solution">
- <p>Solution</p>
- <p>To create this equation, enter the following:</p>
- <p>H2SO4 -> H^+ + HSO4^-</p>
- </div>
- </solution>
- </problem>
+ (none)
+
+
+.. _Chemical Equation Problem XML:
-**Problem Template**:
+=============================
+Chemical Equation Problem XML
+=============================
+
+Template
+--------
.. code-block:: xml
@@ -205,7 +151,7 @@ Chemical equation problems use MathJax to create formulas. For more information
<p>Problem text</p>
<customresponse>
- <chemicalequationinput size="50" label="label text"/>
+ <chemicalequationinput size="NUMBER" label="LABEL TEXT"/>
<answer type="loncapa/python">
if chemcalc.chemical_equations_equal(submission[0], 'TEXT REPRESENTING CHEMICAL EQUATION'):
@@ -226,359 +172,440 @@ Chemical equation problems use MathJax to create formulas. For more information
</solution>
</problem>
+Tags
+----
+* ``<customresponse>``: Indicates that this problem has a custom response.
+* ``<chemicalequationinput>``: Specifies that the answer to this problem is a chemical equation.
+* ``<answer type=loncapa/python>``: Contains the Python script that grades the problem.
-.. _Custom Response:
+**Tag:** ``<customresponse>``
-Custom Response ("Custom Python-Evaluated Input") Problems
------------------------------------------------------------
+Indicates that this problem has a custom response. The ``<customresponse>`` tags must surround the ``<chemicalequation>`` tags.
-In custom Python-evaluated input (also called “write-your-own-grader”) problems, the grader evaluates a student’s response using a Python script that you create and embed in the problem.
+ Attributes
-**Sample Problem**
+ (none)
-.. image:: ../Images/CustomPythonExample.png
- :alt: Image of a custom response problem
+ Children
-.. list-table::
- :widths: 20 80
+ * ``<chemicalequationinput>``
+ * ``<answer>``
- * - ``<script type="loncapa/python">``
- - Indicates that the problem contains a Python script.
- * - ``<customresponse cfn="test_add_to_ten">``
- -
- * - ``<customresponse cfn="test_add" expect="20">``
- -
- * - <textline size="10" correct_answer="3"/>
- - This tag includes the ``size``, ``correct_answer``, and ``label`` attributes. The ``correct_answer`` attribute is optional.
+**Tag:** ``<chemicalequationinput>``
-**Sample Problem XML**:
+Indicates that the answer to this problem is a chemical equation and creates a response field where the student enters an answer.
-.. code-block:: xml
+ Attributes
- <problem>
- <p>This question has two parts.</p>
+ .. list-table::
+ :widths: 20 80
- <script type="loncapa/python">
+ * - Attribute
+ - Description
+ * - size
+ - Specifies the size of the response field, in characters.
+ * - label (required)
+ - Contains the text of the principal question in the problem.
- def test_add(expect, ans):
- try:
- a1=int(ans[0])
- a2=int(ans[1])
- return (a1+a2) == int(expect)
- except ValueError:
- return False
+ Children
+
+ (none)
- def test_add_to_ten(expect, ans):
- return test_add(10, ans)
+**Tag:** ``<answer>``
- </script>
+Contains the Python script that grades the problem.
- <p>Part 1: Enter two integers that sum to 10. </p>
- <customresponse cfn="test_add_to_ten">
- <textline size="10" correct_answer="3" label="Integer #1"/><br/>
- <textline size="10" correct_answer="7" label="Integer #2"/>
- </customresponse>
+ Attributes
- <p>Part 2: Enter two integers that sum to 20. </p>
- <customresponse cfn="test_add" expect="20">
- <textline size="10" label="Integer #1"/><br/>
- <textline size="10" label="Integer #2"/>
- </customresponse>
+ .. list-table::
+ :widths: 20 80
- <solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>For part 1, any two numbers of the form <i>n</i> and <i>10-n</i>, where <i>n</i> is any integer, will work. One possible answer would be the pair 0 and 10.</p>
- <p>For part 2, any pair <i>x</i> and <i>20-x</i> will work, where <i>x</i> is any real number with a finite decimal representation. Both inputs have to be entered either in standard decimal notation or in scientific exponential notation. One possible answer would be the pair 0.5 and 19.5. Another way to write this would be 5e-1 and 1.95e1.</p>
- </div>
- </solution>
- </problem>
+ * - Attribute
+ - Description
+ * - type (required)
+ - Must be "loncapa/python".
-**Templates**
+ Children
+
+ (none)
+
+
+.. _Drag and Drop Problem XML:
+
+=========================
+Drag and Drop Problem XML
+=========================
-The following template includes answers that appear when the student clicks **Show Answer**.
+Template
+--------
.. code-block:: xml
<problem>
+ <p>Problem text</p>
+ <customresponse>
+ <drag_and_drop_input no_labels="false" one_per_target="true" target_outline="true" img="/static/TARGET_IMAGE.gif">
+ <draggable can_reuse="true" label="NAME 1" id="1"/>
+ <draggable can_reuse="true" label="NAME 2" id="2"/>
+ <target id="0" h="HEIGHT (in pixels)" w="WIDTH (in pixels)" y="Y-COORDINATE" x="X-COORDINATE"/>
+ <target id="1" h="HEIGHT (in pixels)" w="WIDTH (in pixels)" y="Y-COORDINATE" x="X-COORDINATE"/>
+ </drag_and_drop_input>
+ <answer type="loncapa/python"> correct_answer = [ {'draggables': ['2'], 'targets': ['0' ], 'rule':'unordered_equal' }, {'draggables': ['none'], 'targets': ['1' ], 'rule':'unordered_equal' }] if draganddrop.grade(submission[0], correct_answer): correct = ['correct'] else: correct = ['incorrect'] </answer>
+ </customresponse>
+ <solution>
+ <img src="/static/ANSWER_IMAGE.gif"/>
+ </solution>
+ </problem>
- <script type="loncapa/python">
- def test_add(expect,ans):
- a1=float(ans[0])
- a2=float(ans[1])
- return (a1+a2)== float(expect)
- </script>
+Tags
+----
+* ``<drag_and_drop_input/>``: Indicates the problem is a drag and drop problem.
+* ``<draggable/>``: Specifies a single object that a student will drag onto the base image.
+* ``<target>``: Specifies the location on the base image where a draggable must be dropped.
- <p>Problem text</p>
- <customresponse cfn="test_add" expect="20">
- <textline size="10" correct_answer="11" label="Integer #1"/><br/>
- <textline size="10" correct_answer="9" label="Integer #2"/>
- </customresponse>
+**Tag:** ``<drag_and_drop_input/>``
- <solution>
- <div class="detailed-solution">
- <p>Solution or Explanation Heading</p>
- <p>Solution or explanation text</p>
- </div>
- </solution>
- </problem>
+ Attributes
-The following template does not return answers when the student clicks **Show Answer**. If your problem doesn't include answers for the student to see, make sure to set **Show Answer** to **Never** in the problem component.
+ .. list-table::
+ :widths: 20 80
-.. code-block:: xml
+ * - Attribute
+ - Description
+ * - img (required)
+ - Relative path to an image that will be the base image. All draggables can be dragged onto it.
+ * - target_outline
+ - Specifies whether an outline (gray dashed line) should be drawn around targets (if they are specified). It can be either 'true' or 'false'. If not specified, the targets do not have outlines.
+ * - one_per_target
+ - Specify whether to allow more than one draggable to be placed onto a single target. It can be either 'true' or 'false'. If not specified, the default value is 'true'.
+ * - no_labels (required)
+ - default is false, in default behaviour if label is not set, label is obtained from id. If no_labels is true, labels are not automatically populated from id, and one can not set labels and obtain only icons.
- <problem>
+ Children
- <script type="loncapa/python">
- def test_add(expect,ans):
- a1=float(ans[0])
- a2=float(ans[1])
- return (a1+a2)== float(expect)
- </script>
+ * ``<draggable>``
+ * ``<target>``
+**Tag:** ``<draggable/>``
- <p>Enter two real numbers that sum to 20: </p>
- <customresponse cfn="test_add" expect="20">
- <textline size="10" label="Integer #1"/><br/>
- <textline size="10" label="Integer #2"/>
- </customresponse>
+Specifies a single draggable object in a drag and drop problem.
- <solution>
- <div class="detailed-solution">
- <p>Solution or Explanation Heading</p>
- <p>Solution or explanation text</p>
- </div>
- </solution>
- </problem>
+A draggable is what the user must drag out of the slider and drop onto the base image. After a drag operation, if the center of the draggable is located outside the rectangular dimensions of the image, it will be returned to the slider.
-.. _Formula Response:
+For the grader to work, each draggable must have a unique ID.
-Formula Response (Math Expression Input Problems)
--------------------------------------------------
+ Attributes
-**Sample Problem**
+ .. list-table::
+ :widths: 20 80
-.. image:: ../Images/MathExpressionInputExample.gif
- :alt: Image of a math expression input problem
+ * - Attribute
+ - Description
+ * - id (required)
+ - Unique identifier of the draggable object.
+ * - label (optional)
+ - Text label that the user sees.
+ * - icon (optional)
+ - For draggables that are images, the relative path to the image file.
+ * - can_reuse
+ - true or false, default is false. If true, same draggable can be used multiple times.
-.. list-table::
- :widths: 20 80
- :header-rows: 1
+ Children
+
+ (none)
- * - ``<formularesponse>``
- -
- * - ``<formulaequationinput>``
- - This tag includes the ``size`` and ``label`` attributes.
- * - ``<script type="loncapa/python">``
- -
+**Tag:** ``<target>``
-**Sample Problem XML**
+Specifies the location on the base image where a student must drop a draggable item. By design, if the center of a draggable lies within the target (i.e. in the rectangle defined by [[x, y], [x + w, y + h]], it is within the target. Otherwise, it is outside.
-.. code-block:: xml
+If you specify at least one target, and a student drops a draggable item on a location that is outside a target, the draggable item returns to the slider.
- <problem>
- <p>Some problems may ask for a mathematical expression. Practice creating mathematical expressions by answering the questions below.</p>
- <p>Notes:</p>
- <ul>
- <li>Use standard arithmetic operation symbols.</li>
- <li>Indicate multiplication explicitly by using an asterisk (*).</li>
- <li>Use a caret (^) to raise to a power.</li>
- <li>Use an underscore (_) to indicate a subscript.</li>
- <li>Use parentheses to specify the order of operations.</li>
- </ul>
+If you don't specify a target, a student can drop a draggable item anywhere on the base image.
- <p>Write an expression for the product of R_1, R_2, and the inverse of R_3.</p>
- <formularesponse type="ci" samples="R_1,R_2,R_3@1,2,3:3,4,5#10" answer="$VoVi">
- <responseparam type="tolerance" default="0.00001"/>
- <formulaequationinput size="40" label="Enter the equation"/>
- </formularesponse>
+ Attributes
- <script type="loncapa/python">
- VoVi = "(R_1*R_2)/R_3"
- </script>
+ .. list-table::
+ :widths: 20 80
- <p>Let <i>x</i> be a variable, and let <i>n</i> be an arbitrary constant. What is the derivative of <i>x<sup>n</sup></i>?</p>
- <script type="loncapa/python">
- derivative = "n*x^(n-1)"
- </script>
- <formularesponse type="ci" samples="x,n@1,2:3,4#10" answer="$derivative">
- <responseparam type="tolerance" default="0.00001"/>
- <formulaequationinput size="40" label="Enter the equation"/>
- </formularesponse>
+ * - Attribute
+ - Description
+ * - id (required)
+ - Unique identifier of the target object.
+ * - x
+ - X-coordinate on the base image where the top left corner of the target will be positioned.
+ * - y
+ - Y-coordinate on the base image where the top left corner of the target will be positioned.
+ * - w
+ - Width of the target, in pixels.
+ * - h
+ - Height of the target, in pixels.
+ Children
+
+ (none)
+
+
+For more information about how to create drag and drop problems, see `XML Format of Drag and Drop Input
+<https://edx.readthedocs.org/en/latest/course_data_formats/drag_and_drop/drag_and_drop_input.html>`_.
+
+
+.. _Dropdown Problem XML:
+
+==========================
+Dropdown Problem XML
+==========================
+
+Template
+--------
+
+.. code-block:: xml
+
+ <problem>
+ <p>
+ Problem text</p>
+ <optionresponse>
+ <optioninput options="('Option 1','Option 2','Option 3')" correct="Option 2" label="label text"/>
+ </optionresponse>
<solution>
<div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
+ <p>Explanation or Solution Header</p>
+ <p>Explanation or solution text</p>
</div>
</solution>
</problem>
-**Template XML**
-
.. code-block:: xml
<problem>
- <p>Problem text</p>
- <formularesponse type="ci" samples="VARIABLES@LOWER_BOUNDS:UPPER_BOUNDS#NUMBER_OF_SAMPLES" answer="$VoVi">
- <responseparam type="tolerance" default="0.00001"/>
- <formulaequationinput size="20" label="Enter the equation"/>
- </formularesponse>
-
- <script type="loncapa/python">
- VoVi = "(R_1*R_2)/R_3"
- </script>
-
+ <p>Problem text</p>
+ <optionresponse>
+ options="('A','B')"
+ correct="A"/>
+ label="label text"
+ </optionresponse>
+
<solution>
<div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
+ <p>Explanation or Solution Header</p>
+ <p>Explanation or solution text</p>
</div>
</solution>
</problem>
+Tags
+----
-**XML Attribute Information**
+* ``<optionresponse>`` (required): Indicates that the problem is a dropdown problem.
+* ``<optioninput>`` (required): Lists the answer options.
-<script>
+**Tag:** ``<optionresponse>``
+Indicates that the problem is a dropdown problem.
- .. image:: ../Images/formularesponse.png
+ Attributes
+ (none)
-<formularesponse>
+ Children
+ * ``<optioninput>``
- .. image:: ../Images/formularesponse3.png
+**Tag:** ``<optioninput>``
-Children may include ``<formulaequationinput/>``.
+Lists the answer options.
-If you do not need to specify any samples, you should look into the use of the
-Numerical Response input type, as it provides all the capabilities of Formula
-Response without the need to specify any unknown variables.
+ Attributes
-<responseparam>
+ .. list-table::
+ :widths: 20 80
+ * - Attribute
+ - Description
+ * - options (required)
+ - Lists the answer options. The list of all answer options is surrounded by parentheses. Individual answer options are surrounded by single quotation marks (') and separated by commas (,).
+ * - correct (required)
+ - Indicates whether an answer is correct. Possible values are "true" and "false". Only one **correct** attribute can be set to "true".
+ * - label (required)
+ - Specifies the name of the response field.
+
+ Children
- .. image:: ../Images/formularesponse6.png
+ (none)
-<formulaequationinput/>
+.. _Image Mapped Input Problem XML:
-========= ============================================= =====
-Attribute Description Notes
-========= ============================================= =====
-size (optional) defines the size (i.e. the width)
- of the input box displayed to students for
- typing their math expression.
-========= ============================================= =====
+==============================
+Image Mapped Input Problem XML
+==============================
-.. _Image Response:
+Template
+--------
-Image Response (Image Mapped Input Problems)
---------------------------------------------
+.. code-block:: xml
-**Sample Problem**
+ <problem>
+ <startouttext/>
+ <p>In the image below, click the triangle.</p>
+ <endouttext/>
+ <imageresponse>
+ <imageinput src="IMAGE FILE PATH" width="NUMBER" height="NUMBER" rectangle="(X-AXIS,Y-AXIS)-(X-AXIS,Y-AXIS)" />
+ </imageresponse>
+ </problem>
-.. image:: ../Images/image294.png
- :alt: Image of an image mapped input problem
+Tags
+====
-**XML Tags**
+* ``<imageresponse>``: Indicates that the problem is an image mapped input problem.
+* ``<imageinput>``: Specifies the image file and the region in the file that the student must click.
-.. list-table::
- :widths: 20 80
+**Tag:** ``<imageresponse>``
- * - ``<imageresponse>``
- - Indicates that the problem is an image mapped input problem.
- * - ``<imageinput>``
- - Specifies the image file and the region the student must click. This tag includes the ``src``, ``width``, ``height``, and ``rectangle`` attributes.
+Indicates that the problem is an image mapped input problem.
-**Problem Code**:
+ Attributes
-.. code-block:: xml
+ (none)
+
+ Children
+
+ * ``<imageinput>``
+
+**Tag:** ``<imageinput>``
+
+Specifies the image file and the region in the file that the student must click.
+
+ Attributes
+
+ .. list-table::
+ :widths: 20 80
+
+ * - Attribute
+ - Description
+ * - src (required)
+ - The URL of the image
+ * - height (required)
+ - The height of the image, in pixels
+ * - width (required)
+ - The width of the image, in pixels
+ * - rectangle (required)
+ - An attribute with four embedded values in the format (<start_width>,<start_height>)-(<end_width>,<end-height>). All coordinates start with (0,0) in the top left corner and increase in value toward the bottom right corner, very similar to the progression of reading English. The two coordinates defined form the two opposite corners of a box which a student can click inside of.
+
+ Children
+
+ (none)
- <problem>
- <p><b>Example Problem</b></p>
- <startouttext/>
- <p>In the image below, click the triangle.</p>
- <endouttext/>
- <imageresponse>
- <imageinput src="/static/threeshapes.png" width="220" height="150" rectangle="(80,40)-(130,90)" />
- </imageresponse>
- </problem>
-**Problem Template**
+
+.. _JS Input Problem XML:
+
+=============================
+JavaScript Input Problem XML
+=============================
+
+JSInput allows problem authors to turn stand-alone HTML files into problems that can be integrated into the edX platform. Since its aim is flexibility, it can be seen as the input and client-side equivalent of **CustomResponse**.
+
+A JSInput exercise creates an IFrame in a static HTML page, and passes the return value of author-specified functions to the enclosing response type (generally **CustomResponse**). JSInput can also store and retrieve state.
+
+Template
+--------
+
+The following is the basic format of a JSInput problem:
.. code-block:: xml
- <problem>
- <startouttext/>
- <p>In the image below, click the triangle.</p>
- <endouttext/>
- <imageresponse>
- <imageinput src="IMAGE FILE PATH" width="NUMBER" height="NUMBER" rectangle="(X-AXIS,Y-AXIS)-(X-AXIS,Y-AXIS)" />
- </imageresponse>
- </problem>
+ <problem>
+ <script type="loncapa/python">
+ def all_true(exp, ans): return ans == "hi"
+ </script>
+ <customresponse cfn="all_true">
+ <jsinput gradefn="gradefn"
+ height="500"
+ get_statefn="getstate"
+ set_statefn="setstate"
+ html_file="/static/jsinput.html"/>
+ </customresponse>
+ </problem>
-**XML Attribute Information**
+The accepted attributes are:
-<imageresponse>
+============== ============== ========= ==========
+Attribute Name Value Type Required Default
+============== ============== ========= ==========
+html_file URL string Yes None
+gradefn Function name Yes `gradefn`
+set_statefn Function name No None
+get_statefn Function name No None
+height Integer No `500`
+width Integer No `400`
+============== ============== ========= ==========
- .. image:: ../Images/imageresponse1.png
-<imageinput>
+Required Attributes
+-------------------
- .. image:: ../Images/imageresponse2.png
+* **html_file**
-.. _Multiple Choice Response:
+ The **html_file** attribute specifies the HTML file that the IFrame will point to. The HTML file
+ must be located in the content directory.
-Multiple Choice Response (Multiple Choice Problems)
------------------------------------------------------
+ The IFrame is created using the sandbox attribute. Although pop-ups, scripts, and pointer locks are allowed, the IFrame cannot access its parent's attributes.
-Although you can create multiple choice problems by using the Simple Editor in Studio, you may want to see or change the problem's underlying XML.
+ The HTML file must contain a **gradefn** function that the JSInput file can access. To determine whether the **gradefn** function is accessible, in the console, make sure that **gradefn** returns the right thing. When JSInput uses the **gradefn** function, `gradefn` is called with `gradefn`.call(`obj`), where **obj** is the object-part of **gradefn**. For example, if **gradefn** is **myprog.myfn**, JSInput calls **myprog.myfun.call(myprog)**. (This is to ensure "`this`" continues to refer to what `gradefn` expects.)
-**Sample Problem**
+ Aside from that, more or less anything goes. Note that currently there is no support for inheriting CSS or JavaScript from the parent (aside from the Chrome-only **seamless** attribute, which is set to True by default).
-.. image:: ../Images/MultipleChoiceExample.gif
- :alt: Image of a multiple choice problem
+* **gradefn**
-**XML Tags**
+ The **gradefn** attribute specifies the name of the function that will be called when a user clicks **Check**, and that returns the student's answer. Unless both the **get_statefn** and **set_statefn** attributes are also used, this answer is passed as a string to the enclosing response type. In the **customresponse** example above, this means **cfn** will be passed this answer as ``ans``.
-.. list-table::
- :widths: 20 80
+ If the **gradefn** function throws an exception when a student attempts to submit a problem, the submission is aborted, and the student receives a generic alert. The alert can be customised by making the exception name ``Waitfor Exception``; in that case, the alert message will be the exception message.
- * - ``<multiplechoiceresponse>``
- - Indicates that the problem is a multiple choice problem.
- * - ``<choicegroup type="MultipleChoice">``
- - Indicates the beginning of the list of options. Contains the ``label`` attribute.
- * - ``<choice>``
- - Lists an option. This tag includes the ``correct`` and ``name`` attributes.
+ .. important:: To make sure the student's latest answer is passed correctly, make sure that the **gradefn** function is not asynchronous. Additionally, make sure that the function returns promptly. Currently the student has no indication that her answer is being calculated or produced.
-**Problem Code:**
+Optional Attributes
+-------------------
-.. code-block:: xml
+* **set_statefn**
- <problem>
- <p>Lateral inhibition, as was first discovered in the horsehoe crab...</p>
- <multiplechoiceresponse>
- <choicegroup type="MultipleChoice" label="Lateral inhibition, as was first discovered in the horsehoe crab">
- <choice correct="false">is a property of touch sensation, referring to the ability of crabs to detect nearby predators.</choice>
- <choice correct="false">is a property of hearing, referring to the ability of crabs to detect low frequency noises.</choice>
- <choice correct="false">is a property of vision, referring to the ability of crabs eyes to enhance contrasts.</choice>
- <choice correct="true">has to do with the ability of crabs to use sonar to detect fellow horseshoe crabs nearby.</choice>
- <choice correct="false">has to do with a weighting system in the crabs skeleton that allows it to balance in turbulent water.</choice>
- </choicegroup>
- </multiplechoiceresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>Horseshoe crabs were essential to the discovery of lateral inhibition, a property of vision present in horseshoe crabs as well as humans, that enables enhancement of contrast at edges of objects as was demonstrated in class. In 1967, Haldan Hartline received the Nobel prize for his research on vision and in particular his research investigating lateral inhibition using horseshoe crabs.</p>
- </div>
- </solution>
- </problem>
+ Sometimes a problem author will want information about a student's previous answers ("state") to be saved and reloaded. If the attribute **set_statefn** is used, the function given as its value will be passed the state as a string argument whenever there is a state, and the student returns to a problem. The function has the responsibility to then use this state approriately.
+
+ The state that is passed is:
+
+ * The previous output of **gradefn** (i.e., the previous answer) if **get_statefn** is not defined.
+ * The previous output of **get_statefn** (see below) otherwise.
+
+ It is the responsibility of the iframe to do proper verification of the argument that it receives via **set_statefn**.
+
+* **get_statefn**
+
+ Sometimes the state and the answer are quite different. For instance, a problem that involves using a javascript program that allows the student to alter a molecule may grade based on the molecule's hydrophobicity, but from the hydrophobicity it might be incapable of restoring the state. In that case, a
+ *separate* state may be stored and loaded by **set_statefn**. Note that if **get_statefn** is defined, the answer (i.e., what is passed to the enclosing response type) will be a json string with the following format:
+
+ .. code-block:: xml
+
+ {
+ answer: `[answer string]`
+ state: `[state string]`
+ }
-**Template**
+ The enclosing response type must then parse this as json.
+
+* **height** and **width**
+
+ The **height** and **width** attributes are straightforward: they specify the height and width of the IFrame. Both are limited by the enclosing DOM elements, so for instance there is an implicit max-width of around 900.
+
+ In the future, JSInput may attempt to make these dimensions match the HTML file's dimensions (up to the aforementioned limits), but currently it defaults to `500` and `400` for **height** and **width**, respectively.
+
+.. _Multiple Choice Problem XML:
+
+=============================
+Multiple Choice Problem XML
+=============================
+
+Template
+--------
.. code-block:: xml
@@ -599,156 +626,139 @@ Although you can create multiple choice problems by using the Simple Editor in S
</solution>
</problem>
+Tags
+----
-**XML Attribute Information**
+* ``<multiplechoiceresponse>`` (required): Indicates that the problem is a multiple choice problem.
+* ``<choicegroup>`` (required): Indicates the beginning of the list of options.
+* ``<choice>`` (required): Lists an answer option.
+**Tag:** ``<multiplechoiceresponse>``
-<multiplechoiceresponse>
+Indicates that the problem is a multiple choice problem.
-.. image:: ../Images/multipleresponse.png
+ Attributes
+ (none)
-<choicegroup>
+ Children
- .. image:: ../Images/multipleresponse2.png
+ * ``<choicegroup>``
+ * All standard HTML tags (can be used to format text)
+**Tag:** ``<choicegroup>``
-<choice>
+Indicates the beginning of the list of options.
- .. image:: ../Images/multipleresponse3.png
+ Attributes
-.. _Numerical Response:
+ .. list-table::
+ :widths: 20 80
-Numerical Response (Numerical Input Problems)
----------------------------------------------
+ * - Attribute
+ - Description
+ * - label (required)
+ - Specifies the name of the response field.
+ * - type (required)
+ - Must be set to "MultipleChoice".
-The Numerical Response input type accepts a line of text input from the student
-and evaluates the input for correctness based on its numerical value. The input
-is allowed to be a number or a mathematical expression in a fixed syntax.
+ Children
-The answer is correct if it is within a specified numerical tolerance of the
-expected answer.
+ * ``<choice>``
-The expected answer can be specified explicitly or precomputed by a Python
-script.
+**Tag:** ``<choice>``
-Accepted input types include ``<formulaequationinput />`` and ``<textline />``.
-However, the math display on ``<textline math="1" />`` uses a different parser
-and has different capabilities than the response type--this may lead to student
-confusion. For this reason, we strongly urge using ``<formulaequationinput />``
-only, and the examples below show its use.
+Lists an answer option.
-Sample Problem:
+ Attributes
-.. image:: ../Images/image292.png
- :width: 600
- :alt: Image of a numerical response problem
+ .. list-table::
+ :widths: 20 80
+ * - Attribute
+ - Description
+ * - correct (at least one required)
+ - Indicates a correct or incorrect answer. When the attribute is set to "true", the choice is a correct answer. When the attribute is set to "false", the choice is an incorrect answer. Only one choice can be a correct answer.
+ * - name
+ - A unique name that the back end uses to refer to the choice.
-**Problem Code**:
+ Children
+
+ (none)
-.. code-block:: xml
+.. _Numerical Input Problem XML:
-<problem>
- <p><b>Example Problem</b></p>
+===========================
+Numerical Input Problem XML
+===========================
-<p>What base is the decimal numeral system in?
- <numericalresponse answer="10">
- <formulaequationinput label="What base is the decimal numeral system in?"/>
- </numericalresponse>
-</p>
-
- <p>What is the value of the standard gravity constant <i>g</i>, measured in m/s<sup>2</sup>? Give your answer to at least two decimal places.
- <numericalresponse answer="9.80665">
- <responseparam type="tolerance" default="0.01" />
- <formulaequationinput label="Give your answer to at least two decimal places"/>
- </numericalresponse>
-</p>
-
-<!-- Use python script spacing. The following should not be indented! -->
-<script type="loncapa/python">
-computed_response = math.sqrt(math.fsum([math.pow(math.pi,2), math.pow(math.e,2)]))
-</script>
-
-<p>What is the distance in the plane between the points (pi, 0) and (0, e)? You can type math.
- <numericalresponse answer="$computed_response">
- <responseparam type="tolerance" default="0.0001" />
- <formulaequationinput label="What is the distance in the plane between the points (pi, 0) and (0, e)?"/>
- </numericalresponse>
-</p>
-<solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>The decimal numerical system is base ten.</p>
- <p>The standard gravity constant is defined to be precisely 9.80665 m/s<sup>2</sup>.
- This is 9.80 to two decimal places. Entering 9.8 also works.</p>
- <p>By the distance formula, the distance between two points in the plane is
- the square root of the sum of the squares of the differences of each coordinate.
- Even though an exact numerical value is checked in this case, the
- easiest way to enter this answer is to type
- <code>sqrt(pi^2+e^2)</code> into the editor.
- Other answers like <code>sqrt((pi-0)^2+(0-e)^2)</code> also work.
- </p>
- </div>
-</solution>
-</problem>
-
-**Templates**
-
-Exact values
+Templates
+---------
-.. code-block:: xml
+The following templates represent problems with and without a decimal or percentage tolerance.
- <problem>
+Problem with no tolerance
+~~~~~~~~~~~~~~~~~~~~~~~~~
- <numericalresponse answer="10">
- <formulaequationinput label="label text"/>
- </numericalresponse>
+.. code-block:: xml
+ <p>TEXT OF PROBLEM
+ <numericalresponse answer="ANSWER (NUMBER)">
+ <formulaequationinput label="TEXT OF PROBLEM"/>
+ </numericalresponse>
+ </p>
+
<solution>
<div class="detailed-solution">
-
+ <p>TEXT OF SOLUTION</p>
</div>
</solution>
</problem>
-Answers with decimal precision
+Problem with a decimal tolerance
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. code-block:: xml
<problem>
-
- <numericalresponse answer="9.80665">
- <responseparam type="tolerance" default="0.01" />
- <formulaequationinput label="label text"/>
+
+ <p>TEXT OF PROBLEM
+ <numericalresponse answer="ANSWER (NUMBER)">
+ <responseparam type="tolerance" default="NUMBER (DECIMAL, e.g., .02)" />
+ <formulaequationinput label="TEXT OF PROBLEM"/>
</numericalresponse>
-
+ </p>
+
<solution>
<div class="detailed-solution">
-
+ <p>TEXT OF SOLUTION</p>
</div>
</solution>
</problem>
-Answers with percentage precision
+Problem with a percentage tolerance
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. code-block:: xml
<problem>
-
- <numericalresponse answer="100">
- <responseparam type="tolerance" default="10%" />
- <formulaequationinput label="label text"/>
+
+ <p>TEXT OF PROBLEM
+ <numericalresponse answer="ANSWER (NUMBER)">
+ <responseparam type="tolerance" default="NUMBER (PERCENTAGE, e.g., 3%)" />
+ <formulaequationinput label="TEXT OF PROBLEM"/>
</numericalresponse>
+ </p>
<solution>
<div class="detailed-solution">
-
+ <p>TEXT OF SOLUTION</p>
</div>
</solution>
</problem>
-Answers with scripts
+Answer created with a script
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. code-block:: xml
@@ -759,403 +769,231 @@ Answers with scripts
computed_response = math.sqrt(math.fsum([math.pow(math.pi,2), math.pow(math.e,2)]))
</script>
- <numericalresponse answer="$computed_response">
- <responseparam type="tolerance" default="0.0001" />
- <formulaequationinput label="label text"/>
- </numericalresponse>
+ <p>TEXT OF PROBLEM
+ <numericalresponse answer="$computed_response">
+ <responseparam type="tolerance" default="0.0001" />
+ <formulaequationinput label="TEXT OF PROBLEM"/>
+ </numericalresponse>
+ </p>
<solution>
<div class="detailed-solution">
-
+ <p>TEXT OF SOLUTION</p>
</div>
</solution>
</problem>
+Tags
+----
-**XML Attribute Information**
-
-<script>
-
- .. image:: ../Images/numericalresponse.png
-
+* ``<numericalresponse>`` (required): Specifies that the problem is a numerical input problem.
+* ``<formulaequationinput />`` (required): Provides a response field where the student enters a response.
+* ``<responseparam>`` (optional): Specifies a tolerance, or margin of error, for an answer.
+* ``<script>`` (optional):
-``<numericalresponse>``
+.. note:: Some older problems use the ``<textline math="1" />`` tag instead of the ``<formulaequationinput />`` tag. However, the ``<textline math="1" />`` tag has been deprecated. All new problems should use the ``<formulaequationinput />`` tag.
-+------------+----------------------------------------------+-------------------------------+
-| Attribute | Description | Notes |
-+============+==============================================+===============================+
-| ``answer`` | A value to which student input must be | Note that any numeric |
-| | equivalent. Note that this expression can be | expression provided by the |
-| | expressed in terms of a variable that is | student will be automatically |
-| | computed in a script provided in the problem | simplified on the grader's |
-| | by preceding the appropriate variable name | backend. |
-| | with a dollar sign. | |
-| | | |
-| | This answer will be evaluated similar to a | |
-| | student's input. Thus '1/3' and 'sin(pi/5)' | |
-| | are valid, as well as simpler expressions, | |
-| | such as '0.3' and '42' | |
-+------------+----------------------------------------------+-------------------------------+
-
-
-+------------------------+--------------------------------------------+--------------------------------------+
-| Children | Description | Notes |
-+========================+============================================+======================================+
-| ``responseparam`` | used to specify a tolerance on the accepted| |
-| | values of a number. See description below. | |
-+------------------------+--------------------------------------------+--------------------------------------+
-|``formulaequationinput``| An input specifically for taking math | |
-| | input from students. See below. | |
-+------------------------+--------------------------------------------+--------------------------------------+
-| ``textline`` | A format to take input from students, see | Deprecated for NumericalResponse. |
-| | description below. | Use ``formulaequationinput`` instead.|
-+------------------------+--------------------------------------------+--------------------------------------+
-
-
-<responseparam>
-
- .. image:: ../Images/numericalresponse4.png
+**Tag:** ``<numericalresponse>``
-<formulaequationinput/>
+Specifies that the problem is a numerical input problem. The ``<numericalresponse>`` tag is similar to the ``<formularesponse>`` tag, but the ``<numericalresponse>`` tag does not allow unspecified variables.
-========= ============================================= =====
-Attribute Description Notes
-========= ============================================= =====
-size (optional) defines the size (i.e. the width)
- of the input box displayed to students for
- typing their math expression.
-========= ============================================= =====
+ Attributes
-<textline> (While <textline /> is supported, its use is extremely discouraged.
-We urge usage of <formulaequationinput />. See the opening paragraphs of the
-`Numerical Response`_ section for more information.)
+ .. list-table::
+ :widths: 20 80
- .. image:: ../Images/numericalresponse5.png
+ * - Attribute
+ - Description
+ * - answer (required)
+ - The correct answer to the problem, given as a mathematical expression.
-.. _Math Expression Syntax:
+ .. note:: If you include a variable name preceded with a dollar sign ($) in the problem, you can include a script in the problem that computes the expression in terms of that variable.
-Math Expression Syntax
-----------------------
+ The grader evaluates the answer that you provide and the student's response in the same way. The grader also automatically simplifies any numeric expressions that you or a student provides. Answers can include simple expressions such as "0.3" and "42", or more complex expressions such as "1/3" and "sin(pi/5)".
-In NumericalResponses, the student's input may be more complicated than a
-simple number. Expressions like ``sqrt(3)`` and even ``1+e^(sin(pi/2)+2*i)``
-are valid, and evaluate to 1.73 and -0.13 + 2.47i, respectively.
-
-A summary of the syntax follows:
+ Children
+
+ * ``<responseparam>``
+ * ``<formulaequationinput>``
-Numbers
-~~~~~~~
+**Tag:** * ``<formulaequationinput>``
-Accepted number types:
+Creates a response field in the LMS where students enter a response.
-- Integers: '2520'
-- Normal floats: '3.14'
-- With no integer part: '.98'
-- Scientific notation: '1.2e-2' (=0.012)
-- More s.n.: '-4.4e+5' = '-4.4e5' (=-440,000)
-- Appending SI suffixes: '2.25k' (=2,250). The full list:
+ Attributes
- ====== ========== ===============
- Suffix Stands for One of these is
- ====== ========== ===============
- % percent 0.01 = 1e-2
- k kilo 1000 = 1e3
- M mega 1e6
- G giga 1e9
- T tera 1e12
- c centi 0.01 = 1e-2
- m milli 0.001 = 1e-3
- u micro 1e-6
- n nano 1e-9
- p pico 1e-12
- ====== ========== ===============
+ .. list-table::
+ :widths: 20 80
-The largest possible number handled currently is exactly the largest float
-possible (in the Python language). This number is 1.7977e+308. Any expression
-containing larger values will not evaluate correctly, so it's best to avoid
-this situation.
+ * - size (optional)
+ - Defines the width, in characters, of the response field in the LMS.
+
+ Children
-Default Constants
-~~~~~~~~~~~~~~~~~
+ (none)
-Simple and commonly used mathematical/scientific constants are included by
-default. These include:
-
-- ``i`` and ``j`` as ``sqrt(-1)``
-- ``e`` as Euler's number (2.718...)
-- ``pi``
-- ``k``: the Boltzmann constant (~1.38e-23 in Joules/Kelvin)
-- ``c``: the speed of light in m/s (2.998e8)
-- ``T``: the positive difference between 0K and 0°C (285.15)
-- ``q``: the fundamental charge (~1.602e-19 Coloumbs)
+**Tag:** ``<responseparam>``
-Operators and Functions
-~~~~~~~~~~~~~~~~~~~~~~~
+Specifies a tolerance, or margin of error, for an answer.
-As expected, the normal operators apply (with normal order of operations):
-``+ - * / ^``. Also provided is a special "parallel resistors" operator given
-by ``||``. For example, an input of ``1 || 2`` would represent the resistance
-of a pair of parallel resistors (of resistance 1 and 2 ohms), evaluating to 2/3
-(ohms).
+ Attributes
-At the time of writing, factorials written in the form '3!' are invalid, but
-there is a workaround. Students can specify ``fact(3)`` or ``factorial(3)`` to
-access the factorial function.
+ .. list-table::
+ :widths: 20 80
-The default included functions are the following:
+ * - type (optional)
+ - "tolerance": Defines a tolerance for a number
+ * - default (optional)
+ - A number or a percentage specifying a numerical or percent tolerance.
-- Trig functions: sin, cos, tan, sec, csc, cot
-- Their inverses: arcsin, arccos, arctan, arcsec, arccsc, arccot
-- Other common functions: sqrt, log10, log2, ln, exp, abs
-- Factorial: ``fact(3)`` or ``factorial(3)`` are valid. However, you must take
- care to only input integers. For example, ``fact(1.5)`` would fail.
-- Hyperbolic trig functions and their inverses: sinh, cosh, tanh, sech, csch,
- coth, arcsinh, arccosh, arctanh, arcsech, arccsch, arccoth
+ Children
+
+ (none)
+**Tag:** ``<script>``
-.. _Option Response:
+Specifies a script that the grader uses to evaluate a student's response. A problem behaves as if all of the code in all of the script tags were in a single script tag. Specifically, any variables that are used in multiple ``<script>`` tags share a namespace and can be overriden.
-Option Response (Dropdown Problems)
------------------------------------
+As with all Python, indentation matters, even though the code is embedded in XML.
-Although you can create dropdown problems by using the Simple Editor in Studio, you may want to see or change the problem's underlying XML.
+ Attributes
-**Sample Problem**
+ .. list-table::
+ :widths: 20 80
-.. image:: ../Images/DropdownExample.gif
- :alt: Image of an option response problem
+ * - type (required)
+ - Must be set to "loncapa/python".
-**XML Tags**
+ Children
+
+ (none)
-.. list-table::
- :widths: 20 80
- * - ``<optionresponse>``
- - Indicates that the problem is a dropdown problem.
- * - ``<optioninput>``
- - Lists the answer options. This tag includes the ``options``, ``correct``, and ``label`` attributes.
+.. _Math Expression Input Problem XML:
+==================================
+Math Expression Input Problem XML
+==================================
-**Problem Code:**
+Templates
+---------
.. code-block:: xml
<problem>
- <p>
- <em>This exercise first appeared in HarvardX's PH207x Health in Numbers: Quantitative Methods in Clinical & Public Health Research course, fall 2012.</em>
- </p>
- <p>What type of data are the following?</p>
- <p>Age:</p>
- <optionresponse>
- <optioninput options="('Nominal','Discrete','Continuous')" correct="Continuous" label="Age"/>
- </optionresponse>
- <p>Age, rounded to the nearest year:</p>
- <optionresponse>
- <optioninput options="('Nominal','Discrete','Continuous')" correct="Discrete" label="Age, rounded to the nearest year"/>
- </optionresponse>
- <p>Life stage - infant, child, and adult:</p>
- <optionresponse>
- <optioninput options="('Nominal','Discrete','Continuous')" correct="Nominal" label="Life stage"/>
- </optionresponse>
+ <p>Write an expression for the product of R_1, R_2, and the inverse of R_3.</p>
+ <formularesponse type="ci" samples="R_1,R_2,R_3@1,2,3:3,4,5#10" answer="R_1*R_2/R_3">
+ <responseparam type="tolerance" default="0.00001"/>
+ <formulaequationinput size="40" />
+ </formularesponse>
</problem>
-**Template**
-
.. code-block:: xml
<problem>
- <p>
- Problem text</p>
- <optionresponse>
- <optioninput options="('Option 1','Option 2','Option 3')" correct="Option 2" label="label text"/>
- </optionresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
- </div>
- </solution>
- </problem>
+ <p>Problem text</p>
+ <formularesponse type="ci" samples="VARIABLES@LOWER_BOUNDS:UPPER_BOUNDS#NUMBER_OF_SAMPLES" answer="$VoVi">
+ <responseparam type="tolerance" default="0.00001"/>
+ <formulaequationinput size="20" label="Enter the equation"/>
+ </formularesponse>
-.. code-block:: xml
+ <script type="loncapa/python">
+ PYTHON SCRIPT
+ </script>
- <problem>
- <p>Problem text</p>
- <optionresponse>
- options="('A','B')"
- correct="A"/>
- label="label text"
- </optionresponse>
-
<solution>
<div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
+ <p>Explanation or Solution Header</p>
+ <p>Explanation or solution text</p>
</div>
</solution>
</problem>
+Tags
+----
+* ``<formularesponse>``
+* ``<formulaequationinput />``
+* ``<responseparam>``
+* ``<script>``
-**XML Attribute Information**
-
-<optionresponse>
+**Tag:** ``<formularesponse>``
+Specifies that the problem is a math expression input problem. The ``<formularesponse>`` tag is similar to ``<numericalresponse>``, but ``<formularesponse>`` allows unknown variables.
- .. image:: ../Images/option_response1.png
+ Attributes
+ **type**: Can be "cs" (case sensitive, the default) or "ci" (case insensitive, so that capitalization doesn't matter in variable names).
-<optioninput>
+ **answer**: The correct answer to the problem, given as a mathematical expression. If you precede a variable name in the problem with a dollar sign ($), you can include a script in the problem that computes the expression in terms of that variable.
- .. image:: ../Images/optionresponse2.png
+ **samples**: Specifies important information about the problem in four lists:
+ * **variables**: A set of variables that students can enter.
+ * **lower_bounds**: For every defined variable, a lower bound on the numerical tests to use for that variable.
+ * **upper_bounds**: For every defined variable, an upper bound on the numerical tests to use for that variable.
+ * **num_samples**: The number of times to test the expression.
-.. _Schematic Response:
+ Commas separate items inside each of the four individual lists, and the at sign (@), colon (:), and pound sign (#) characters separate the four lists. The format is the following:
-Schematic Response (Circuit Schematic Problems)
------------------------------------------------
+ ``"variables@lower_bounds:upper_bounds#num_samples``
-The Schematic Response input type provides an interactive grid on which the
-student can construct a schematic answer, such as a circuit.
+ For example, a ``<formularesponse>`` tag that includes the **samples** attribute may look like either of the following.
-**Sample Problem**
+ ``<formularesponse samples="x,n@1,2:3,4#10">``
-.. image:: ../Images/CircuitSchematicExample.gif
- :alt: Image of a schematic response explanation
+ ``<formularesponse samples="R_1,R_2,R_3@1,2,3:3,4,5#10">``
-**Problem Code**:
+ Children
-.. code-block:: xml
+ * ``<formulaequationinput />``
+**Tag:** ``<formulaequationinput />``
- <problem>
- <p>Make a voltage divider that splits the provided voltage evenly.</p>
- <schematicresponse>
- <center>
- <schematic height="500" width="600" parts="g,r" analyses="dc"
- initial_value="[["v",[168,144,0],{"value":"dc(1)","_json_":0},["1","0"]],["r",[296,120,0],{"r":"1","_json_":1},["1","output"]],["L",[296,168,3],{"label":"output","_json_":2},["output"]],["w",[296,216,168,216]],["w",[168,216,168,192]],["w",[168,144,168,120]],["w",[168,120,296,120]],["g",[168,216,0],{"_json_":7},["0"]],["view",-67.49999999999994,-78.49999999999994,1.6000000000000003,"50","10","1G",null,"100","1","1000"]]"
- />
- </center>
- <answer type="loncapa/python">
- dc_value = "dc analysis not found"
- for response in submission[0]:
- if response[0] == 'dc':
- for node in response[1:]:
- dc_value = node['output']
- if dc_value == .5:
- correct = ['correct']
- else:
- correct = ['incorrect']
- </answer>
- </schematicresponse>
- <schematicresponse>
- <p>Make a high pass filter.</p>
- <center>
- <schematic height="500" width="600" parts="g,r,s,c" analyses="ac"
- submit_analyses="{"ac":[["NodeA",1,9]]}"
- initial_value="[["v",[160,152,0],{"name":"v1","value":"sin(0,1,1,0,0)","_json_":0},["1","0"]],["w",[160,200,240,200]],["g",[160,200,0],{"_json_":2},["0"]],["L",[240,152,3],{"label":"NodeA","_json_":3},["NodeA"]],["s",[240,152,0],{"color":"cyan","offset":"0","_json_":4},["NodeA"]],["view",64.55878906250004,54.114697265625054,2.5000000000000004,"50","10","1G",null,"100","1","1000"]]"/>
- </center>
- <answer type="loncapa/python">
- ac_values = None
- for response in submission[0]:
- if response[0] == 'ac':
- for node in response[1:]:
- ac_values = node['NodeA']
- print "the ac analysis value:", ac_values
- if ac_values == None:
- correct = ['incorrect']
- elif ac_values[0][1] < ac_values[1][1]:
- correct = ['correct']
- else:
- correct = ['incorrect']
- </answer>
- </schematicresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>A voltage divider that evenly divides the input voltage can be formed with two identically valued resistors, with the sampled voltage taken in between the two.</p>
- <p><img src="/c4x/edX/edX101/asset/images_voltage_divider.png"/></p>
- <p>A simple high-pass filter without any further constaints can be formed by simply putting a resister in series with a capacitor. The actual values of the components do not really matter in order to meet the constraints of the problem.</p>
- <p><img src="/c4x/edX/edX101/asset/images_high_pass_filter.png"/></p>
- </div>
- </solution>
- </problem>
+Creates a response field where a student types an answer to the problem in plain text, as well as a second field below the response field where the student sees a typeset version of the plain text. The parser that renders the student's plain text into typeset math is the same parser that evaluates the student's response for grading.
-.. _String Response:
+ Attributes
-String Response (Text Input Problems)
--------------------------------------
+ .. list-table::
+ :widths: 20 80
-Although you can create text input problems by using the Simple Editor in Studio, you may want to see or change the problem's underlying XML. For example, you can add hints that appear when students enter common incorrect answers, or modify the problem's XML so that students can submit regular expressions as answers.
+ * - Attribute
+ - Description
+ * - size (optional)
+ - Specifies the width, in characters, of the response field where students enter answers.
-The regular expression that the student enters must contain the part of the answer that the instructor specifies. For example, if an instructor has specified ``<answer=".*example answer.*" type="regexp">``, correct answers include ``example answered``, ``two example answers``, or even ``==example answer==``, but not ``examples`` or ``example anser``.
+ Children
+
+ (none)
-You can add ``regexp`` to the value of the ``type`` attribute, for example: ``type="ci regexp"`` or ``type="regexp"`` or ``type="regexp cs"``. In this case, any answer or hint will be treated as regular expressions.
+**Tag:** ``<responseparam>``
-**Sample Problem**
+Used to define an upper bound on the variance of the numerical methods used to approximate a test for equality.
-.. image:: ../Images/TextInputExample.gif
- :alt: Image of a string response problem
+ Attributes
-**XML Tags**
+ .. list-table::
+ :widths: 20 80
-.. list-table::
- :widths: 20 80
+ * - Attribute
+ - Description
+ * - default (required)
+ - A number or a percentage specifying how close the student and grader expressions must be. Failure to include a tolerance leaves expressions vulnerable to unavoidable rounding errors during sapling, causing some student input to be graded as incorrect, even if it is algebraically equivalent to the grader's expression.
+ * - type
+ - "tolerance"--defines a tolerance for a number
- * - ``<stringresponse>``
- - Indicates that the problem is a text input problem.
- * - ``<textline>``
- - Child of ``<stringresponse>``. Lists the answer options and contains the ``label`` attribute.
- * - ``<additional_answer>`` (optional)
- - Specifies an additional correct answer for the problem. A problem can contain an unlimited number of additional answers.
- * - ``<hintgroup>`` (optional)
- - Indicates that the instructor has provided hints for certain common incorrect answers.
- * - ``<stringhint />`` (optional)
- - Child of ``<hintgroup>``. Specifies the text of the incorrect answer to provide the hint for. Contains answer, type, name.
- * - ``<hintpart>``
- - Contains the name from ``<stringhint>``. Associates the incorrect answer with the hint text for that incorrect answer.
- * - ``<startouttext />``
- - Indicates the beginning of the text of the hint.
- * - ``<endouttext />``
- - Indicates the end of the text of the hint.
-
-**Sample Problem Code**
+ Children
+
+ (none)
-.. code-block:: xml
+.. _Text Input Problem XML:
- <problem>
- <p>
- <em>This problem is adapted from an exercise that first appeared in MITx's 14.73x The Challenges of Global Poverty course, spring 2013.</em>
- </p>
- <p>What is the technical term that refers to the fact that, when enough people sleep under a bednet, the disease may altogether disappear?</p>
- <stringresponse answer=".*herd immunity.*" type="ci regexp">
- <additional_answer>community immunity</additional_answer>
- <additional_answer>population immunity</additional_answer>
- <textline size="20" label="What is the technical term that refers to the fact that, when enough people sleep under a bednet, the disease may altogether disappear?"/>
- <hintgroup>
- <stringhint answer="contact immunity" type="ci" name="contact_immunity_hint" />
- <hintpart on="contact_immunity_hint">
- <startouttext />
- In contact immunity, a vaccinated individual passes along his immunity to another person through contact with feces or bodily fluids. The answer to the question above refers to the form of immunity that occurs when so many members of a population are protected, an infectious disease is unlikely to spread to the unprotected population.
- <endouttext />
- </hintpart >
- <stringhint answer="firewall immunity" type="ci" name="firewall_immunity_hint" />
- <hintpart on="firewall_immunity_hint">
- <startouttext />
- Although a firewall provides protection for a population, the term "firewall" is used more in computing and technology than in epidemiology.
- <endouttext />
- </hintpart >
- </hintgroup>
- </stringresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>The correct answer is <b>herd immunity</b>. As more and more people use bednets, the risk of malaria begins to fall for everyone – users and non-users alike. This can fall to such a low probability that malaria is effectively eradicated from the group (even when the group does not have 100% bednet coverage).</p>
- </div>
- </solution>
- </problem>
+======================
+Text Input Problem XML
+======================
-**Template**
+Template
+--------
.. code-block:: xml
@@ -1188,61 +1026,141 @@ You can add ``regexp`` to the value of the ``type`` attribute, for example: ``ty
</solution>
</problem>
-**XML Attribute Information**
-
-<stringresponse>
-
- .. raw:: html
-
- <table border="1" class="docutils" width="60%">
- <colgroup>
- <col width="15%">
- <col width="75%">
- <col width="10%">
- </colgroup>
- <thead valign="bottom">
- <tr class="row-odd"><th class="head">Attribute</th>
- <th class="head">Description</th>
- <th class="head">Notes</th>
- </tr>
- </thead>
- <tbody valign="top">
- <tr class="row-even"><td>type</td>
- <td>(optional) “[ci] [regex]”. Add “ci” if the student response should be graded case-insensitively. The default is to take case into consideration when grading. Add “regexp” for correct answer to be treated as regular expression.</td>
- <td> </td>
- </tr>
- <tr class="row-odd"><td>answer</td>
- <td>The string that is used to compare with student answer. If "regexp" is not presented in value of <em>type</em> attribute, student should enter value equal to exact value of this attribute in order to get credit. If "regexp" is presented in value of <em>type</em> attribute, value of <em>answer</em> is treated as regular expression and exact match of this expression and student answer will be done. If search is successful, student will get credit.</td>
- <td> </td>
- </tr>
- </tbody>
- </table>
-
- <table border="1" class="docutils" width="60%">
- <colgroup>
- <col width="15%">
- <col width="75%">
- <col width="10%">
- </colgroup>
- <thead valign="bottom">
- <tr class="row-odd"><th class="head">Children</th>
- <th class="head">Description</th>
- <th class="head">Notes</th>
- </tr>
- </thead>
- <tbody valign="top">
- <tr class="row-even"><td>textline</td>
- <td>used to accept student input. See description below.</td>
- <td> </td>
- </tr>
- <tr class="row-odd"><td>additional_answer</td>
- <td>todo</td>
- <td> </td>
- </tr>
- </tbody>
- </table>
-
-
-<textline>
-
- .. image:: ../Images/stringresponse2.png
\ No newline at end of file
+Tags
+----
+
+* ``<stringresponse>``: Indicates that the problem is a text input problem.
+* ``<textline>``: Child of ``<stringresponse>``. Creates a response field in the LMS where the student enters a response.
+* ``<additional_answer>`` (optional): Specifies an additional correct answer for the problem. A problem can contain an unlimited number of additional answers.
+* ``<hintgroup>`` (optional): Indicates that the instructor has provided hints for certain common incorrect answers.
+* ``<stringhint />`` (optional): Child of ``<hintgroup>``. Specifies the text of the incorrect answer to provide the hint for. Contains answer, type, name.
+* ``<hintpart>``: Contains the name from ``<stringhint>``. Associates the incorrect answer with the hint text for that incorrect answer.
+* ``<startouttext />``: Indicates the beginning of the text of the hint.
+* ``<endouttext />``: Indicates the end of the text of the hint.
+
+**Tag:** ``<stringresponse>``
+
+Indicates that the problem is a text input problem.
+
+ Attributes
+
+ .. list-table::
+ :widths: 20 80
+
+ * - Attribute
+ - Description
+ * - answer (required)
+ - Specifies the correct answer. To designate the answer as a regular expression, add "regexp" to the **type** attribute. If you do not add "regexp" to the **type** attribute, the student's answer must match the value in this attribute exactly.
+ * - type (optional)
+ - Can specify whether the problem is case sensitive and allows regular expressions. If the ``<stringresponse>`` tag includes ``type="ci"``, the problem is not case sensitive. If the tag includes ``type="cs"``, the problem is case sensitive. If the tag includes ``type="regexp"``, the problem allows regular expressions. A **type** attribute in a ``<stringresponse>`` tag can also combine these values. For example, ``<stringresponse type="regexp cs">`` specifies that the prolem allows regular expressions and is case sensitive.
+
+ Children
+
+ * ``<textline />`` (required)
+ * ``<additional_answer>`` (optional)
+ * ``<hintgroup>`` (optional)
+
+**Tag:** ``<textline />``
+
+Creates a response field in the LMS where the student enters a response.
+
+ Attributes
+
+ .. list-table::
+ :widths: 20 80
+
+ * - Attribute
+ - Description
+ * - label (required)
+ - Contains the text of the problem.
+ * - size (optional)
+ - Specifies the size, in characters, of the response field in the LMS.
+ * - hidden (optional)
+ - If set to "true", students cannot see the response field.
+ * - correct_answer (optional)
+ - Lists the correct answer to the problem.
+
+ Children
+
+ (none)
+
+**Tag:** ``<additional_answer>``
+
+Specifies an additional correct answer for the problem. A problem can contain an unlimited number of additional answers.
+
+ Attributes
+
+ (none)
+
+ Children
+
+ (none)
+
+**Tag:** ``<hintgroup>``
+
+Indicates that the instructor has provided hints for certain common incorrect answers.
+
+ Attributes
+
+ (none)
+
+ Children
+
+ * ``<stringhint>`` (required)
+
+**Tag:** ``<stringhint>``
+
+Specifies a common incorrect answer to the problem.
+
+ Attributes
+
+ .. list-table::
+ :widths: 20 80
+
+ * - Attribute
+ - Description
+ * - answer (required)
+ - The text of the incorrect answer.
+ * - name (required)
+ - The name of the hint that you want to provide.
+ * - type
+ - Specifies whether the text of the specified incorrect answer is case sensitive. Can be set to "cs" (case sensitive) or "ci" (case insensitive).
+
+ Children
+
+ * ``<hintpart>`` (required)
+
+**Tag:** ``<hintpart>``
+
+Associates a common incorrect answer with the hint for that incorrect answer.
+
+ Attributes
+
+ .. list-table::
+ :widths: 20 80
+
+ * - Attribute
+ - Description
+ * - on
+ - The name of the hint. This must be the same as the **name** attribute of the ``<stringhint>`` tag. (The ``<stringhint>`` tag provides the name of the hint and the incorrect answer to associate with the hint. The ``<hintpart>`` tag contains the name of the hint and the text of the hint.)
+
+ Children
+
+ * ``<startouttext />`` (required)
+ * ``<endouttext />`` (required)
+
+**Tags:** ``<startouttext />`` and ``<endouttext>``
+
+Surround the text of the hint.
+
+ Attributes
+
+ (none)
+
+ Children
+
+ (none)
+
+
+
+
diff --git a/docs/en_us/course_authors/source/common_problems.rst b/docs/en_us/course_authors/source/common_problems.rst
index 2374aa3..e613146 100644
--- a/docs/en_us/course_authors/source/common_problems.rst
+++ b/docs/en_us/course_authors/source/common_problems.rst
@@ -1,13 +1,10 @@
.. _Common Problems:
-############################
+###############
Common Problems
-############################
+###############
-*Common problems* are typical problems such as multiple choice problems
-and other problems whose answers are simple for students to select or
-enter. You can create all of these problems using the Simple Editor in
-Studio. You don't have to use XML or switch to the Advanced Editor.
+*Common problems* are typical problems such as multiple choice problems and other problems whose answers are simple for students to select or enter. You can create all of these problems using the Simple Editor in Studio. You don't have to use XML or switch to the Advanced Editor. (However, this section also provides sample XML code for these problems in the Advanced Editor.)
The following are the common problem types in Studio:
@@ -26,9 +23,7 @@ The following are the common problem types in Studio:
These problems are easy to access in Studio. To create them, click
**Problem** under **Add New Component**, click the **Common Problem
-Types** tab, and then click the name of the problem. (Note that
-**Checkbox** doesn't appear in the list of common problem types. To
-create a checkbox problem, you'll click **Blank Common Problem**.)
+Types** tab, and then click the name of the problem.
.. note:: All problems must include labels for accessibility. The label generally includes the text of the main question in your problem. To add a label for a common problem, surround the text of the label with angle brackets pointed toward the text (>>*label text*<<).
@@ -50,6 +45,11 @@ at least one correct answer.
Create a Checkbox Problem
==========================
+You can create checkbox problems in the Simple Editor or in the Advanced Editor.
+
+Simple Editor
+-------------
+
#. Under **Add New Component**, click **Problem**.
#. In the **Select Problem Component Type** screen, click **Checkboxes** on the **Common Problem Types** tab.
#. In the Problem component that appears, click **Edit**.
@@ -81,88 +81,45 @@ following.
Learning about the benefits of preventative healthcare can be particularly
difficult. >>Check all of the reasons below why this may be the case.<<
- [x] A large amount of time passes between undertaking a preventative measure
- and seeing the result.
+ [x] A large amount of time passes between undertaking a preventative measure and seeing the result.
[ ] Non-immunized people will always fall sick.
- [x] If others are immunized, fewer people will fall sick regardless of a
- particular individual's choice to get immunized or not.
+ [x] If others are immunized, fewer people will fall sick regardless of a particular individual's choice to get immunized or not.
[x] Trust in healthcare professionals and government officials is fragile.
[explanation]
- People who are not immunized against a disease may still not fall sick from
- the disease. If someone is trying to learn whether or not preventative measures
- against the disease have any impact, he or she may see these people and conclude,
- since they have remained healthy despite not being immunized, that immunizations
- have no effect. Consequently, he or she would tend to believe that immunization
+ People who are not immunized against a disease may still not fall sick from the disease. If someone is trying to learn whether or not preventative measures against the disease have any impact, he or she may see these people and conclude, since they have remained healthy despite not being immunized, that immunizations have no effect. Consequently, he or she would tend to believe that immunization
(or other preventative measures) have fewer benefits than they actually do.
[explanation]
-==========================
-Checkbox Problem XML
-==========================
+Advanced Editor
+---------------
+
+To create this problem in the Advanced Editor, click the **Advanced** tab in the Problem component editor, and then replace the existing code with the following code.
.. code-block:: xml
<problem>
<startouttext/>
- <p>Learning about the benefits of preventative healthcare can be particularly
- difficult. Check all of the reasons below why this may be the case.</p>
+ <p>Learning about the benefits of preventative healthcare can be particularly difficult. Check all of the reasons below why this may be the case.</p>
<choiceresponse>
<checkboxgroup direction="vertical" label="Check all of the reasons below why this may be the case">
- <choice correct="true"><text>A large amount of time passes between undertaking
- a preventative measure and seeing the result.</text></choice>
- <choice correct="false"><text>Non-immunized people will always fall sick.</text>
- </choice>
- <choice correct="true"><text>If others are immunized, fewer people will fall
- sick regardless of a particular individual's choice to get immunized or not.
- </text></choice>
- <choice correct="true"><text>Trust in healthcare professionals and government
- officials is fragile.</text></choice>
+ <choice correct="true"><text>A large amount of time passes between undertaking a preventative measure and seeing the result.</text></choice>
+ <choice correct="false"><text>Non-immunized people will always fall sick.</text></choice>
+ <choice correct="true"><text>If others are immunized, fewer people will fall sick regardless of a particular individual's choice to get immunized or not.</text></choice>
+ <choice correct="true"><text>Trust in healthcare professionals and government officials is fragile.</text></choice>
</checkboxgroup>
<solution>
<div class="detailed-solution">
<p>Explanation</p>
- <p>People who are not immunized against a disease may still not fall sick from the
- disease. If someone is trying to learn whether or not preventative measures
- against the disease have any impact, he or she may see these people and conclude,
- since they have remained healthy despite not being immunized, that immunizations
- have no effect. Consequently, he or she would tend to believe that immunization
- (or other preventative measures) have fewer benefits than they actually do.</p>
+ <p>People who are not immunized against a disease may still not fall sick from the disease. If someone is trying to learn whether or not preventative measures against the disease have any impact, he or she may see these people and conclude, since they have remained healthy despite not being immunized, that immunizations have no effect. Consequently, he or she would tend to believe that immunization (or other preventative measures) have fewer benefits than they actually do.</p>
</div>
</solution>
</choiceresponse>
</problem>
-=============================
-Checkbox Problem XML Template
-=============================
-
-.. code-block:: xml
-
- <problem>
- <startouttext/>
- <p>Question text</p>
-
- <choiceresponse>
-
- <checkboxgroup direction="vertical" label="label text">
- <choice correct="false"><text>Answer option 1 (incorrect)</text></choice>
- <choice correct="true"><text>Answer option 2 (correct)</text></choice>
- </checkboxgroup>
-
- <solution>
- <div class="detailed-solution">
- <p>Solution or Explanation Heading</p>
- <p>Solution or explanation text</p>
- </div>
- </solution>
-
- </choiceresponse>
- </problem>
-
.. _Dropdown:
@@ -183,6 +140,11 @@ the dropdown arrow.
Create a Dropdown Problem
==========================
+You can create dropdown problems in the Simple Editor or in the Advanced Editor.
+
+Simple Editor
+-------------
+
To create a dropdown problem, follow these steps.
#. Under **Add New Component**, click **Problem**.
@@ -224,9 +186,10 @@ following.
Life stage - infant, child, and adult:
[[(Nominal), Discrete, Continuous]]
-==========================
-Dropdown Problem XML
-==========================
+Advanced Editor
+---------------
+
+To create this problem in the Advanced Editor, click the **Advanced** tab in the Problem component editor, and then replace the existing code with the following code.
**Problem Code:**
@@ -251,42 +214,6 @@ Dropdown Problem XML
</optionresponse>
</problem>
-**Template**
-
-.. code-block:: xml
-
- <problem>
- <p>
- Problem text</p>
- <optionresponse>
- <optioninput options="('Option 1','Option 2','Option 3')" correct="Option 2" label="label text"/>
- </optionresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
- </div>
- </solution>
- </problem>
-
-.. code-block:: xml
-
- <problem>
- <p>Problem text</p>
- <optionresponse>
- options="('A','B')"
- correct="A"/>
- label="label text"
- </optionresponse>
-
- <solution>
- <div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
- </div>
- </solution>
- </problem>
-
.. _Multiple Choice:
*******************
@@ -306,6 +233,11 @@ the question.
Create a Multiple Choice Problem
==================================
+You can create multiple choice problems in the Simple Editor or in the Advanced Editor.
+
+Simple Editor
+-------------
+
#. Under **Add New Component**, click **Problem**.
#. In the **Select Problem Component Type** screen, click **Multiple
Choice** on the **Common Problem Types** tab.
@@ -358,7 +290,10 @@ following.
investigating lateral inhibition using horseshoe crabs.
[Explanation]
-**Problem Code:**
+Advanced Editor
+---------------
+
+To create this problem in the Advanced Editor, click the **Advanced** tab in the Problem component editor, and then replace the existing code with the following code.
.. code-block:: xml
@@ -381,29 +316,6 @@ following.
</solution>
</problem>
-
-**Template**
-
-.. code-block:: xml
-
- <problem>
- <p>Question text</p>
- <multiplechoiceresponse>
- <choicegroup type="MultipleChoice" label="label text">
- <choice correct="false" name="a">Incorrect choice</choice>
- <choice correct="true" name="b">Correct choice</choice>
- </choicegroup>
- </multiplechoiceresponse>
-
- <solution>
- <div class="detailed-solution">
- <p>Explanation or solution header</p>
- <p>Explanation or solution text</p>
- </div>
- </solution>
- </problem>
-
-
.. _Numerical Input:
*******************
@@ -413,11 +325,11 @@ Numerical Input
In numerical input problems, students enter numbers or specific and
relatively simple mathematical expressions to answer a question.
-.. image:: Images/NumericalInputExample.gif
- :alt: Image of a simple numerical input problem
+.. image:: Images/image292.png
+ :alt: Image of a numerical input problem
Note that students' responses don't have to be exact for these problems. You can
-specify a margin of error, or tolerance. For more information, see the instructions below.
+specify a margin of error, or tolerance. You can also specify a correct answer explicitly, or use a Python script. For more information, see the instructions below.
Responses for numerical input problems can include integers, fractions,
and constants such as *pi* and *g*. Responses can also include text
@@ -426,11 +338,25 @@ representing common functions, such as square root (sqrt) and log base 2
sine (sin) and arcsine (arcsin). For these functions, Studio changes the
text that the student enters into mathematical symbols. The following
example shows the way Studio renders students' text responses in
-numerical input problems. To see more examples, scroll down to **Examples**.
+numerical input problems.
.. image:: Images/Math5.gif
:alt: Image of a numerical input probem rendered by Studio
+The following are a few more examples of the way that Studio renders numerical input
+text that students enter.
+
+.. image:: Images/Math1.gif
+ :alt: Image of a numerical input probem rendered by Studio
+.. image:: Images/Math2.gif
+ :alt: Image of a numerical input probem rendered by Studio
+.. image:: Images/Math3.gif
+ :alt: Image of a numerical input probem rendered by Studio
+.. image:: Images/Math4.gif
+ :alt: Image of a numerical input probem rendered by Studio
+.. image:: Images/Math5.gif
+ :alt: Image of a numerical input probem rendered by Studio
+
==================
Student Answers
==================
@@ -440,7 +366,7 @@ Student Answers
Math Expression Syntax
----------------------
-In numerical input problems, the student's input may be more complicated than a
+In numerical input problems, the **student's input** may be more complicated than a
simple number. Expressions like ``sqrt(3)`` and even ``1+e^(sin(pi/2)+2*i)``
are valid, and evaluate to 1.73 and -0.13 + 2.47i, respectively.
@@ -495,7 +421,7 @@ default. These include:
Operators and Functions
~~~~~~~~~~~~~~~~~~~~~~~
-As expected, the normal operators apply (with normal order of operations):
+The normal operators apply (with normal order of operations):
``+ - * / ^``. Also provided is a special "parallel resistors" operator given
by ``||``. For example, an input of ``1 || 2`` would represent the resistance
of a pair of parallel resistors (of resistance 1 and 2 ohms), evaluating to 2/3
@@ -529,8 +455,8 @@ For example, the following example problems require the Advanced Editor.
For more information about including a Python script in your problem, see :ref:`Custom Python Evaluated Input`.
-Create a Numerical Input Problem in the Simple Editor
--------------------------------------------------------
+Simple Editor
+-------------
#. Under **Add New Component**, click **Problem**.
#. In the **Select Problem Component Type** screen, click **Numerical
@@ -567,35 +493,19 @@ following.
::
- >>How many different countries do edX students live in as of May 2013?<<
+ >>What base is the decimal numeral system in?<<
- = 193 +- 5%
+ = 10
[explanation]
- As of edX's first birthday, in May 2013, edX students live in 193 different countries.
+ The decimal numerial system is base ten.
[explanation]
-Create a Numerical Input Problem in the Advanced Editor
--------------------------------------------------------
-
-
-**Examples**
-
-The following are a few more examples of the way that Studio renders numerical input
-text that students enter.
-
-.. image:: Images/Math1.gif
- :alt: Image of a numerical input probem rendered by Studio
-.. image:: Images/Math2.gif
- :alt: Image of a numerical input probem rendered by Studio
-.. image:: Images/Math3.gif
- :alt: Image of a numerical input probem rendered by Studio
-.. image:: Images/Math4.gif
- :alt: Image of a numerical input probem rendered by Studio
-.. image:: Images/Math5.gif
- :alt: Image of a numerical input probem rendered by Studio
+Advanced Editor
+---------------
+To create this problem in the Advanced Editor, click the **Advanced** tab in the Problem component editor, and then replace the existing code with the following code.
**Problem Code**:
@@ -645,83 +555,7 @@ text that students enter.
</solution>
</problem>
-**Templates**
-
-Exact values
-
-.. code-block:: xml
-
- <problem>
-
- <numericalresponse answer="10">
- <formulaequationinput label="label text"/>
- </numericalresponse>
-
- <solution>
- <div class="detailed-solution">
-
- </div>
- </solution>
- </problem>
-
-Answers with decimal precision
-
-.. code-block:: xml
-
- <problem>
-
- <numericalresponse answer="9.80665">
- <responseparam type="tolerance" default="0.01" />
- <formulaequationinput label="label text"/>
- </numericalresponse>
-
- <solution>
- <div class="detailed-solution">
-
- </div>
- </solution>
- </problem>
-
-Answers with percentage precision
-
-.. code-block:: xml
-
- <problem>
-
- <numericalresponse answer="100">
- <responseparam type="tolerance" default="10%" />
- <formulaequationinput label="label text"/>
- </numericalresponse>
-
- <solution>
- <div class="detailed-solution">
-
- </div>
- </solution>
- </problem>
-
-Answers with scripts
-.. code-block:: xml
-
- <problem>
-
- <!-- Use python script spacing. The following should not be indented! -->
- <script type="loncapa/python">
- computed_response = math.sqrt(math.fsum([math.pow(math.pi,2), math.pow(math.e,2)]))
- </script>
-
- <numericalresponse answer="$computed_response">
- <responseparam type="tolerance" default="0.0001" />
- <formulaequationinput label="label text"/>
- </numericalresponse>
-
- <solution>
- <div class="detailed-solution">
-
- </div>
- </solution>
- </problem>
.. _Text input:
@@ -744,7 +578,12 @@ text input problems to allow for typographical errors.
Create a Text Input Problem
==================================
-To create a text input problem, follow these steps.
+You can create multiple choice problems in the Simple Editor or in the Advanced Editor.
+
+Simple Editor
+-------------
+
+To create a text input problem in the Simple Editor, follow these steps.
#. Under **Add New Component**, click **Problem**.
#. In the **Select Problem Component Type** screen, click **Text Input**
@@ -784,7 +623,49 @@ following.
This can fall to such a low probability that malaria is effectively eradicated
from the group (even when the group does not have 100% bednet coverage).
[explanation]
-
+
+Advanced Editor
+---------------
+
+To create this problem in the Advanced Editor, click the **Advanced** tab in the Problem component editor, and then replace the existing code with the following code.
+
+.. code-block:: xml
+
+ <problem>
+ <p>
+ <em>This problem is adapted from an exercise that first appeared in MITx's 14.73x The Challenges of Global Poverty course, spring 2013.</em>
+ </p>
+ <p>What is the technical term that refers to the fact that, when enough people sleep under a bednet, the disease may altogether disappear?</p>
+ <stringresponse answer=".*herd immunity.*" type="ci regexp">
+ <additional_answer>community immunity</additional_answer>
+ <additional_answer>population immunity</additional_answer>
+ <textline size="20" label="What is the technical term that refers to the fact that, when enough people sleep under a bednet, the disease may altogether disappear?"/>
+ <hintgroup>
+ <stringhint answer="contact immunity" type="ci" name="contact_immunity_hint" />
+ <hintpart on="contact_immunity_hint">
+ <startouttext />
+ In contact immunity, a vaccinated individual passes along his immunity to another person through contact with feces or bodily fluids. The answer to the question above refers to the form of immunity that occurs when so many members of a population are protected, an infectious disease is unlikely to spread to the unprotected population.
+ <endouttext />
+ </hintpart >
+ <stringhint answer="firewall immunity" type="ci" name="firewall_immunity_hint" />
+ <hintpart on="firewall_immunity_hint">
+ <startouttext />
+ Although a firewall provides protection for a population, the term "firewall" is used more in computing and technology than in epidemiology.
+ <endouttext />
+ </hintpart >
+ </hintgroup>
+ </stringresponse>
+ <solution>
+ <div class="detailed-solution">
+ <p>Explanation</p>
+ <p>The correct answer is <b>herd immunity</b>. As more and more people use bednets, the risk of malaria begins to fall for everyone – users and non-users alike. This can fall to such a low probability that malaria is effectively eradicated from the group (even when the group does not have 100% bednet coverage).</p>
+ </div>
+ </solution>
+ </problem>
+
+
+
+
=========================================
Multiple Responses in Text Input Problems
=========================================
@@ -792,13 +673,43 @@ Multiple Responses in Text Input Problems
You can specify more than one correct response for text input problems.
For example, instead of requiring students to enter exactly "Dr. Martin Luther
King, Junior," you can allow answers of "Martin Luther King," "Doctor Martin
-Luther King," and other variations.
+Luther King," and other variations. To do this, you can use the Simple Editor or the Advanced Editor.
-To do this, include "or=" (without the quotation marks) before each additional
-correct response.
+Simple Editor
+-------------
+
+To specify additional correct responses in the Simple Editor, include "or=" (without the quotation marks) before each additional correct response.
+
+::
+
+ >>What African-American led the United States civil rights movement during the 1960s?<<
+ = Dr. Martin Luther King, Jr.
+ or= Dr. Martin Luther King, Junior
+ or= Martin Luther King, Jr.
+ or= Martin Luther King
+
+
+
+Advanced Editor
+---------------
+
+To specify additional correct responses in the Advanced Editor, add an ``<additional_answer>`` for each correct response inside the opening and closing ``<stringresponse>`` tags.
+
+.. code-block:: xml
+
+ <problem>
+
+ <p>What African-American led the United States civil rights movement during the 1960s?</p>
+
+ <stringresponse answer="Dr. Martin Luther King, Jr." type="ci" >
+ <additional_answer>Dr. Martin Luther King, Junior</additional_answer>
+ <additional_answer>Martin Luther King, Jr.</additional_answer>
+ <additional_answer>Martin Luther King</additional_answer>
+ <textline label="What African-American led the United States civil rights movement during the 1960s?" size="20"/>
+ </stringresponse>
+
+ </problem>
-.. image:: Images/TextInput_MultipleAnswer.gif
- :alt: Image of multiple responses in a text input problem
=========================================
Case Sensitivity and Text Input Problems
@@ -809,7 +720,7 @@ and require a case sensitive answer.
To make a text input response case sensitive, you must use :ref:`Advanced Editor`.
-In the advanced editor, you see that the **type** attribute of the **stringresponse**
+In the Advanced Editor, you see that the **type** attribute of the **stringresponse**
element equals **ci**, for *case insensitive*. For example:
::
@@ -837,8 +748,7 @@ accommodates the correct answer, and provides extra space for possible incorrect
If the default response field length is not sufficient, you can change it using :ref:`Advanced Editor`.
-In the advanced editor, in the XML block for the answer, you see that the **size** attribute of the **textline**
-element equals **20**:
+In the advanced editor, in the XML block for the answer, you see that the **size** attribute of the **textline** element equals **20**:
::
@@ -858,106 +768,8 @@ To change the response field length, change the value of the **size** attribute:
Hints and Regular Expressions in Text Input Problems
====================================================
-You can provide hints for common incorrect answers in text input problems. You can also set a text input problem to allow a regular expression as an answer. To do this, you'll have to modify the problem's XML in the Advanced Editor. For more information, see :ref:`String Response`.
-
-Although you can create text input problems by using the Simple Editor in Studio, you may want to see or change the problem's underlying XML. For example, you can add hints that appear when students enter common incorrect answers, or modify the problem's XML so that students can submit regular expressions as answers.
+You can provide hints that appear when students enter common incorrect answers in text input problems. You can also set a text input problem to allow a regular expression as an answer. To do this, you'll have to modify the problem's XML in the Advanced Editor.
The regular expression that the student enters must contain the part of the answer that the instructor specifies. For example, if an instructor has specified ``<answer=".*example answer.*" type="regexp">``, correct answers include ``example answered``, ``two example answers``, or even ``==example answer==``, but not ``examples`` or ``example anser``.
-You can add ``regexp`` to the value of the ``type`` attribute, for example: ``type="ci regexp"`` or ``type="regexp"`` or ``type="regexp cs"``. In this case, any answer or hint will be treated as regular expressions.
-
-**Sample Problem**
-
-.. image:: ../Images/TextInputExample.gif
- :alt: Image of a string response problem
-
-**XML Tags**
-
-.. list-table::
- :widths: 20 80
-
- * - ``<stringresponse>``
- - Indicates that the problem is a text input problem.
- * - ``<textline>``
- - Child of ``<stringresponse>``. Lists the answer options and contains the ``label`` attribute.
- * - ``<additional_answer>`` (optional)
- - Specifies an additional correct answer for the problem. A problem can contain an unlimited number of additional answers.
- * - ``<hintgroup>`` (optional)
- - Indicates that the instructor has provided hints for certain common incorrect answers.
- * - ``<stringhint />`` (optional)
- - Child of ``<hintgroup>``. Specifies the text of the incorrect answer to provide the hint for. Contains answer, type, name.
- * - ``<hintpart>``
- - Contains the name from ``<stringhint>``. Associates the incorrect answer with the hint text for that incorrect answer.
- * - ``<startouttext />``
- - Indicates the beginning of the text of the hint.
- * - ``<endouttext />``
- - Indicates the end of the text of the hint.
-
-**Sample Problem Code**
-
-.. code-block:: xml
-
- <problem>
- <p>
- <em>This problem is adapted from an exercise that first appeared in MITx's 14.73x The Challenges of Global Poverty course, spring 2013.</em>
- </p>
- <p>What is the technical term that refers to the fact that, when enough people sleep under a bednet, the disease may altogether disappear?</p>
- <stringresponse answer=".*herd immunity.*" type="ci regexp">
- <additional_answer>community immunity</additional_answer>
- <additional_answer>population immunity</additional_answer>
- <textline size="20" label="What is the technical term that refers to the fact that, when enough people sleep under a bednet, the disease may altogether disappear?"/>
- <hintgroup>
- <stringhint answer="contact immunity" type="ci" name="contact_immunity_hint" />
- <hintpart on="contact_immunity_hint">
- <startouttext />
- In contact immunity, a vaccinated individual passes along his immunity to another person through contact with feces or bodily fluids. The answer to the question above refers to the form of immunity that occurs when so many members of a population are protected, an infectious disease is unlikely to spread to the unprotected population.
- <endouttext />
- </hintpart >
- <stringhint answer="firewall immunity" type="ci" name="firewall_immunity_hint" />
- <hintpart on="firewall_immunity_hint">
- <startouttext />
- Although a firewall provides protection for a population, the term "firewall" is used more in computing and technology than in epidemiology.
- <endouttext />
- </hintpart >
- </hintgroup>
- </stringresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation</p>
- <p>The correct answer is <b>herd immunity</b>. As more and more people use bednets, the risk of malaria begins to fall for everyone – users and non-users alike. This can fall to such a low probability that malaria is effectively eradicated from the group (even when the group does not have 100% bednet coverage).</p>
- </div>
- </solution>
- </problem>
-
-**Template**
-
-.. code-block:: xml
-
- <problem>
- <p>Problem text</p>
- <stringresponse answer="**.Correct answer 1.**" type="ci regexp">
- <additional_answer>Correct answer 2</additional_answer>
- <additional_answer>Correct answer 3</additional_answer>
- <textline size="20" label="label text"/>
- <hintgroup>
- <stringhint answer="Incorrect answer A" type="ci" name="hintA" />
- <hintpart on="hintA">
- <startouttext />Text of hint for incorrect answer A<endouttext />
- </hintpart >
- <stringhint answer="Incorrect answer B" type="ci" name="hintB" />
- <hintpart on="hintB">
- <startouttext />Text of hint for incorrect answer B<endouttext />
- </hintpart >
- <stringhint answer="Incorrect answer C" type="ci" name="hintC" />
- <hintpart on="hintC">
- <startouttext />Text of hint for incorrect answer C<endouttext />
- </hintpart >
- </hintgroup>
- </stringresponse>
- <solution>
- <div class="detailed-solution">
- <p>Explanation or Solution Header</p>
- <p>Explanation or solution text</p>
- </div>
- </solution>
- </problem>
\ No newline at end of file
+You can add ``regexp`` to the value of the ``type`` attribute, for example: ``type="ci regexp"`` or ``type="regexp"`` or ``type="regexp cs"``. In this case, any answer or hint are treated as regular expressions.
\ No newline at end of file
diff --git a/docs/en_us/course_authors/source/create_problem_component.rst b/docs/en_us/course_authors/source/create_problem_component.rst
index b3f9e05..7db0628 100644
--- a/docs/en_us/course_authors/source/create_problem_component.rst
+++ b/docs/en_us/course_authors/source/create_problem_component.rst
@@ -428,10 +428,6 @@ Note that *problem randomization* is different from the **Randomization** settin
.. note:: Creating problems with versions that can be randomized requires you to export your course, edit some of your course's XML files in a text editor, and then re-import your course. We recommend that you create a backup copy of your course before you do this. We also recommend that you only edit the files that will contain polls in the text editor if you're very familiar with editing XML.
-==========================
-Terminology
-==========================
-
===========
Terminology
===========
@@ -561,3 +557,34 @@ students to go back and resubmit a problem.
- Delete the entire Problem component in Studio and create a new
Problem component with the content and settings that you want. Then
ask all your students to complete the new problem.
+
+.. _Problem XML:
+
+***********
+Problem XML
+***********
+
+XML tags are generally specific to a problem type. For example, only multiple choice problems contain the ``<multiplechoiceresponse>`` tag, and only drag and drop problems use the ``<draggable>`` tag. However, the following tags are common to most problems.
+
+.. list-table::
+ :widths: 20 80
+
+ * - ``<problem> </problem>``
+ - These must be the first and last tags for any content created in the Advanced
+ Editor in a Problem component.
+ * - ``<startouttext/>``
+ - The ``<startouttext />`` tag indicates the beginning of a line or block of text.
+ * - ``<endouttext/>``
+ - The ``<endouttext />`` tag indicates the end of a line or block of text.
+ * - ``<solution> <div class="detailed-solution"> </div> </solution>`` (optional)
+ - If you want to include more information in the problem, such as a detailed explanation of the problem's answer, you'll enter the text between the two ``<div>`` tags, which are inside the ``<solution>`` tags. (These tags do not have to be on the same line.)
+
+Additionally, several different problem types use the following tags.
+
+.. list-table::
+ :widths: 20 80
+
+ * - ``<textline>``
+ - Creates an answer space where students enter a response. Must contain a **size** attribute; may contain **label**, **math**, **correct_answer**. Used in text input and some custom Python-evaluated input problems.
+ * - ``<customresponse> </customresponse>``
+ -
--
libgit2 0.26.0