Announcements

Differential Equations

posted May 30, 2010, 7:27 AM by karam kassem   [ updated May 30, 2010, 8:04 AM ]

المعادلة التفاضلية الخطية المتجانسة من المرتبة الثانية بأمثال ثابتة

الشكل العام للمعادلة


R ينتمي لـ  c, b, a حيث


خوارزمية حل المعادلة

أولاً :  نقوم بإيجاد المعادلة المميزة المكافئة للمعادلة التفاضلية


ثانياً : نقوم ايجاد جذور المعادلة المميزة

ونصادف هنا ثلاث حالات وهي :

1 . جذري المعادلة المميزة حقيقيان ومختلفان
فيكون حل المعادلة التفاضلية هو



2 . للمعادلة جذر مضاعف (جذرين متساويين)
فيكون حل المعادلة التفاضلية هو



3 . جذري المعادلة ينتميان لمجموعة الأعداد العقدية (عددين مركبين)
فيكون حل المعادلة التفاضلية هو





والشيئ الذي أردت الوصول إليه من الشرح السابق هو نمذجة خوارزمية الحلّ على شكل برنامج يقوم بكل العمليات السابقة

لتحميل كود البرنامج اضغط هنا -  أتمنى أن يعجبكم

Equation of the second-class

posted May 14, 2010, 1:08 PM by karam kassem   [ updated May 23, 2010, 1:32 AM ]

حل معادلة من الدرجة الثانية
من الشكل


ننقاش الحالات المعممة بداية وهي :

1 . إذا كانت دلتا أكبر من الصفر
          يكون عندها للمعادلة جذرين

2 . إذا كانت دلتا تساوي الصفر
          يكون للمعادلة جذر مضاعف وحيد

3 . إذا كانت دلتا تحت الصفر
         يكون للمعادلة جذور عقدية

لا أريد الدخول في كيفية الحلّ لأن حل معادلة من هذا النوع سهل للغياية
ولكن خوارزمية الوصول للحلول واظهارها هي أهم في هذه الحالة

في الملف المُرفق (في أسفل الصفحة) ملف رماز مصدري بلغة باسكال - وهو برنامج لحل أي معادلة من الدرجة الثانية




اقوال عن اينشتاين

posted May 3, 2010, 10:41 AM by karam kassem   [ updated May 3, 2010, 10:47 AM ]






الشيئان الذان ليس لهما حدود، الكون و غباء الإنسان، مع أني لست متأكدا بخصوص الكون

أهم شيء أن لا تتوقف عن التساؤل

أجمل إحساس هو الغموض، إنه مصدر الفن والعلوم

كل ما هو عظيم وملهم صنعه إنسان عَمِل بحرية

إذا لم يوافق الواقعُ النظريةَ، غيِّر الواقع

الجنون هو أن تفعل الشيء مرةً بعد مرةٍ وتتوقع نتيجةً مختلفةً

الحقيقة هي ما يثبُت أمام إمتحان التجربة

يستطيع أي أحمقٍ جعل الأشياء تبدو أكبر وأعقد, لكنك تحتاج إلى عبقري شجاع لجعلها تبدو عكس ذلك

الخيال أهم من المعرفة

الحقيقة ليست سوى وهم، لكنه وهم ثابت

يبدأ الإنسان بالحياة، عندما يستطيع الحياة خارج نفسه

أنا لا أفكر بالمستقبل، إنه يأتي بسرعة

من لم يخطئ، لم يجرب شيئاً جديداً

العلم شيءٌ رائعٌ، إذا لم تكن تعتاش منه

سر الإبداع هو أن تعرف كيف تخفي مصادرك

العلم ليس سوى إعادة ترتيبٍ لتفكيرك اليومي

لا يمكننا حل مشكلةٍ باستخدام العقلية نفسها التي أنشأتها

الثقافة هي ما يبقى بعد أن تنسى كل ما تعلمته في المدرسة

المعادلات أهم بالنسبة لي، السياسة للحاضر والمعادلة للأبدية

إذا كان أ= النجاح . فإن أ = ب +ج + ص. حيث ب=العمل. ج=اللعب. ص=إبقاء فمك مغلقاً

كلما اقتربت القوانين من الواقع أصبحت غير ثابتة، وكلما اقتربت من الثبات أصبحت غير واقعية

أنا لا أعرف السلاح الذي سيستخدمه الإنسان في الحرب العالمية الثالثة، لكني أعرف أنه سيستخدم العصا والحجر في الحرب العالمية الرابعة

اثمن ما في العالم هو الحدس او الفكرة اللامعة

الامر الوحيد الذي اسمح له بالتدخل في علمي وابحاثي هو معلوماتي وثقافتي الخاصة

العلم بدون علم اعرج, والدين بدون علم اعمى

انا لست موهوب, انا فضولي

اذا عشت مرة اخرى لاخترت ان اكون مواسيرجي

بين الماضي والحاضر والمستقبل ليس هناك سوى وهم في تفكير العقل البشري..اذا لاحظتم ان – الاوقات الحزينة نشعر بها انها طويلة بينما الايام
الفرحة تمر كالدقيقة- وهذه هي النسبية

افضل عادة سيئة صامتة عن فضيلة متكابرة

العقل البديهي هو هبة مقدسة, والعقل المعقول هو خادم مثمر..لقد اختلقنا مجتمع يحترم الخادم وينسى الهبة المقدسة

كل الديانات, الفنون والعلوم متفرعة على نفس الشجرة

النسبية تعلمنا الرباط او العلاقة بين الاوصاف المختلفة لشيء ما مع الحقيقة ذاتها

Insertion sort

posted Apr 12, 2010, 5:33 PM by karam kassem   [ updated Apr 14, 2010, 1:19 PM ]

Algorithm


Every iteration of insertion sort removes an element from the input data, inserting it into the correct position in the already-sorted list, until no input elements remain. The choice of which element to remove from the input is arbitrary, and can be made using almost any choice algorithm.

Sorting is typically done in-place. The resulting array after k iterations has the property where the first k + 1 entries are sorted. In each iteration the first remaining entry of the input is removed, inserted into the result at the correct position, thus extending the result:

Array prior to the insertion of x

becomes

Array after the insertion of x

with each element greater than x copied to the right as it is compared against x.

The most common variant of insertion sort, which operates on arrays, can be described as follows:


  1. Suppose there exists a function called Insert designed to insert a value into a sorted sequence at the beginning of an array. It operates by beginning at the end of the sequence and shifting each element one place to the right until a suitable position is found for the new element. The function has the side effect of overwriting the value stored immediately after the sorted sequence in the array.
  2. To perform an insertion sort, begin at the left-most element of the array and invoke Insert to insert each element encountered into its correct position. The ordered sequence into which the element is inserted is stored at the beginning of the array in the set of indices already examined. Each insertion overwrites a single value: the value being inserted.
Pseudocode of the complete algorithm follows, where the arrays are zero-based and the for-loop includes both the top and bottom limits (as in Pascal) :

insertionSort(array A)
begin
for i := 1 to length[A]-1 do
begin
value := A[i];
j := i - 1;
done := false;
repeat
if A[j] > value then
begin
    A[j + 1] := A[j];
    j := j - 1;
if j < 0 then
    done := true;
end
else
    done := true;
until done;
 A[j + 1] := value;
end;
end;



The same algorithm in Python :
def insertion_sort(array):
for i in xrange(1, len(array) - 1):
temp_value = array[i]
j = i - 1
while j > 0 and array[j] > temp_value:
array[j + 1] = array[j]
j -= 1
array[j + 1] = temp_value
return array


by C++ :

int * insertionsort(int *A; int length)
{
for (int i = 0; i <= length-2; i++)
{
int value = A[i];
int j = i - 1;
bool done = false;
do
if (A[j] > value)
{
A[j + 1] = A[j];
j -= 1;
if (j < 0)
done = true;
}else
done = true;
while !done;
A[j + 1] = value;
}
        return A;
}

Matrix multiplication

posted Apr 12, 2010, 5:06 PM by karam kassem   [ updated Apr 12, 2010, 5:55 PM ]

Ordinary matrix product

The ordinary matrix product is the most often used and the most important way to multiply matrices. It is defined between two matrices only if the width of the first matrix equals the height of the second matrix. Multiplying an m×n matrix with an n×p matrix results in an m×p matrix. If many matrices are multiplied together, and their dimensions are written in a list in order, e.g. m×n, n×p, p×q, q×r, the size of the result is given by the first and the last numbers (m×r), and the values surrounding each comma must match for the result to be defined. The ordinary matrix product is not commutative.


The element x3,4 of the above matrix product is computed as follows

The first coordinate in matrix notation denotes the row and the second the column; this order is used both in indexing and in giving the dimensions. The element x_{{\color{Blue}i}{\color{Red}j}} at the intersection of row i and column j of the product matrix is the dot product (or scalar product) of row i of the first matrix and column j of the second matrix. This explains why the width and the height of the matrices being multiplied must match: otherwise the dot product is not defined.


The figure to the right illustrates the product of two matrices A and B, showing how each intersection in the product matrix corresponds to a row of A and a column of B. The size of the output matrix is always the largest possible, i.e. for each row of A and for each column of B there are always corresponding intersections in the product matrix. The product matrix AB consists of all combinations of dot products of rows of A and columns of B.

The values at the intersections marked with circles are :

Formal definition

Formally, for

for some field F, then
where the elements of AB are given by

for each pair i and j with 1 ≤ im and 1 ≤ jp. The algebraic system of "matrix units" summarizes the abstract properties of this kind of multiplication.


Relationship with the inner product and the outer product

The Euclidean inner product and outer product are the simplest special cases of the ordinary matrix product. The inner product of two column vectors A and B is A\cdot B = A^TB, where T denotes the matrix transpose. More explicitly,



Matrix multiplication can be viewed in terms of these two operations by considering how the matrix product works on block matrices.

Decomposing A into row vectors and B into column vectors:



This is an outer product where the real product inside is replaced with the inner product. In general, block matrix multiplication works exactly like ordinary matrix multiplication, but the real product inside is replaced with the matrix product.

An alternative method results when the decomposition is done the other way around (A decomposed into column vectors and B into row vectors):



This method emphasizes the effect of individual column/row pairs on the result, which is a useful point of view with e.g. covariance matrices, where each such pair corresponds to the effect of a single sample point. An example for a small matrix:



One more useful decomposition results when B is decomposed into columns and A is left undecomposed. Then A is seen to act separately on each column of B, transforming them in parallel. Conversely, B acts separately on each row of A.

If x is a vector and A is decomposed into columns, then \mathbf{A}x = A_1x_1+A_2x_2+\cdots+A_nx_n. The column vectors of A give directions and units for coordinate axes and the elements of x are coordinates on the corresponding axes. \mathbf{A}x is then the vector which has those coordinates in the coordinate system given by the column vectors of A.


Algorithms for efficient matrix multiplication


The running time of square matrix multiplication, if carried out naively, is O(n3). The running time for multiplying rectangular matrices (one m×p-matrix with one p×n-matrix) is O(mnp). But more efficient algorithms do exist. Strassen's algorithm, devised by Volker Strassen in 1969 and often referred to as "fast matrix multiplication", is based on a clever way of multiplying two 2 × 2 matrices which requires only 7 multiplications (instead of the usual 8), at the expense of several additional addition and subtraction operations. Applying this trick recursively gives an algorithm with a multiplicative cost of O( n^{\log_{2}7}) \approx O(n^{2.807}). Strassen's algorithm is awkward to implement, compared to the naive algorithm, and it lacks numerical stability. Nevertheless, it is beginning to appear in libraries such as BLAS, where it is computationally interesting for matrices with dimensions n > 100, and is very useful for large matrices over exact domains such as finite fields, where numerical stability is not an issue.

The currently O(nk) algorithm with the lowest known exponent k is the Coppersmith–Winograd algorithm. It was presented by Don Coppersmith and Shmuel Winograd in 1990, has an asymptotic complexity of O(n2.376). It is similar to Strassen's algorithm: a clever way is devised for multiplying two k × k matrices with fewer than k3 multiplications, and this technique is applied recursively. It improves on the constant factor in Strassen's algorithm, reducing it to 4.537. However, the constant term hidden by the Big O Notation is so large that the Coppersmith–Winograd algorithm is only worthwhile for matrices that are too large to handle on present-day computers.

Since any algorithm for multiplying two n × n matrices has to process all 2 × n² entries, there is an asymptotic lower bound of ω(n2) operations. Raz (2002) proves a lower bound of Ω(m2logm) for bounded coefficient arithmetic circuits over the real or complex numbers.

Cohn et al. (2003, 2005) put methods, such as the Strassen and Coppersmith–Winograd algorithms, in an entirely different group-theoretic context. They show that if families of wreath products of Abelian with symmetric groups satisfying certain conditions exists, matrix multiplication algorithms with essential quadratic complexity exist. Most researchers believe that this is indeed the case - a lengthy attempt at proving this was undertaken by the late Jim Eve.

Because of the nature of matrix operations and the layout of matrices in memory, it is typically possible to gain substantial performance gains through use of parallelisation and vectorization. It should therefore be noted that some lower time-complexity algorithms on paper may have indirect time complexity costs on real machines.


Relationship to linear transformations


Matrices offer a concise way of representing linear transformations between vector spaces, and (ordinary) matrix multiplication corresponds to the composition of linear transformations. This will be illustrated here by means of an example using three vector spaces of specific dimensions, but the correspondence applies equally to any other choice of dimensions.

Let X, Y, and Z be three vector spaces, with dimensions 4, 2, and 3, respectively, all over the same field, for example the real numbers. The coordinates of a point in X will be denoted as xi, for i = 1 to 4, and analogously for the other two spaces.

Two linear transformations are given: one from Y to X, which can be expressed by the system of linear equations


\begin{align}   x_1 & = a_{1,1}y_1+a_{1,2}y_2 \\   x_2 & = a_{2,1}y_1+a_{2,2}y_2 \\   x_3 & = a_{3,1}y_1+a_{3,2}y_2 \\   x_4 & = a_{4,1}y_1+a_{4,2}y_2 \end{align}

and one from Z to Y, expressed by the system

\begin{align}   y_1 & = b_{1,1}z_1+b_{1,2}z_2+b_{1,3}z_3 \\   y_2 & = b_{2,1}z_1+b_{2,2}z_2+b_{2,3}z_3 \end{align}

These two transformations can be composed to obtain a transformation from Z to X. By substituting, in the first system, the right-hand sides of the equations of the second system for their corresponding left-hand sides, the xi can be expressed in terms of the zk:

\begin{align}   x_1 & = a_{1,1}(b_{1,1}z_1{+}b_{1,2}z_2{+}b_{1,3}z_3)+a_{1,2}(b_{2,1}z_1{+}b_{2,2}z_2{+}b_{2,3}z_3) \\       & = (a_{1,1} b_{1,1}{+}a_{1,2} b_{2,1})z_1+(a_{1,1} b_{1,2}{+}a_{1,2} b_{2,2})z_2+(a_{1,1} b_{1,3}{+}a_{1,2} b_{2,3})z_3 \\   x_2 & = a_{2,1}(b_{1,1}z_1{+}b_{1,2}z_2{+}b_{1,3}z_3)+a_{2,2}(b_{2,1}z_1{+}b_{2,2}z_2{+}b_{2,3}z_3) \\       & = (a_{2,1} b_{1,1}{+}a_{2,2} b_{2,1})z_1+(a_{2,1} b_{1,2}{+}a_{2,2} b_{2,2})z_2+(a_{2,1} b_{1,3}{+}a_{2,2} b_{2,3})z_3 \\   x_3 & = a_{3,1}(b_{1,1}z_1{+}b_{1,2}z_2{+}b_{1,3}z_3)+a_{3,2}(b_{2,1}z_1{+}b_{2,2}z_2{+}b_{2,3}z_3) \\       & = (a_{3,1} b_{1,1}{+}a_{3,2} b_{2,1})z_1+(a_{3,1} b_{1,2}{+}a_{3,2} b_{2,2})z_2+(a_{3,1} b_{1,3}{+}a_{3,2} b_{2,3})z_3 \\   x_4 & = a_{4,1}(b_{1,1}z_1{+}b_{1,2}z_2{+}b_{1,3}z_3)+a_{4,2}(b_{2,1}z_1{+}b_{2,2}z_2{+}b_{2,3}z_3) \\       & = (a_{4,1} b_{1,1}{+}a_{4,2} b_{2,1})z_1+(a_{4,1} b_{1,2}{+}a_{4,2} b_{2,2})z_2+(a_{4,1} b_{1,3}{+}a_{4,2} b_{2,3})z_3 \end{align}

These three systems can be written equivalently in matrix–vector notation – thereby reducing each system to a single equation – as follows:

  \begin{bmatrix}     x_1 \\     x_2 \\     x_3 \\     x_4   \end{bmatrix} =   \begin{bmatrix}     a_{1,1} & a_{1,2} \\     a_{2,1} & a_{2,2} \\     a_{3,1} & a_{3,2} \\     a_{4,1} & a_{4,2}   \end{bmatrix}   \begin{bmatrix}     y_1 \\     y_2   \end{bmatrix}
  \begin{bmatrix}     y_1 \\     y_2   \end{bmatrix} =   \begin{bmatrix}     b_{1,1} & b_{1,2} & b_{1,3} \\     b_{2,1} & b_{2,2} & b_{2,3}   \end{bmatrix}   \begin{bmatrix}     z_1 \\     z_2 \\     z_3   \end{bmatrix}
  \begin{bmatrix}     x_1 \\     x_2 \\     x_3 \\     x_4   \end{bmatrix} =   \begin{bmatrix}     a_{1,1} b_{1,1}{+}a_{1,2} b_{2,1} & a_{1,1} b_{1,2}{+}a_{1,2} b_{2,2} & a_{1,1} b_{1,3}{+}a_{1,2} b_{2,3} \\     a_{2,1} b_{1,1}{+}a_{2,2} b_{2,1} & a_{2,1} b_{1,2}{+}a_{2,2} b_{2,2} & a_{2,1} b_{1,3}{+}a_{2,2} b_{2,3} \\     a_{3,1} b_{1,1}{+}a_{3,2} b_{2,1} & a_{3,1} b_{1,2}{+}a_{3,2} b_{2,2} & a_{3,1} b_{1,3}{+}a_{3,2} b_{2,3} \\     a_{4,1} b_{1,1}{+}a_{4,2} b_{2,1} & a_{4,1} b_{1,2}{+}a_{4,2} b_{2,2} & a_{4,1} b_{1,3}{+}a_{4,2} b_{2,3}   \end{bmatrix}   \begin{bmatrix}     z_1 \\     z_2 \\     z_3   \end{bmatrix}

Representing these three equations symbolically and more concisely as

  \begin{align}     \mathbf{x} = \mathbf{Ay} \\     \mathbf{y} = \mathbf{Bz} \\     \mathbf{x} = \mathbf{Cz} \\   \end{align}

inspection of the entries of matrix C reveals that C = AB.

This can be used to formulate a more abstract definition of matrix multiplication, given the special case of matrix–vector multiplication: the product AB of matrices A and B is the matrix C such that for all vectors z of the appropriate shape Cz = A(Bz).



Scalar multiplication


The scalar multiplication of a matrix A = (aij) and a scalar r gives a product r A of the same size as A. The entries of r A are given by

 (r\mathbf{A})_{ij} = r \cdot a_{ij}. \,

For example, if

\mathbf{A}=\begin{bmatrix} a & b \\ c & d \end{bmatrix}

then

 r \cdot \mathbf{A}=\begin{bmatrix} r \cdot a & r \cdot b \\ r \cdot c & r \cdot d \end{bmatrix}

If we are concerned with matrices over a more general ring, then the above multiplication is the left multiplication of the matrix A with scalar p while the right multiplication is defined to be

 (\mathbf{A}r)_{ij} = a_{ij} \cdot r. \,

When the underlying ring is commutative, for example, the real or complex number field, the two multiplications are the same. However, if the ring is not commutative, such as the quaternions, they may be different. For example

  i\begin{bmatrix}      i & 0 \\      0 & j \\    \end{bmatrix} = \begin{bmatrix}     -1 & 0 \\      0 & k \\   \end{bmatrix} \ne \begin{bmatrix}     -1 & 0 \\     0 & -k \\   \end{bmatrix} = \begin{bmatrix}     i & 0 \\     0 & j \\   \end{bmatrix}i.



Powers of matrices


Square matrices can be multiplied by themselves repeatedly in the same way that ordinary numbers can. This repeated multiplication can be described as a power of the matrix. Using the ordinary notion of matrix multiplication, the following identities hold for an n-by-n matrix A, a positive integer k, and a scalar c:

\mathbf{A}^{0} = \mathbf{I}
\mathbf{A}^{k} = \prod_{i=1}^k \mathbf{A}
\ ( c\mathbf{A} )^k = c^k\mathbf{A}^k
\ \text{det} (A^k) = \text{det}(A)^k.

The naive computation of matrix powers is to multiply k times the matrix A to the result, starting with the identity matrix just like the scalar case. This can be improved using the binary representation of k, a method commonly used to scalars. An even better method is to use the eigenvalue decomposition of A.

Calculating high powers of matrices can be very time-consuming, but the complexity of the calculation can be dramatically decreased by using the Cayley-Hamilton theorem, which takes advantage of an identity found using the matrices' characteristic polynomial and gives a much more effective equation for Ak, which instead raises a scalar to the required power, rather than a matrix.

Powers of Diagonal Matrices

The power, k, of a diagonal matrix A, is the diagonal matrix whose diagonal entries are the k powers of the original matrix A.

  A^k = \begin{bmatrix}      a_{11} & 0 & 0 & 0 & \cdots \\      0 & a_{22} & 0 & 0 & \cdots \\      0 & 0 & a_{33} & 0 & \cdots \\      \vdots & \vdots & \vdots & \vdots & \vdots \\      0 & 0 & 0 & \cdots & a_{nn}   \end{bmatrix}^k = \begin{bmatrix}      a_{11}^k & 0 & 0 & 0 & \cdots \\      0 & a_{22}^k & 0 & 0 & \cdots \\      0 & 0 & a_{33}^k & 0 & \cdots \\      \vdots & \vdots & \vdots & \vdots & \vdots \\      0 & 0 & 0 & \cdots & a_{nn}^k   \end{bmatrix}

When raising an arbitrary matrix (not necessarily a diagonal matrix) to a power, it is often helpful to diagonalize the matrix first.



s

Linux Shells

posted Apr 6, 2010, 5:33 PM by karam kassem   [ updated Apr 6, 2010, 6:03 PM ]

Shell


‫كثيرا من المستخدمين لنظام لينوك ‪  Linux system‬لا يعرفوا مفهوم كلمة الصدفة ‪ shell‬ بالرغم أنهم ل يستطيعون التعامل مع لينوكس‬
‫بدون هذه الصدفة ‪.... shell‬وحتى تعرف أكثر عن هذه الصدفة ‪ shell‬ وما أهميتها ما عليك فقط إل أن..........تستمر في القراءة.

‫تعتبر الصدفة ‪  shell‬حلقة الوصل بين المستخدم وبين نواة نظام التشغيل لينوكس ‪. Linux kernel‬حيث أن أي أمر تكتبه في المحث ‫‪  prompt‬تقوم الصدفة ‪ shell‬ بأخذ الأمر ‪  command‬وتفسيره ثم يمرر النتيجة إلى قلب النظام التشغيل لينوكس Linux Kernel
‫‪.‬وكما قلت أن الصدفة ‪ shell‬عبارة عن مفسرة للوامر والصدفة ‪  shell‬تحتوي في الأساس على أوامر خاص بها، ويمكن للصدفة أن تستخدم جميع البرامج والدوات المتوفرة على النظام.‬

‫ولكي يكون الكلام أكثر دقة ، فالصدفة تستطيع أن تعتبرها ‪، macro processor‬بحيث أنك عندما تدخل لها سطر أمر فإنها تقوم بمعالجة هذا‬ ‫السطر بحيث أنها تقوم بتقسيم هذا السطر إلى عدة أجزاء وكل جزء من الجزاء يتم ترجمته إلى تعليمات يفهمها نظام التشغيل .‬

‫وقبل أن ندخل في التفاصيل يجب أن أنوه إلى شيء مهم وهو أنه بمجرد أن تضغط زر التشغيل الخاص بالحاسب فإن هذه العمليات تحدث بالترتيب لكي تتمكن من التعامل مع النظام أو (النواة) في حالتنا هذه، والعمليات بالترتيب هي كالتي:‬

  • يقوم ‪  BIOS‬بتحميل أول مقطع ‪  sector‬في القرص الصلب ، حيث أنه يوجد برنامج تحميل النواة ‪  LILO‬أو ‪ ، GRUB‬يتم تحميله‬ إلى الذاكرة الرئيسية ‪ RAM‬ ومن ثم يتم تنفيذ أي منهما ثم تظهر لك قائمة بها نظم التشغيل التي توجد بحاسبك ، طبعا في حالتنا هذه سوف نختار‬ نظام لينوكس (بغض النظر عن التوزيعة المستخدمة .‬ ‫ يتم تحميل النواة من القرص الصلب إلى الذاكرة ، وهو عبارة عن ملف مضغوط يدعى ‪. image‬‬
  • يتم فك ضغط هذا الملف ، ثم يتم تنفيذ الوامر الخاصة ببدء العمليات المكلفة بإدارة الجهاز.‬
  • تقوم النواة بعمل فحص للجهزة الموجودة وبدء تشغيلها .‬
  • تقوم النواة بتفعيل ‪ mount‬ نظام الملفات الجذرية ‪ ، root file system‬ولنقل مثل ‪/dev/hda‬‬
  • تقوم النواة بتنفيذ ‪ ،/ sbin/init‬حيث أن هذا البرنامج أول برنامج تنفذه النواة ، لذلك فإن ‪  PID‬الخاص به يساوي 1 .‬
  • تقوم ‪  init‬بتنفيذ كل الملفات النصية التنفيذية ‪ script‬ الخاصة بمستوى التشغيل ‪ ، run level 
  • تقوم ‪  init‬بإنتاج برامج ‪ getty‬ لكل طرفية ‪. terminal‬‬
  • getty‬ هو المحث الذي يظهر لك، ويطلب منك أن تدخل اسم المستخدم و كلمة المرور ، ومن ثم ينفذ المر ‪  /bin/login‬للتأكد من صحة‬ ‫المدخلت.‬
    ‫وفي النهاية يقوم المر ‪  login‬ببدء عمل الصدفة ‪. shell‬‬





الشكل التالي يوضح آلية عمل الصدفة Shell  .. آلية تفسير الأمر




‫هذا الشكل يوضح الخطوات التي تتخذها الصدفة ‪  shell‬لتقرر ما الذي ستفعله مع الأوامر التي يكتبها المستخدم،وأول خطوة تقوم بها الصدفة shell‬ أنه تحدد ما إذا كان الأمر الذي كتبه المستخدم من الوامر الأساسية للصدفة أم لا، فإذا لم تكن من الوامر الأساسية فإنها ترى ما إذا‬ ‫كانت من البرامج التطبيقية،والبرامج التطبيقية تنقسم إلى قسمين هما:‬

  • ‫برامج خدمية خاصة بالنظام مثل ‪  ls , rm‬أو برامج تطبيقية للمستخدمين سواء كانت هذه البرامج تجارية أو عامة.‬
  • ‫والصدفة ‪  shell‬تحاول في أن تجد هذه البرامج التطبيقية وذلك بالنظر في جميع الفهارس والتي توجد في مسار بحثك، وهذا المسار عبارة عن قائمة‬ ‫من الفهارس حيث توجد فيها البرامج القابلة للتنفيذ،وإذا لم يكن الأمر المدخل من أوامر الصدفة ‪  shell‬الداخلية أو ملفا قابل للتنفيذ في المسار‬الذي توجد عليه فإنه سوف يظهر لك رسالة خطأ.أما إذا كان أمرا من أوامر الصدفة ‪  shell‬الأساسية أو ملفا قابل للتنفيذ فإنهما سوف يذهبان‬ ‫إلى ‪ system calls‬ ثم يتم تمريرهما إلى قلب النظام ‪. system kernel‬‬


‫وتتميز الصدفة بمفسر للغة البرمجة ‪  interpretive programming language‬قوي،ولغة برمجة الصدفة‬ shell programming language
‫تحتوي على معظم أدوات لغات البرمجة عالية المستوى مثل لجمل التكرارية والدوال والمتغيرات‬ والمصفوفات .

‫يمكن أن تكتب أوامر وتستخدم معها الأدوات البرمجية الخاصة بالصدفة في ملف نصي عادي ، وهذه الوامر تقوم مثل بأحد المهام الحيوية بالنسبة لك‬ ‫أو لبرامجك ، ثم تقوم بحفظ هذا الملف الذي كتبت فيه هذه الوامر بامتداد ‪ ، sh‬وبالتالي يسمى هذا الملف بملف نصي تنفيذي ‪ . script‬وفي كل‬
‫مرة تنفذ هذا الملف يقوم بتنفيذ كل الوامر التي كتبتها فيه بدون أن تكتبها أنت بنفسك مرة أخرى ، بمعنى أنه وفر عليك عناء كتابة عدة سطور قد تصل‬
‫إلى اللف في كل مرة تريد تنفيذ فيها هذه المهمة .‬

‫قبل أن أكمل أحب التنويه على شيء مهم قد يكون غائبا أو غامضا للكثيرين منا ، وهو عبارة عن سؤال ، ما هو الفرق بين سطر الوامر الذي اكتبه أنا‬
‫وبين الملف النصي التنفيذي؟‬
‫والاجابة هي أن سطر الوامر ل تستطيع أن تقوم بالعمليات البرمجية ذات المستوى العالي ، مثل الجمل التكرارية ، لذلك فإننا نلجأ لحل مثالي وهو الملف‬ ‫النصي التنفيذي ‪. script‬‬




الصدفات الأكثر شيوعاً :

  • ‫الصدفة ‪Bourne shell‬
  • ‫الصدفة ‪C shell‬‬
  • ‫الصدفة ‪Korn shell
  • ‫الصدفة ‪BASH shell‬‬
  • ويوجد صدفات أخرى ...

يمكن لنظتم التشغيل أن يحتوي أكثر من صدفة في الوقت ذاته . . . ولمعرفة الصدفات shell الموجودة نقوم بكتابة الأمر التالي :

echo $SHELL

Python Script Language

posted Apr 6, 2010, 5:24 PM by karam kassem


The Python programming language

The programming language you will be learning is Python. Python is an exam-ple of a high-level language; other high-level languages you might have heard of are C, C++, Perl, and Java.

As you might infer from the name “high-level language,” there are also low-level languages, sometimes referred to as “machine languages” or “assembly anguages.” Loosely speaking, computers can only execute programs written in low-level languages. Thus, programs written in a high-level language have to be processed before they can run. This extra processing takes some time, which is a small disadvantage of high-level languages.

But the advantages are enormous. First, it is much easier to program in a high-level language. Programs written in a high-level language take less time to write, they are shorter and easier to read, and they are more likely to be correct. Second, high-level languages are portable, meaning that they can run on different kinds of computers with few or no modifications. Low-level programs can run on only one kind of computer and have to be rewritten to run on another.

Due to these advantages, almost all programs are written in high-level languages. Low-level languages are used only for a few specialized applications.

Two kinds of programs process high-level languages into low-level languages: interpreters and compilers. An interpreter reads a high-level program and executes it, meaning that it does what the program says. It processes the pro- gram a little at a time, alternately reading lines and performing computations.








A compiler reads the program and translates it completely before the program starts running. In this case, the high-level program is called the source code, and the translated program is called the object code or the executable. Once a program is compiled, you can execute it repeatedly without further translation




Stack

posted Apr 5, 2010, 10:47 AM by karam kassem   [ updated Apr 10, 2010, 6:35 AM ]

The restrictions on a stack imply that if the elements A,B,C,D,E are added to the stack, n that order, then th efirst element to be removed/deleted must be E. Equivalently we say that the last element to be inserted into the stack will be the first to be removed. For this reason stacks are sometimes referred to as Last In First Out (LIFO) lists. The restrictions on queue imply that the first element which is inserted into the queue will be the first one to be removed. Thus A is the first letter to be removed, and queues are known as First In First Out (FIFO) lists. Note that the data object queue as defined here need not necessarily correspond to the mathemathical concept of queue in which the insert/delete rules may be different.



  • Construction a stack :
        Stack's element have to be record of tow elements
        first element is the key
        second element is the pointer

type

    stack = ^pstack;

    pstack = record

        key     : char;

        next    : stack;

        end;



  • Push procedure :
        to insert new element to the stack
        and it has tow parameters
        firs parameter is the element
        second parameter is the stack

procedure push(ch : char; var x : stack);
var    temp : stack;
begin
    new(temp);
    temp^.key := ch;
    temp^.next := x;
    x := temp;

end;



  • Pop procedure :
        to insert last element in the stack to the second parameter , then remove this element from the stack
        and parameter like first one

procedure pop(var x : stack; var ch : char);
var

    temp : stack;

begin

    temp := x;

    x := x^.next;

    ch := temp^.key;

    dispose(temp);
end;




bubble sort

posted Apr 5, 2010, 10:33 AM by karam kassem   [ updated Apr 14, 2010, 12:54 PM ]

Bubble Sort Algorithm
The philosophy of Bubble Sort is to look at adjacent elements in the array and put them in order. We will look at the first two elements, swap them if necessary; then look at the second and third elements, swapping if necessary; then look at the third and the fourth and so on. After one pass through the array, the largest item will be at the end of the array (prove this to yourself). Similarly, if we make another complete pass through the array, the second largest item will be in position. If we make n such passes, all of the array will be sorted.

As with many of our algorithms, Bubble Sort creates a sorted portion of the array (at the end) and an unsorted portion. We can improve its run-time slightly (not asymptotically), by making each pass only go through the unsorted portion of the array.

Step-by-step example




Let us take the array of numbers "5 1 4 2 8", and sort the array from lowest number to greatest number using bubble sort algorithm. In each step, elements written in bold are being compared.

First Pass:
( 5 1 4 2 8 ) \to ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps them.
( 1 5 4 2 8 ) \to ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 ) \to ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 ) \to ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.
Second Pass:
( 1 4 2 5 8 ) \to ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \to ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.
Third Pass:
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \to ( 1 2 4 5 8 )
Finally, the array is sorted, and the algorithm can terminate.

by C++ :

int* bubblesort(int *A; int length)
{
    int temp;
    for (int i = 0; i <= length-1; i++)
        for (int j = i; j <= length)
            if (A[i] > A[j])
            {
                temp = A[i];
                A[i] = A[j];
                A[j] = temp;
            }
    return A;
}


by Python :

def bubble( array ) :
    for i in range(0, len(array)-1) :
        for j in range(i, len(array)) :
            if array[i] > array[j] :
                temp = array[i]
                array[i] = array[j]
                array[j] = temp

by Pascal :

type
    vector = array [1..10] of integer ;
procedure bubble( var vec : vector );
var
    i, j : integer;
    temp : integer;
begin
    for i := 1 to 10-1 do
        for j := i to 10 do
            if vec[i] > vec[j] then
            begin
                temp := vec[i];
                vec[i] := vec[j];
                vec[j] := temp;
            end;
end;

1-9 of 9