<?xml version="1.0" encoding="utf-8"?>
<!-- generator="FeedCreator 1.7.2-ppt DokuWiki" -->
<?xml-stylesheet href="http://secant.cs.purdue.edu/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="http://secant.cs.purdue.edu/feed.php">
        <title>Science Education in Computational Thinking cs190c</title>
        <description></description>
        <link>http://secant.cs.purdue.edu/</link>
        <image rdf:resource="http://secant.cs.purdue.edu/lib/images/favicon.ico" />
       <dc:date>2009-11-22T11:17:38-05:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:addfunc?rev=1201819781"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:additionalfunt09?rev=1234424813"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:catalog?rev=1228859072"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:clickers?rev=1228858337"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:cytoscape_tutorial?rev=1206517254"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:demonenergy1.png?rev=1237926058"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:example_sounds?rev=1233867081"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:final?rev=1209573025"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:grading?rev=1230661516"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:graph_operations?rev=1207856184"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:here?rev=1231187891"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:inst09?rev=1231796439"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:instta?rev=1201226036"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:integrity?rev=1197037146"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:interactive_matplotlib?rev=1204299242"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab1?rev=1200102269"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab10?rev=1216915982"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab10_09?rev=1241060427"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab11?rev=1207100438"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab11_09?rev=1239025114"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab12?rev=1216916010"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab12_09?rev=1241060481"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab13?rev=1216916031"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab13_09?rev=1241060522"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab14?rev=1216916053"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab14_09?rev=1241061412"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab15?rev=1209137025"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab15_09?rev=1241191936"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab1_09?rev=1233819340"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab2?rev=1208533113"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab2_09?rev=1233819314"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab3?rev=1216915903"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab3_09?rev=1233819293"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab4?rev=1216915871"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab4_09?rev=1234364450"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab5?rev=1208533228"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab5_09?rev=1234544333"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab6?rev=1216915834"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab6_09?rev=1235681627"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab7?rev=1216915777"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab7_09?rev=1235948623"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab8?rev=1216915725"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab8_09?rev=1236732391"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab9?rev=1216915957"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:lab9_10?rev=1238014951"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:labs?rev=1209136906"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:labs09?rev=1240773441"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:links?rev=1231528849"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:more_detail?rev=1201819639"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:notes?rev=1231768258"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:notes09?rev=1241022904"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:nvsenergy1.png?rev=1237926193"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:objout?rev=1226441400"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:policies?rev=1199478164"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset1?rev=1200084392"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset1_09?rev=1232569272"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset1sol_09?rev=1233332645"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset2?rev=1233192827"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset2_09?rev=1232978237"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset2sol_09?rev=1233899939"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset3?rev=1233189101"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset3_09?rev=1233407662"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset3sol_09?rev=1234535709"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:problemset4?rev=1208177706"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project1?rev=1202321157"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project1_09?rev=1234505829"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project1sol_09?rev=1234795605"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project2?rev=1234806974"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project2_09?rev=1236958577"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project2sol_09?rev=1237318623"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project3?rev=1204304276"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project3_09?rev=1237926553"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project3c_09?rev=1240191954"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project3sol_09?rev=1239664476"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project4?rev=1207572064"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project4_09?rev=1240257243"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project4c_09?rev=1240341571"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:project4sol_09?rev=1240260544"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:projects?rev=1221751775"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:projects09?rev=1240266287"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:provide?rev=1240339159"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:ps3_p2_lib.py?rev=1201279887"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:ps3problems2.py?rev=1201278915"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:psets?rev=1221751682"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:psets09?rev=1234421565"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:publiccal?rev=1197039363"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:requiredfunc09?rev=1234190375"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:sample_ideal_gas_discussion?rev=1206335427"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:sidebar?rev=1228859382"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:start-s09?rev=1241360762"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:start?rev=1240248642"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:stereo09?rev=1234283496"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:syllabus?rev=1227127698"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:ta?rev=1222789808"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:ta09?rev=1233179114"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:textsoft?rev=1199902027"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:textsoft09?rev=1232642198"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:velocitydistr1.png?rev=1237926623"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:vpython_3d_line_plot?rev=1204203607"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:workload?rev=1197553547"/>
                <rdf:li rdf:resource="http://secant.cs.purdue.edu/cs190c:workload09?rev=1232644437"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="http://secant.cs.purdue.edu/lib/images/favicon.ico">
        <title>Science Education in Computational Thinking</title>
        <link>http://secant.cs.purdue.edu/</link>
        <url>http://secant.cs.purdue.edu/lib/images/favicon.ico</url>
    </image>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:addfunc?rev=1201819781">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-31T17:49:41-05:00</dc:date>
        <title>cs190c:addfunc</title>
        <link>http://secant.cs.purdue.edu/cs190c:addfunc?rev=1201819781</link>
        <description>Project 1: Specification of Additional Functions

 square_sample(freq, amp, dur)

This function returns a square wave with frequency freq, amplitude amp, and duration dur (in seconds). The amplitude should be specified with a range of 0 to 1 where 1 represents the maximal amplitude. To obtain the actual amplitude in the sample use the WAVE_MAX value to scale it to an appropriate value.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:additionalfunt09?rev=1234424813">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-12T02:46:53-05:00</dc:date>
        <title>cs190c:additionalfunt09</title>
        <link>http://secant.cs.purdue.edu/cs190c:additionalfunt09?rev=1234424813</link>
        <description>Project 1: Specification of Additional Functions

 Note: all mono -&gt; stereo functions should return a new array, rather than trying to work in-place.

equal_scale(freq, amp, dur, sampler=sin_sample)

Return an ascending chromatic scale starting on freq where each tone is dur seconds long.  A short silence should be inserted between notes.  The function sampler may optionally be passed into the function to determine which waveform should be used (if none is passed, sin_sample you wrote earlier is…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:catalog?rev=1228859072">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-09T16:44:32-05:00</dc:date>
        <title>cs190c:catalog</title>
        <link>http://secant.cs.purdue.edu/cs190c:catalog?rev=1228859072</link>
        <description>Spring 2009; 3 credits. Lectures MW 11:30-12:20, 2-hour labs on Friday.

Computer Science has become indispensable to scientific inquiry and is permeating science in a transformative manner.  The course introduces science majors to computational thinking via basic programming concepts, data and data management concepts, simulation, and visual interaction. The course will use Python and various Python libraries including VPython, NumPy, and NetworkX.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:clickers?rev=1228858337">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-09T16:32:17-05:00</dc:date>
        <title>cs190c:clickers</title>
        <link>http://secant.cs.purdue.edu/cs190c:clickers?rev=1228858337</link>
        <description>*  Each student enrolled in CS190C is loaned an iclicker device (&lt;http://www.iclicker.com/&gt;) for the semester.
	*  During the first class, students will register a clicker to be associated with their name.
	*  Each class period will have 3-5 clicker questions.  Answering a real question correctly gives a student 1 point. There are no points for answering participation questions. A student gets 1 point for responding to at least 75% of the questions during one class period. 
	*  Clicker responses…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:cytoscape_tutorial?rev=1206517254">
        <dc:format>text/html</dc:format>
        <dc:date>2008-03-26T03:40:54-05:00</dc:date>
        <title>cs190c:cytoscape_tutorial</title>
        <link>http://secant.cs.purdue.edu/cs190c:cytoscape_tutorial?rev=1206517254</link>
        <description>Before using Cytoscape, download it from &lt;http://www.cytoscape.org/download.php?file=cyto2_5_2&gt; and install it.  

Consider the graph given by the example edge list: 
1 2
1 3
2 4
4 1
3 4
3 5
5 4
4 6
6 7
7 6
6 8
8 9
9 10
10 8
11 9
16 11
16 15
15 12
12 16
11 12
11 13
15 14
14 13
13 12
13 14
 Save it in a text file named fig1.txt (make sure there are no empty lines after the last line).</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:demonenergy1.png?rev=1237926058">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-24T16:20:58-05:00</dc:date>
        <title>cs190c:demonenergy1.png</title>
        <link>http://secant.cs.purdue.edu/cs190c:demonenergy1.png?rev=1237926058</link>
        <description></description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:example_sounds?rev=1233867081">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-05T15:51:21-05:00</dc:date>
        <title>cs190c:example_sounds</title>
        <link>http://secant.cs.purdue.edu/cs190c:example_sounds?rev=1233867081</link>
        <description>Here are some sample sounds you may find useful in testing your code. 

	*  Sine wave @ 440Hz: ([ code]) ([ wav])
	*  Echo ([ code]) ([ wav]) ([ wav])
	*  Equal scale ([ code]) ([ wav ])
	*  Volume scaling ([ code]) ([ wav]) ([ wav])
	*  View a wave [ code])</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:final?rev=1209573025">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-30T12:30:25-05:00</dc:date>
        <title>cs190c:final</title>
        <link>http://secant.cs.purdue.edu/cs190c:final?rev=1209573025</link>
        <description>Wednesday April 30, 2008

 This is an in-lab, open book final exam.  The exam contains three types of questions: questions that have a written answer (typed or handwritten), questions for which you have the option to run a program/statements, and questions for which you are required to write and run a program.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:grading?rev=1230661516">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-30T13:25:16-05:00</dc:date>
        <title>cs190c:grading</title>
        <link>http://secant.cs.purdue.edu/cs190c:grading?rev=1230661516</link>
        <description>Final Grades

 Final grades will be assigned according to the following approximate weighting:  

	*  Midterm Exams 	20% (10% each)
	*  Final Exam  	20%
	*  Programming Projects 25%
	*  Problem Sets  	15%
	*  Lab Assignments 15%
	*  Participation  5% (clicker responses)</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:graph_operations?rev=1207856184">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-10T15:36:24-05:00</dc:date>
        <title>cs190c:graph_operations</title>
        <link>http://secant.cs.purdue.edu/cs190c:graph_operations?rev=1207856184</link>
        <description>NetworkX: Useful Operations

Graph methods

These functions are called on a graph G by calling, e.g., G.to_undirected().  In the code that is given to you, node IDs will be strings. 

	*  to_undirected(): converts an directed graph to an undirected version.
	*  add_edge(src, dst): adds an edge between the nodes with IDs src and dst.
	*  add_edges_from(edge_list): like add_edge, but allows multiple edges to be added in a single call
	*  edges(): returns a list of edges in the graph.  Each edge is…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:here?rev=1231187891">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-05T15:38:11-05:00</dc:date>
        <title>cs190c:here</title>
        <link>http://secant.cs.purdue.edu/cs190c:here?rev=1231187891</link>
        <description>Software Information

 All software is free and is cross-platform compatible (running on Windows, Mac,UNIX/Linux ). 

	*  Python (2.5.2) and VPython (not the Visual 5 beta version) 
		*  &lt;http://www.python.org&gt;
		*  &lt;http://www.vpython.org&gt;
		*  Download: &lt;http://www.vpython.org/download.html&gt;
		*  Download and install for Windows: VPython-Win-Py2.5-3.2.11.exe
		*  Documentation: &lt;http://www.vpython.org/webdoc/visual/index.html&gt;</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:inst09?rev=1231796439">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-12T16:40:39-05:00</dc:date>
        <title>cs190c:inst09</title>
        <link>http://secant.cs.purdue.edu/cs190c:inst09?rev=1231796439</link>
        <description>The course was developed by faculty in Computer Science, Physics, Chemistry and Statistics.  Below is the list of faculty involved and their main responsibilities and expertise.

CS Faculty 

	*  Professor S. E. Hambrusch, 1179 Lawson Building; 494-1831; &lt;seh@cs.purdue.edu&gt;
		*  Office Hours:  Monday, 10-11am; Wednesday 1-2pm; or by appointment</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:instta?rev=1201226036">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-24T20:53:56-05:00</dc:date>
        <title>cs190c:instta</title>
        <link>http://secant.cs.purdue.edu/cs190c:instta?rev=1201226036</link>
        <description>The course was developed by faculty in Computer Science, Physics, Chemistry and Statistics.  In its first offering it will be team taught.  Below is the list of people involved and their main responsibilities and expertise.

CS Faculty 

	*  Professor S. E. Hambrusch, 1179 Lawson Building; 494-1831; seh@cs.purdue.edu
		*  Office Hours:  Monday 2:30-3:30pm, Thursday 3-4pm, or by appointment
		*  Organizational matters, grading issues, overall course material questions</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:integrity?rev=1197037146">
        <dc:format>text/html</dc:format>
        <dc:date>2007-12-07T09:19:06-05:00</dc:date>
        <title>cs190c:integrity</title>
        <link>http://secant.cs.purdue.edu/cs190c:integrity?rev=1197037146</link>
        <description>Academic Integrity Policy 

As a student at Purdue you are subject to the Purdue University Student Code of Conduct (&lt;http://www.purdue.edu/ODOS/osrr/integrity.htm&gt;), which enjoins you to respect the highest standards of honesty and integrity. As a student in the Computer Sciences Department you must also read and sign the Department Academic Integrity Policy available at &lt;http://www.cs.purdue.edu/resources/policies/academic/integrity.shtml&gt; (use your Purdue Career Account login and password to …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:interactive_matplotlib?rev=1204299242">
        <dc:format>text/html</dc:format>
        <dc:date>2008-02-29T10:34:02-05:00</dc:date>
        <title>cs190c:interactive_matplotlib</title>
        <link>http://secant.cs.purdue.edu/cs190c:interactive_matplotlib?rev=1204299242</link>
        <description>Interactive Matplotlib

 Normally, matplotlib will not show plots until you call pylab.show().  However, if you call pylab.ion() before plotting, matplotlib will show the window immediately.  For best results, decorate (set title, axis labels, etc) after calling pylab.plot() or pylab.hist().  You should still call pylab.show() at the end of your code, otherwise python will not wait for you to close the graph windows before exiting.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab1?rev=1200102269">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-11T20:44:29-05:00</dc:date>
        <title>cs190c:lab1</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab1?rev=1200102269</link>
        <description>*  Calculate wind chill by inputting the temperature in Fahrenheit and the wind speed in mph.  
		*  Use the formula to calculate the wind chill.
		*  Wind chill link. 
		*    T = 35.74 + 0.6215T - 35.75(V^0.16) + 0.4275T(V^0.16)

	*  Average a user-supplied number of numbers.  The user should first be prompted to enter how many numbers to average, and then be prompted for each number. Print the average.
		*  Remember to be wary of floating point numbers.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab10?rev=1216915982">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:13:02-05:00</dc:date>
        <title>cs190c:lab10</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab10?rev=1216915982</link>
        <description>Lab 10: First Hour

	*  Go over the [word frequency program].
	*  In Lab problem:
			*  Read in the file [dictionary.txt] and create a Python dictionary that contains each word in the file.  Then, prompt the user for a file to spell check.  Print out each word that is in the user's file that does not reside in the dictionary.  The words you print out should be unique and in alphabetical order.  Use the word frequency program as a template of how to split apart the words in the file.  You should …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab10_09?rev=1241060427">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-29T23:00:27-05:00</dc:date>
        <title>cs190c:lab10_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab10_09?rev=1241060427</link>
        <description>Numerically Stable and Unstable Methods to Compute the Variance

The variance of n sample values \(x_1\), \(x_2\), ... , \(x_n\) is one measure of statistical dispersion, obtained by averaging the squared distance of the sample values from the expected value (mean). The mean captures the location of a distribution and the variance captures the degree of the values being spread out. The square root of the variance is called the standard deviation.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab11?rev=1207100438">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-01T21:40:38-05:00</dc:date>
        <title>cs190c:lab11</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab11?rev=1207100438</link>
        <description>First Hour

	*  Return and go over exam 2.
	*  In-Lab problem
		*  In Project 4, you will be required to manipulate graphs using the networkX package.  In the in-lab problem, you need to fill in the body of the function replace_scc which replace all the strongly connected components of a graph with single nodes that you read in using import_edge_list(filename).  You can use the following [sample input].  It's suggested that you use the strongly_connected_components function on the graph that you…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab11_09?rev=1239025114">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-06T09:38:34-05:00</dc:date>
        <title>cs190c:lab11_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab11_09?rev=1239025114</link>
        <description>Basic graph manipulations in NetworkX

Remember, when working with NetworkX, you want this import: 

import networkx as nx

 This lets you use the NetworkX module with nx.&lt;function&gt; rather than networkx.&lt;function&gt;. When working with visualization, you must also import pylab.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab12?rev=1216916010">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:13:30-05:00</dc:date>
        <title>cs190c:lab12</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab12?rev=1216916010</link>
        <description>Today's in-lab project is similar to the movie-matching game called six degrees of Kevin Bacon.  We are providing you a data file that represents an undirected graph where there exists an edge between an actor and a movie if that actor was in that movie.  Thus, your problem is to leverage NetworkX such that you can perform lookups of the shortest paths between actors.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab12_09?rev=1241060481">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-29T23:01:21-05:00</dc:date>
        <title>cs190c:lab12_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab12_09?rev=1241060481</link>
        <description>Cytoscape

 Here is a tutorial on Cytoscape that will walked through today. Here are the [graph] and [node attributes] used.

In-Lab Problem

 Today's in-lab project is similar to the movie-matching game called six degrees of Kevin Bacon.  We are providing you a data file that represents an undirected graph where there exists an edge between an actor and a movie if that actor was in that movie.  Thus, your problem is to leverage NetworkX such that you can perform lookups of the shortest paths be…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab13?rev=1216916031">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:13:51-05:00</dc:date>
        <title>cs190c:lab13</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab13?rev=1216916031</link>
        <description>For today's lab, we will be investigating the benefits of using an efficient algorithm.   We will be searching datasets ranging in size from 100 to 10,000 elements. 

	*  Sizes of the lists should be from 100 to 10,000, stepping by 100.  The list should be the numbers from 0 to N-1.
sizes = range(100,10000, 100)</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab13_09?rev=1241060522">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-29T23:02:02-05:00</dc:date>
        <title>cs190c:lab13_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab13_09?rev=1241060522</link>
        <description>Python Dictionaries Review

Recall that dictionaries are Python are used to associate data with a key that can be of any time (as opposed to a list, where a key is always an integer). In this lab, you will use a dictionary that has a string as a key and an integer as the associated data. In the lab, whenever you come across a word, you want to add one to the associated number. The problem is, the word is not always in the dictionary already (which means it has occurred 0 times). We can use the g…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab14?rev=1216916053">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:14:13-05:00</dc:date>
        <title>cs190c:lab14</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab14?rev=1216916053</link>
        <description>Lab 14: First Hour

For today's lab, you are to work independently.   You will have one hour to complete the assignment.  If, at the expiration of this one hour, you are unfinished, submit what you have finished. 

Write a program that will encrypt and decrypt simple lower-case strings using a substitution cipher, like a cryptoquote.  The key, or the mapping from the plaintext letters to the code letters is given in .  This is only one possible mapping, there are 26!-1 different mappings.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab14_09?rev=1241061412">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-29T23:16:52-05:00</dc:date>
        <title>cs190c:lab14_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab14_09?rev=1241061412</link>
        <description>Recursion Revisited

Fast Exponentiation

 


def recPower(a, n):
# raises a to the n-th power
    print &quot;n =&quot;, n
    if n ==  0:
        return 1
    else:
        factor = recPower(a, n/2)
        if n%2 == 0:    	# n is even
            return factor*factor
        else:           	# n is odd
            return factor*factor*a

if __name__ == &quot;__main__&quot;:
    print recPower(2,25)</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab15?rev=1209137025">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T11:23:45-05:00</dc:date>
        <title>cs190c:lab15</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab15?rev=1209137025</link>
        <description>*  Ending Survey
	*  Review for the final and donuts
	*  TA Evaluation</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab15_09?rev=1241191936">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-01T11:32:16-05:00</dc:date>
        <title>cs190c:lab15_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab15_09?rev=1241191936</link>
        <description>Final Exam Review

A sample final exam is posted on Blackboard for your reviewing pleasures.

Computability Review

	*  Problem 1: Write a program to find the smallest positive integral solution to x^2 - 4729494y^2 = 1. 
	*  Problem 2: Given a list of numbers, divide it into two new lists that add up to the same sum.
	*  Problem 3: Write a Python P program that takes an an input another Python program Q which has no input. P should decide if Q ever prints “done”.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab1_09?rev=1233819340">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-05T02:35:40-05:00</dc:date>
        <title>cs190c:lab1_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab1_09?rev=1233819340</link>
        <description>Links of Interest

	*  Course survey
	*  Accessing your ITaP home drive from another computer:
		*  &lt;http://help.itap.purdue.edu/viewarticle.php?articleid=367&amp;refid=4&gt;
		*  &lt;http://help.itap.purdue.edu/viewarticle.php?articleid=515&amp;refid=4&gt;
		*  For CS home drive, replace rosetta.ics.purdue.edu with vermouth.cs.purdue.edu</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab2?rev=1208533113">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-18T11:38:33-05:00</dc:date>
        <title>cs190c:lab2</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab2?rev=1208533113</link>
        <description>Matrix multiplication using arrays.  

	*  Read in number n which indicates the dimensions of the matrix.  
			*  Create the matrix array with the zeros function, reading in n^2 numbers from file matrixA.txt.  
			*  After reading in the matrix A, print out A.  
			*  Next, read in n^2 numbers from file matrixB.txt.   
			*  Next, print out matrix B.  
			*  Note: solution below reads row by row and reads files simultaneously
			*  Then, use matrix multiplication to calculate A*B, and print out …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab2_09?rev=1233819314">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-05T02:35:14-05:00</dc:date>
        <title>cs190c:lab2_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab2_09?rev=1233819314</link>
        <description>Demo Problems

import math

def main():
    y = input('Enter number of terms for approximation of e: ')
    total = 0.0
    fac = 1
    for i in range(y):
        total += 1.0 / fac
        fac *= i + 1
    print 'The approximated value of e is:', total
    print 'The actual value from math.e is:', math.e

main()</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab3?rev=1216915903">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:11:43-05:00</dc:date>
        <title>cs190c:lab3</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab3?rev=1216915903</link>
        <description>Lab 3: Examples using functions (first hour)


## What do these functions return?
def mystery(x):
    if x &gt; 8:
        return 1;
    if x &lt; 3:
        return 5;
    else:
        return 10;

val = 2
mystery(val)
mystery(mystery(val))
mystery(mystery(mystery(val)))</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab3_09?rev=1233819293">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-05T02:34:53-05:00</dc:date>
        <title>cs190c:lab3_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab3_09?rev=1233819293</link>
        <description>Demo Problems

def main():
    f = open('actor2.txt', 'r')
    previous_year = ''
    for line in f:
        nomination = line.split(',')
        if nomination[0] != previous_year:
            print nomination[1]
        previous_year = nomination[0]
    f.close()

main()</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab4?rev=1216915871">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:11:11-05:00</dc:date>
        <title>cs190c:lab4</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab4?rev=1216915871</link>
        <description>*  Plot function for vertical percolation in Matplotlib  
		*  the function is f(p) = 1–(1-p^n)^n  
		*  plotting multiple figures in different frames [ code] and plotting all graphs in one frame [ code]


	*  While loop that loops until something is true.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab4_09?rev=1234364450">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-11T10:00:50-05:00</dc:date>
        <title>cs190c:lab4_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab4_09?rev=1234364450</link>
        <description>Demo Problems

Visualizing an Audio File

Download this file  and make sure it's called moon.wav instead of cs190c_moon.wav or anything else. Then, save the below code in a .py file in the same location you saved the moon.wav and run it. 

import snd_io
import snd_utils

if __name__ == '__main__':
    data = snd_io.read_wav_file('moon.wav')
    snd_utils.view_wav(data, 0, 500)</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab5?rev=1208533228">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-18T11:40:28-05:00</dc:date>
        <title>cs190c:lab5</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab5?rev=1208533228</link>
        <description>*  Example of recursion: Using VPython to draw an H-tree. [Source code.]
		*  In-Lab Problem: Write a recursive function that takes as one parameter -- a list with nested lists containing integers.  Sum up all the elements.
			*  Hint: You will want to use the following syntax in your program.
if type(L) == list:</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab5_09?rev=1234544333">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-13T11:58:53-05:00</dc:date>
        <title>cs190c:lab5_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab5_09?rev=1234544333</link>
        <description>Demo Problems

Random Grid Visualization

from visual import *
from random import randint

def visualize(grid):
    global scene

    #hide all the objects in the scene
    for object in scene.objects:
        object.visible = False

    rows = len(grid)                        # get number of rows
    cols = len(grid[0])                     # get number of cols

    for row in range(rows):      
        for col in range(cols):

            # Choose the color for the box.  Colors are specified in…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab6?rev=1216915834">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:10:34-05:00</dc:date>
        <title>cs190c:lab6</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab6?rev=1216915834</link>
        <description>Lab 6: First hour

	*  Returned exam and discussed related issues. [  Exam 1 solutions.]
		*  Spoke about academic misconduct.
			*  High level discussion is acceptable collaboration on the problem sets.  Copying of code is cheating, and will be reported.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab6_09?rev=1235681627">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-26T15:53:47-05:00</dc:date>
        <title>cs190c:lab6_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab6_09?rev=1235681627</link>
        <description>Demo Problems

Optional Arguments for Functions

&gt;&gt;&gt; def f(a, b, c):
	print a, b, c

&gt;&gt;&gt; f(1, 2, 3)
1 2 3
&gt;&gt;&gt; f(c=1, b=2, a=3)
3 2 1
&gt;&gt;&gt; def f(a, b, c=3):
	print a, b, c

&gt;&gt;&gt; f(1, 2, 3)
1 2 3
&gt;&gt;&gt; f(1, 2)
1 2 3
&gt;&gt;&gt; def f(l=[]):
	l.append(1)
	return l

&gt;&gt;&gt; f()
[1]
&gt;&gt;&gt; f()
[1, 1]
&gt;&gt;&gt; f()
[1, 1, 1]</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab7?rev=1216915777">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:09:37-05:00</dc:date>
        <title>cs190c:lab7</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab7?rev=1216915777</link>
        <description>*  Discussion of numerical stability
			*  Binary decimal structure.  Is it possible to represent every number exactly? 
&gt;&gt;&gt; a = 3.1
&gt;&gt;&gt; a
3.1000000000000001
&gt;&gt;&gt; a = 35.95
&gt;&gt;&gt; a
35.950000000000003

			*  IEEE floating point structure
			*  Numpy's round allows you to choose the number of decimal places, but how can you floor a decimal to two places?
a = floor(a * 100.0)/100.0</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab7_09?rev=1235948623">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-01T18:03:43-05:00</dc:date>
        <title>cs190c:lab7_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab7_09?rev=1235948623</link>
        <description>In-Lab Problem

Download the following files:  and [percolation_provided.py].

Your task is to implement a simple, vertical percolation algorithm. In vertical percolation, you start at the top of the grid and check whether there exists a column allowing flow to the bottom (which does not include left or right flow). In other words, a grid percolates vertically if there is a column of zeroes in the grid.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab8?rev=1216915725">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:08:45-05:00</dc:date>
        <title>cs190c:lab8</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab8?rev=1216915725</link>
        <description>The variance of n sample values \(x_1\), \(x_2\), ... , \(x_n\) is one measure of statistical dispersion, obtained by averaging the squared distance of the sample values from the expected value (mean). The mean captures the location of a distribution and the variance captures the degree of the values being spread out. The square root of the variance is called the standard deviation.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab8_09?rev=1236732391">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-10T20:46:31-05:00</dc:date>
        <title>cs190c:lab8_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab8_09?rev=1236732391</link>
        <description>In-Lab Problem

Today's lab involves solving Sudoku puzzles using recursion. If you are already familiar with Sudoku, you can skip the introduction section.

Download the following file: 

Here is a GUI version on which you can watch the recursion working:</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab9?rev=1216915957">
        <dc:format>text/html</dc:format>
        <dc:date>2008-07-24T12:12:37-05:00</dc:date>
        <title>cs190c:lab9</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab9?rev=1216915957</link>
        <description>Lab 9: Part 1

	*  Go over trees from Wednesday lecture
			*  [Binary Tree]
			*  [File System Tree]

	*  In-lab assignment
			*  To the binary tree program, you are to add a function that performs a post order traversal of the tree.  (This is what is provided as input to create a tree.)  This means that if you are at a node, add the traversal of the left node to the string, then the traversal of the right node to the string, then the node itself.  After writing the function, write a __main__ pr…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:lab9_10?rev=1238014951">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-25T17:02:31-05:00</dc:date>
        <title>cs190c:lab9_10</title>
        <link>http://secant.cs.purdue.edu/cs190c:lab9_10?rev=1238014951</link>
        <description>In-Lab Problem</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:labs?rev=1209136906">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-25T11:21:46-05:00</dc:date>
        <title>cs190c:labs</title>
        <link>http://secant.cs.purdue.edu/cs190c:labs?rev=1209136906</link>
        <description>Lab 15 - April 25 

 Lab 14 - April 18 

 Lab 13 - April 11 

 Lab 12 - April 4 

 Lab 11 - March 28 

 Lab 10 - March 21 

 Lab 9 - March 7 

 Lab 8 - February 29 

 Lab 7 - February 22

 Lab 6 - February 15

 Lab 5 - February 8

 Lab 4 - February 1</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:labs09?rev=1240773441">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-26T15:17:21-05:00</dc:date>
        <title>cs190c:labs09</title>
        <link>http://secant.cs.purdue.edu/cs190c:labs09?rev=1240773441</link>
        <description>CS 190C, Spring 2009: Lab Assignments
 DateTopic Lab 15   May 1  Review Problems   Lab 14   April 24  Recursion Revisited  Lab 13   April 17  Dictionaries  Lab 12   April 10  Solve a Graph Problem, Cytoscape  Lab 11   April 3  Basic NetworkX operations  Lab 10   March 27  Numerical instabilities     March 20  spring break  Lab 9   March 13  work on project 2; no other in-lab work Lab 8  March 6  Recursion  Lab 7  February 27  Percolation   Lab 6  February 20  MatPlotLib  Lab 5  February 13  VPyt…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:links?rev=1231528849">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-09T14:20:49-05:00</dc:date>
        <title>cs190c:links</title>
        <link>http://secant.cs.purdue.edu/cs190c:links?rev=1231528849</link>
        <description>Helpful links

Python Related

	*  Python Tutorial, Guido van Rossum;  download from &lt;http://docs.python.org/tut/&gt; 
	*  Python Basics: &lt;http://www.astro.ufl.edu/~warner/prog/python.html&gt; (good summary of useful features) 
	*  Debugging from “How to Think like a Python Programmer” by Allen B. Downey - [pdf] file</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:more_detail?rev=1201819639">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-31T17:47:19-05:00</dc:date>
        <title>cs190c:more_detail</title>
        <link>http://secant.cs.purdue.edu/cs190c:more_detail?rev=1201819639</link>
        <description>Project 1: Specification of Required Functions

 This section gives the specifications for the functions you are required to implement.  The name and parameters of each function should not be changed.  While the specifications may look long and, it may seem, will take a lot of code to implement, the functions are, in fact, quite short. Be sure to understand and follow the conventions given next.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:notes?rev=1231768258">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-12T08:50:58-05:00</dc:date>
        <title>cs190c:notes</title>
        <link>http://secant.cs.purdue.edu/cs190c:notes?rev=1231768258</link>
        <description>Spring 2008 Lecture Material

 This page contains the slides and programs used in class. This material will generally be posted after the lecture. Material covered using the Python interpreter may not be included. 
DateTopicFilesWed, Apr 23  Quantum Computing; Course evaluations  Mon, Apr 21  Complexity; DNA Computing   Wed, Apr 16  Computability  Mon, Apr 14  One more data structure: kd-trees  Wed, Apr 9   History of Computer Science   Mon, Apr 7  Scientific Computing   Wed, Apr 2  Scientific C…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:notes09?rev=1241022904">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-29T12:35:04-05:00</dc:date>
        <title>cs190c:notes09</title>
        <link>http://secant.cs.purdue.edu/cs190c:notes09?rev=1241022904</link>
        <description>Spring 2009 Lecture Material

 This page contains the slides and programs used in class. This material will generally be posted after the lecture. Material covered using the Python interpreter may not be included. 
DateTopicFilesWed, Apr 29   DNA Computing &amp; Review    Mon, Apr 27   Complexity  Wed, Apr 22   Computability  Mon, Apr 20  History of Computing   Wed, Apr 15   Dictionaries    Mon, Apr 13   Graphs, Intro to Dictionaries    Wed, Apr 8   Bioinformatics: Protein interactions   Mon, Apr 6 …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:nvsenergy1.png?rev=1237926193">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-24T16:23:13-05:00</dc:date>
        <title>cs190c:nvsenergy1.png</title>
        <link>http://secant.cs.purdue.edu/cs190c:nvsenergy1.png?rev=1237926193</link>
        <description></description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:objout?rev=1226441400">
        <dc:format>text/html</dc:format>
        <dc:date>2008-11-11T17:10:00-05:00</dc:date>
        <title>cs190c:objout</title>
        <link>http://secant.cs.purdue.edu/cs190c:objout?rev=1226441400</link>
        <description>Objectives

The course introduces students to the principles of computational thinking.   Programming methods and computational principles are introduced in a problem-driven way using Python and making extensive use of Python libraries. Upon completion of the course, students:</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:policies?rev=1199478164">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-04T15:22:44-05:00</dc:date>
        <title>cs190c:policies</title>
        <link>http://secant.cs.purdue.edu/cs190c:policies?rev=1199478164</link>
        <description>Academic Integrity Policy  As a student at Purdue you are subject to the Purdue University Student Code of Conduct, which enjoins you to respect the highest standards of honesty and integrity. As a student in the Computer Science Department you must also read and sign the Department Academic Integrity Policy (use your Purdue Career Account login and password to access).</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset1?rev=1200084392">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-11T15:46:32-05:00</dc:date>
        <title>cs190c:problemset1</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset1?rev=1200084392</link>
        <description>Posted: Friday, January 11, 2008 

Due: Thursday, January 17, 2008, 10pm (electronic submission via Blackboard)

You have the following choice: Complete problems 1, 2, 3, and 4. Or, complete problems 2, 4, and 5. 

Each program should be in a separate file.  Name your files problem1.py through problem5.py. This is a good template for your programs for this problem set.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset1_09?rev=1232569272">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-21T15:21:12-05:00</dc:date>
        <title>cs190c:problemset1_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset1_09?rev=1232569272</link>
        <description>Posted: Friday, January 16, 2009

Due: Friday, January 23, 2009, 10pm (electronic submission via Blackboard)

Each program should be in a separate file.  Name your files problem1.py and problem2.py. Please use the following template for your programs.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset1sol_09?rev=1233332645">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-30T11:24:05-05:00</dc:date>
        <title>cs190c:problemset1sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset1sol_09?rev=1233332645</link>
        <description># CS190C: Spring 2009
# Daniel Tang
# Problem Set 1, Problem 1

def main():
    print 'This program calculates the wind chill, given a temperature in'
    print 'degrees Fahrenheit and wind speed in miles per hour.'
    print
    t = input('Enter the temperature in degrees Fahrenheit: ')
    v = input('Enter the wind speed in miles per hour: ')
    # Calculate the wind chill w. This should mostly look like graphing
    # calculator syntax on the right-hand side of the equals sign. The only
    #…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset2?rev=1233192827">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-28T20:33:47-05:00</dc:date>
        <title>cs190c:problemset2</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset2?rev=1233192827</link>
        <description>Posted: Friday, January 18, 2008 

Due: Thursday, January 24, 2008, 10pm (electronic submission via Blackboard)

Each program should be in a separate file.  Name your files problem1.py through problem3.py. This is a good template for your programs for this problem set.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset2_09?rev=1232978237">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-26T08:57:17-05:00</dc:date>
        <title>cs190c:problemset2_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset2_09?rev=1232978237</link>
        <description>Posted: Friday, January 23, 2009

Due: Friday, January 30, 2009, 10pm (electronic submission via Blackboard)

Each program should be in a separate file.  Name your files problem1.py and problem2.py. Please use the following template for your programs.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset2sol_09?rev=1233899939">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-06T00:58:59-05:00</dc:date>
        <title>cs190c:problemset2sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset2sol_09?rev=1233899939</link>
        <description>import math

def main():
    x = input('Enter value to get sine of in radians: ')
    if 0 &lt;= x &lt;= 2*math.pi:
        n = input('Enter number of iterations for approximation: ')
        total = 0.0
        fac = 1
        xp = x
        sign = 1
        for i in range(1, 2*n, 2):
            total += sign * xp / fac
            xp *= x ** 2
            fac *= (i+1)*(i+2)
            sign *= -1
        real_sin = math.sin(x)
        print 'The approximated value of the sine of', x, 'is:', total
 …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset3?rev=1233189101">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-28T19:31:41-05:00</dc:date>
        <title>cs190c:problemset3</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset3?rev=1233189101</link>
        <description>Posted: Friday, January 25, 2008 

Due: Friday, February 1, 2008, 10pm (electronic submission via Blackboard)

The functions for each problems should be in a separate file.  Name your files problem1.py and problem2.py. In addition, return file ps3_p2_lib.py (independent of any changes you made)</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset3_09?rev=1233407662">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-31T08:14:22-05:00</dc:date>
        <title>cs190c:problemset3_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset3_09?rev=1233407662</link>
        <description>Posted: Friday, January 30, 2009

Due: Friday, February 6, 2009, 10pm (electronic submission via Blackboard)

Your code for each problem should be in a separate file.  Name the files problem1.py and problem2.py and make sure to follow any additional instructions given within each problem.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset3sol_09?rev=1234535709">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-13T09:35:09-05:00</dc:date>
        <title>cs190c:problemset3sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset3sol_09?rev=1234535709</link>
        <description>Alternate DNA_complement: 

def DNA_complement(str):
    str = str.replace('a','x')
    str = str.replace('t','a')
    str = str.replace('x','t')
    str = str.replace('g','y')
    str = str.replace('c','g')
    str = str.replace('y','c')
    return str</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:problemset4?rev=1208177706">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-14T08:55:06-05:00</dc:date>
        <title>cs190c:problemset4</title>
        <link>http://secant.cs.purdue.edu/cs190c:problemset4?rev=1208177706</link>
        <description>Posted: Monday, April 14, 2008 

Due: Wednesday, April 23, 2008, 10pm 

Introduction

 In Problem 2 of  Problem Set 3, you wrote three functions that implemented queries on points.  The function scanned a list of points stored in arbitrary order.  This problem set revisits spatial queries for 2-dimensional data sets, but uses a more efficient technique for storing and accessing the data.  We consider three queries--find_point, in_rect, and closest--along with two data structures for their implem…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project1?rev=1202321157">
        <dc:format>text/html</dc:format>
        <dc:date>2008-02-06T13:05:57-05:00</dc:date>
        <title>cs190c:project1</title>
        <link>http://secant.cs.purdue.edu/cs190c:project1?rev=1202321157</link>
        <description>Posted: February 1, 2008

Due dates: 

	*  Part 1: Friday, February 8, 10pm
	*  Part 2: Friday, February 15, 10pm  

Introduction

In this project you will explore the generation and manipulation of digital sound. You will write basic functions that generate sounds, read/write .wav files, and alter and transform sounds waves based on common principles.  You will then use the functions to generate interesting sounds serving certain needs.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project1_09?rev=1234505829">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-13T01:17:09-05:00</dc:date>
        <title>cs190c:project1_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project1_09?rev=1234505829</link>
        <description>Posted: February 6, 2009

Due dates: 

	*  Part 1: Friday, February 13, 10pm
	*  Part 2: Wednesday, February 25, 10pm  

Introduction

In this project you will explore the generation and manipulation of digital sound. You will write basic functions that generate, alter and transform sounds waves based on specified  principles.  You will then use the functions to generate new sounds. In particular, choosing a characteristic sound snippet (clap, cough, bark, etc), you will generate a “massive re…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project1sol_09?rev=1234795605">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-16T09:46:45-05:00</dc:date>
        <title>cs190c:project1sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project1sol_09?rev=1234795605</link>
        <description>import math
#
# math.sin(t) - calculate sin() for t in radians
#

from numpy import zeros, empty, array, append, int16
import numpy
from snd_io import *

#
# zeros(n) - create an array of zeros
# empty(n) - create an empty (uninitialized) array
# array(l) - construct an array from a list
# append(a,b) - append array b to a and return the result
#

# Helpful constants
WAVE_MAX = 32767            # Max sample value
WAVE_MIN = -32768           # Min sample value
SAMPLE_FREQUENCY = 22050    # Sampli…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project2?rev=1234806974">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-16T12:56:14-05:00</dc:date>
        <title>cs190c:project2</title>
        <link>http://secant.cs.purdue.edu/cs190c:project2?rev=1234806974</link>
        <description>Posted: February 15, 2008

Due dates: 

	*  Part 1: Friday, February 22, 10pm
	*  Part 2: Friday, February 29, 10pm  

Introduction

	*   Imagine a landscape filled with patches of dry grass. A fire has started at one end and it jumps from one patch to another. What is the probability that the fire manages to cross the entire area? 
	*  Imagine a system composed of randomly distributed insulating and metallic materials. What is the probability that the system is an electric conductor?
	*  Imagin…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project2_09?rev=1236958577">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-13T11:36:17-05:00</dc:date>
        <title>cs190c:project2_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project2_09?rev=1236958577</link>
        <description>Posted: Thursday, February 26, 2009

Due dates: 

	*  Part 1: Friday,  March 6, 10pm
	*  Part 2: Friday,  March 13, 10pm 

Introduction

	*   Imagine a landscape filled with patches of dry grass. A fire has started at one end and it jumps from one patch to another. What is the probability that the fire manages to cross the entire area? 
	*  Imagine a system composed of randomly distributed insulating and metallic materials. What is the probability that the system is an electric conductor?
	*  Im…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project2sol_09?rev=1237318623">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-17T15:37:03-05:00</dc:date>
        <title>cs190c:project2sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project2sol_09?rev=1237318623</link>
        <description>percolation_wave.py

from visual import rate
from percolation_provided import *
def percolation_wave(input_grid, trace=False, short=True):
    &quot;&quot;&quot;
    Percolation algorithm by wave. Uses input_grid to determine where flow is
    allowed, trace to determine whether or not to visualize it graphically,
    and short to determine whether or not to exit early. Essentially, if your
    algorithm exits early, the code inside the 'if short' condition is what
    your code might look like.
    &quot;&quot;&quot;
    fl…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project3?rev=1204304276">
        <dc:format>text/html</dc:format>
        <dc:date>2008-02-29T11:57:56-05:00</dc:date>
        <title>cs190c:project3</title>
        <link>http://secant.cs.purdue.edu/cs190c:project3?rev=1204304276</link>
        <description>Posted: Friday, February 29, 2008

Due dates: 

	*  Part 1, Ideal gas simulation, Friday, March 7, 10pm; 
	*  Part 2, Ising spin simulation, Friday March 21, 10pm  

Introduction

 You have already seen a number of examples using randomization to solve problems and to generate experimental results. In the percolation project, grids were generated according to a specified probability distribution to experimentally determine the percolation probability. This approach is an example of a Monte Carlo…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project3_09?rev=1237926553">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-24T16:29:13-05:00</dc:date>
        <title>cs190c:project3_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project3_09?rev=1237926553</link>
        <description>Posted: Monday,  March 23, 2009

Due date: Friday, April 3, 2009  

Introduction

 You have already seen a number of examples using randomization to solve problems and to generate experimental results. In the percolation project, grids were generated according to a specified probability distribution to experimentally determine the percolation probability. This approach is an example of a Monte Carlo method, an algorithm that relies on repeated random sampling to compute results. Monte Carlo meth…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project3c_09?rev=1240191954">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-19T21:45:54-05:00</dc:date>
        <title>cs190c:project3c_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project3c_09?rev=1240191954</link>
        <description>Posted: Monday, April 20, 2009

Due date: Friday, Mai 1, 2009, 10pm

In part I of the project on the Monte Carlo “demon algorithm” you used the demon algorithm to simulate a simple, uniform physical system representing ideal gas with moving molecules inside a closed container. The extension of this project considers the Ising Model, which simulates an idealized 2-D lattice arrangement of particles that have a spin; i.e., their state is either +1 or -1. Such a system models, for example, magn…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project3sol_09?rev=1239664476">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-13T19:14:36-05:00</dc:date>
        <title>cs190c:project3sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project3sol_09?rev=1239664476</link>
        <description>#! /usr/bin/python

# Tools for randomness
# randint - pick a random integer in the given closed interval
# uniform - generate a (floating point) random number from the given interval
from random import randint, uniform
from math import sqrt
import pylab

def setupGraph(title, xlabel, ylabel, hold=False):
    pylab.title(title)
    pylab.xlabel(xlabel)
    pylab.ylabel(ylabel)
    pylab.grid(True)
    pylab.hold(hold)
    
def ideal_gas(
        N,                              # Number of partic…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project4?rev=1207572064">
        <dc:format>text/html</dc:format>
        <dc:date>2008-04-07T08:41:04-05:00</dc:date>
        <title>cs190c:project4</title>
        <link>http://secant.cs.purdue.edu/cs190c:project4?rev=1207572064</link>
        <description>Posted: March 28, 2008

Due dates: 

	*  Part 1: Friday, April 4, 10pm
	*  Part 2: Friday, April 11, 10pm  

  Most cellular processes are carried out by complexes of multiple physically interacting proteins. Identifying and analyzing the components of these complexes provides insights into the functional mechanisms in cells. Modern experimental technologies, such as yeast-to-hybrid and co-precipitation combined with mass spectrometry, allow us to investigate the components of the complexes on a…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project4_09?rev=1240257243">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-20T15:54:03-05:00</dc:date>
        <title>cs190c:project4_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project4_09?rev=1240257243</link>
        <description>Posted: Monday, April 6, 2009

Due date:  Friday, April 17, 10pm  

  Most cellular processes are carried out by complexes of multiple physically interacting proteins. Identifying and analyzing the components of these complexes provides insights into the functional mechanisms in cells. Modern experimental technologies, such as yeast-to-hybrid and co-precipitation combined with mass spectrometry, allow us to investigate the components of the complexes on a large scale. However, data from these te…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project4c_09?rev=1240341571">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-21T15:19:31-05:00</dc:date>
        <title>cs190c:project4c_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project4c_09?rev=1240341571</link>
        <description>Posted: Monday, April 20, 2009

Due date: Friday, May 1, 2009, 10pm

In Part I of the Protein-Protein Interaction Project you used the MCL algorithm to find clusters which were then evaluated by computing coverage and performance.  These two metrics are based on properties of the graph.  In Part II, you will evaluate the quality of the clustering using biological information obtained from the Gene Ontology (GO).  GO is a publicly available set of structured vocabularies that describe various asp…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:project4sol_09?rev=1240260544">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-20T16:49:04-05:00</dc:date>
        <title>cs190c:project4sol_09</title>
        <link>http://secant.cs.purdue.edu/cs190c:project4sol_09?rev=1240260544</link>
        <description>#! /usr/bin/env python

import networkx
import pylab
import numpy
from bio_provided_sp09 import *

def preprocess_graph(G):
    print 'Graph G has', len(G), 'nodes and', len(G.edges()), 'edges.'

    C = networkx.connected_component_subgraphs(G)

    print 'There are', len(C), 'connected components.'

    sizes = []
    for g in C:
        pylab.figure(0)
        sizes.append(len(g))

    max_size = max(sizes)
    print 'The largest component has', max_size, 'nodes.'

    if len(C) &gt; 1:
        …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:projects?rev=1221751775">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-18T11:29:35-05:00</dc:date>
        <title>cs190c:projects</title>
        <link>http://secant.cs.purdue.edu/cs190c:projects?rev=1221751775</link>
        <description>Project 1: Manipulating Digital Audio:  Description 

Project 2: Computational Experiments on Percolation in Grids:    Description  

Project 3: Simulating Physical Systems:  Description 

Project 4: Analyzing Protein-Protein Interactions  Description</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:projects09?rev=1240266287">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-20T18:24:47-05:00</dc:date>
        <title>cs190c:projects09</title>
        <link>http://secant.cs.purdue.edu/cs190c:projects09?rev=1240266287</link>
        <description>Description TopicSample Solutions Project 1   Manipulating and creating sound files  Solution  Project 2   Percolation in Grids     Project 3  Simulating a Physical System  Solution  Project 4  Analyzing Protein Interactions   Solution  Project3c Project4c Continuing Project 3 or 4</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:provide?rev=1240339159">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-21T14:39:19-05:00</dc:date>
        <title>cs190c:provide</title>
        <link>http://secant.cs.purdue.edu/cs190c:provide?rev=1240339159</link>
        <description>input graphs

  

 

 

 



GO matrices - IGNORE for part I

 







Clustering

If you use this clustering, you probably need to also write a function to read this file in. The function should skip the first line, which is used for cytoscape, and then split all other lines by the equals sign. The right side is the cluster number and the left side is the node name.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:ps3_p2_lib.py?rev=1201279887">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-25T11:51:27-05:00</dc:date>
        <title>cs190c:ps3_p2_lib.py</title>
        <link>http://secant.cs.purdue.edu/cs190c:ps3_p2_lib.py?rev=1201279887</link>
        <description>from visual import box, sphere, vector

def read_points(filename):
    &quot;&quot;&quot;
    Read points from file filename.

    &gt;&gt;&gt; read_points(&quot;testdata0.txt&quot;)
    [[0.0, 0.0], [1.0, -1.0], [2.0, 3.0]]
    &quot;&quot;&quot;

    file = open(filename, 'r')
    points = []                             #initialize our list of points

    for line in file:
        point = []                          #a point is just a list of numbers
        str_coords = line.split()           #split the line
                                …</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:ps3problems2.py?rev=1201278915">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-25T11:35:15-05:00</dc:date>
        <title>cs190c:ps3problems2.py</title>
        <link>http://secant.cs.purdue.edu/cs190c:ps3problems2.py?rev=1201278915</link>
        <description>from ps3_p2_lib import *

&quot;&quot;&quot;
    This is the skeleton file for problem set 3, problem 2.
&quot;&quot;&quot;

def distance(p, q):
    return 0  #return distance 

def closest(points, p):
    return [5,5]  #return closest point

def nearest_neighbors(points):
    return  [[0,0], [5,5]]  #return pair of points

def in_rect(points, p, q):
    return 0   #return number of points</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:psets?rev=1221751682">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-18T11:28:02-05:00</dc:date>
        <title>cs190c:psets</title>
        <link>http://secant.cs.purdue.edu/cs190c:psets?rev=1221751682</link>
        <description>Problem Set 1   Problem Set 2   Problem Set 3  Problem Set 4</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:psets09?rev=1234421565">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-12T01:52:45-05:00</dc:date>
        <title>cs190c:psets09</title>
        <link>http://secant.cs.purdue.edu/cs190c:psets09?rev=1234421565</link>
        <description>DescriptionTopicSample Solutions Problem Set 1   Warmup problems  Solution  Problem Set 2   Approximations of sin(x) and pi  Solution  Problem Set 3  String and list manipulations  Solution  Problem Set 4</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:publiccal?rev=1197039363">
        <dc:format>text/html</dc:format>
        <dc:date>2007-12-07T09:56:03-05:00</dc:date>
        <title>cs190c:publiccal</title>
        <link>http://secant.cs.purdue.edu/cs190c:publiccal?rev=1197039363</link>
        <description></description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:requiredfunc09?rev=1234190375">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-09T09:39:35-05:00</dc:date>
        <title>cs190c:requiredfunc09</title>
        <link>http://secant.cs.purdue.edu/cs190c:requiredfunc09?rev=1234190375</link>
        <description>Spring 09, Project 1: Specification of Required Functions

 This section gives the specifications for the functions you are required to implement.  The name and parameters of each function should not be changed.  While the specifications may look long, they will take a lot of code to implement. Be sure to understand and follow the conventions given next.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:sample_ideal_gas_discussion?rev=1206335427">
        <dc:format>text/html</dc:format>
        <dc:date>2008-03-24T01:10:27-05:00</dc:date>
        <title>cs190c:sample_ideal_gas_discussion</title>
        <link>http://secant.cs.purdue.edu/cs190c:sample_ideal_gas_discussion?rev=1206335427</link>
        <description>The ideal gas simulation was run for several values of N, from N=50 to 500 in increments of 50.  Each run was done with with steps=3000 and totalEnergy=500. This is still considered a small-size experiment and some of the irregularities in the plots may be due to N no larger than 500.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:sidebar?rev=1228859382">
        <dc:format>text/html</dc:format>
        <dc:date>2008-12-09T16:49:42-05:00</dc:date>
        <title>cs190c:sidebar</title>
        <link>http://secant.cs.purdue.edu/cs190c:sidebar?rev=1228859382</link>
        <description>Course Website

	*  09 Course Home
	*  Syllabus
	*  Objectives and Outcomes
	*  Catalog Description
	*  S09 Course Notes
	*  S09 Problem Sets
	*  S09 Projects

SECANT Website

	*  SECANT Home</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:start-s09?rev=1241360762">
        <dc:format>text/html</dc:format>
        <dc:date>2009-05-03T10:26:02-05:00</dc:date>
        <title>cs190c:start-s09</title>
        <link>http://secant.cs.purdue.edu/cs190c:start-s09?rev=1241360762</link>
        <description>Welcome to the spring 2009 home page of CS190C, Introduction to Computational Thinking. The course introduces science majors to computational thinking via basic programming concepts, data and data management concepts, simulation, and visual interaction. The course will use Python and various Python libraries including VPython, NumPy, and NetworkX.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:start?rev=1240248642">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-20T13:30:42-05:00</dc:date>
        <title>cs190c:start</title>
        <link>http://secant.cs.purdue.edu/cs190c:start?rev=1240248642</link>
        <description>Welcome to the spring 2008 home page of CS190C, Introduction to Computational Thinking. The course introduces science majors to computational thinking via basic programming concepts, data and data management concepts, simulation, and visual interaction. The course will use Python and various Python libraries including VPython, NumPy, and NetworkX.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:stereo09?rev=1234283496">
        <dc:format>text/html</dc:format>
        <dc:date>2009-02-10T11:31:36-05:00</dc:date>
        <title>cs190c:stereo09</title>
        <link>http://secant.cs.purdue.edu/cs190c:stereo09?rev=1234283496</link>
        <description>Stereo Sounds

 Until now we have considered only monaural sounds, however the very same principles apply to stereophonic sounds.  The advantage of stereo sound is that it allows a sound to be “positioned” from left to right. The human ear determines the position of a sound, in part, by the relative intensities of the sound in the left and right ears.  Stereo sounds have two independent channels, one for each ear.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:syllabus?rev=1227127698">
        <dc:format>text/html</dc:format>
        <dc:date>2008-11-19T15:48:18-05:00</dc:date>
        <title>cs190c:syllabus</title>
        <link>http://secant.cs.purdue.edu/cs190c:syllabus?rev=1227127698</link>
        <description>Part I: Basic Tools (6 weeks)

	*  Introduction to Python.  Elementary values and data types.  	
	*  Straight line programs, assignments to variables, type conversion, math library.
	*  Strings, lists, and tuples.  Vectors and arrays. Conditionals and loop structures.
	*  Plotting using MatPlotLib and 3D visualization in VPython.
	*  Functions, parameters, and scope. Recursion.
	*  Exam 1</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:ta?rev=1222789808">
        <dc:format>text/html</dc:format>
        <dc:date>2008-09-30T11:50:08-05:00</dc:date>
        <title>cs190c:ta</title>
        <link>http://secant.cs.purdue.edu/cs190c:ta?rev=1222789808</link>
        <description>Teaching Assistants 

	*  Aaron Lint, GTA, &lt;alint@cs.purdue.edu&gt;
		*  Appointments are preferred and encouraged.
		*  Questions related to labs, grading and record-keeping, problem sets and projects. 


	*  Kanchi Daiya, UTA, kdaiya@purdue.edu
		*  lab assistant</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:ta09?rev=1233179114">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-28T16:45:14-05:00</dc:date>
        <title>cs190c:ta09</title>
        <link>http://secant.cs.purdue.edu/cs190c:ta09?rev=1233179114</link>
        <description>Teaching Assistants 

	*  Daniel Tang, GTA,  &lt;dytang@cs.purdue.edu&gt;
		*  Office hours: Tuesday/Thursday, 3-4pm or by appointment
		*  Office: LWSN Commons


	*  Lauren Stuart, UTA, &lt;lstuart@purdue.edu&gt;
		*  Lab assistant  


 Research Assistants working on the SECANT Project</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:textsoft?rev=1199902027">
        <dc:format>text/html</dc:format>
        <dc:date>2008-01-09T13:07:07-05:00</dc:date>
        <title>cs190c:textsoft</title>
        <link>http://secant.cs.purdue.edu/cs190c:textsoft?rev=1199902027</link>
        <description>Required Text Books

	*  Python Programming: An Introduction to Computer Science, John Zelle, Franklin, Beedle &amp; Associates, 2004.
	*  Python in a Nutshell, Alex Martelli, O'Reilly, 2006

Related material

	*  Python Tutorial, Guido van Rossum, 2006;  download from &lt;http://docs.python.org/tut/&gt; 
	*  How to Think Like a (Python) Programmer by Allen B. Downey; &lt;http://www.greenteapress.com/thinkpython/&gt; - free textbook from Green Tea Press. More a traditional CS intro programming text, but some of…</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:textsoft09?rev=1232642198">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-22T11:36:38-05:00</dc:date>
        <title>cs190c:textsoft09</title>
        <link>http://secant.cs.purdue.edu/cs190c:textsoft09?rev=1232642198</link>
        <description>Course Text Books

	*  Python Programming: An Introduction to Computer Science, John Zelle, Franklin, Beedle &amp; Associates, 2004. &lt;http://www.fbeedle.com/99-6.html&gt; 
	*  Learning Python, M. Lutz, O'Reilly, 2007.  &lt;http://oreilly.com/catalog/9780596513986/&gt;. The electronic version of this text is available through Purdue Libraries at &lt;http://proquest.safaribooksonline.com/9780596513986&gt;.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:velocitydistr1.png?rev=1237926623">
        <dc:format>text/html</dc:format>
        <dc:date>2009-03-24T16:30:23-05:00</dc:date>
        <title>cs190c:velocitydistr1.png</title>
        <link>http://secant.cs.purdue.edu/cs190c:velocitydistr1.png?rev=1237926623</link>
        <description></description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:vpython_3d_line_plot?rev=1204203607">
        <dc:format>text/html</dc:format>
        <dc:date>2008-02-28T08:00:07-05:00</dc:date>
        <title>cs190c:vpython_3d_line_plot</title>
        <link>http://secant.cs.purdue.edu/cs190c:vpython_3d_line_plot?rev=1204203607</link>
        <description>VPython 3D Line Plots

For project 3 part 2, you will generate a plot with two independent variables and one dependent variable by adding 3D curves to the same VPython window across multiple runs of ising_model(..).  

Below is a code skeleton to get you started.</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:workload?rev=1197553547">
        <dc:format>text/html</dc:format>
        <dc:date>2007-12-13T08:45:47-05:00</dc:date>
        <title>cs190c:workload</title>
        <link>http://secant.cs.purdue.edu/cs190c:workload?rev=1197553547</link>
        <description>Expected Course Workload

	*  Four problem sets (which will include small programming assignments) 
	*  Five Python projects focused on science applications
	*  Students will complete small programming assignments in lab sessions in teams
	*  Two midterm exams (2/13 and 3/26, both 7-8pm) 
	*  One comprehensive final exam</description>
    </item>
    <item rdf:about="http://secant.cs.purdue.edu/cs190c:workload09?rev=1232644437">
        <dc:format>text/html</dc:format>
        <dc:date>2009-01-22T12:13:57-05:00</dc:date>
        <title>cs190c:workload09</title>
        <link>http://secant.cs.purdue.edu/cs190c:workload09?rev=1232644437</link>
        <description>Expected Course Workload

	*  Four problem sets (small programming assignments) 
	*  Five Python projects focused on science applications
	*  Students will complete small programming assignments in lab sessions in teams
	*  Two evening exams: Thursday, February 19, 6:30-7:30pm, Thursday, April 2, 6:30-7:30pm, LWSN 1106
	*  One comprehensive final exam</description>
    </item>
</rdf:RDF>
