UNITY (programming language)
યુનિટી એ કે. મણિ ચાંડી અને જયદેવ મિશ્રા દ્વારા તેમના પુસ્તક પેરેલલ પ્રોગ્રામ ડિઝાઇનઃ એ ફાઉન્ડેશન માટે બનાવવામાં આવેલી પ્રોગ્રામિંગ ભાષા છે. તે એક સૈદ્ધાંતિક ભાષા છે જે ક્યાં, ક્યારે અથવા કેવી રીતે તેના બદલે શું તેના પર ધ્યાન કેન્દ્રિત કરે છે. ભાષામાં પ્રવાહ નિયંત્રણની કોઈ પદ્ધતિ નથી, અને જ્યાં સુધી નિવેદનો અમલ દરમિયાન ફેરફારો કરવાનું બંધ ન કરે ત્યાં સુધી પ્રોગ્રામ સ્ટેટમેન્ટ બિનનિર્ધારિત રીતે ચાલે છે. આ કાર્યક્રમોને અનિશ્ચિત સમય સુધી ચલાવવાની મંજૂરી આપે છે, જેમ કે ઓટો-પાયલોટ અથવા પાવર પ્લાન્ટ સલામતી પ્રણાલીઓ, તેમજ કાર્યક્રમો કે જે સામાન્ય રીતે સમાપ્ત થાય છે (જે અહીં એક નિશ્ચિત બિંદુ પર ભેગા થાય છે). વર્ણન તમામ નિવેદનો સોંપણીઓ છે, અને #દ્વારા અલગ કરવામાં આવે છે. એક નિવેદનમાં a, b, c: = x, y, z, અથવા a: = x | | b: = y | c: = z સ્વરૂપની બહુવિધ સોંપણીઓ હોઈ શકે છે. તમારી પાસે ક્વોન્ટિફાઇડ સ્ટેટમેન્ટ લિસ્ટ પણ હોઈ શકે છે, <#x, y: અભિવ્યક્તિઃ: નિવેદન>, જ્યાં અભિવ્યક્તિને સંતોષતા મૂલ્યોમાં x અને y ને અવ્યવસ્થિત રીતે પસંદ કરવામાં આવે છે. એક પરિમાણિત સોંપણી સમાન છે. <| x, y: અભિવ્યક્તિઃઃ નિવેદન> માં, અભિવ્યક્તિને સંતોષતા x અને y ની તમામ જોડીઓ માટે નિવેદન એક સાથે ચલાવવામાં આવે છે. ઉદાહરણો બબલ સૉર્ટ બબલ અડીને આવેલી સંખ્યાઓની સરખામણી કરીને એરેને સૉર્ટ કરે છે, અને જો તે ખોટા ક્રમમાં હોય તો તેને અદલાબદલી કરે છે. અપેક્ષિત સમય, પ્રોસેસર્સ અને અપેક્ષિત કાર્યનો ઉપયોગ કરવો. તમારી પાસે માત્ર સમયની અપેક્ષા રાખવાનું કારણ એ છે કે k હંમેશા અવ્યવસ્થિત રીતે પસંદ કરવામાં આવે છે. આને k ને જાતે ફેરવીને સુધારી શકાય છે. પ્રોગ્રામ પરપોટાઓ n: પૂર્ણાંક, A: એરે [0.n-1] પૂર્ણાંકની શરૂઆતમાં n = 20 #<| | i: 0 <= i અને i <n::: A [i] = રેન્ડ ()% 100> સોંપો <#k: 0 <= k <2:: <| i: i% 2 = k અને 0 <= i <n-1:: A [i], A [i + 1]: = A [i + 1], A [i] જો A [i]> A [i + 1]> અંતિમ ક્રમ-ક્રમ તમે ક્રમ-ક્રમ સાથે સમયને ક્રમબદ્ધ કરી શકો છો. તમારે પ્રોસેસરોની જરૂર છે, અને કામ કરો. પ્રોગ્રામ રેન્કસોર્ટ n: પૂર્ણાંક, A, R: એરે [0.n-1] પૂર્ણાંકની શરૂઆતમાં n = 15 #<| | i: 0 <= i <n:: A [i], R [i] = રેન્ડ ()% 100, i> સોંપો <| i: 0 <= i <n:: R [i]: = <+ j: 0 <= j <n અને (A [j] <A [i] અથવા (A [j] = A [i] અને (j <i))::: 1> #<| i: 0 <= i <n:: A [R [i]: = A [i]> અંત ફ્લોયડ-વાર્શ પ્રોગ્રામ ટૂંકો પાથ n, k: પૂર્ણાંક, D: એરે [0.n-1,0.n-1] પૂર્ણાંકની શરૂઆતમાં n = 10 #k = 0 #<| i, j: 0 <= i <n અને 0 <= j <n:: D [i, j] = રેન્ડ ()% 100> અસાઇન કરો <| i, j: 0 <= i <n અને 0 <= j <n:: D [i, j]: = મિનિટ (D [i, j], D [i, k] + D [k, j])> | k: = k + 1 જો k <n-1 અંત હોય તો આપણે આ વધુ ઝડપથી કરી શકીએ છીએ. નીચેના પ્રોગ્રામ્સ પ્રોસેસર્સ અને વર્કનો ઉપયોગ કરીને સમયના તમામ જોડીઓના સૌથી ટૂંકા માર્ગની ગણતરી કરે છે. પ્રોગ્રામ ટૂંકો પાથ 2 જાહેર કરે છે n: પૂર્ણાંક, D: એરે [0.n-1,0.n-1] પૂર્ણાંકની શરૂઆતમાં n = 10 #<| i, j: 0 <= i <n અને 0 <= j <n:: D [i, j] = rand ()% 10> સોંપો <| i, j: 0 <= i <n અને 0 <= j <n:: D [i, j]: = min (D [i, j], <min k: 0 <= k <n::: D [i, k] + D [k, j]> અંત પછી રાઉન્ડ, D [i, j] માં સૌથી ટૂંકા પાથની લંબાઈ શામેલ છે. આગામી રાઉન્ડમાં, લંબાઈ, અને તેથી વધુ. સંદર્ભો કે. મણિ ચાંડી અને જયદેવ મિશ્રા (1988) પેરેલલ પ્રોગ્રામ ડિઝાઇનઃ એ ફાઉન્ડેશન. પ્રાયોગિક પ્રોગ્રામિંગ ભાષાઓ