r.mapcalcgrass - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

r.mapcalc - रेखापुंज मानचित्र कैलकुलेटर।

कीवर्ड

रेखापुंज, बीजगणित

SYNOPSIS

r.mapcalc
r.mapcalc --मदद
r.mapcalc [-s] [अभिव्यक्ति=स्ट्रिंग] [पट्टिका=नाम] [बीज=पूर्णांक] [--अधिलेखित]
[--मदद] [--वाचाल] [--शांत] [--ui]

झंडे:
-s
यादृच्छिक बीज उत्पन्न करें (परिणाम गैर-नियतात्मक है)

--ओवरराइट
आउटपुट फ़ाइलों को मौजूदा फ़ाइलों को अधिलेखित करने की अनुमति दें

--मदद
प्रिंट उपयोग सारांश

--शब्दशः
वर्बोज़ मॉड्यूल आउटपुट

--शांत
शांत मॉड्यूल आउटपुट

--यूआई
बलपूर्वक GUI संवाद लॉन्च करना

पैरामीटर:
अभिव्यक्ति=स्ट्रिंग
मूल्यांकन हेतु अभिव्यक्ति

पट्टिका=नाम
मूल्यांकन करने के लिए अभिव्यक्ति युक्त फ़ाइल

बीज=पूर्णांक
रैंड() फ़ंक्शन के लिए बीज

वर्णन

r.mapcalc रेखापुंज मानचित्र परतों पर अंकगणित करता है। नई रेखापुंज मानचित्र परतें बनाई जा सकती हैं
जो अंकगणितीय अभिव्यक्तियाँ हैं जिनमें मौजूदा रेखापुंज मानचित्र परतें, पूर्णांक या फ़्लोटिंग शामिल हैं
बिंदु स्थिरांक, और कार्य।

कार्यक्रम उपयोग
r.mapcalc अभिव्यक्ति का रूप है:

परिणाम = अभिव्यक्ति

जहां परिणाम गणना के परिणाम को समाहित करने के लिए रेखापुंज मानचित्र परत का नाम है
और अभिव्यक्ति मौजूदा रेखापुंज मानचित्र परतों को शामिल करने वाली कोई कानूनी अंकगणितीय अभिव्यक्ति है
(के सिवाय परिणाम स्वयं), पूर्णांक या फ़्लोटिंग पॉइंट स्थिरांक, और ज्ञात फ़ंक्शन
कैलकुलेटर। अभिव्यक्ति में कोष्ठक की अनुमति है और इसे किसी भी गहराई तक नेस्ट किया जा सकता है।
परिणाम उपयोगकर्ता के वर्तमान मैपसेट में बनाया जाएगा।

As अभिव्यक्ति= यह पहला विकल्प है, यह डिफ़ॉल्ट है. इसका मतलब है कि एक गुजर रहा है
कमांड लाइन पर अभिव्यक्ति तब तक संभव है जब तक अभिव्यक्ति उद्धृत और एक स्थान है
पहले से पहले शामिल किया गया है = संकेत। उदाहरण ('foo' परिणामी मानचित्र है):
r.mapcalc "फू = 1"
या:
r.mapcalc 'फू = 1'
एक गैर-उद्धृत अभिव्यक्ति (अर्थात कई तर्कों में विभाजित) काम नहीं करेगी, न ही उसे छोड़ना
= चिह्न से पहले का स्थान:
r.mapcalc 'foo=1'
क्षमा मांगना, मान्य पैरामीटर नहीं है
फ़ाइल से कमांड पढ़ने के लिए, फ़ाइल = का स्पष्ट रूप से उपयोग करें, उदाहरण के लिए:
r.mapcalc फ़ाइल=फ़ाइल
या:
r.mapcalc फ़ाइल=- <फ़ाइल
या:
r.mapcalc फ़ाइल=- <
फू = 1
EOF

सूत्र में प्रवेश किया r.mapcalc उपयोगकर्ता द्वारा दोनों में दर्ज किया गया है परिणाम मानचित्र शीर्षक
(जो कि श्रेणी फ़ाइल में दिखाई देता है परिणाम) और इतिहास फ़ाइल में परिणाम.

कुछ वर्णों का कमांड शेल के लिए विशेष अर्थ होता है। यदि उपयोगकर्ता इनपुट दर्ज कर रहा है
सेवा मेरे r.mapcalc कमांड लाइन पर, अभिव्यक्तियों को एकल उद्धरण चिह्नों के भीतर संलग्न किया जाना चाहिए।
नीचे नोट्स देखें।

ऑपरेटरों और आदेश of प्रधानता
निम्नलिखित ऑपरेटर समर्थित हैं:
ऑपरेटर अर्थ प्रकार प्राथमिकता
-------------------------------------------------- ------------
- निषेध अंकगणित 12
~ बिटवाइज़ 12 का पूरक
! तार्किक नहीं 12
^ घातांक अंकगणित 11
% मापांक अंकगणित 10
/ विभाजन अंकगणित 10
* गुणन अंकगणित 10
+ जोड़ अंकगणित 9
- घटाव अंकगणित 9
<< लेफ्ट शिफ्ट बिटवाइज़ 8
>> राइट शिफ्ट बिटवाइज़ 8
>>> दायां शिफ्ट (अहस्ताक्षरित) बिटवाइज़ 8
> तार्किक 7 से अधिक
>= तार्किक 7 से बड़ा या बराबर
<तार्किक से कम 7
<= तार्किक 7 से कम या बराबर
==बराबर तार्किक 6
!=बराबर नहीं तार्किक 6
और बिटवाइज़ और बिटवाइज़ 5
| बिटवाइज़ या बिटवाइज़ 4
&& तार्किक और तर्कसंगत 3
&&& तार्किक और[1] तार्किक 3
|| तर्कसंगत या तर्कसंगत 2
||| तार्किक या[1] तार्किक 2
?: सशर्त तार्किक 1
(मापांक विभाजन पर शेषफल है)

[1] &&& और ||| ऑपरेटर अन्य ऑपरेटरों की तुलना में शून्य मानों को अलग ढंग से संभालते हैं। देखें
अनुभाग हकदार नल समर्थन अधिक विवरण के लिए नीचे।

ऑपरेटरों को बाएं से दाएं लागू किया जाता है, उच्च प्राथमिकता वाले ऑपरेटरों को लागू किया जाता है
कम प्राथमिकता वाले लोगों से पहले। 0 से विभाजन और 0 से मापांक स्वीकार्य हैं और
शून्य परिणाम दें. यदि तुलना सत्य है तो तार्किक संचालक 1 परिणाम देते हैं, 0
अन्यथा।

रास्टर नक्शा परत नामों
अभिव्यक्ति में कुछ भी जो संख्या, ऑपरेटर या फ़ंक्शन नाम नहीं है, उसे लिया जाता है
एक रेखापुंज मानचित्र परत नाम बनें। उदाहरण:

ऊंचाई
x3
3डी.उसका

अधिकांश GRASS रेखापुंज मानचित्र परतें इस नामकरण परंपरा को पूरा करती हैं। हालाँकि, यदि एक रेखापुंज मानचित्र परत
यदि कोई ऐसा नाम है जो उपरोक्त नियम के विपरीत है तो उसे उद्धृत किया जाना चाहिए। उदाहरण के लिए,
अभिव्यक्ति

एक्स = एबी

इसकी व्याख्या इस प्रकार की जाएगी: x एक ऋण b के बराबर है, जबकि

एक्स = "अब"

इसकी व्याख्या इस प्रकार की जाएगी: x नामित रेखापुंज मानचित्र परत के बराबर है अब

भी

एक्स = 3107

पैदा करेगा x जबकि संख्या 3107 से भरा हुआ है

एक्स = "3107"

रैस्टर मैप परत की प्रतिलिपि बनायेगा 3107 रेखापुंज मानचित्र परत पर x.

उद्धरण की आवश्यकता नहीं है जब तक कि रेखापुंज मानचित्र परत के नाम संख्याओं की तरह न दिखें या उनमें शामिल न हों
ऑपरेटर्स, या जब तक प्रोग्राम गैर-इंटरैक्टिव रूप से नहीं चलाया जाता है। यहां दिए गए उदाहरण मानते हैं
कार्यक्रम अंतःक्रियात्मक रूप से चलाया जाता है। नीचे नोट्स देखें।

r.mapcalc उपयोगकर्ता के वर्तमान मैपसेट के अनुसार रेखापुंज मानचित्र परतों की तलाश करेगा
खोज पथ. खोज पथ को ओवरराइड करना और मैपसेट को निर्दिष्ट करना संभव है
रेखापुंज मानचित्र परत का चयन करने के लिए। यह रैस्टर मैप परत नाम निर्दिष्ट करके किया जाता है
फार्म:

नाम@मैपसेट

उदाहरण के लिए, निम्नलिखित एक कानूनी अभिव्यक्ति है:

परिणाम = x@स्थायी / y@मिट्टी

निर्दिष्ट मैपसेट का मैपसेट खोज पथ में होना आवश्यक नहीं है। (यह विधि
मैपसेट खोज पथ को ओवरराइड करना न केवल सभी GRASS कमांड के लिए सामान्य है r.mapcalc.)

RSI पड़ोस आपरिवर्तक
मानचित्र और छवियाँ डेटा बेस फ़ाइलें हैं जो रैस्टर प्रारूप में संग्रहीत होती हैं, अर्थात, द्वि-आयामी
पूर्णांक मानों के आव्यूह. में r.mapcalc, मानचित्रों का अनुसरण a द्वारा किया जा सकता है पड़ोस आपरिवर्तक
जो मूल्यांकन की जा रही वर्तमान सेल से एक सापेक्ष ऑफसेट निर्दिष्ट करता है। प्रारूप है
मानचित्र[आर,सी], जहां r पंक्ति ऑफसेट है और c कॉलम ऑफ़सेट है. उदाहरण के लिए, मानचित्र[1,2]
नीचे दी गई सेल की एक पंक्ति और वर्तमान सेल के दाईं ओर दो कॉलम को संदर्भित करता है,
मानचित्र[-2,-1] सेल को दो पंक्तियों के ऊपर और एक कॉलम को करंट के बाईं ओर संदर्भित करता है
सेल, और मानचित्र[0,1] वर्तमान सेल के दाईं ओर एक कॉलम सेल को संदर्भित करता है। यह
सिंटैक्स एक ही मानचित्र के भीतर या उसके पार पड़ोस-प्रकार के फिल्टर के विकास की अनुमति देता है
एकाधिक मानचित्र.

रास्टर नक्शा परत मानों से la वर्ग पट्टिका
कभी-कभी किसी श्रेणी से जुड़े मान का उपयोग करना वांछनीय होता है लेबल के स्थान पर
श्रेणी मान स्वयं। यदि रैस्टर मैप परत नाम के पहले है @ ऑपरेटर, फिर
रेखापुंज मानचित्र परत के लिए श्रेणी फ़ाइल में लेबल के बजाय अभिव्यक्ति में उपयोग किया जाता है
श्रेणी मान.

उदाहरण के लिए, मान लीजिए कि रेखापुंज मानचित्र परत मिट्टी.पी.एच (मिट्टी पीएच मान का प्रतिनिधित्व) में एक है
निम्नानुसार लेबल के साथ श्रेणी फ़ाइल:

बिल्ली लेबल
------------------
0 कोई डेटा नहीं
1 1.4
2 2.4
3 3.5
4 5.8
5 7.2
6 8.8
7 9.4

फिर अभिव्यक्ति:

परिणाम = @soils.ph

श्रेणी मान 0, 1.4, 2.4, 3.5, 5.8, 7.2, 8.8 और 9.4 के साथ परिणाम देगा।

ध्यान दें कि यह ऑपरेटर केवल रैस्टर मैप परतों पर ही लागू किया जा सकता है और एक फ़्लोटिंग उत्पन्न करता है
अभिव्यक्ति में बिंदु मान. इसलिए, श्रेणी लेबल को वैध से शुरू होना चाहिए
संख्या। यदि श्रेणी लेबल पूर्णांक है, तो इसे फ़्लोटिंग पॉइंट द्वारा दर्शाया जाएगा
संख्या। यदि श्रेणी लेबल किसी संख्या से शुरू नहीं होता है या गायब है, तो यह होगा
परिणामी रेखापुंज मानचित्र में NULL (कोई डेटा नहीं) द्वारा दर्शाया गया है।

ग्रे स्केल समकक्ष और रंग अलग
मानचित्र श्रेणियों को निर्दिष्ट रंगों में हेरफेर करना अक्सर सहायक होता है। यह है
विशेष रूप से तब उपयोगी होता है जब कोशिकाओं के वर्णक्रमीय गुणों का कोई अर्थ होता है (जैसा कि इमेजरी के साथ होता है)।
डेटा), या जब मानचित्र श्रेणी मान वास्तविक मात्राओं का प्रतिनिधित्व करते हैं (जैसे कि जब श्रेणी मान
वास्तविक उन्नयन मूल्यों को प्रतिबिंबित करें)। मानचित्र रंग हेरफेर भी दृश्य पहचान में सहायता कर सकता है,
और मानचित्र मुद्रण।

# ऑपरेटर का उपयोग मानचित्र श्रेणी मानों को उनके ग्रे स्केल में परिवर्तित करने के लिए किया जा सकता है
समतुल्य या रेखापुंज मानचित्र परत के लाल, हरे, या नीले घटकों को निकालने के लिए
अलग रेखापुंज मानचित्र परतें।

परिणाम = #मानचित्र

प्रत्येक श्रेणी मान को इसमें परिवर्तित करता है नक्शा 0-255 की सीमा में एक मान जो दर्शाता है
श्रेणी के लिए रंग द्वारा निहित ग्रे स्केल स्तर। यदि मानचित्र में ग्रे स्केल रंग है
तालिका, तो ग्रे स्तर वह है जिसका #map मूल्यांकन करता है। अन्यथा, इसकी गणना इस प्रकार की जाती है:

0.10 * लाल + 0.81 * हरा + 0.01 * नीला

वैकल्पिक रूप से, आप इसका उपयोग कर सकते हैं:

परिणाम = y#मानचित्र

एनटीएससी वेटिंग का उपयोग करने के लिए:

0.30 * लाल + 0.59 * हरा + 0.11 * नीला

या, आप इसका उपयोग कर सकते हैं:

परिणाम = i#map

समान भार का उपयोग करने के लिए:

0.33 * लाल + 0.33 * हरा + 0.33 * नीला

# ऑपरेटर के तीन अन्य रूप हैं: r#map, g#map, b#map। ये लाल, हरा,
या नामित रेखापुंज मानचित्र में क्रमशः नीले घटक। GRASS शैल स्क्रिप्ट आर.मिश्रण
इनमें से प्रत्येक घटक को दो रेखापुंज मानचित्र परतों से निकालता है, और उन्हें एक द्वारा जोड़ता है
उपयोगकर्ता-निर्दिष्ट प्रतिशत. ये रूप रंगों को अलग करने की अनुमति देते हैं। उदाहरण के लिए, को
से लाल घटक निकालें नक्शा और इसे नई 0-255 मानचित्र परत में संग्रहीत करें लाल, उपभोक्ता
टाइप कर सकते हैं:

लाल = r#मानचित्र

इस मानचित्र को ग्रे रंग निर्दिष्ट करने के लिए टाइप करें:

r.रंग मानचित्र=लाल रंग=नियम
काली
सफेद

इस मानचित्र को लाल रंग निर्दिष्ट करने के लिए टाइप करें:

r.रंग मानचित्र=लाल रंग=नियम
काली
लाल

कार्य
वर्तमान में समर्थित फ़ंक्शन नीचे तालिका में सूचीबद्ध हैं। परिणाम का प्रकार
अंतिम कॉलम में दर्शाया गया है। F इसका मतलब है कि फ़ंक्शंस का परिणाम हमेशा फ़्लोटिंग होता है
बिंदु मान, I इसका मतलब है कि फ़ंक्शन एक पूर्णांक परिणाम देता है, और * इंगित करता है कि
यदि फ़ंक्शन का कोई भी तर्क फ़्लोटिंग पॉइंट मान है तो परिणाम फ़्लोट होता है
पूर्णांक यदि सभी तर्क पूर्णांक हैं।

फ़ंक्शन विवरण प्रकार
-------------------------------------------------- -------------------------
abs(x) x का निरपेक्ष मान लौटाता है *
acos(x) x का व्युत्क्रम कोज्या (परिणाम डिग्री में है) F
asin(x) x की व्युत्क्रम ज्या (परिणाम डिग्री में है) F
atan(x) x की व्युत्क्रम स्पर्श रेखा (परिणाम डिग्री में है) F
atan(x,y) y/x का व्युत्क्रम स्पर्शरेखा (परिणाम डिग्री में है) F
x की cos(x) कोज्या (x डिग्री में है) F
डबल(x) x को डबल-प्रिसिजन फ्लोटिंग पॉइंट F में बदलें
eval([x,y,...,]z) सूचीबद्ध expr के मानों का मूल्यांकन करें, परिणाम z को पास करें
exp(x) x F का घातीय फलन
exp(x,y) x से घात y F
फ़्लोट(x) x को एकल-सटीक फ़्लोटिंग पॉइंट F में परिवर्तित करें
ग्राफ(x,x1,y1[x2,y2..]) ग्राफ F में बिंदुओं के आधार पर x को ay में बदलें
graph2(x,x1[,x2,..],y1[,y2..])
ग्राफ़ का वैकल्पिक रूप() एफ
यदि निर्णय विकल्प: *
यदि(x) 1 यदि x शून्य नहीं है, अन्यथा 0
यदि(x,a) a यदि x शून्य नहीं है, अन्यथा 0
यदि(x,a,b) a यदि x शून्य नहीं है, तो b अन्यथा
यदि(x,a,b,c) a यदि x > 0, b यदि x शून्य है, c यदि x < 0
int(x) x को पूर्णांक में बदलें [ ट्रंकेट्स ] I
isnull(x) जांचें कि क्या x = NULL है
लॉग(x) x F का प्राकृतिक लॉग
लॉग(x,b) x बेस b F का लॉग
max(x,y[,z...]) सूचीबद्ध लोगों का सबसे बड़ा मूल्य *
माध्यिका(x,y[,z...]) सूचीबद्ध लोगों का माध्य मान *
min(x,y[,z...]) सूचीबद्ध लोगों का सबसे छोटा मान *
सूचीबद्ध लोगों का mode(x,y[,z...]) मोड मान *
nmax(x,y[,z...]) NULLs को छोड़कर, सूचीबद्ध लोगों का सबसे बड़ा मूल्य *
nmedian(x,y[,z...]) NULLs को छोड़कर, सूचीबद्ध लोगों का औसत मूल्य *
nmin(x,y[,z...]) NULLs को छोड़कर, सूचीबद्ध लोगों का सबसे छोटा मान *
nmode(x,y[,z...]) सूचीबद्ध लोगों का मोड मान, NULLs को छोड़कर *
not(x) 1 यदि x शून्य है, अन्यथा 0
pow(x,y) x से घात y *
रैंड(ए,बी) यादृच्छिक मान x : a <= x < b *
राउंड(x) राउंड x से निकटतम पूर्णांक I तक
राउंड(x,y) राउंड x को y के निकटतम गुणज तक
कुछ पूर्णांक i के लिए राउंड(x,y,z) राउंड x से निकटतम y*i+z तक
x की ज्या (x डिग्री में है) F
sqrt(x) x F का वर्गमूल
tan(x) x की स्पर्श रेखा (x डिग्री में है) F
xor(x,y) एक्सक्लूसिव-या (XOR) x और y I का
आंतरिक चर:
row() चलती हुई विंडो की वर्तमान पंक्ति
col() चलती विंडो का वर्तमान कॉलम
x() चलती विंडो का वर्तमान x-निर्देशांक
y() चलती विंडो का वर्तमान y-निर्देशांक
ewres() वर्तमान पूर्व-पश्चिम संकल्प
nsres() वर्तमान उत्तर-दक्षिण संकल्प
शून्य() शून्य मान
ध्यान दें, पंक्ति() और col() अनुक्रमण 1 से शुरू होता है।

चल बिन्दु मानों in la अभिव्यक्ति
अभिव्यक्ति में फ़्लोटिंग पॉइंट संख्याओं की अनुमति है। फ़्लोटिंग पॉइंट नंबर एक संख्या है
जिसमें एक दशमलव बिंदु होता है:
2.3 12.0 12. .81
अभिव्यक्ति में फ़्लोटिंग पॉइंट मानों को एक विशेष तरीके से नियंत्रित किया जाता है। अंकगणित के साथ और
तार्किक ऑपरेटर, यदि कोई ऑपरेंड फ्लोट है, तो दूसरा फ्लोट में परिवर्तित हो जाता है और
ऑपरेशन का परिणाम फ्लोट है। इसका मतलब है, विशेष रूप से पूर्णांकों का विभाजन
परिणाम एक (काटे गए) पूर्णांक में होता है, जबकि फ़्लोट्स के विभाजन के परिणामस्वरूप सटीक फ़्लोटिंग होता है
बिंदु मान। प्रकार * (उपरोक्त तालिका देखें) के कार्यों के साथ, परिणाम यदि कोई हो तो फ़्लोट होता है
तर्क फ़्लोट है, अन्यथा पूर्णांक है।

नोट: यदि आप पूर्णांक संख्याओं के साथ गणना करते हैं, तो परिणामी मानचित्र पूर्णांक होगा। अगर आप
एक फ्लोट परिणाम प्राप्त करना चाहते हैं, दशमलव बिंदु को पूर्णांक संख्याओं में जोड़ें।

यदि आप फ़्लोटिंग पॉइंट डिवीजन चाहते हैं, तो कम से कम एक तर्क फ़्लोटिंग होना चाहिए
बिंदु मान। उनमें से किसी एक को 1.0 से गुणा करने पर एक फ़्लोटिंग-पॉइंट परिणाम प्राप्त होगा, जैसा कि होगा
फ्लोट() का उपयोग करना:
r.mapcalc "ndvi = फ्लोट(lsat.4 - lsat.3) / (lsat.4 + lsat.3)"

नल समर्थन
· शून्य से भाग देने पर परिणाम शून्य होना चाहिए.

· शून्य से मापांक का परिणाम शून्य होना चाहिए।

· किसी भी अंकगणित या तार्किक ऑपरेशन में शून्य-मान का परिणाम शून्य होना चाहिए।
(हालांकि, &&& और ||| को विशेष रूप से व्यवहार किया जाता है, जैसा कि नीचे बताया गया है)।

· &&& और ||| x शून्य होने पर भी ऑपरेटर निम्नलिखित सिद्धांतों का पालन करते हैं:
x &&& गलत == गलत
गलत &&& x == गलत
एक्स ||| सच == सच
सच ||| एक्स == सत्य

· फ़ंक्शन तर्कों में NULL-मानों का परिणाम NULL होना चाहिए (हालाँकि, if(), eval() और
isnull() को विशेष रूप से व्यवहार किया जाता है, जैसा कि नीचे बताया गया है)।

· eval() फ़ंक्शन हमेशा अपना अंतिम तर्क लौटाता है

· if() के लिए स्थिति यह है:
अगर(एक्स)
यदि x शून्य है तो शून्य; 0 यदि x शून्य है; 1 अन्यथा
अगर(एक्स,ए)
यदि x शून्य है तो शून्य; a यदि x गैर-शून्य है; 0 अन्यथा
अगर(एक्स,ए,बी)
यदि x शून्य है तो शून्य; a यदि x गैर-शून्य है; बी अन्यथा
यदि(x,n,z,p)
यदि x शून्य है तो शून्य; n यदि x ऋणात्मक है;
z यदि x शून्य है; p यदि x धनात्मक है

· (नया) फ़ंक्शन शून्य(x) देता है: 1 यदि x शून्य है; 0 अन्यथा. नई)
फ़ंक्शन null() (जिसमें कोई तर्क नहीं है) एक पूर्णांक NULL लौटाता है।

· गैर-शून्य, लेकिन अमान्य, फ़ंक्शंस के तर्कों का परिणाम शून्य होना चाहिए।
उदाहरण:
लॉग(-2)
sqrt(-2)
pow(a,b) जहां a ऋणात्मक है और b पूर्णांक नहीं है

शून्य समर्थन: कृपया ध्यान दें कि शून्य कोशिकाओं के साथ किए गए किसी भी गणित का परिणाम हमेशा शून्य होता है
इन कोशिकाओं के लिए मूल्य. यदि आप तुरंत NULL सेल को बदलना चाहते हैं, तो isnull() का उपयोग करें
if-स्टेटमेंट में परीक्षण फ़ंक्शन।

उदाहरण: उपयोगकर्ता चाहते हैं कि शून्य-मूल्य वाली कोशिकाओं को शून्य की तरह माना जाए। मानचित्र ए और जोड़ने के लिए
B (जहाँ B में NULLs हैं) मानचित्र C प्राप्त करने के लिए उपयोगकर्ता निम्न प्रकार के निर्माण का उपयोग कर सकता है:

सी = ए + यदि(शून्य(बी),0,बी)

नल और शर्तेँ:

एक तर्क प्रपत्र के लिए:
यदि(x) = शून्य यदि x शून्य है
यदि(x) = 0 यदि x = 0
यदि(x) = 1 अन्यथा (अर्थात x न तो शून्य है और न ही 0)।

दो तर्क प्रपत्र के लिए:
यदि(x,a) = शून्य यदि x शून्य है
यदि(x,a) = 0 यदि x = 0
if(x,a) = a अन्यथा (यानी x न तो NULL है और न ही 0)।

तीन तर्क प्रपत्र के लिए:
यदि(x,a,b) = शून्य यदि x शून्य है
यदि(x,a,b) = b यदि x = 0
if(x,a,b) = a अन्यथा (यानी x न तो NULL है और न ही 0)।

चार तर्क प्रपत्र के लिए:
यदि(x,a,b,c) = शून्य यदि x शून्य है
यदि(x,a,b,c) = a यदि x > 0
यदि(x,a,b,c) = b यदि x = 0
यदि(x,a,b,c) = c यदि x < 0
आम तौर पर, सभी ऑपरेटर और अधिकांश फ़ंक्शंस अपने तर्कों में से कोई भी होने पर NULL लौटाते हैं
शून्य हैं.
फ़ंक्शन if(), isnull() और eval() अपवाद हैं।
फ़ंक्शन isnull() यदि इसका तर्क NULL है तो 1 लौटाता है और अन्यथा 0 लौटाता है। यदि उपयोगकर्ता
विपरीत चाहता है, ! ऑपरेटर, उदाहरण के लिए "!isnull(x)" का उपयोग किया जाना चाहिए।

यदि पहला तर्क NULL है तो if() के सभी रूप NULL लौटाते हैं। 2, 3 और 4 तर्क प्रपत्र
यदि "चयनित" तर्क शून्य है, तो if() शून्य लौटाता है, उदाहरण के लिए:
if(0,a,b) = b चाहे a शून्य हो
if(1,a,b) = a, भले ही b शून्य हो
eval() हमेशा अपना अंतिम तर्क लौटाता है, इसलिए यदि अंतिम तर्क है तो यह केवल NULL लौटाता है
शून्य।

नोट: उपयोगकर्ता == ऑपरेटर का उपयोग करके NULL का परीक्षण नहीं कर सकता, क्योंकि यदि कोई हो तो वह NULL लौटाता है
या दोनों तर्क शून्य हैं, अर्थात यदि x और y दोनों शून्य हैं, तो "x == y" और "x != y" हैं
दोनों क्रमशः 1 और 0 के बजाय शून्य हैं।
यदि उपयोगकर्ता NULL को अज्ञात मात्रा का प्रतिनिधित्व करने वाला मानता है तो यह व्यवहार समझ में आता है।
उदाहरण के लिए यदि x और y दोनों अज्ञात हैं, तो "x == y" और "x != y" के मान भी हैं
अज्ञात; यदि उन दोनों में अज्ञात मान हैं, तो उपयोगकर्ता को नहीं पता कि वे दोनों हैं या नहीं
समान मूल्य है.

टिप्पणियाँ

प्रयोग से आदेश line
यदि अभिव्यक्ति कमांड लाइन पर दी गई है तो अतिरिक्त सावधानी बरतनी चाहिए। कुछ पात्र
UNIX शेल के लिए विशेष अर्थ रखते हैं। इनमें अन्य शामिल हैं:
* ( ) > एवं |

अभिव्यक्ति के चारों ओर एकल उद्धरण चिह्न लगाने की सलाह दी जाती है; उदाहरण:
'परिणाम = उन्नयन*2'
उद्धरण चिह्नों के बिना, *, जिसका UNIX शेल के लिए विशेष अर्थ है, बदल दिया जाएगा
और r.mapcalc * के अलावा कुछ और देखेंगे।

विभिन्न संगणना
सामान्य तौर पर, प्रत्येक r.mapcalc कमांड में जितना संभव हो उतना करना बेहतर होता है। उदाहरण के लिए
इसके बजाय:
r.mapcalc "$GIS_OPT_OUTPUT.r = r#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * r#$GIS_OPT_SECOND"
r.mapcalc "$GIS_OPT_OUTPUT.g = g#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * g#$GIS_OPT_SECOND"
r.mapcalc "$GIS_OPT_OUTPUT.b = b#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * b#$GIS_OPT_SECOND"

उपयोग:
r.mapcalc <
$GIS_OPT_OUTPUT.r = r#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * r#$GIS_OPT_SECOND
$GIS_OPT_OUTPUT.g = g#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * g#$GIS_OPT_SECOND
$GIS_OPT_OUTPUT.b = b#$GIS_OPT_FIRST * .$GIS_OPT_PERCENT + (1.0 - .$GIS_OPT_PERCENT) * b#$GIS_OPT_SECOND
EOF

चूँकि उत्तरार्द्ध प्रत्येक इनपुट मानचित्र को केवल एक बार पढ़ेगा।

पीछे की ओर अनुकूलता
GRASS 6 के साथ पश्चगामी संगतता के लिए, यदि कोई विकल्प नहीं दिया गया है, तो यह निर्माण करता है
फ़ाइल = - (जो stdin से पढ़ता है), ताकि आप इसका उपयोग जारी रख सकें उदाहरण:
r.mapcalc <फ़ाइल
या:
r.mapcalc <
फू = 1
EOF
लेकिन जब तक आपको पिछले GRASS GIS संस्करणों के साथ अनुकूलता की आवश्यकता न हो, फ़ाइल = का स्पष्ट रूप से उपयोग करें,
जैसा कि ऊपर कहा।

जब मानचित्र के नाम में बड़े अक्षर या बिंदु हों, जिन्हें रखने की अनुमति नहीं है
मॉड्यूल विकल्प नाम, r.mapcalc आदेश बिना उद्धरण चिह्नों के भी मान्य होगा:
r.mapcalc ऊँचाई_A=1
r.mapcalc ऊंचाई.1=1
हालाँकि, इस वाक्यविन्यास को उद्धरण के रूप में अनुशंसित नहीं किया गया है जैसा कि ऊपर अधिक सुरक्षित बताया गया है। उद्धरणों का उपयोग करना
भविष्य में पश्चगामी संगत और वैध दोनों है।

इंटरैक्टिव निवेश in आदेश line
उन सूत्रों के लिए जिन्हें उपयोगकर्ता मानक इनपुट से दर्ज करता है (कमांड लाइन के बजाय),
एक पंक्ति निरंतरता सुविधा अब मौजूद है। यदि उपयोगकर्ता किसी के अंत में बैकस्लैश जोड़ता है
इनपुट लाइन, r.mapcalc यह मानता है कि उपयोगकर्ता द्वारा दर्ज किया जा रहा फॉर्मूला जारी रहता है
अगली इनपुट लाइन. इनपुट लाइनों की संभावित संख्या या की कोई सीमा नहीं है
एक सूत्र की लंबाई.

अगर r.mapcalc उपयोगकर्ता द्वारा दर्ज किया गया फॉर्मूला बहुत लंबा है, केवल मानचित्र शीर्षक में ही शामिल होगा
इसमें से कुछ, लेकिन अधिकांश (यदि सभी नहीं) सूत्र को इतिहास फ़ाइल में रखा जाएगा
la परिणाम नक्शा।

जब उपयोगकर्ता इनपुट दर्ज करता है r.mapcalc कमांड लाइन पर गैर-संवादात्मक रूप से, प्रोग्राम
उपयोगकर्ता को मौजूदा मानचित्र परतों को अधिलेखित न करने की चेतावनी नहीं दी जाएगी। इसलिए उपयोगकर्ताओं को लेना चाहिए
प्रोग्राम आउटपुट को रैस्टर मैप नाम निर्दिष्ट करने में सावधानी बरतें जो अभी तक उनके वर्तमान में मौजूद नहीं हैं
मैपसेट

रास्टर मुखौटा से निपटने
r.mapcalc रैस्टर MASK हैंडलिंग के सामान्य GRASS व्यवहार का पालन करता है, इसलिए MASK ही है
मौजूदा GRASS रेखापुंज मानचित्र को पढ़ते समय लागू किया जाता है। इसका तात्पर्य यह है कि, उदाहरण के लिए,
आदेश:
r.mapcalc "ऊंचाई_अतिरंजित = ऊंचाई * 3"
यदि MASK सक्रिय है तो नकाबपोश पिक्सेल का सम्मान करते हुए एक मानचित्र बनाएं।

हालाँकि, एक ऐसा नक्शा बनाते समय जो किसी भी नक्शे पर आधारित नहीं है, उदाहरण के लिए एक स्थिरांक से एक नक्शा:
r.mapcalc "बेस_हाइट = 200.0"
बनाया गया रेखापुंज मानचित्र केवल एक संगणना क्षेत्र तक ही सीमित है लेकिन इससे प्रभावित नहीं होता है
एक सक्रिय मास्क. यह अपेक्षित है क्योंकि, जैसा कि ऊपर बताया गया है, MASK तभी लगाया जाता है जब
पढ़ना, रेखापुंज मानचित्र लिखते समय नहीं।

यदि इस मामले में भी MASK लागू किया जाना चाहिए, तो MASK सहित एक if() कथन
इस्तेमाल किया जाना चाहिए, उदाहरण के लिए:
r.mapcalc "base_height = if(MASK, 200.0, null())"
MASK से संबंधित अभिव्यक्तियों का परीक्षण करते समय ध्यान रखें कि जब MASK सक्रिय होता है तो आप नहीं देखते हैं
नकाबपोश क्षेत्रों में डेटा, भले ही वे शून्य न हों। देखना आर.मास्क ब्योरा हेतु।

विकसित करना समारोह
यदि गणना का आउटपुट केवल एक मानचित्र होना चाहिए लेकिन अभिव्यक्ति इतनी जटिल है
इसे कई अभिव्यक्तियों में विभाजित करना बेहतर है, eval फ़ंक्शन का उपयोग किया जा सकता है:
r.mapcalc << EOF
eval(elev_200 = ऊंचाई - 200,
ऊँचाई_5 = 5 * ऊँचाई,
ऊंचाई_पी = पाउ(ऊंचाई_5, 2))
ऊंचाई_परिणाम = (0.5 * ऊंचाई_200) + 0.8 * ऊंचाई_पी
EOF
यह उदाहरण इनपुट प्रदान करने के लिए यूनिक्स-जैसे << EOF सिंटैक्स का उपयोग करता है r.mapcalc.

ध्यान दें कि अस्थायी चर (मानचित्र) नहीं बनाए गए हैं और इस प्रकार इससे कोई फर्क नहीं पड़ता
चाहे उनका अस्तित्व हो या न हो. उपरोक्त उदाहरण में, यदि मानचित्र ऊंचाई_200 मौजूद है तो यह नहीं होगा
अधिलेखित कर दिया जाएगा और कोई त्रुटि उत्पन्न नहीं होगी। कारण यह है कि अभी नाम Elev_200 है
अस्थायी चर (मानचित्र) को दर्शाता है न कि मौजूदा मानचित्र को। के निम्नलिखित भाग
अभिव्यक्ति अस्थायी ऊंचाई_200 का उपयोग करेगी और मौजूदा ऊंचाई_200 बरकरार रहेगी
और इसका उपयोग नहीं किया जाएगा. यदि कोई उपयोगकर्ता मौजूदा मानचित्र का उपयोग करना चाहता है, तो अस्थायी का नाम
चर (मानचित्र) बदला जाना चाहिए।

बिना सोचे समझे संख्या जनक आरंभीकरण
रैंड () फ़ंक्शन द्वारा उपयोग किए जाने वाले छद्म-यादृच्छिक संख्या जनरेटर को एक से आरंभ किया जा सकता है
का उपयोग कर विशिष्ट मूल्य बीज विकल्प। इसका उपयोग पिछले को दोहराने के लिए किया जा सकता है
गणना।

वैकल्पिक रूप से, इसे सिस्टम समय और पीआईडी ​​का उपयोग करके आरंभ किया जा सकता है -r झंडा।
इसके परिणामस्वरूप हर बार एक अलग बीज का उपयोग किया जाना चाहिए।

किसी भी स्थिति में, बीज को मानचित्र के इतिहास में लिखा जाएगा, और इसका उपयोग करके देखा जा सकता है
आर.जानकारी.

यदि आप चाहते हैं कि अन्य लोग आपके परिणामों को सत्यापित कर सकें, तो इसका उपयोग करना बेहतर होगा
बीज बीज की आपूर्ति करने का विकल्प जो या तो स्क्रिप्ट में निर्दिष्ट है या से उत्पन्न है
एक स्पष्ट बीज दिए गए छद्म-यादृच्छिक संख्या जनरेटर जैसी निर्धारक प्रक्रिया।

ध्यान दें कि रैंड() फ़ंक्शन एक घातक त्रुटि उत्पन्न करेगा यदि दोनों में से कोई भी नहीं बीज विकल्प न ही
la -s झंडा दिया गया है.

उदाहरण

दो रेखापुंज मानचित्र परतों के औसत की गणना करने के लिए a और b:
एवे = (ए + बी)/2
भारित औसत बनाने के लिए:
एवे = (5*ए + 3*बी)/8.0
रेखापुंज मानचित्र परत का द्विआधारी प्रतिनिधित्व तैयार करना a ताकि श्रेणी 0 0 ही रहे
और अन्य सभी श्रेणियां 1 हो जाती हैं:
मुखौटा = ए != 0
इसे इसके द्वारा भी पूरा किया जा सकता है:
मुखौटा = यदि(ए)
रेखापुंज मानचित्र परत को छुपाने के लिए b रेखापुंज मानचित्र परत द्वारा a:
परिणाम = यदि(ए,बी)
5 से नीचे के सभी मानों को NULL में बदलने के लिए:
न्यूमैप = यदि (मानचित्र<5, शून्य(), 5)
ग्राफ़() फ़ंक्शन उपयोगकर्ताओं को x,y के जोड़े का उपयोग करके xy रूपांतरण निर्दिष्ट करने की अनुमति देता है
निर्देशांक कुछ स्थितियों में एक मूल्य से दूसरे मूल्य में परिवर्तन आसानी से नहीं होता है
गणितीय रूप से स्थापित, लेकिन इसे 2-डी ग्राफ़ और फिर रैखिक रूप से दर्शाया जा सकता है
अंतर्वेशित ग्राफ़() फ़ंक्शन इसे पूरा करने का अवसर प्रदान करता है। एक एक्स-अक्ष
मान ग्राफ़ फ़ंक्शन को संबंधित ग्राफ़ के साथ प्रदान किया जाता है जिसे ए द्वारा दर्शाया गया है
x,y युग्मों की श्रृंखला। x मान एकरस रूप से बढ़ते रहना चाहिए (प्रत्येक या से बड़ा)।
पिछले के बराबर)। ग्राफ फ़ंक्शन जोड़े के बीच रैखिक रूप से प्रक्षेप करता है। कोई एक्स
न्यूनतम x मान से कम मूल्य (अर्थात पहले) से संबंधित y मान वापस आ जाएगा।
पिछले से अधिक किसी भी x मान के साथ संबंधित y मान वापस आ जाएगा।
अनुरोध पर विचार करें:
नया नक्शा = ग्राफ (मानचित्र, 1,10, 2,25, 3,50)
X (मानचित्र) मान प्रदान किए गए और y (न्यूमैप) मान लौटाए गए:
0, 10
1, 10
1.5, 17.5
2.9, 47.5
4, 50
100, 50

ज्ञात मुद्दें

निरंतरता पंक्तियाँ \ के साथ समाप्त होनी चाहिए और होनी चाहिए नहीं अनुगामी श्वेत स्थान (रिक्त स्थान या टैब)। अगर
उपयोगकर्ता निरंतरता पंक्तियों, त्रुटि संदेशों के अंत में सफेद स्थान छोड़ता है
द्वारा उत्पादित r.mapcalc अर्थहीन हो जाएगा और समीकरण उपयोगकर्ता के रूप में काम नहीं करेगा
अभिप्रेत। यह eval() फ़ंक्शन के लिए विशेष रूप से महत्वपूर्ण है।

वर्तमान में, इसमें कोई टिप्पणी तंत्र नहीं है r.mapcalc. शायद उसमें एक क्षमता जोड़ दी जाए
जब उपयोगकर्ता द्वारा a के प्रारंभ में # डाला जाता है तो संपूर्ण पंक्ति को अनदेखा कर दिया जाएगा
लाइन मानो मौजूद ही न हो, काम करेगी।

फ़ंक्शन को उपयोगकर्ता को केवल रिक्त स्थान के बजाय "अंत" या "बाहर निकलें" टाइप करने की आवश्यकता होनी चाहिए
पंक्ति। इससे अनेक लिपियों को श्वेत स्थान द्वारा अलग किया जा सकेगा।

r.mapcalc NULL सेलों पर संचालन के मामले में कोई चेतावनी नहीं छापता। इसे छोड़ दिया गया है
उपयोगकर्ता को isnull() फ़ंक्शन का उपयोग करना होगा।

onworks.net सेवाओं का उपयोग करके ऑनलाइन r.mapcalcgrass का उपयोग करें