ספרים - אפקה - המכללה האקדמית להנדסה בת"א

Download details: Visual Basic .NET Resource Kit

How to Design Programs: An Introduction to Computing and Programming

How to Design Programs: An Introduction to Computing and Programming

Contents

I Processing Simple Forms of Data

1 Students, Teachers, and Computers

2 Numbers, Expressions, Simple Programs
2.1 Numbers and Arithmetic
2.2 Variables and Programs
2.3 Word Problems
2.4 Errors
2.5 Designing Programs

3 Programs are Function Plus Variable Definitions
3.1 Composing Functions
3.2 Variable Definitions
3.3 Finger Exercises on Composing Functions

4 Conditional Expressions and Functions
4.1 Booleans and Relations
4.2 Functions that Test Conditions
4.3 Conditionals and Conditional Functions
4.4 Designing Conditional Functions

5 Symbolic Information
5.1 Finger Exercises with Symbols

6 Compound Data, Part 1: Structures
6.1 Structures
6.2 Extended Exercise: Drawing Simple Pictures
6.3 Structure Definitions
6.4 Data Definitions
6.5 Designing Functions for Compound Data
6.6 Extended Exercise: Moving Circles and Rectangles
6.7 Extended Exercise: Hangman

7 The Varieties of Data
7.1 Mixing and Distinguishing Data
7.2 Designing Functions for Mixed Data
7.3 Composing Functions, Revisited
7.4 Extended Exercise: Moving Shapes
7.5 Input Errors

8 Intermezzo 1: Syntax and Semantics
8.1 The Scheme Vocabulary
8.2 The Scheme Grammar
8.3 The Meaning of Scheme
8.4 Errors
8.5 Boolean Expressions
8.6 Variable Definitions
8.7 Structure Definitions

II Processing Arbitrarily Large Data

9 Compound Data, Part 2: Lists
9.1 Lists
9.2 Data Definitions for Lists of Arbitrary Length
9.3 Processing Lists of Arbitrary Length
9.4 Designing Functions for Self-Referential Data Definitions
9.5 More on Processing Simple Lists

10 More on Processing Lists
10.1 Functions that Produce Lists
10.2 Lists that Contain Structures
10.3 Extended Exercise: Moving Pictures

11 Natural Numbers
11.1 Defining Natural Numbers
11.2 Processing Natural Numbers of Arbitrary Size
11.3 Extended Exercise: Creating Lists, Testing Functions
11.4 Alternative Data Definitions for Natural Numbers
11.5 More on the Nature of Natural Numbers

12 Composing Functions, Revisited Again
12.1 Designing Complex Programs
12.2 Recursive Auxiliary Functions
12.3 Generalizing Problems, Generalizing Functions
12.4 Extended Exercise: Rearranging Words

13 Intermezzo 2: List Abbreviations

III More on Processing Arbitrarily Large Data

14 More Self-referential Data Definitions
14.1 Structures in Structures
14.2 Extended Exercise: Binary Search Trees
14.3 Lists in Lists
14.4 Extended Exercise: Evaluating Scheme

15 Mutually Referential Data Definitions
15.1 Lists of Structures, Lists in Structures
15.2 Designing Functions for Mutually Referential Definitions
15.3 Extended Exercise: More on Web Pages

16 Development through Iterative Refinement
16.1 Data Analysis
16.2 Defining Data Classes and Refining Them
16.3 Refining Functions and Programs

17 Processing Two Complex Pieces of Data
17.1 Processing Two Lists Simultaneously: Case 1
17.2 Processing Two Lists Simultaneously: Case 2
17.3 Processing Two Lists Simultaneously: Case 3
17.4 Function Simplification
17.5 Designing Functions that Consume Two Complex Inputs
17.6 Exercises on Processing Two Complex Inputs
17.7 Extended Exercise: Evaluating Scheme, Part 2
17.8 Equality and Testing

18 Intermezzo 3: Local Definitions and Lexical Scope
18.1 Organizing Programs with local
18.2 Lexical Scope and Block Structure

IV Abstracting Designs

19 Similarities in Definitions
19.1 Similarities in Functions
19.2 Similarities in Data Definitions

20 Functions are Values
20.1 Syntax and Semantics
20.2 Contracts for Abstract and Polymorphic Functions

21 Designing Abstractions from Examples
21.1 Abstracting from Examples
21.2 Finger Exercises with Abstract List Functions
21.3 Abstraction and a Single Point of Control
21.4 Extended Exercise: Moving Pictures, Again
21.5 Note: Designing Abstractions from Templates

22 Designing Abstractions with First-Class Functions
22.1 Functions that Produce Functions
22.2 Designing Abstractions with Functions-as-Values
22.3 A First Look at Graphical User Interfaces

23 Mathematical Examples
23.1 Sequences and Series
23.2 Arithmetic Sequences and Series
23.3 Geometric Sequences and Series
23.4 The Area Under a Function
23.5 The Slope of a Function

24 Intermezzo 4: Defining Functions on the Fly

V Generative Recursion

25 A New Form of Recursion
25.1 Modeling a Ball on a Table
25.2 Sorting Quickly

26 Designing Algorithms
26.1 Termination
26.2 Structural versus Generative Recursion
26.3 Making Choices

27 Variations on a Theme
27.1 Fractals
27.2 From Files to Lines, from Lists to Lists of Lists
27.3 Binary Search
27.4 Newton's Method
27.5 Extended Exercise: Gaussian Elimination

28 Algorithms that Backtrack
28.1 Traversing Graphs
28.2 Extended Exercise: Checking (on) Queens

29 Intermezzo 5: The Cost of Computing and Vectors
29.1 Concrete Time, Abstract Time
29.2 The Definition of ``on the Order of''
29.3 A First Look at Vectors

VI Accumulating Knowledge

30 The Loss of Knowledge
30.1 A Problem with Structural Processing
30.2 A Problem with Generative Recursion

31 Designing Accumulator-Style Functions
31.1 Recognizing the Need for an Accumulator
31.2 Accumulator-Style Functions
31.3 Transforming Functions into Accumulator-Style

32 More Uses of Accumulation
32.1 Extended Exercise: Accumulators on Trees
32.2 Extended Exercise: Missionaries and Cannibals
32.3 Extended Exercise: Board Solitaire

33 Intermezzo 6: The Nature of Inexact Numbers
33.1 Fixed-size Number Arithmetic
33.2 Overflow
33.3 Underflow
33.4 DrScheme's Numbers

VII Changing the State of Variables

34 Memory for Functions

35 Assignment to Variables
35.1 Simple Assignments at Work
35.2 Sequencing Expression Evaluations
35.3 Assignments and Functions
35.4 A First Useful Example

36 Designing Functions with Memory
36.1 The Need for Memory
36.2 Memory and State Variables
36.3 Functions that Initialize Memory
36.4 Functions that Change Memory

37 Examples of Memory Usage
37.1 Initializing State
37.2 State Changes from User Interactions
37.3 State Changes from Recursion
37.4 Finger Exercises on State Changes
37.5 Extended Exercise: Exploring Places

38 Intermezzo 7: The Final Syntax and Semantics
38.1 The Vocabulary of Advanced Scheme
38.2 The Grammar of Advanced Scheme
38.3 The Meaning of Advanced Scheme
38.4 Errors in Advanced Scheme

VIII Changing Compound Values

39 Encapsulation
39.1 Abstracting with State Variables
39.2 Practice with Encapsulation

40 Mutable Structures
40.1 Structures from Functions
40.2 Mutable Functional Structures
40.3 Mutable Structures
40.4 Mutable Vectors
40.5 Changing Variables, Changing Structures

41 Designing Functions that Change Structures
41.1 Why Mutate Structures
41.2 Structural Design Recipes and Mutation, Part 1
41.3 Structural Design Recipes and Mutation, Part 2
41.4 Extended Exercise: Moving Pictures, a Last Time

42 Equality
42.1 Extensional Equality
42.2 Intensional Equality

43 Changing Structures, Vectors, and Objects
43.1 More Practice with Vectors
43.2 Collections of Structures

Object-Oriented System Development: HTML Edition

Object-Oriented System Development: HTML Edition

Preface
1 Overview
Scope; Objects; Development Paradigms; Development Phases; Summary;

Part 1: Analysis

2 Introduction to Analysis
Purpose; Models; Process; Summary;
3 Object Statics
Instances; Classes; Attributes; Attribute Features; Constraints; Identifying Objects and Classes; Summary;
4 Object Relationships
Relationships; Collections; Identifying Relationships; Summary;
5 Object Dynamics
Describing Behavior; Transition Networks; Examples; Reducing Complexity; Summary;
6 Object Interaction
Transitions; Sending and Receiving Events; Interaction Notations; Examples; Summary;
7 Class Relationships
Property Inheritance; Subclasses; Multiple Inheritance; Sibling Relationships; Set Operations; Inheritance of Relations; Summary;
8 Instances
Subclasses and Instances; Metaclasses; Parametric Instances ; Summary;
9 Ensembles
Ensembles; Other Decomposition Constructs; Ensembles as Systems; Summary;
10 Constructing a System Model
Requirements Fragment; Use Cases; Subsystems; Vocabulary; Classes; Ensembles; Model; Summary;
11 Other Requirements
Resources; Timing; Other Constraints; Summary;
12 The Analysis Process
Software Development Process; Default Sequence of Steps; OO Analysis of the OO Analysis Process; Alternative Processes; Tools; Summary;
13 Domain Analysis
Models; Reuse; Summary;
14 The Grady Experience

Part II: Design

15 From Analysis to Design
Continuity; Transformation; Design Phases; Design Criteria; Managing Design; Summary;
16 Description and Computation
Translating Analysis Models; From Abstract to Concrete; Composing Classes; Controlling Transitions; Generic Classes; Generating Instances; Design for Testability; Transformation and Composition; Summary;
17 Attributes in Design
Defining Attributes; Concrete Attributes; Views; Exports; Composition and Inheritance; Summary;
18 Relationships in Design
Relationships; Collections; Coordinators; Relations versus Composites; Summary;
19 Designing Transitions
States and Guards; Atomicity; Timing Constraints; Concrete Transitions; Summary;
20 Interaction Designs
Callbacks; Replies; Invocations; Control Flow; Summary;
21 Dispatching
Selection; Resolution; Routing; Summary;
22 Coordination
Joint Actions; Controlling Groups; Open Systems; Summary;
23 Clustering Objects
Clustering; Cluster Objects; System Tools and Services; Persistence; Summary;
24 Designing Passive Objects
Transformations; Storage Management; Passive Objects in C++; Summary;
25 Performance Optimization
Optimization and Evolution; Algorithmic Optimization; Performance Transformations; Optimization in C++; Summary;
26 From Design to Implementation
Testing; Performance Assessment; Summary;
Appendix: Notation Summary
OAN; ODL;

Differential Geometry. Honours 1996 Michael Murray

Differential Geometry. Honours 1996
Contents
Co-ordinate independent calculus.
Introduction
Smooth functions
Derivatives as linear operators.
The chain rule.
Diffeomorphisms and the inverse function theorem.
Differentiable manifolds
Co-ordinate charts
Linear manifolds.
Topology of a manifold
Smooth functions on a manifold.
The tangent space.
The derivative of a function.
Co-ordinate tangent vectors and one-forms.
How to calculate.
Submanifolds
Tangent space to a submanifold
Smooth functions between manifolds
The tangent to a smooth map.
Submanifolds again.
Vector fields.
The Lie bracket.
Differential forms.
The exterior algebra of a vector space.
Differential forms and the exterior derivative.
Pulling back differential forms
Integration of differential forms
Orientation.
Integration again
Stokes theorem.
Manifolds with boundary.
Stokes theorem.
Partitions of unity.
Vector fields and the tangent bundle.
Vector fields and derivations.
Tensor products
About this document ...

Linear Algebra I+II

Linear Algebra I+II: "Linear Algebra "

תכנות מונחה עצמים ארז קלר

600 עמודים, ספר לימוד המיועד למתחילים העושים את צעדיהם הראשונים בעולם ה- .NET Framework ,בשפת C# ובתכנות מונחה עצמים, אולם גם מתכנתים בעלי ניסיון העושים הסבה משפות אחרות יוכלו למצוא בו עניין.
מעבר ללימוד שפת C#, השפה המרכזית של עולם ה- .NET Framework , הספר מתמקד בהיכרות עם עולם התכנות מונחה העצמים.
ההסברים מלווים בדוגמאות רבות הניתנות להורדה.

Compilers - Contents

Compilers - Contents

Preface
Acknowledgements
1 Introduction

1.1 Objectives
1.2 Systems programs and translators
1.3 The relationship between high-level languages and translators

2 Translator classification and structure

2.1 T-diagrams
2.2 Classes of translator
2.3 Phases in translation
2.4 Multi-stage translators
2.5 Interpreters, interpretive compilers, and emulators

3 Compiler construction and bootstrapping

3.1 Using a high-level host language
3.2 Porting a high-level translator
3.3 Bootstrapping
3.4 Self-compiling compilers
3.5 The half bootstrap
3.6 Bootstrapping from a portable interpretive compiler
3.7 A P-code assembler

4 Machine emulation

4.1 Simple machine architecture
4.2 Addressing modes
4.3 Case study 1 - a single-accumulator machine
4.4 Case study 2 - a stack-oriented computer

5 Language specification

5.1 Syntax, semantics, and pragmatics
5.2 Languages, symbols, alphabets and strings
5.3 Regular expressions
5.4 Grammars and productions
5.5 Classic BNF notation for productions
5.6 Simple examples
5.7 Phrase structure and lexical structure
5.8 -productions
5.9 Extensions to BNF
5.10 Syntax diagrams
5.11 Formal treatment of semantics

6 Simple assemblers

6.1 A simple ASSEMBLER language
6.2 One- and two-pass assemblers, and symbol tables
6.3 Towards the construction of an assembler
6.4 Two-pass assembly
6.5 One-pass assembly

7 Advanced assembler features

7.1 Error detection
7.2 Simple expressions as addresses
7.3 Improved symbol table handling - hash tables
7.4 Macro-processing facilities
7.5 Conditional assembly
7.6 Relocatable code
7.7 Further projects

8 Grammars and their classification

8.1 Equivalent grammars
8.2 Case study - equivalent grammars for describing expressions
8.3 Some simple restrictions on grammars
8.4 Ambiguous grammars
8.5 Context sensitivity
8.6 The Chomsky hierarchy
8.7 Case study - Clang

9 Deterministic top-down parsing

9.1 Deterministic top-down parsing
9.2 Restrictions on grammars so as to allow LL(1) parsing
9.3 The effect of the LL(1) conditions on language design

10 Parser and scanner construction

10.1 Construction of simple recursive descent parsers
10.2 Case studies
10.3 Syntax error detection and recovery
10.4 Construction of simple scanners
10.5 Case studies
10.6 LR parsing
10.7 Automated construction of scanners and parsers

11 Syntax-directed translation

11.1 Embedding semantic actions into syntax rules
11.2 Attribute grammars
11.3 Synthesized and inherited attributes
11.4 Classes of attribute grammars
11.5 Case study - a small student database

12 Using Coco/R - overview

12.1 Installing and running Coco/R
12.2 Case study - a simple adding machine
12.3 Scanner specification
12.4 Parser specification
12.5 The driver program

13 Using Coco/R - Case studies

13.1 Case study - Understanding C declarations
13.2 Case study - Generating one-address code from expressions
13.3 Case study - Generating one-address code from an AST
13.4 Case study - How do parser generators work?
13.5 Project suggestions

14 A simple compiler - the front end

14.1 Overall compiler structure
14.2 Source handling
14.3 Error reporting
14.4 Lexical analysis
14.5 Syntax analysis
14.6 Error handling and constraint analysis
14.7 The symbol table handler
14.8 Other aspects of symbol table management - further types

15 A simple compiler - the back end

15.1 The code generation interface
15.2 Code generation for a simple stack machine
15.3 Other aspects of code generation

16 Simple block structure

16.1 Parameterless procedures
16.2 Storage management

17 Parameters and functions

17.1 Syntax and semantics
17.2 Symbol table support for context sensitive features
17.3 Actual parameters and stack frames
17.4 Hypothetical stack machine support for parameter passing
17.5 Context sensitivity and LL(1) conflict resolution
17.6 Semantic analysis and code generation
17.7 Language design issues

18 Concurrent programming

18.1 Fundamental concepts
18.2 Parallel processes, exclusion and synchronization
18.3 A semaphore-based system - syntax, semantics, and code generation
18.4 Run-time implementation

Appendix

Tools for Thought by Howard Rheingold: Table of Contents

Tools for Thought by Howard Rheingold: Table of Contents

Acknowledgements
Dedication
Chapter One: The Computer Revolution Hasn't Happened Yet
Chapter Two: The First Programmer Was a Lady
Chapter Three: The First Hacker and his Imaginary Machine
Chapter Four: Johnny Builds Bombs and Johnny Builds Brains
Chapter Five: Ex-Prodigies and Antiarcraft Guns
Chapter Six: Inside Information
Chapter Seven: Machines to Think With
Chapter Eight: Witness to History: The Mascot of Project Mac
Chapter Nine: The Loneliness of a Long-Distance Thinker
Chapter Ten: The New Old Boys from the ARPAnet
Chapter Eleven: The Birth of the Fantasy Amplifies
Chapter Twelve: Brenda and the Future Squad
Chapter Thirteen: Knowledge Engineers and Epistemological Entrepreneurs
Chapter Fourteen: Xanadu, Network Culture, and Beyond

Image Processing Course - CS Department - Technion

Image Processing Course - CS Department - Technion עיבוד תמונות מיכאל אלעד הטכניון

FOLDOC - Computing Dictionary

FOLDOC - Computing Dictionary: "Enter a word or phrase in the box at the top of any page and click the Search button or hit Enter"

NASA THESAURUS

NASA THESAURUS
התזאורוס של נאס"א 1139 עמודים מהדורה 2004 - קובץ אקרובט "כבד" הורדה איטית

אנציקלופדיה של סדרות מספרים שלמים

On-Line Encyclopedia of Integer Sequences (Look-Up)

Description of the Database (or, What is the Next Term?)
What comes next after 1, 2, 4, 9, 20, 48, 115, 286, 719, ... ? (for example). This is the place to find out!
The main table is a collection of number sequences arranged in lexicographic order. The entry for each sequence gives:
the beginning of the sequence
its name or description
any references or links
any formulae
cross-references to other sequences
the name of the person who submitted it, etc

Overview (Java 2 Platform SE 5.0)

Overview (Java 2 Platform SE 5.0)
: "JavaTM 2 Platform Standard Edition 5.0 API Specification "

How This API Document Is Organized
This API (Application Programming Interface) document has pages corresponding to the items in the navigation bar, described as follows.
Overview
The Overview page is the front page of this API document and provides a list of all packages with a summary for each. This page can also contain an overall description of the set of packages.

Package
Each package has a page that contains a list of its classes and interfaces, with a summary for each. This page can contain four categories:

Interfaces (italic)
Classes
Enums
Exceptions
Errors
Annotation Types

more....

Eythan Levy's HomePage

Eythan Levy's HomePage

Links:

Algorithmic ressources on the internet:
The Stony Brook Algorithm Repository : an interesting collection of algorithm implementations.
Dictionary of Algorithms and Data Structures
Scientific books download:
Algorithms and Complexity, by Herbert S. Wilf.
Generatingfunctionology, by Herbert S. Wilf, everything you always wanted to know about generating functions, and more....
Introduction to Probability, by Charles Grinstead & J. Laurie Snell.
Graph Theory, by Reinhard Diestel.
Latex:
Getting started with LATEX : a (very) short and easy introduction to LATEX.
The not so short introduction to LaTeX2e : a more complete book.
Others:
The Directory of Computing Science Journals

How to Think Like a Computer Scientist: Learning with Python

How to Think Like a Computer Scientist: Learning with Python

by Allen B. Downey, Jeffrey Elkner and Chris Meyers

Printed copies now available from Green Tea Press. Table of Contents
Foreword
Preface
Contributor List
Chapter 1: The way of the program
Chapter 2: Variables, expressions, and statements
Chapter 3: Functions
Chapter 4: Conditionals and recursion
Chapter 5: Fruitful functions
Chapter 6: Iteration
Chapter 7: Strings
Chapter 8: Lists
Chapter 9: Tuples
Chapter 10: Dictionaries
Chapter 11: Files and exceptions
Chapter 12: Classes and objects
Chapter 13: Classes and functions
Chapter 14: Methods
Chapter 15: Sets of objects
Chapter 16: Inheritance
Chapter 17: Linked Lists
Chapter 18: Stacks
Chapter 19: Queues and priority queues
Chapter 20: Trees
Appendix A: Debugging
Appendix B: Creating a new datatype
Appendix C: Complete Python listings
Appendix D: Recommendations for further reading
GNU Free Document License
Index

How To Think Like A Computer Scientist

How To Think Like A Computer Scientist: "Java Version
by Allen B. Downey"

Table of Contents
Chapter 1: The way of the program
Chapter 2: Variables and types
Chapter 3: Methods
Chapter 4: Conditionals, graphics and recursion
Chapter 5: Fruitful methods
Chapter 6: Iteration
Chapter 7: Strings and things
Chapter 8: Interesting objects
Chapter 9: Create your own objects
Chapter 10: Arrays
Chapter 11: Arrays of Objects
Chapter 12: Objects of Arrays
Chapter 13: Object-oriented programming
Chapter 14: Linked lists
Chapter 15: Stacks
Chapter 16: Queues and Priority Queues
Chapter 17: Trees
Chapter 18: Heap
Chapter 19: Table
Appendix C: The Slate Class
Index

How To Think Like A Computer Scientist

How To Think Like A Computer Scientist
Learning with C++
by Allen B. Downey

Contributor List
Chapter 1: The way of the program
Chapter 2: Variables and types
Chapter 3: Function
Chapter 4: Conditionals and recursion
Chapter 5: Fruitful functions
Chapter 6: Iteration
Chapter 7: Strings and things
Chapter 8: Structures
Chapter 9: More structures
Chapter 10: Vectors
Chapter 11: Member functions
Chapter 12: Vectors of Objects
Chapter 13: Objects of Vectors
Chapter 14: Classes and invariants
Chapter 15: Object-oriented programming
Chapter 16: Pointers and References
Chapter 17: Templates
Chapter 18: Linked lists
Chapter 19: Stacks
Chapter 20: Queues and Priority Queues
Chapter 21: Trees
Chapter 22: Heap
Chapter 23: File Input/Output and pmatrices
Appendix A: Quick reference for pclasses
Index

ספרים - אפקה - המכללה האקדמית להנדסה בת"א

Thursday, November 04, 2004

Download details: Visual Basic .NET Resource Kit

Download details: Visual Basic .NET Resource Kit

Download details: Visual Basic .NET Resource Kit

How to Design Programs: An Introduction to Computing and Programming

Wednesday, November 03, 2004

Object-Oriented System Development: HTML Edition

Tuesday, November 02, 2004

Differential Geometry. Honours 1996 Michael Murray

Linear Algebra I+II

תכנות מונחה עצמים ארז קלר

Compilers - Contents

Monday, November 01, 2004

Tools for Thought by Howard Rheingold: Table of Contents

Sunday, October 31, 2004

Image Processing Course - CS Department - Technion

Saturday, October 30, 2004

FOLDOC - Computing Dictionary

NASA THESAURUS

Thursday, October 28, 2004

אנציקלופדיה של סדרות מספרים שלמים

Overview (Java 2 Platform SE 5.0)

Eythan Levy's HomePage

How to Think Like a Computer Scientist: Learning with Python

How To Think Like A Computer Scientist

How To Think Like A Computer Scientist

About Me

רשימת ספרים

Archives