/**
 * 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.papyrus.aiml.profile.AIML.Layer_weight_constraints.constraints;

/**
 * <!-- begin-user-doc -->
 * A representation of the model object '<em><b>basic</b></em>'.
 * <!-- end-user-doc -->
 *
 * <p>
 * The following features are supported:
 * </p>
 * <ul>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.basic#getKernel_initializer <em>Kernel initializer</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.basic#getKernel_constraint <em>Kernel constraint</em>}</li>
 *   <li>{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.basic#getKernel_regularizer <em>Kernel regularizer</em>}</li>
 * </ul>
 *
 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getbasic()
 * @model abstract="true"
 * @generated
 */
public interface basic extends LayerWithFilter {
	/**
	 * Returns the value of the '<em><b>Kernel initializer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Kernel 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>Kernel initializer</em>' attribute.
	 * @see #setKernel_initializer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getbasic_Kernel_initializer()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getKernel_initializer();

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

	/**
	 * Returns the value of the '<em><b>Kernel constraint</b></em>' reference.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Kernel constraint</em>' reference isn't clear,
	 * there really should be more of a description here...
	 * </p>
	 * <!-- end-user-doc -->
	 * @return the value of the '<em>Kernel constraint</em>' reference.
	 * @see #setKernel_constraint(constraints)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getbasic_Kernel_constraint()
	 * @model required="true" ordered="false"
	 * @generated
	 */
	constraints getKernel_constraint();

	/**
	 * Sets the value of the '{@link org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.basic#getKernel_constraint <em>Kernel constraint</em>}' reference.
	 * <!-- begin-user-doc -->
	 * <!-- end-user-doc -->
	 * @param value the new value of the '<em>Kernel constraint</em>' reference.
	 * @see #getKernel_constraint()
	 * @generated
	 */
	void setKernel_constraint(constraints value);

	/**
	 * Returns the value of the '<em><b>Kernel regularizer</b></em>' attribute.
	 * <!-- begin-user-doc -->
	 * <p>
	 * If the meaning of the '<em>Kernel 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>Kernel regularizer</em>' attribute.
	 * @see #setKernel_regularizer(String)
	 * @see org.eclipse.papyrus.aiml.profile.AIML.Convolution_layers.Convolution_layersPackage#getbasic_Kernel_regularizer()
	 * @model dataType="org.eclipse.uml2.types.String" ordered="false"
	 * @generated
	 */
	String getKernel_regularizer();

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

} // basic
