/**
 * Copyright (c) 2020 CEA LIST
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v2.0 which
 * accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 * 
 * SPDX-License-Identifier: EPL-2.0
 * 
 */
package org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers;

import org.eclipse.emf.common.util.EList;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>Convolution</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getIn_channels <em>In channels</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getGroups <em>Groups</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#isBiais <em>Biais</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getPadding_mode <em>Padding mode</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getData_format <em>Data format</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getDilation_rate <em>Dilation rate</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getActivation <em>Activation</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getBias_initializer <em>Bias initializer</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getActivity_regularizer <em>Activity regularizer</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getBias_constraint <em>Bias constraint</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getBias_regularizer <em>Bias regularizer</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution()
 * @model abstract="true"
 * @generated
 */
public interface Convolution extends Convolution_layers {
	/**
	 * Returns the value of the '<em><b>In channels</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>In channels</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>In channels</em>' attribute.
	 * @see #setIn_channels(int)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_In_channels()
	 * @model dataType="org.eclipse.uml2.types.Integer" ordered="false"
	 * @generated
	 */
	int getIn_channels();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getIn_channels <em>In channels</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>In channels</em>' attribute.
	 * @see #getIn_channels()
	 * @generated
	 */
	void setIn_channels(int value);

	/**
	 * Returns the value of the '<em><b>Groups</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Groups</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Groups</em>' attribute.
	 * @see #setGroups(int)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Groups()
	 * @model dataType="org.eclipse.uml2.types.Integer" ordered="false"
	 * @generated
	 */
	int getGroups();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getGroups <em>Groups</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Groups</em>' attribute.
	 * @see #getGroups()
	 * @generated
	 */
	void setGroups(int value);

	/**
	 * Returns the value of the '<em><b>Biais</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Biais</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Biais</em>' attribute.
	 * @see #setBiais(boolean)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Biais()
	 * @model dataType="org.eclipse.uml2.types.Boolean" ordered="false"
	 * @generated
	 */
	boolean isBiais();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#isBiais <em>Biais</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Biais</em>' attribute.
	 * @see #isBiais()
	 * @generated
	 */
	void setBiais(boolean value);

	/**
	 * Returns the value of the '<em><b>Padding mode</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Padding mode</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Padding mode</em>' attribute.
	 * @see #setPadding_mode(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Padding_mode()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getPadding_mode();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getPadding_mode <em>Padding mode</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Padding mode</em>' attribute.
	 * @see #getPadding_mode()
	 * @generated
	 */
	void setPadding_mode(String value);

	/**
	 * Returns the value of the '<em><b>Data format</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Data format</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Data format</em>' attribute.
	 * @see #setData_format(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Data_format()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getData_format();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getData_format <em>Data format</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Data format</em>' attribute.
	 * @see #getData_format()
	 * @generated
	 */
	void setData_format(String value);

	/**
	 * Returns the value of the '<em><b>Dilation rate</b></em>' attribute list.
	 * The list contents are of type {@link java.lang.Integer}.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Dilation rate</em>' attribute list isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Dilation rate</em>' attribute list.
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Dilation_rate()
	 * @model dataType="org.eclipse.uml2.types.Integer" ordered="false"
	 * @generated
	 */
	EList<Integer> getDilation_rate();

	/**
	 * Returns the value of the '<em><b>Activation</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Activation</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Activation</em>' attribute.
	 * @see #setActivation(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Activation()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getActivation();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getActivation <em>Activation</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Activation</em>' attribute.
	 * @see #getActivation()
	 * @generated
	 */
	void setActivation(String value);

	/**
	 * Returns the value of the '<em><b>Bias initializer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Bias initializer</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Bias initializer</em>' attribute.
	 * @see #setBias_initializer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Bias_initializer()
	 * @model dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
	 * @generated
	 */
	String getBias_initializer();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getBias_initializer <em>Bias initializer</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Bias initializer</em>' attribute.
	 * @see #getBias_initializer()
	 * @generated
	 */
	void setBias_initializer(String value);

	/**
	 * Returns the value of the '<em><b>Activity regularizer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Activity regularizer</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Activity regularizer</em>' attribute.
	 * @see #setActivity_regularizer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Activity_regularizer()
	 * @model dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
	 * @generated
	 */
	String getActivity_regularizer();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getActivity_regularizer <em>Activity regularizer</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Activity regularizer</em>' attribute.
	 * @see #getActivity_regularizer()
	 * @generated
	 */
	void setActivity_regularizer(String value);

	/**
	 * Returns the value of the '<em><b>Bias constraint</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Bias constraint</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Bias constraint</em>' attribute.
	 * @see #setBias_constraint(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Bias_constraint()
	 * @model dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
	 * @generated
	 */
	String getBias_constraint();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getBias_constraint <em>Bias constraint</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Bias constraint</em>' attribute.
	 * @see #getBias_constraint()
	 * @generated
	 */
	void setBias_constraint(String value);

	/**
	 * Returns the value of the '<em><b>Bias regularizer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Bias regularizer</em>' attribute isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Bias regularizer</em>' attribute.
	 * @see #setBias_regularizer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getConvolution_Bias_regularizer()
	 * @model dataType="org.eclipse.uml2.types.String" required="true" ordered="false"
	 * @generated
	 */
	String getBias_regularizer();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution#getBias_regularizer <em>Bias regularizer</em>}' attribute.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Bias regularizer</em>' attribute.
	 * @see #getBias_regularizer()
	 * @generated
	 */
	void setBias_regularizer(String value);

} // Convolution
