### Homework

### Turn in HW9 here. Homework 9 (Critters)

Due **Tuesday, December 4, 9:00pm***No submissions accepted after Friday, December 7, 9:00pm*

### Turn in HW8 here. Homework 8 (GeoLocation)

Due **Tuesday, November 27, 9:00pm***No submissions accepted after Friday, November 30, 9:00pm*

### Turn in HW7 here. Homework 7 (DNA)

Due **Tuesday, November 20, 9:00pm***No submissions accepted after Friday, November 23, 9:00pm*

### Turn in HW6 here. Homework 6 (Mad Libs)

Due **Tuesday, November 13, 9:00pm***No submissions accepted after Friday, November 16, 9:00pm*

### Turn in HW5 here. Homework 5 (Guessing Game)

Due **Tuesday, October 30, 9:00pm***No submissions accepted after Friday, November 2, 9:00pm*

### Turn in HW4 here. Homework 4 (Budgeter)

Due **Tuesday, October 23, 9:00pm***No submissions accepted after Friday, October 26, 9:00pm*

### Turn in HW3 here. Homework 3 (Cafe Wall)

Due **Tuesday, October 16, 9:00pm***No submissions accepted after Friday, October 19, 9:00pm*

### Turn in HW2 here Homework 2 (ASCII Art / Rocket Ship)

Due **Tuesday, October 9, 9:00pm***No submissions accepted after Friday, October 12, 9:00pm*

### Turn in HW1 here Homework 1 (Song)

Due **Wednesday, October 3, 9:00pm***No submissions accepted after Saturday, October 6, 9:00pm*

## CSE 142 Programming Assignment #7: DNA

This assignment focuses on arrays and file/text processing. Turn in a file named DNA.java. You will also need the two

input files dna.txt and ecoli.txt from the course web site. Save these files in the same folder as your program.

The assignment involves processing data from genome files. Your program should work with the two given input files. If

you are curious (this is not required), the National Center for Biotechnology Information publishes many other bacteria

genome files. The last page tells you how to use your program to process other published genome files.

Background Information About DNA:

Note: This section explains the biology behind the assignment. It is for your information only; you need not fully

understand it to complete the assignment.

Deoxyribonucleic acid (DNA) is a complex biochemical macromolecule that carries genetic information for cellular life

forms and some viruses. DNA is also the mechanism through which genetic information from parents is passed on during

reproduction. DNA consists of long chains of chemical compounds called nucleotides. Four nucleotides are present in

DNA: Adenine (A), Cytosine (C), Guanine (G), and Thymine (T). DNA has a double-helix structure (see diagram below)

containing complementary chains of these four nucleotides connected by hydrogen bonds.

Certain regions of the DNA are called genes. Most genes encode instructions for building proteins (they’re called

“protein-coding” genes). These proteins are responsible for carrying out most of the life processes of the organism.

Nucleotides in a gene are organized into codons. Codons are groups of three nucleotides and are written as the first letters

of their nucleotides (e.g., TAC or GGA). Each codon uniquely encodes a single amino acid, a building block of proteins.

The process of building proteins from DNA has two major phases called transcription and translation, in which a gene is

replicated into an intermediate form called mRNA, which is then processed by a structure called a ribosome to build the

chain of amino acids encoded by the codons of the gene.

The chemical structure of DNA.

DNA translation.

The sequences of DNA that encode proteins occur between a start codon (which we will assume to be ATG) and a stop

codon (which is any of TAA, TAG, or TGA). Not all regions of DNA are genes; large portions that do not lie between a

valid start and stop codon are called intergenic DNA and have other (possibly unknown) function. Computational

biologists examine large DNA data files to find patterns and important information, such as which regions are genes.

Sometimes they are interested in the percentages of mass accounted for by each of the four nucleotide types. Often high

percentages of Cytosine (C) and Guanine (G) are indicators of important genetic data.

For more information, visit the Wikipedia page about DNA at the following address, or use your favorite search engine:

http://en.wikipedia.org/wiki/DNA

2 of 4

Program Description:

In this assignment you read an input file containing named sequences of nucleotides and produce information about them.

For each nucleotide sequence, your program counts the occurrences of each of the four nucleotides (A, C, G, and T). The

program also computes the mass percentage occupied by each nucleotide type, rounded to one digit past the decimal

point. Next the program reports the codons (trios of nucleotides) present in each sequence and predicts whether or not the

sequence is a protein-coding gene. For us, a protein-coding gene is a string that matches the following constraints:

• begins with a valid start codon (ATG)

• ends with a valid stop codon (TAA, TAG, or TGA)

• contains at least 5 codons, including its initial start codon and final stop codon

• Cytosine (C) and Guanine (G) combined account for at least 30% of its mass

(These are approximations for our assignment, not exact constraints used in computational biology to identify proteins.)

Input Data:

The DNA data consists of line pairs. The first line has the name of the nucleotide sequence, and the second is the

nucleotide sequence itself. Notice that the nucleotides in the input file can be either upper or lowercase.

Input file dna.txt (partial):

cure for cancer protein

ATGCCACTATGGTAG

captain picard hair growth protein

ATgCCAACATGgATGCCcGATAtGGATTgA

bogus protein

CCATtAATgATCaCAGTt

…

Program Behavior:

Your program begins with an introduction. Then your program asks for an input and output file. You may assume the

user will type the name of an existing input file and is in the format described previously. Your program opens the input

file to process the nucleotide sequences and outputs the results in the given output file. Notice the nucleotide sequence is

output in uppercase, the nucleotide counts and mass percentages are in A, C, G, T order, and the codons are not unique.

Log of execution (user input underlined):

This program reports information about DNA

nucleotide sequences that may encode proteins.

Input file name? dna.txt

Output file name? output.txt

Output file output.txt after above execution (partial):

Name: cure for cancer protein

Nucleotides: ATGCCACTATGGTAG

Nucleotide counts: [4, 3, 4, 4]

Mass percentages: [27.3, 16.8, 30.6, 25.3]

Codons: [ATG, CCA, CTA, TGG, TAG]

Encodes a protein: yes

Name: captain picard hair growth protein

Nucleotides: ATGCCAACATGGATGCCCGATATGGATTGA

Nucleotide counts: [9, 6, 8, 7]

Mass percentages: [30.7, 16.8, 30.5, 22.1]

Codons: [ATG, CCA, ACA, TGG, ATG, CCC, GAT, ATG, GAT, TGA]

Encodes a protein: yes

Name: bogus protein

Nucleotides: CCATTAATGATCACAGTT

Nucleotide counts: [6, 4, 2, 6]

Mass percentages: [35.1, 19.3, 13.1, 32.5]

Codons: [CCA, TTA, ATG, ATC, ACA, GTT]

Encodes a protein: no

…

3 of 4

Implementation Guidelines and Hints:

The main purpose of this assignment is to demonstrate your understanding of arrays and array traversals with for loops.

Therefore, you should use arrays to store the various data for each sequence. In particular, your nucleotide counts, mass

percentages, and codons should all be stored using arrays. Additionally you should use arrays and for loops to

transform the data from one form to another as follows:

• from the original nucleotide sequence string to nucleotide counts;

• from nucleotide counts to mass percentages; and

• from the original nucleotide sequence string to codon triplets.

You may find it useful to know that you can print any array in a convenient comma-separated format using the method

Arrays.toString, which accepts an array as a parameter and returns a string representation of it. For example:

int[] numbers = {10, 20, 30, 40};

System.out.println(“my data: ” + Arrays.toString(numbers));

The preceding code produces the following output:

my data: [10, 20, 30, 40]

To compute mass percentages, use the following as the mass of each nucleotide (g/mol):

• Adenine (A): 135.128

• Cytosine (C): 111.103

• Guanine (G): 151.128

• Thymine (T): 125.107

For example, the mass of the sequence ATGGAC is (135.128 + 125.107 + 151.128 + 151.128 + 135.128 + 111.103) or

808.722. Of this, 270.256 (33.4%) is from the two Adenines, 111.103 (13.7%) is from the Cytosine, 302.256 (37.4%) is

from the two Guanines, and 125.107 (15.5%) is from the Thymine.

We suggest that you start this program by writing the code to read the input file. Try writing code to simply read each

protein’s name and sequence of nucleotides and print them. Read each line from the input file using Scanner’s nextLine

method. This will read an entire line of input and return it as a String.

Next, try writing the code that passes over the nucleotide sequence and counts the number of As, Cs, Gs, and Ts. You can

use String’s charAt method to get individual characters of a string. Put your counts into an array of size 4. To map

between nucleotides and array indexes, you may write a method that converts single characters (i.e. A, C, T, G) into

indices (i.e. 0 to 3).

Once you have the counts working correctly, you can convert your counts into a new array of percentages of mass for

each nucleotide using the preceding nucleotide mass values. If you’ve written code to map between nucleotide letters and

array indexes, it may also help you to look up mass values in an array such as the following:

double[] masses = {135.128, 111.103, 151.128, 125.107};

You may store your mass percentages already rounded to one digit past the decimal or you can round when printing the

mass percentages array using printf. If you choose to store your mass percentages pre-rounded, you may want to use

Math.round as follows:

double d1 = 3.14159265;

d1 = Math.round(d1 * 10.0) / 10.0;

double d2 = 1.6666667;

d2 = Math.round(d2 * 10.0) / 10.0;

System.out.print(“d1 = ” + d1 + “; d2 = ” + d2);

The preceding code produces the following output: d1 = 3.1; d2 = 1.7

After computing mass percentages, you must break apart the sequence into codons and examine each codon. You may

wish to review the methods of String objects as presented in Chapters 3 and 4, such as substring, charAt, indexOf,

toUpperCase, and toLowerCase.

We also suggest that you first get your program working correctly printing its output to the console before you save the

output to a file. Once you have your program printing correct output to the console, save the output to a file by using a

PrintStream as described in Section 6.4 of the textbook.

You may assume that the input file exists, is readable, and contains valid input. You may assume that each sequence’s

length will be a multiple of 3, although the nucleotides on a given line might be in either uppercase or lowercase form or a

combination. Your program overwrites any existing data in the output file (the default PrintStream behavior).

4 of 4

Style Guidelines:

For this assignment you should have four class constants:

• one for the minimum number of codons a valid protein must have, as an integer (default of 5)

• a second for the percentage of mass from C and G in order for a protein to be valid, as an integer (default of 30)

• a third for the number of unique nucleotides (4, representing A, C, G, and T)

• a fourth for the number of nucleotides per codon (3)

For full credit it should be possible to change the first two constant values (minimum codons and minimum mass

percentage) and cause your program to change its behavior for evaluating protein validity. The other two constants won’t

ever be changed but are still useful to make your program more readable. You should refer to these constants in your

code and should never refer to the bare number such as 4 or 3 directly. You should use no other constants in your

program other than the constants named above.

We will grade your method structure strictly on this assignment. Use at least four nontrivial methods besides main.

These methods should use parameters and returns, including arrays, as appropriate. The methods should be wellstructured and avoid redundancy. No one method should do too large a share of the overall task. The Case Study in book

section 7.6 is a good example of a larger program with methods that pass arrays as parameters.

Your main method should be a concise summary of the overall program. It is okay for main to contain some code such as

println statements. But the main method should not perform too large a share of the overall work itself, such as

examining each of the characters representing nucleotides. Also avoid “chaining,” when many methods call each other

without ever returning to main. For reference, our solution is around 130 lines long and has 6 methods besides main,

though you don’t need to match this.

We will also check strictly for redundancy on this assignment. If you have a very similar piece of code that is repeated

several times in your program, eliminate the redundancy such as by creating a method, by using for loops over the

elements of arrays, and/or by factoring if/else code as described in section 4.3 of the textbook.

You are limited to features in Chapters 1 through 7. Follow past style guidelines such as indentation, names, variables,

types, line lengths, and comments (at the beginning of your program, on each method, and on complex sections of code).

Optional Additional Input Files:

If you would like to generate additional input files to test your program, you can create them from actual NCBI genetic

data. The following web site has many data files that contain complete genomes for bacterial organisms:

ftp://ftp.ncbi.nih.gov/genomes/Bacteria/

The site contains many directories with names of organisms. After entering a directory, you can find and save a genome

file (a file whose name ends with .fna) and a protein table (a file whose name ends with .ptt). On the course web site we

will provide you with a program to convert these .fna and .ptt files into input files suitable for your homework.

The Homework 7 in UW

CSE 142: Computer Programming I, Autumn 2011

http://www.cs.washington.edu/education/courses/cse142/11au/homework.shtml

My solution ( 86 lines ):

import java.io.*;

import java.util.Arrays;

import java.util.Scanner;

public class DNA_HW_7 {

static final int minimumCodons = 5; // The minimum number of codons.

static final int percentage = 30; // The percentage of mass from C and G.

static final int uniqueNucleotides = 4; // The number of unique nucleotides.

static final int nucleotidesPerCodon = 3; // The number of nucleotides per codon.

static boolean checkValid = true; // To check if it's a valid sequences of nucleotides.

static double [] masses = {135.128, 111.103, 151.128, 125.107, 100.000};

static double totalMass = 0;

public static void main(String[] args) {

Scanner a = new Scanner(System.in);

System.out.println("This program reports information about DNA nucleotide sequences that may encode proteins.");

int Try = 0;

do {

try {

System.out.print("Input file name: ");

String inputName = a.nextLine(); // get file name...

System.out.print("Output file name: ");

String output = a.nextLine(); // set file name...

Scanner view = new Scanner (new File(inputName));

PrintStream outputTxt = new PrintStream(new File(output));

while(view.hasNextLine()){

checkValid = true;

String Line1 = view.nextLine();

String Line2 = view.nextLine().toUpperCase();

theOutputConsole(Line1, Line2, counts(Line2), Masses(Line2), condonsList(Line2));

outputTxtFile(Line1, Line2, counts(Line2), Masses(Line2), condonsList(Line2), output, outputTxt);

}

}catch(FileNotFoundException e) {

System.out.print("Input file not found. Try again:");

try = 1;

}

}while(try = =1);

}

public static void theOutputConsole(String RegionName, String Nucleotides, int []Counts, double [] tatalMass, String [] condonsList){

System.out.println("Region Name: " + RegionName);

System.out.println("Nucleotides: " + Nucleotides);

System.out.println("Nuc. Counts: " + Arrays.toString(Counts));

System.out.println("Total Mass%: " + Arrays.toString(tatalMass)+" of "+ totalMass);

System.out.println("Codons List: " + Arrays.toString(condonsList));

System.out.println("Is Protein?: " + ((check(Nucleotides, Counts, condonsList))?"YES\n":"NO\n"));

}

public static int [] counts(String line){

int [] a = new int[uniqueNucleotides];

int Junk = 0;

for(int i = 0; i < line.length(); i++){

if (line.charAt(i)=='A') a[0]++;

else if (line.charAt(i)=='C') a[1]++;

else if (line.charAt(i)=='G') a[2]++;

else if (line.charAt(i)=='T') a[3]++;

else if (line.charAt(i)=='-') Junk++;

else checkValid = false; // it's invalid because it contains nucleotides that are not the 4 unique nucleotides.

}

totalMass = Math.round((a[0]*masses[0] + a[1]*masses[1]+ a[2]*masses[2] + a[3]*masses[3] +Junk*masses[4])*10.0)/10.0;

return a;

}

public static double [] Masses(String line){

int[] x = counts(line);

double [] a = new double [uniqueNucleotides];

for (int i= 0; i<a.length; i++) a[i] = Math.round((x[i]*masses[i]/totalMass)*1000.0)/10.0;

return a;

}

public static String [] condonsList(String line){

String noJunk = line.replaceAll("-","");

String [] a = new String[noJunk.length()/nucleotidesPerCodon];

for (int i = 0, j = 0; i+nucleotidesPerCodon<=noJunk.length()&&j<=noJunk.length()/nucleotidesPerCodon; i+=nucleotidesPerCodon, j++) a[j] = noJunk.substring(i, i+nucleotidesPerCodon);

return a;

}

public static void outputTxtFile(String RegionName, String Nucleotides, int []Counts, double [] tatalMass, String [] condonsList, String output, PrintStream outputTxt) throws FileNotFoundException{

outputTxt.print("Region Name: " + RegionName);

outputTxt.println("Nucleotides: " + Nucleotides);

outputTxt.println("Nuc. Counts: " + Arrays.toString(Counts));

outputTxt.println("Total Mass%: " + Arrays.toString(tatalMass)+" of "+ totalMass);

outputTxt.println("Codons List: " + Arrays.toString(condonsList));

outputTxt.println("Is Protein?: " + ((check(Nucleotides, Counts, condonsList))?"YES":"NO"));

outputTxt.println();

}

public static boolean check(String Nucleotides, int []Counts, String [] condonsList){

if (checkValid)checkValid = ((Nucleotides.replaceAll("-","").length()/nucleotidesPerCodon)>=minimumCodons);

if (checkValid)checkValid = ((Counts[1]*masses[1] + Counts[2]*masses[2]) / totalMass)>=(percentage/100.0);

if (checkValid)checkValid = (condonsList[0].equals("ATG"));

if (checkValid)checkValid = (condonsList[condonsList.length-1].equals("TAA")||condonsList[condonsList.length-1].equals("TAG")||condonsList[condonsList.length-1].equals("TGA"));

return checkValid;

}

}

## cwake/**Assign3.java**

## 142 dna cse

Q: Where do I start?

A: Try to break the problem into pieces. First try to read a record (a name and its sequence of nucleotides) from the file. Then try to count the nucleotides. Look at the diagram of the arrays on the HW7 spec for inspiration. If you aren't very familiar with arrays, perhaps try looking at practice problems about them first until you feel comfortable.

Q: How do I read two lines at a time?

A: Well, the thing that you do to read one line at a time.... do that twice in a row.

Q: How do I examine the letters of the line to see which nucleotide they are (A, C, G, or T)?

A: Look at section 4.4 in the textbook about Text Processing, and look over section 7 problems about text processing. The class's method is useful.

Q: How do I place the nucleotide into the right element of the array, when counting the occurrences of nucleotides?

A: Look at the lecture example on section attendance. It's okay to use statements to express the mapping between the characters and the array indexes, as long as you avoid redundancy as much as possible.

Q: Why are my mass percentages way off?

A: Are you sure that you are weighting each nucleotide by its mass as listed in the handout? For example, adenine has a molar mass of 135.128.

Q: Why are my mass percentages SLIGHTLY off (0.1 or so)?

A: Usually that's because you didn't round correctly or used the wrong type somewhere ( vs ).

Q: I have a lot of repetitive code. How do I make it less redundant?

A: You must work especially hard on this assignment to eliminate redundancy. Use techniques we've practiced in the past, such as factoring common code out of an statement, or creating a helping method to hold common code. Look at the "Sections" program from lecture or at Chapter 7's case study to learn how to write good methods that use arrays as parameters/returns.

## Computer Science and Engineering (CSE)

[ undergraduate program | graduate program | faculty ]

*All courses, faculty listings, and curricular and degree requirements described herein are subject to change or deletion without notice. *

### Courses

*For course descriptions not found in the *UC San Diego General Catalog 2021–22*, please contact the department for more information.*

### Lower Division

CSE 3. Fluency in Information Technology (4)

Introduces the concepts and skills necessary to effectively use information technology. Includes basic concepts and some practical skills with computer and networks. ** Prerequisites:** none.

CSE 4GS. Mathematical Beauty in Rome (4)

Exploration of topics in mathematics and engineering as they relate to classical architecture in Rome, Italy. In depth geometrical analysis and computer modeling of basic structures (arches, vaults, domes), and on-site studies of the Colosseum, Pantheon, Roman Forum, and St. Peter’s Basilica. ** Prerequisites:** MATH 10A or MATH 20A; department approval, and corequisite of CSE 6GS.

CSE 6GS. Mathematical Beauty in Rome Lab (4)

Companion course to CSE 4GS where theory is applied and lab experiments are carried out “in the field” in Rome, Italy. For final projects, students will select a complex structure (e.g., the Colosseum, the Pantheon, St. Peter’s, etc.) to analyze and model, in detail, using computer-based tools. ** Prerequisites:** MATH 10A or MATH 20A; department approval, and corequisite of CSE 4GS.

CSE 8A. Introduction to Programming and Computational Problem-Solving I (4)

Introductory course for students interested in computer science and programming. Basics of programming including variables, conditionals, loops, functions/methods. Structured data storage such as arrays/lists and dictionaries, including data mutation. Hands-on experience with designing, writing, hand-tracing, compiling or interpreting, executing, testing, and debugging programs. Students solve relevant computational problems using a high-level programming language. CSE 8A is part of a two-course sequence (CSE 8A-B) that is equivalent to CSE 11. Students should take CSE 8B to complete the CSE 8A-B track. Students who have taken CSE 8B or CSE 11 may not take or receive credit for CSE 8A. Students may receive credit for one of the following: COGS 18, CSE 8A, or CSE 6R. Recommended preparation: No prior programming experience is assumed, but comfort using computers is helpful. Students should consult the “CSE Course Placement Advice” web page for assistance in choosing which CSE course to take first. ** Prerequisites:** restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 8B. Introduction to Programming and Computational Problem-Solving II (4)

Introductory programming using an object-oriented approach with the Java programming language. Builds on basic programming constructs introduced in CSE 8A to introduce class design and use, interfaces, basic class hierarchies, recursion, event-based programming, error reporting with exceptions, and file I/O. Basics of command-line navigation for file management and running programs. Development, testing, and debugging of more complex programs. CSE 8B is part of a two-course sequence (CSE 8A-B) that is equivalent to CSE 11. No credit offered for CSE 8B if CSE 11 taken previously. Students may not receive credit for CSE 8B and CSE 11. Students should consult the “CSE Course Placement Advice” web page for assistance in choosing which CSE course to take first ** Prerequisites:** CSE 8A; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 11. Introduction to Programming and Computational Problem-Solving: Accelerated Pace (4)

Accelerated introductory programming including an object-oriented approach. Covers basic programming topics from CSE 8A including variables, conditionals, loops, functions/methods, structured data storage, and mutation. Also covers topics from CSE 8B including the Java programming language, class design, interfaces, basic class hierarchies, recursion, event-based programming, and file I/O. Basics of command-line navigation for file management and running programs. Zero units of credit offered for CSE 11 if CSE 8B taken previously or concurrently. Recommended preparation: Significant prior programming experience (for example, high school AP CSA). Students should consult the “CSE Course Placement Advice” web page for assistance in choosing a first CSE course. ** Prerequisites:**restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 12. Basic Data Structures and Object-Oriented Design (4)

Use and implementation of basic data structures including linked lists, stacks, and queues. Use of advanced structures such as binary trees and hash tables. Object-oriented design including interfaces, polymorphism, encapsulation, abstract data types, pre-/post-conditions. Recursion. Uses Java and Java Collections. ** Prerequisites:** CSE 8B or CSE 11, and concurrent enrollment with CSE 15L; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 15L. Software Tools and Techniques Laboratory (2)

Hands-on exploration of software development tools and techniques. Investigation of the scientific process as applied to software development and debugging. Emphasis is on weekly hands-on laboratory experiences, development of laboratory notebooking techniques as applied to software design. ** Prerequisites:**CSE 8B or CSE 11, and concurrent enrollment with CSE 12; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 20. Discrete Mathematics (4)

Basic discrete mathematical structures: sets, relations, functions, sequences, equivalence relations, partial orders, and number systems. Methods of reasoning and proofs: prepositional logic, predicate logic, induction, recursion, and pigeonhole principle. Infinite sets and diagonalization. Basic counting techniques; permutation and combinations. Applications will be given to digital logic design, elementary number theory, design of programs, and proofs of program correctness. Students who have completed MATH 109 may not receive credit for CSE 20. Credit not offered for both MATH 15A and CSE 20. Equivalent to MATH 15A. ** Prerequisites:** COGS 7 or CSE 8B or CSE 11. Prerequisite courses must have been completed with a grade of C– or better; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 21. Mathematics for Algorithms and Systems (4)

This course will provide an introduction to the discrete mathematical tools needed to analyze algorithms and systems. Enumerative combinatorics: basic counting principles, inclusion-exclusion, and generating functions. Matrix notation. Applied discrete probability. Finite automata. ** Prerequisites:** CSE 20 or MATH 15A; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 30. Computer Organization and Systems Programming (4)

Introduction to organization of modern digital computers—understanding the various components of a computer and their interrelationships. Study of a specific architecture/machine with emphasis on systems programming in C and Assembly languages in a UNIX environment. ** Prerequisites:** CSE 12 and CSE 15L; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 42. Building and Programming Electronic Devices (2)

This course allows students to use what they learned in introductory programming courses to make things happen in the real world. Working in teams, students will first learn to program Arduino-based devices. Teams of students will design a custom device and program it to do their bidding. This course is targeted to first-year students and sophomores in engineering and science disciplines who want to practice applying what they have learned in a programming class and to have the chance to program things other than computers. Program or materials fees may apply. ** Prerequisites:** restricted to first-year and sophomore students; instructor approval required.

CSE 86. C++ for Java Programmers (2)

Helps the Java programmer to be productive in the C++ programming environment. Topics include the similarities and differences between Java and C++ with special attention to pointers, operator overloading, templates, the STL, the preprocessor, and the C++ Runtime Environment. ** Prerequisites:** CSE 12 or consent of instructor.

CSE 87. First-year Student Seminar (1)

The First-year Student Seminar Program is designed to provide new students with the opportunity to explore an intellectual topic with a faculty member in a small seminar setting. First-year student seminars are offered in all campus departments and undergraduate colleges, and topics vary from quarter to quarter. Enrollment is limited to fifteen to twenty students, with preference given to entering first-year students. ** Prerequisites:** none.

CSE 90. Undergraduate Seminar (1)

A seminar providing an overview of a topic of current research interest to the instructor. The goal is to present a specialized topic in computer science and engineering students. May be taken for credit three times when topics vary.

CSE 91. Perspectives in Computer Science and Engineering (2)

A seminar format discussion led by CSE faculty on topics in central areas of computer science, concentrating on the relation among them, recent developments, and future directions. ** Prerequisites:** majors only.

CSE 99. Independent Study in Computer Science and Engineering (4)

Independent reading or research by special arrangement with a faculty member. ** Prerequisites:** lower-division standing. Completion of thirty units at UC San Diego with a UC San Diego GPA of 3.0. Special Studies form required. Department stamp required. Consent of instructor and approval of the department.

### Upper Division

CSE 100. Advanced Data Structures (4)

High-performance data structures and supporting algorithms. Use and implementation of data structures like (un)balanced trees, graphs, priority queues, and hash tables. Also, memory management, pointers, recursion. Theoretical and practical performance analysis, both average case and amortized. Uses C++ and STL. Credit not offered for both MATH 176 and CSE 100. Equivalent to MATH 176. Recommended preparation: background in C or C++ programming. **Prerequisites:** CSE 12 and CSE 15L and CSE 21 or MATH 154 or MATH 184A and CSE 5A or CSE 30 or ECE 15 or MAE 9; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 101. Design and Analysis of Algorithms (4)

Design and analysis of efficient algorithms with emphasis of nonnumerical algorithms such as sorting, searching, pattern matching, and graph and network algorithms. Measuring complexity of algorithms, time and storage. NP-complete problems. ** Prerequisites:**CSE 100 or MATH 176; restricted to undergraduates. Graduate students will be allowed as space permits.

CSE 103. A Practical Introduction to Probability and Statistics (4)

Distributions over the real line. Independence, expectation, conditional expectation, mean, variance. Hypothesis testing. Learning classifiers. Distributions over R^n, covariance matrix. Binomial, Poisson distributions. Chernoff bound. Entropy. Compression. Arithmetic coding. Maximal likelihood estimation. Bayesian estimation. CSE 103 is not duplicate credit for ECE 109, ECON 120A, or MATH 183. ** Prerequisites:** MATH 20A-B and MATH 184A or CSE 21 or MATH 154; restricted to CS25, CS26, CS27, and CS28 majors. Other students will be allowed as space permits.

CSE 105. Theory of Computability (4)

An introduction to the mathematical theory of computability. Formal languages. Finite automata and regular expression. Push-down automata and context-free languages. Computable or recursive functions: Turing machines, the halting problem. Undecidability. Credit not offered for both MATH 166 and CSE 105. Equivalent to MATH 166. ** Prerequisites:** (CSE 12) and (CSE 15L) and (CSE 20 or MATH 109 or MATH 15A or MATH 31CH) and (CSE 21 or MATH 100A or MATH 103A or MATH 154 or MATH 184 or MATH 184A); restricted to students with sophomore, junior, or senior standing. Graduate students will be allowed as space permits.

CSE 106. Discrete and Continuous Optimization (4)

One frequently deals with problems in engineering, data science, business, economics, and other disciplines for which algorithmic solutions that optimize a given quantity under constraints are desired. This course is an introduction to the models, theory, methods, and applications of discrete and continuous optimization. Topics include shortest paths, flows, linear, integer, and convex programming, and continuous optimization techniques such as steepest descent and Lagrange multipliers. **Prerequisites:** MATH 18 or MATH 31AH and MATH 20C or MATH 31BH and CSE 21 or DSC 40B or MATH 154 or MATH 184A.

CSE 107. Introduction to Modern Cryptography (4)

Topics include private and public-key cryptography, block ciphers, data encryption, authentication, key distribution and certification, pseudorandom number generators, design and analysis of protocols, zero-knowledge proofs, and advanced protocols. Emphasizes rigorous mathematical approach including formal definitions of security goals and proofs of protocol security. ** Prerequisites:** (MATH 184 or CSE 21 or MATH 154) and CSE 101 and CSE 105; restricted to students within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 110. Software Engineering (4)

Introduction to software development and engineering methods, including specification, design, implementation, testing, and process. An emphasis on team development, agile methods, and use of tools such as IDE’s, version control, and test harnesses. ** Prerequisites:** CSE 100; restricted to students with junior or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 112. Advanced Software Engineering (4)

This course will cover software engineering topics associated with large systems development such as requirements and specifications, testing and maintenance, and design. Specific attention will be given to development tools and automated support environments. ** Prerequisites:**CSE 110; restricted to students within the CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 113. Errors, Defects, and Failures (4)

Errors, resulting in defects and ultimately system failure, occur in engineering and also other areas such as medical care. The ways in which failures occur, and the means for their prevention, mitigation, and management, will be studied. Emphasis will be on software systems but also include the study of practice of other areas. **Prerequisites:** CSE 12 and CSE 21.

CSE 118. Ubiquitous Computing (4)

Explores emerging opportunities enabled by cheap sensors and networked computing devices. Small research projects will be conducted in teams, culminating in project presentations at the end of the term. Section will cover material relevant to the project, such as research methods, software engineering, teamwork, and project management. ** Prerequisites:** any course from the following: CSE 131, CSE 132B, COGS 102C, COGS 121, COGS 184, COMT 111B, COMT 115, ECE 111, ECE 118, ECE 191, ECE 192, or ICAM 160B; or consent of instructor.

CSE 120. Principles of Computer Operating Systems (4)

Basic functions of operating systems; basic kernel structure, concurrency, memory management, virtual memory, file systems, process scheduling, security and protection. ** Prerequisites:** CSE 30 and CSE 101 and CSE 110; restricted to students within the CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 123. Computer Networks (4)

Introduction to concepts, principles, and practice of computer communication networks with examples from existing architectures, protocols, and standards with special emphasis on the internet protocols. Layering and the OSI model; physical and data link layers; local and wide area networks; datagrams and virtual circuits; routing and congestion control; internetworking. Transport protocols. Credit may not be received for both CSE 123 and ECE 158A. ** Prerequisites:** CSE 30 and CSE 101 and CSE 110; restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 124. Networked Services (4)

(Renumbered from CSE 123B.) The architecture of modern networked services, including data center design, enterprise storage, fault tolerance, and load balancing. Protocol software structuring, the Transmission Control Protocol (TCP), remote procedure calls, protocols for digital audio and video communication, overlay and peer-to-peer systems, secure communication. Credit may not be received for both CSE 124 and ECE 158B. Students may not receive credit for both CSE 123B and CSE 124. ** Prerequisites:** CSE 30 and CSE 101 and CSE 110; restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 125. Software System Design and Implementation (4)

Design and implementation of large, complex software systems involving multiple aspects of CSE curriculum. Emphasis is on software system design applied to a single, large group project with close interaction with instructor. ** Prerequisites:** senior standing with substantial programming experience, and consent of instructor. Department stamp required.

CSE 127. Introduction to Computer Security (4)

Topics include basic cryptography, security/threat analysis, access control, auditing, security models, distributed systems security, and theory behind common attack and defense techniques. The class will go over formal models as well as the bits and bytes of security exploits. ** Prerequisites:** (CSE 21 or MATH 154 or MATH 184A) and (CSE 120 or CSE 123 or CSE 124); restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 130. Programming Languages: Principles and Paradigms (4)

(Formerly CSE 173.) Introduction to programming languages and paradigms, the components that comprise them, and the principles of language design, all through the analysis and comparison of a variety of languages (e.g., Pascal, Ada, C++, PROLOG, ML.) Will involve programming in most languages studied. ** Prerequisites:**CSE 12 and (CSE 100 or MATH 176) and (CSE 105 or MATH 166); restricted to students within the CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 131. Compiler Construction (4)

(Formerly CSE 131B.) Introduction to the compilation of programming languages, practice of lexical and syntactic analysis, symbol tables, syntax-directed translation, type checking, code generation, optimization, interpretation, and compiler structure. (Students may receive repeat credit for CSE 131A and CSE 131B by completing CSE 131.) ** Prerequisites:** CSE 100 and CSE 105 and CSE 130; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 132A. Database System Principles (4)

Basic concepts of databases, including data modeling, relational databases, query languages, optimization, dependencies, schema design, and concurrency control. Exposure to one or several commercial database systems. Advanced topics such as deductive and object-oriented databases, time allowing. ** Prerequisites:** CSE 100; restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 132B. Database Systems Applications (4)

Design of databases, transactions, use of trigger facilities and datablades. Performance measuring, organization of index structures. ** Prerequisites:** CSE 132A; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 134B. Web Client Languages (4)

Design and implementation of interactive World Wide Web clients using helper applications and plug-ins. The main language covered will be Java. ** Prerequisites:** CSE 100; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 135. Online Database Analytics Applications (4)

Database, data warehouse, and data cube design; SQL programming and querying with emphasis on analytics; online analytics applications, visualizations, and data exploration; performance tuning. ** Prerequisites:** CSE 100 or MATH 176; restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. Graduate students will be allowed as space permits.

CSE 136. Enterprise-Class Web Applications (4)

Design and implementation of very large-scale, web-based applications. Topics covered typically include modeling organizational needs, design and revision management, J2EE or similar software platforms, web server and application server functionality, reuse of object-oriented components, model-view-controller and other design patterns, clustering, load-balancing, fault-tolerance, authentication, and usage accounting. ** Prerequisites:**CSE 135.

CSE 140. Components and Design Techniques for Digital Systems (4)

Design of Boolean logic and finite state machines; two-level, multilevel combinational logic design, combinational modules and modular networks, Mealy and Moore machines, analysis and synthesis of canonical forms, sequential modules. ** Prerequisites:**(CSE 20 or MATH 15A or MATH 109) and CSE 30; CSE 140L must be taken concurrently; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits

CSE 140L. Digital Systems Laboratory (2)

Implementation with computer-aided design tools for combinational logic minimization and state machine synthesis. Hardware construction of a small digital system. ** Prerequisites:** (CSE 20 or MATH 15A or MATH 109) and CSE 30; CSE 140 must be taken concurrently; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 141. Introduction to Computer Architecture (4)

Introduction to computer architecture. Computer system design. Processor design. Control design. Memory systems. Two units of credit offered for CSE 141 if CSE 142 taken previously. ** Prerequisites:**CSE 30 and CSE 140 and CSE 140L; CSE 141L should be taken concurrently; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 141L. Project in Computer Architecture (2)

Hands-on computer architecture project aiming to familiarize students with instruction set architecture, and design of process. Control and memory systems. ** Prerequisites:** CSE 30 and CSE 140 and CSE 140L; CSE 141 should be taken concurrently; restricted to CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 142. Introduction to Computer Architecture: A Software Perspective (4)

This course covers the operation, structure, and programming interfaces of modern CPUs with an emphasis on exploiting processor features to improve software performance and efficiency. The topics covered in this course include performance, energy, x86 assembly, compiler optimizations, pipelining, instruction-level parallelism, caches, memory-level parallelism, multi-threading, multi-core processors, and SIMD. Two units of credit offered for CSE 142 if CSE 141 taken previously or concurrently. * Prerequisites: *CSE 30 and CSE 100; CSE 142L should be taken concurrently. Restricted to students within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 142L. Software Project for Computer Architecture (2)

This course provides hands-on experience in using the features of modern CPUs to increase the performance and efficiency of programs. * Prerequisites:* CSE 30 and CSE 100; CSE 142 should be taken concurrently. Restricted to students within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 143. Microelectronic System Design (4)

VLSI process technologies; circuit characterization; logic design styles; clocking strategies; computer-aided design tools; subsystem design; design case studies. System design project from hardware description, logic synthesis, physical layout to design verification. ** Prerequisites:** CSE 140 or CSE 170A or ECE 81.

CSE 145. Embedded System Design Project (4)

Project class building an embedded computing system. Learn fundamental knowledge of microcontrollers, sensors, and actuators. Introduction to the hardware and software tools to build project in a team environment and end-to-end system building. ** Prerequisites:**instructor approval required, by application only.

CSE 148. Advanced Processor Architecture Design Project (4)

Students will use hardware description language tools to add advanced architectural features to a basic processor design. These features may include pipelining, superscalar execution, branch prediction, and advanced cache features. Designs will be implemented in programmable logic devices. ** Prerequisites:** CSE 141 and CSE 141L; restricted to students with sophomore, junior, or senior standing. Graduate students will be allowed as space permits.

CSE 150A. Introduction to Artificial Intelligence: Probabilistic Reasoning and Decision-Making (4)

Introduction to probabilistic models at the heart of modern artificial intelligence. Specific topics to be covered include probabilistic methods for reasoning and decision-making under uncertainty; inference and learning in Bayesian networks; prediction and planning in Markov decision processes; applications to intelligent systems, speech and natural language processing, information retrieval, and robotics. **Prerequisites:** (CSE 12 or DSC 40B) and (CSE 15L or DSC 80) and (COGS 118D or CSE 103 or ECE 109 or ECON 120A or MATH 180A or MATH 183) and (MATH 20A) and (MATH 18 or MATH 31AH); restricted to students within the CS25, CS26, CS27, CS28, EC26, and DS25 majors. All other students will be allowed as space permits.

CSE 150B. Introduction to Artificial Intelligence: Search and Reasoning (4)

The course will introduce important ideas and algorithms in search and reasoning and demonstrate how they are used in practical AI applications. Topics include A* search, adversarial search, Monte Carlo tree search, reinforcement learning, constraint solving and optimization, propositional and first-order reasoning. **Prerequisites:**(CSE 12 or DSC 40B) and (CSE 15L or DSC 80) and (COGS 118D or CSE 103 or ECE 109 or ECON 120A or MATH 180A or MATH 183) and (CSE 100); restricted to students within the CS25, CS26, CS27, CS28, EC26, and DS25 majors. All other students will be allowed as space permits.

CSE 151A. Introduction to Machine Learning (4)

Broad introduction to machine learning. The topics include some topics in supervised learning, such as k-nearest neighbor classifiers, decision trees, boosting, and perceptrons; and topics in unsupervised learning, such as k-means and hierarchical clustering. In addition to the actual algorithms, the course focuses on the principles behind the algorithms. Students may not receive credit for both CSE 151A and COGS 188, nor may they receive credit for both CSE 151A and CSE 151. **Prerequisites:** (CSE 12 or DSC 40B) and (CSE 15L or DSC 80) and (COGS 118D or CSE 103 or ECE 109 or ECON 120A or MATH 181A or MATH 183) and (MATH 18 or MATH 31AH) and (MATH 20C or MATH 31BH); restricted to students within the CS25, CS26, CS27, CS28, EC26, and DS25 majors. All other students will be allowed as space permits.

CSE 151B. Deep Learning (4)

(Formerly CSE 154.) This course covers the fundamentals of neural networks. We introduce linear regression, logistic regression, perceptrons, multilayer networks and back-propagation, convolutional neural networks, recurrent networks, and deep networks trained by reinforcement learning. Students may receive credit for one of the following: CSE 151B, CSE 154, or COGS 181. *Prerequisites:*(MATH 20C or MATH 31BH) and (BENG 134 or COGS 118D or CSE 103 or ECE 109 or ECON 120A or MAE 108 or MATH 181A or MATH 183 or MATH 186); restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, EC26, and DS25 majors. All other students will be allowed as space permits.

CSE 152A. Introduction to Computer Vision I (4)

This course provides a broad introduction to the foundations, algorithms, and applications of computer vision. It introduces classical models and contemporary methods, from image formation models to deep learning, to address problems of 3-D reconstruction and object recognition from images and video. Topics include filtering, feature detection, stereo vision, structure from motion, motion estimation, and recognition. Programming assignments will be in Python. Students may not receive credit for both CSE 152A and CSE 152. **Prerequisites:**(MATH 18 or MATH 31AH) and (CSE 12 or DSC 30) and (CSE 15L or DSC 80); Python programming experience recommended; restricted to students within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 152B. Introduction to Computer Vision II (4)

This course covers advanced topics needed to apply computer vision in industry or follow current research. Example topics include real-time systems for 3-D computer vision, machine learning tools such as support-vector machine (SVM) and boosting for image classification, and deep neural networks for object detection and semantic segmentation. **Prerequisites:** CSE 152A or CSE 152 or CSE166; Python programming experience recommended; restricted to students within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 156. Statistical Natural Language Processing (4)

Natural language processing (NLP) is a field of AI which aims to equip computers with the ability to intelligently process natural (human) language. This course will explore statistical techniques for the automatic analysis of natural language data. Specific topics covered include probabilistic language models, which define probability distributions over text passages; text classification; sequence models; parsing sentences into syntactic representations; and machine translation. **Prerequisites:**MATH 20C or MATH 31BH and MATH 18 or MATH 31AH and COGS 118A or CSE 150 or CSE 151; restricted to students with sophomore, junior, or senior standing within the CS25, CS26, CS27, CS28, and EC26 majors. All other students will be allowed as space permits.

CSE 158. Recommender Systems and Web Mining (4)

Current methods for data mining and predictive analytics. Emphasis is on studying real-world data sets, building working systems, and putting current ideas from machine learning research into practice. ** Prerequisites:**(CSE 12 or DSC 40B) and (CSE 15L or DSC 80) and (BENG 100 or BENG 134 or COGS 118D or CSE 103 or ECE 109 or ECON 120A or MATH 180A or MATH 181A or MATH 183 or MATH 186); restricted to CS25, CS26, CS27, CS28, EC26, and DS25 majors. All other students will be allowed as space permits.

CSE 160. Introduction to Parallel Computing (4)

Introduction to high performance parallel computing: parallel architecture, algorithms, software, and problem-solving techniques. Areas covered: Flynn’s taxonomy, processor-memory organizations, shared and nonshared memory models: message passing and multithreading, data parallelism; speedup, efficiency and Amdahl’s law, communication and synchronization, isoefficiency and scalability. Assignments given to provide practical experience. ** Prerequisites:** CSE 100 or MATH 176; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits

CSE 163. Advanced Computer Graphics (4)

Topics include an overview of many aspects of computer graphics, including the four main computer graphics areas of animation, modeling, rendering, and imaging. Programming projects in image and signal processing, geometric modeling, and real-time rendering. ** Prerequisites:** CSE 167; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 164. GPU Programming (4)

Principles and practices of programming graphics processing units (GPUs). GPU architecture and hardware concepts, including memory and threading models. Modern hardware-accelerated graphics pipeline programming. Application of GPU programming to rendering of game graphics, including physical, deferring, and global lighting models. Recommended preparation: *Practical Rendering and Computation with Direct3D 11* by Jason Zink, Matt Pettineo, and Jack Hoxley. ** Prerequisites:**CSE 167.

CSE 165. 3-D User Interaction (4)

This course focuses on design and evaluation of three-dimensional (3-D) user interfaces, devices, and interaction techniques. The course consists of lectures, literature reviews, and programming assignments. Students will be expected to create interaction techniques for several different 3-D interaction devices. Program or materials fees may apply. ** Prerequisites:**CSE 167; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 166. Image Processing (4)

Principles of image formation, analysis, and representation. Image enhancement, restoration, and segmentation; stochastic image models. Filter design, sampling, Fourier and wavelet transforms. Selected applications in computer graphics and machine vision. ** Prerequisites:** (DSC 40B or MATH 18 or MATH 31AH or MATH 20F) and (CSE 100 or DSC 80 or MATH 176); restricted to sophomore, junior, and senior students. Graduate students allowed as space permits.

CSE 167. Computer Graphics (4)

Representation and manipulation of pictorial data. Two-dimensional and three-dimensional transformations, curves, surfaces. Projection, illumination, and shading models. Raster and vector graphic I/O devices; retained-mode and immediate-mode graphics software systems and applications. Students may not receive credit for both MATH 155A and CSE 167. ** Prerequisites:** CSE 100 or MATH 176; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 168. Computer Graphics II: Rendering (4)

Weekly programming assignments that will cover graphics rendering algorithms. During the course the students will learn about ray tracing, geometry, tessellation, acceleration structures, sampling, filtering, shading models, and advanced topics such as global illumination and programmable graphics hardware. ** Prerequisites:** CSE 167; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 169. Computer Animation (4)

Advanced graphics focusing on the programming techniques involved in computer animation. Algorithms and approaches for both character animation and physically based animation. Particular subjects may include skeletons, skinning, key framing, facial animation, inverse kinematics, locomotion, motion capture, video game animation, particle systems, rigid bodies, clothing, and hair. Recommended preparation: An understanding of linear algebra. ** Prerequisites:** CSE 167; restricted to CS25, CS26, CS27, and EC26 majors. All other students will be allowed as space permits.

CSE 170. Interaction Design (5)

Introduces fundamental methods and principles for designing, implementing, and evaluating user interfaces. Topics include user-centered design, rapid prototyping, experimentation, direct manipulation, cognitive principles, visual design, social software, software tools. Learn by doing: Work with a team on a quarter-long design project. Cross-listed with COGS 120. Students may not receive credit for COGS 120 and CSE 170. Recommended preparation: Basic familiarity with HTML. ** Prerequisites:** CSE 11 or CSE 8B and COGS 187A or COGS 1 or DSGN 1.

CSE 176A. Health Care Robotics (4)

Robotics has the potential to improve well-being for millions of people and support caregivers and to aid the clinical workforce. We bring together engineers, clinicians, and end-users to explore this exciting new field. The course is project-based, interactive, and hands-on, and involves working closely with stakeholders to develop prototypes that solve real-world problems. Students will explore the latest research in health care robotics, human-robot teaming, and health design. Program or materials fees may apply. ** Prerequisites:** CSE 110 or CSE 170 or COGS 120; restricted to sophomore, junior, and senior students.

CSE 176E. Robot Systems Design and Implementation (4)

End-to-end system design of embedded electronic systems including PCB design and fabrication, software control system development, and system integration. Program or materials fees may apply. May be coscheduled with CSE 276E.**Prerequisites:** restricted to junior and senior students; instructor approval required.

CSE 180. Biology Meets Computing (4)

Topics include an overview of various aspects of bioinformatics and will simultaneously introduce students to programming in Python. The assessments in the course represent various programming challenges and include solving diverse biological problems using popular bioinformatics tools. Students may not receive credit for CSE 180 and CSE 180R. **Prerequisites:** BILD 1.

CSE 180R. Biology Meets Computing (4)

Topics include an overview of various aspects of bioinformatics and will simultaneously introduce students to programming in Python. The assessments in the course represent various programming challenges and include solving diverse biological problems using popular bioinformatics tools. This will be a fully online class based on extensive educational materials and online educational platform Stepik developed with HHMI, NIH, and ILTI support. Students may not receive credit for CSE 180 and CSE 180R. **Prerequisites:** BILD 1 or BILD 4 or CSE 3 or CSE 7 or CSE 8A or CSE 8B or CSE 11.

CSE 181. Molecular Sequence Analysis (4)

This course covers the analysis of nucleic acid and protein sequences, with an emphasis on the application of algorithms to biological problems. Topics include sequence alignments, database searching, comparative genomics, and phylogenetic and clustering analyses. Pairwise alignment, multiple alignment, DNS sequencing, scoring functions, fast database search, comparative genomics, clustering, phylogenetic trees, gene finding/DNA statistics. Students may receive credit for one of the following: CSE 181, BIMM 181, or BENG 181. ** Prerequisites:**(CSE 100 or MATH 176) and (CSE 101) and (BIMM 100 or CHEM 114C); restricted to BE28, BI34, CH37, and CS27 majors. CSE 181 is cross-listed with BIMM 181 and BENG 181.

CSE 182. Biological Databases (4)

This course provides an introduction to the features of biological data, how those data are organized efficiently in databases, and how existing data resources can be utilized to solve a variety of biological problems. Object oriented databases, data modeling and description. Survey of current biological database with respect to above, implementation of a database on a biological topic. Cross-listed with BIMM 182 and BENG 182. Students may receive credit for one of the following: CSE 182, BENG 182, or BIMM 182. **Prerequisites:** CSE 100 or MATH 176; restricted to BE28, BI34, CH37, and CS27 majors.

CSE 184. Computational Molecular Biology (4)

This advanced course covers the application of machine learning and modeling techniques to biological systems. Topics include gene structure, recognition of DNA and protein sequence patterns, classification, and protein structure prediction. Pattern discovery, Hidden Markov models/support victor machines/neural network/profiles. Protein structure prediction, functional characterization or proteins, functional genomics/proteomics, metabolic pathways/gene networks. Cross-listed with BIMM 184/BENG 184/CHEM 184. ** Prerequisites:**BIMM 181 or BENG 181 or CSE 181, BENG 182 or BIMM 182 or CSE 182 or CHEM 182. Bioinformatics majors only.

CSE 185. Advanced Bioinformatics Laboratory (4)

This course emphasizes the hands-on application of bioinformatics to biological problems. Students will gain experience in the application of existing software, as well as in combining approaches to answer specific biological questions. Topics include sequence alignment, fast database search, comparative genomics, expression analysis, computational proteomics, genome-wide association studies, next-generation sequencing, genomics, and big data. Students may not receive credit for CSE 185 and BIMM 185. Restricted to CS27, BI34, BE28, and CH37 major codes. **Prerequisites:** CSE 11 or CSE 8B and CSE 12 and MATH 20C or MATH 31BH and BILD 1 and BIEB 123 or BILD 4 or BIMM 101 or CHEM 109.

CSE 190. Topics in Computer Science and Engineering (4)

Topics of special interest in computer science and engineering. Topics may vary from quarter to quarter. May be repeated for credit with the consent of instructor. ** Prerequisites:** consent of instructor. Department stamp required.

CSE 191. Seminar in CSE (1–4)

A seminar course on topics of current interest. Students, as well as the instructor, will be actively involved in running the course/class. This course cannot be counted toward a technical elective. ** Prerequisites:** consent of instructor. Department stamp required.

CSE 192. Senior Seminar in Computer Science and Engineering (1)

The Senior Seminar Program is designed to allow senior undergraduates to meet with faculty members in a small group setting to explore an intellectual topic in CSE (at the upper-division level). Topics will vary from quarter to quarter. Senior seminars may be taken for credit up to four times, with a change in topic, and permission of the department. Enrollment is limited to twenty students, with preference given to seniors. (P/NP grades only.) ** Prerequisites:**upper-division standing; department stamp required and consent of instructor.

CSE 193. Introduction to Computer Science Research (4)

Introduction to research in computer science. Topics include defining a CS research problem, finding and reading technical papers, oral communication, technical writing, and independent learning. Course participants apprentice with a CSE research group and propose an original research project. **Prerequisites:** consent of the department chair. Department stamp required.

CSE 195. Teaching (4)

Teaching and tutorial assistance in a CSE course under the supervision of the instructor. (P/NP grades only.) ** Prerequisites:** consent of the department chair. Department stamp required.

CSE 197. Field Study in Computer Science and Engineering (4)

Directed study accompanying full-time on-site computer science internships. (P/NP grades only.) ** Prerequisites:** consent of the instructor and approval of the department. Restricted to CS25, CS26, CS27, and CS28 majors only.

CSE 198. Directed Group Study (2 or 4)

Computer science and engineering topics whose study involves reading and discussion by a small group of students under the supervision of a faculty member. (P/NP grades only.) ** Prerequisites:** consent of the instructor. Department stamp required.

CSE 199. Independent Study for Undergraduates (2 or 4)

Independent reading or research by special arrangement with a faculty member. (P/NP grades only.) ** Prerequisites:** consent of the instructor. Department stamp required.

CSE 199H. CSE Honors Thesis Research for Undergraduates (4)

Undergraduate research for completing an honors project under the supervision of a CSE faculty member. May be taken across multiple quarters. Students should enroll for a letter grade. May be taken for credit three times. ** Prerequisites:**Admission to the CSE department honors program. Consent of the instructor. Department stamp required.

### Graduate

CSE 200. Computability and Complexity (4)

Computability review, including halting problem, decidable sets, r.e. sets, many-one reductions; TIME(t(n)), SPACE(s(n)) and general relations between these classes; L, P, PSPACE, NP; NP—completeness; hierarchy theorems; RP, BPP. ** Prerequisites:** CSE 105 or equivalent.

CSE 201A. Advanced Complexity (4)

Polynomial-time hierarchy (PH), BPP in second level of PH, Savitch’s theorem, NL=coNL, nonuniform and circuit complexity, some circuit lower bounds, IP=PSPACE, probabilistic proof checking (PCP), application of PCP to approximation hardness, complexity of proof systems, parallel complexity classes NC and AC, P-completeness. Recommended preparation: CSE 200. ** Prerequisites:** graduate standing.

CSE 202. Algorithm Design and Analysis (4)

The basic techniques for the design and analysis of algorithms. Divide-and-conquer, dynamic programming, data structures, graph search, algebraic problems, randomized algorithms, lower bounds, probabilistic analysis, parallel algorithms. ** Prerequisites:** CSE 101 or equivalent.

CSE 203A. Advanced Algorithms (4)

Modern advances in design and analysis of algorithms. Exact syllabus varies. Topics include approximation, randomized algorithms, probabilistic analysis, heuristics, online algorithms, competitive analysis, models of memory hierarchy, parallel algorithms, number-theoretic algorithms, cryptanalysis, computational geometry, computational biology, network algorithms, VLSI CAD algorithms. ** Prerequisites:** CSE 202.

CSE 203B. Convex Optimization Formulations and Algorithms (4)

We study the formulations and algorithms solving convex optimization problems. The topics include convex sets, functions, optimality conditions, duality concepts, gradient descent, conjugate gradient, interior-point methods, and applications. The objective of the course is to provide students the background and techniques for scientific computing and system optimization. Students cannot receive credit for CSE 203B if they have taken either ECE 273 or MATH 245B. **Prerequisites:** Linear Algebra is recommended.

CSE 205A. Logic in Computer Science (4)

(Formerly CSE 208D) Mathematical logic as a tool in computer science. Propositional logic, resolution, first-order logic, completeness and incompleteness theorems with computational viewpoint, finite model theory, descriptive complexity, logic programming, nonmonotonic reasoning, temporal logic. Applications to databases, automatic theorem proving, program verification, and distributed systems. ** Prerequisites:** CSE 200 or consent of instructor.

CSE 206A. Lattice Algorithms and Applications (4)

(Formerly CSE 207C) Introduction to the algorithmic theory of point lattices (aka algorithmic geometry of numbers), and some of its most important applications in cryptography and cryptanalysis. Topics usually include LLL basis reduction algorithm, cryptanalysis of broadcast RSA, hardness of approximating lattice problems. ** Prerequisites:** CSE 202, CSE 200, or concurrent.

CSE 207. Modern Cryptography (4)

Private and public key cryptography, introduction to reduction-based proofs of security, concrete security, block ciphers, pseudorandom functions and generators, symmetric encryption, asymmetric encryption, computational number theory, RSA and discrete log systems, message authentication, digital signatures, key distribution and key management. ** Prerequisites:** CSE 202 or consent of instructor.

CSE 208. Advanced Cryptography (4)

Zero-knowledge, secure computation, session-key distribution, protocols, electronic payment, one-way functions, trapdoor permutations, pseudorandom bit generators, hardcore bits. ** Prerequisites:** CSE 202, CSE 200, and CSE 207 or consent of instructor.

CSE 209A. Topics/Seminar in Algorithms, Complexity, and Logic (1–4)

Topics of special interest in algorithms, complexity, and logic to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 209B. Topics/Seminar in Cryptography (1–4)

Topics of special interest in cryptography to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 210. Principles of Software Engineering (4)

(Formerly CSE 264A.) General principles in modern software engineering. Both theoretical and practical topics are covered. Theoretical topics include proofs of correctness, programming language semantics, and theory of testing. Practical topics include structured programming, modularization techniques, design of languages for reliable programming, and software tools. ** Prerequisites:** CSE 100, 131A, 120, or consent of instructor.

CSE 211. Software Testing and Analysis (4)

Survey of testing and analysis methods. Introduction to advanced topics in area as well as traditional production methods. Topics include inspections and reviews, formal analysis, verification and validation standards, nonstatistical testing, statistical-testing and reliability models, coverage methods, testing and analysis tools, and organization management and planning. Methods special to special development approaches such as object-oriented testing will also be described. ** Prerequisites:** undergraduate major in computer science or extensive industrial experience.

CSE 216. Research Topics in Human-Computer Interaction (4)

Prepares students to conduct original HCI research by reading and discussing seminal and cutting-edge research papers. Topics include design, social software, input techniques, mobile, and ubiquitous computing. Student pairs perform a quarter-long mini research project that leverages campus research efforts. Cross-listed with COGS 230. ** Prerequisites:** none.

CSE 218. Advanced Topics in Software Engineering (4)

This course will cover a current topic in software engineering in depth. Topics in the past have included software tools, impacts of programming language design, and software system structure. (S/U grades permitted.) ** Prerequisites:** none.

CSE 219. Design at Large (1)

New societal challenges, cultural values, and technological opportunities are changing design—and vice versa. The seminar explores this increased scale, real-world engagement, and disruptive impact. Invited speakers from UC San Diego and beyond share cutting-edge research on interaction, design, and learning. Cross-listed with COGS 229. (S/U grades only.) ** Prerequisites:** none.

CSE 221. Operating Systems (4)

Operating system structures, concurrent computation models, scheduling, synchronization mechanisms, address spaces, memory management protection and security, buffering, streams, data-copying reduction techniques, file systems, naming, caching, disk organization, mapped files, remote file systems, case studies of major operating systems. ** Prerequisites:** CSE 120 and 121, or consent of instructor.

CSE 222A. Computer Communication Networks (4)

(Formerly CSE 222.) Computer communication network concepts, protocols, and architectures, with an emphasis on an analysis of algorithms, protocols, and design methodologies. Topics will include layering, error control, flow control, congestion control, switching and routing, quality of service management, mobility, naming, security, and selected contemporary topics. ** Prerequisites:** CSE 123A or consent of instructor.

CSE 222B. Internet Algorithmics (4)

(Formerly CSE 228H.) Techniques for speeding up internet implementations, including system restructuring, new algorithms, and hardware innovations. Topics include models for protocols, systems and hardware; efficiency principles; applying these principles to deriving techniques for efficient implementation of common endnode and router functions. ** Prerequisites:** CSE 123A or CSE 222A, or consent of instructor.

CSE 223B. Distributed Computing and Systems (4)

Efficient primitives for distributed operating systems and high-performance network servers, including concurrent and event-driven server architectures, remote procedure calls, and load shedding. Distributed naming, directory, and storage services, replication for fault tolerance, and security in distributed systems. ** Prerequisites:** CSE 221, CSE 222A, or consent of instructor.

CSE 224. Graduate Networked Systems (4)

This course will provide a broad understanding of network design and implementation. Topics include techniques for building distributed applications, sockets programming, remote procedure calls (RPC), scale-out distributed directories, distributed consensus and state management, fault tolerance, networked storage, indirection, overlay networks, load balancing, and datacenter design. **Prerequisites:** graduate standing or consent of instructor. This course is intended for MS students. PhD students may only take the course if they are not in systems/networking concentrations.

CSE 227. Computer Security (4)

Security and threat models, risk analysis, authentication and authorization, auditing, operating systems security, access control mechanisms, protection mechanisms, distributed systems/network security, security architecture, electronic commerce security mechanisms, security evaluation. ** Prerequisites:** CSE 221 or consent of instructor.

CSE 229A. Topics/Seminar in Computer Systems (1–4)

Discussion on problems of current research interest in computer systems. Possible areas of focus include distributed computing, computational grid, operating systems, fault-tolerant computing, storage systems, system services for the World Wide Web. Topics to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 229C. Topics/Seminar in Computer Security (1–4)

Discussion on problems of current research interest in computer security. Topics to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 230. Principles of Programming Languages (4)

(Formerly CSE 273.) Functional versus imperative programming. Type systems and polymorphism; the ML language. Higher order functions, lazy evaluation. Abstract versus concrete syntax, structural and well-founded induction. The lambda calculus, reduction strategies, combinators. Denotational semantics, elementary domain theory. ** Prerequisites:** CSE 130 or equivalent, or consent of instructor.

CSE 231. Advanced Compiler Design (4)

(Formerly CSE 264C.) Advanced material in programming languages and translator systems. Topics include compilers, code optimization, and debugging interpreters. ** Prerequisites:** CSE 100, 131A–B, or consent of instructor.

CSE 232. Principles of Database Systems (4)

(Formerly CSE 264D.) Database models including relational, hierarchic, and network approaches. Implementation of databases including query languages and system architectures. ** Prerequisites:** CSE 100 or consent of instructor.

CSE 232B. Database System Implementation (4)

A hands-on approach to the principles of databases implementation. Algebraic rewriters/optimizers, query processors, triggers. Beyond centralized relational databases. ** Prerequisites:** CSE 232.

CSE 233. Database Theory (4)

Theory of databases. Theory of query languages, dependency theory, deductive databases, incomplete information, complex objects, object-oriented databases, and more. Connections to logic and complexity theory including finite model theory and descriptive complexity. ** Prerequisites:** CSE 200.

CSE 237A. Introduction to Embedded Computing (4)

Embedded system technologies including processors, DSP, memory, and software. System interfacing basics, communication strategies, sensors, and actuators. Mobile and wireless technology in embedded systems. Using predesigned hardware and software components. Design case studies in wireless, multimedia, and/or networking domains. ** Prerequisites:** basic courses in digital hardware, algorithms and data structures, elementary calculus, and probability; or consent of instructor.

CSE 237B. Software for Embedded Systems (4)

Embedded computing elements, device interfaces, time-critical IO handling. Embedded software design under size, performance, and reliability constraints. Software timing and functional validation. Programming methods and compilation for embeddable software. Embedded runtime systems. Case studies of real-time software systems. ** Prerequisites:** CSE 237A; or basic courses in programming, algorithms and data structures, elementary calculus, discrete math, computer architecture; or consent of instructor.

CSE 237C. Validation and Testing of Embedded Systems (4)

Embedded system building blocks including IP cores. Cosimulation. Formal verification using model checking. Verification environments. Test challenges in core integration: compliance, feature, random, and collision testing. Core access and test integration. Interface-based verification and standards. ** Prerequisites:** CSE 237A; or basic courses in algorithms and data structures, elementary calculus, discrete math, symbolic logic, computer architecture; or consent of instructor.

CSE 237D. Design Automation and Prototyping for Embedded Systems (4)

System representation and modeling. Abstract and language models. Simulation as a modeling activity. Computational and hw/sw system prototypes. System analysis using models. Constraint and interface modeling. Behavioral compilation and synthesis. ** Prerequisites:** CSE 237A; or basic courses in digital logic design, algorithms and data structures, elementary calculus, discrete math, symbolic logic, computer architecture; or consent of instructor.

CSE 239A. Topics/Seminar in Databases (1–4)

Discussion on problems of current research interest in databases. Possible areas of focus include core database issues, data management on the web, data integration, new database models and applications, formal methods in databases. Topics to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 239B. Topics/Seminar in Programming Languages (1–2)

Discussion on problems of current research interest in programming languages, formal methods, and software engineering. Possible areas of focus include program verification, program synthesis, language design and implementation, developer productivity tools, language-based security. Topics to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be taken for credit up to eighteen times for a maximum of eighteen units. * Prerequisites: *consent of instructor.

CSE 240A. Principles of Computer Architecture (4)

(Formerly CSE 240.) This course will cover fundamental concepts in computer architecture. Topics include instruction set architecture, pipelining, pipeline hazards, bypassing, dynamic scheduling, branch prediction, superscalar issue, memory-hierarchy design, advanced cache architectures, and multiprocessor architecture issues. ** Prerequisites:** CSE 141 or consent of instructor.

CSE 240B. Parallel Computer Architecture (4)

This course covers advanced topics in parallel computer architecture, including on-chip and off-chip interconnection networks, cache coherence, cache consistency, hardware multithreading, multi-core and tiled architectures. It incorporates the latest research and development on parallel architectures and compilation techniques for those architectures. CSE 240A recommended. ** Prerequisites:** graduate standing.

CSE 240C. Advanced Microarchitecture (4)

This course covers advanced topics in computer architecture. It incorporates the latest research and development on topics such as branch prediction, instruction-level parallelism, cache hierarchy design, speculative multithreading, reliable architectures, and power-management techniques. CSE 240A recommended. ** Prerequisites:** graduate standing.

CSE 241A/ECE 260B. VLSI Integration of Computing Circuitry (4)

VLSI integrated-circuit building blocks of computing systems, and their implementation. Computer-aided design and performance simulations, design exercises and projects. Devices, standard cells and interconnects, clocking, power/ground distribution, arithmetic modules, memories. Methodologies and tradeoffs in system implementation. ** Prerequisites:** layout (CSE 165 or ECE 260A) and logic design (CSE 140 or ECE 111), or consent of instructor.

CSE 243A. Introduction to Synthesis Methodologies in VLSI CAD (4)

Hardware software codesign, architectural level synthesis, control synthesis and optimization, scheduling, binding, register and bus sharing, interconnect design, module selection, combinational logic optimization, state minimization, state encoding, and retiming. ** Prerequisites:** none.

CSE 244A. VLSI Test (4)

Design for test, testing economics, defects, failures and faults, fault models, fault simulation, automatic test pattern generation, functional testing, memory, PLA, FPGA, microprocessor test, and fault diagnosis. ** Prerequisites:** none.

CSE 245. Computer Aided Circuit Simulation and Verification (4)

This course is about the computer algorithms, techniques, and theory used in the simulation and verification of electrical circuits. ** Prerequisites:** CSE 241A or consent of instructor.

CSE 248. Algorithmic and Optimization Foundations for VLSI CAD (4)

Algorithmic techniques and optimization frameworks for large-scale, difficult optimizations. Primal-dual multicommodity flow approximations, approximations for geometric and graph Steiner formulations, continuous placement optimization, heuristics for Boolean satisfiability, multilevel methods, semidefinite programming, and application to other formulations (e.g., scheduling). ** Prerequisites:** CSE 241A or CSE 242A, or consent of instructor.

CSE 249A. Topics/Seminar in Computer Architecture (1–4)

Topics of special interest in computer architecture to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 249B. Topics/Seminar in VLSI (1–4)

Topics of special interest in VLSI to be presented by faculty and students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. ** Prerequisites:** consent of instructor.

CSE 250A. Principles of Artificial Intelligence: Probabilistic Reasoning and Learning (4)

Methods based on probability theory for reasoning and learning under uncertainty. Content may include directed and undirected probabilistic graphical models, exact and approximate inference, latent variables, expectation-maximization, hidden Markov models, Markov decision processes, applications to vision, robotics, speech, and/or text. Recommended preparation: CSE 103 or similar course. ** Prerequisites:** graduate standing in CSE or consent of instructor.

CSE 251A. Principles of Machine Learning: Learning Algorithms (4)

(Formerly CSE 250B.) Algorithms for supervised and unsupervised learning from data. Content may include maximum likelihood; log-linear models, including logistic regression and conditional random fields; nearest neighbor methods; kernel methods; decision trees; ensemble methods; optimization algorithms; topic models; neural networks; and backpropagation. Renumbered from CSE 250B. Students may not receive credit for CSE 251A and CSE 250B. Recommended preparation: CSE 103 or similar course. ** Prerequisites:** graduate standing or consent of instructor.

CSE 251B. Principles of Machine Learning: Neural Networks for Pattern Recognition (4)

(Formerly CSE 253.) This course covers Hopfield networks, application to optimization problems layered perceptrons, recurrent networks, and unsupervised learning. Programming exercises explore model behavior with a final project or exam on a cognitive science, artificial intelligence, or optimization problem of the student’s choice. Renumbered from CSE 253. Students may not receive credit for CSE 251B and CSE 253. Recommended preparation: Knowledge of C. * Prerequisites:* graduate standing.

CSE 251C. Principles of Machine Learning: Machine Learning Theory (4)

(Formerly CSE 250C.) Theoretical foundations of machine learning. Topics include concentration of measure, the PAC model, uniform convergence bounds, and VC dimension. Possible topics include online learning, learning with expert advice, multiarmed bandits, and boosting. Renumbered from CSE 250C. Students may not receive credit for CSE 251C and CSE 250C. Recommended preparation: CSE 103 and CSE 101 or similar course. * Prerequisites:* graduate standing or consent of instructor.

CSE 252A. Computer Vision I (4)

Comprehensive introduction to computer vision providing broad coverage including low-level vision (image formation, photometry, color, image feature detection), inferring 3-D properties from images (shape-from shading, stereo vision, motion interpretation) and object recognition. Companion to CSE 252B covering complementary topics. ** Prerequisites:** MATH 10D and MATH 20A–F or equivalent.

CSE 252B. Computer Vision II (4)

Comprehensive introduction to computer vision providing focused coverage of multiview geometry, structure from motion, image segmentation, motion segmentation, texture analysis and recognition, object detection, and image-based rendering. Companion to CSE 252A covering complementary topics. ** Prerequisites:** MATH 10D and MATH 20A–F or equivalent.

CSE 252C. Selected Topics in Vision and Learning (1–4)

Selected topics in computer vision and statistical pattern recognition, with an emphasis on recent developments. Possible topics include grouping and segmentation, object recognition and tracking, multiple view geometry, kernel-based methods, dimensionality reduction, and mixture models. ** Prerequisites:** CSE 252 or equivalent and CSE 250B or equivalent.

CSE 252D. Advanced Computer Vision (4)

This course covers advanced concepts in computer vision. Example topics include 3-D reconstruction, face recognition, object detection, semantic segmentation, action recognition, and domain adaptation. Consistent with recent developments, deep learning forms a significant fraction of the class. Lectures and assignments cover recent works on fundamental problems in computer vision, with the aim to prepare students for pursuing careers in the field. Recommended preparation: Completion of one of CSE 252A, 252B, 250A, or 250B is highly recommended. * Prerequisites:* graduate standing.

CSE 254. Statistical Learning (4)

Learning algorithms based on statistics. Possible topics include minimum-variance unbiased estimators, maximum likelihood estimation, likelihood ratio tests, resampling methods, linear logistic regression, feature selection, regularization, dimensionality reduction, manifold detection. An upper-division undergraduate course on probability and statistics such as MATH 183 or 186, or any graduate course on statistics, pattern recognition, or machine learning is recommended. ** Prerequisites:** graduate standing.

CSE 255. Data Mining and Predictive Analytics (4)

Learning methods for applications. Content may include data preparation, regression and classification algorithms, support vector machines, random forests, class imbalance, overfitting, decision theory, recommender systems and collaborative filtering, text mining, analyzing social networks and social media, protecting privacy, A/B testing. Recommended preparation: CSE 103 or similar. ** Prerequisites:** graduate standing or consent of instructor.

CSE 256/LING 256. Statistical Natural Language Processing (4)

An introduction to modern statistical approaches to natural language processing: part of speech tagging, word sense disambiguation and parsing, using Markov models, hidden Markov models, and probabilistic context-free grammars. Recommended preparation: LIGN 165, LIGN 245, CSE 151, CSE 250A, or CSE 254. **Prerequisites:** graduate standing or consent of instructor.

CSE 257. Search and Optimization (4)

The course will cover core algorithms for sequential decision-making problems in autonomous systems. Topics include heuristic search, Monte Carlo search, deep reinforcement learning, nonlinear optimization, mixed-integer optimization, and stochastic optimization. **Prerequisites:** graduate standing or consent of instructor.

CSE 258. Recommender Systems and Web Mining (4)

Current methods for data mining and predictive analytics. Emphasis is on studying real-world data sets, building working systems, and putting current ideas from machine learning research into practice. Recommended preparation: No previous background in machine learning is required, but students should be comfortable with programming (all example code will be in Python), and with basic optimization and linear algebra. ** Prerequisites:** graduate standing.

CSE 258A. Cognitive Modeling (4)

Connectionist models and a sampling of other cognitive modeling techniques. Models of language processing, memory, sequential processes, and vision. Areas covered may vary depending on student and faculty interests. Can be repeated for credit. CSE 151 or CSE 250B or CSE 253 or CSE 254, or equivalent experience recommended. ** Prerequisites:** graduate standing.

CSE 259. Seminar in Artificial Intelligence (1)

A weekly meeting featuring local (and occasional external) speakers discussing their current research in artificial intelligence neural networks, and genetic algorithms. (S/U grades only.) ** Prerequisites:** none.

CSE 260. Parallel Computation (4)

(Formerly CSE 274A.) This course provides an overview of parallel hardware, algorithms, models, and software. Topics include Flynn’s taxonomy, interconnection networks, memory organization, a survey of commercially available multiprocessors, parallel algorithm paradigms and complexity criteria, parallel programming environments and tools for parallel debugging, language specification, mapping, performance, etc. ** Prerequisites:** graduate standing or consent of instructor.

CSE 262. System Support for Applications of Parallel Computation (4)

This course will explore design of software support for applications of parallel computation. Topics include programming languages, run time support, portability, and load balancing. The course will terminate in a project. ** Prerequisites:** consent of instructor.

CSE 272. Advanced Image Synthesis (4)

Computer graphics techniques for creating realistic images. Topics include ray tracing, global illumination, subsurface scattering, and participating media. CSE 168 or equivalent recommended.

CSE 274. Selected Topics in Graphics (2–4)

Selected topics in computer graphics, with an emphasis on recent developments. Possible topics include computer animation, shape modeling and analysis, image synthesis, appearance modeling, and real-time rendering. CSE 168 or CSE 169 recommended. ** Prerequisites:** graduate standing or consent of instructor.

CSE 276A. Introduction to Robotics (4)

This course provides an introduction to the fundamentals of robotics across kinematics, sensor systems, estimation, control, and planning. The contents include introduction to robotics in general, kinematics of robot systems, robot arm systems, sensors for robots, basic vision for robots, estimation methods, perception, robot localization and navigation, control of robot systems, robot motion planning, robot task planning, robot architectures, and evaluation of robot systems. It is expected that students have a solid understanding of linear algebra, can program in Python or C++, and have a basic understanding of methods for reasoning under uncertainty. **Prerequisites:** graduate standing.

CSE 276B. Human Robot Interaction (4)

Robots are entering human spaces. How do we make them functional, useful, and acceptable? This course explores the core computational, engineering, and experimental challenges in human-robot interaction. Course topics include shared autonomy, perception of people and context, coordination, collaboration, human-guided learning, robot design, and experimental robotics. Students will review seminal and recent papers in the field and engage in team-based projects with physical, mobile robots. This class requires expertise in software development. Prior exposure to robotics, computer vision, or machine learning is recommended. Students should be comfortable reading and analyzing scientific papers at the graduate level. Students may not receive credit for CSE 276B and CSE 291 (A00) taught winter 2017 with the same subtitle. **Prerequisites:** graduate standing.

CSE 276C. Mathematics for Robotics (4)

The course will provide a comprehensive introduction to the key mathematical concepts used for modeling, implementing, and evaluation of robot systems. The course will use small home assignments tasks and a larger robot project to exercise the topics covered in class. The students should have a basic knowledge of mathematics and know one or more programming languages such as Python or MATLAB for completion of homework assignments. **Prerequisites:** graduate standing.

CSE 276D. Healthcare Robotics (4)

Robotics has the potential to improve well-being for millions of people, support care givers, and aid the clinical workforce. This course brings together engineers, clinicians, and end-users to explore this exciting new field. It is project-based, interactive, and hands on, and involves working closely with stakeholders to develop prototypes that solve real-world problems. Students will explore the latest research in healthcare robotics, human-robot teaming, and health design. JSOE students should be comfortable building and experimenting within their area of expertise (e.g., CSE, software development, MAE, rapid prototyping). Students with clinical backgrounds should be familiar with translational research methods. Students may not receive credit for CSE 276D and CSE 291 (H00) taught spring 2017 with the same subtitle. Program or materials fees may apply. **Prerequisites:** graduate standing.

CSE 276E. Robot Systems Design and Implementation (4)

End to end system design of embedded electronic systems including PCB design and fabrication, software control system development, and system integration. Program or materials fees may apply. May be coscheduled with CSE 176E. **Prerequisites:** instructor approval required to ensure sufficient programming and project experience to be successful in the course.

CSE 280A. Algorithms in Computational Biology (4)

(Formerly CSE 206B.) The course focuses on algorithmic aspects of modern bioinformatics and covers the following topics: computational gene hunting, sequencing, DNA arrays, sequence comparison, pattern discovery in DNA, genome rearrangements, molecular evolution, computational proteomics, and others. ** Prerequisites:** CSE 202 preferred or consent of instructor.

CSE 282/BENG 202. Bioinformatics II: Sequence and Structure Analysis—Methods and Applications (4)

(Formerly CSE 257A/BENG 202.) Introduction to methods for sequence analysis. Applications to genome and proteome sequences. Protein structure, sequence-structure analysis. ** Prerequisites:** Pharm 201 or consent of instructor.

CSE 283/BENG 203. Bioinformatics III: Functional Genomics (4)

Annotating genomes, characterizing functional genes, profiling, reconstructing pathways. ** Prerequisites:** Pharm 201, BENG 202/CSE 282, or consent of instructor.

CSE 284. Personal Genomics for Bioinformaticians (4)

This course provides an introduction to bioinformatics techniques for analyzing and interpreting human genomes. Topics covered include an introduction to medical and population genetics, ancestry, finding and interpreting disease-causing variants, genome-wide association studies, genetic risk prediction, analyzing next-generation sequencing data, how to scale current genomics techniques to analyze hundreds of thousands of genomes, and the social impact of the personal genomics revolution. Programming experience, familiarity with the UNIX command line, and a basic course in probability and statistics are strongly recommended. Students may not receive credit for CSE 284 and CSE 291 (E00) taught winter 2017 with the same subtitle. **Prerequisites:** graduate standing.

CSE 290. Seminar in Computer Science and Engineering (1–4)

(Formerly CSE 280A.) A seminar course in which topics of special interest in computer science and engineering will be presented by staff members and graduate students under faculty direction. Topics vary from quarter to quarter. May be repeated for credit. (S/U grades only.) ** Prerequisites:** consent of instructor. (Offered as faculty resources permit.)

CSE 291. Topics in Computer Science and Engineering (1–4)

Topics of special interest in computer science and engineering. Topics may vary from quarter to quarter. May be taken for credit nine times with the consent of instructor. ** Prerequisites:** consent of instructor. (S/U grades permitted.) (Offered as faculty resources permit.)

CSE 292. Faculty Research Seminar (1)

(Formerly CSE 282.) Computer science and engineering faculty will present one-hour seminars of the current research work in their areas of interest. ** Prerequisites:** CSE graduate status.

CSE 293. Special Project in Computer Science and Engineering (1–12)

The student will conceive, design, and execute a project in computer science under the direction of a faculty member. The project will typically include a large programming or hardware design task, but other types of projects are possible. ** Prerequisites:** CSE graduate student status. (CS 75, 76, 77, 78, 79, 80, 81) (S/U grades only.)

CSE 294. Research Meeting in CSE (2)

Advanced study and analysis of active research in computer science and computer engineering. Discussion of current research and literature in the research specialty of the staff member teaching the course. ** Prerequisites:** consent of instructor.

CSE 298. Independent Study (1–16)

Open to properly qualified graduate students who wish to pursue a problem through advanced study under the direction of a member of the staff. (S/U grades only.) ** Prerequisites:** consent of instructor.

CSE 299. Research (1–16)

Research. ** Prerequisites:** consent of faculty.

CSE 500. Teaching Assistantship (2–4)

A course in which teaching assistants are aided in learning proper teaching methods by means of supervision of their work by the faculty: handling of discussions, preparation and grading of examinations and other written exercises, and student relations. May be used to meet teaching experience requirement for candidates for the PhD degree. Number of units for credit depends on number of hours devoted to class or section assistance. ** Prerequisites:** graduate standing and consent of instructor.

CSE 599. Teaching Methods in Computer Science (2)

Training in teaching methods in the field of computer science. This course examines theoretical and practical communication and teaching techniques particularly appropriate to computer science. ** Prerequisites:** consent of faculty.

### You will also be interested:

- Tonal leg extension
- Hades vinyl
- Aesthetic white stickers
- Pro wrestling in los angeles
- Christian worship songs youtube
- Turbocharged s10

Wardrobes lined the walls. Katya immediately dragged Kirill to one of the cupboards - Come here, see what I'll show. Behind the door was a huge collection of all kinds of sex devices, and not only lesbian ones, the purpose of many of them could be understood intuitively, while some of. Them were a complete mystery to Kirill.

**850**851 852